Actual source code: bddcprivate.c
1: #include <../src/mat/impls/aij/seq/aij.h>
2: #include <petsc/private/pcbddcimpl.h>
3: #include <petsc/private/pcbddcprivateimpl.h>
4: #include <petsc/private/kernels/blockinvert.h>
5: #include <../src/mat/impls/dense/seq/dense.h>
6: #include <petscdmplex.h>
7: #include <petscblaslapack.h>
8: #include <petsc/private/sfimpl.h>
9: #include <petsc/private/dmpleximpl.h>
10: #include <petscdmda.h>
12: static PetscErrorCode MatMPIAIJRestrict(Mat, MPI_Comm, Mat *);
14: /* if range is true, it returns B s.t. span{B} = range(A)
15: if range is false, it returns B s.t. range(B) _|_ range(A) */
16: static PetscErrorCode MatDenseOrthogonalRangeOrComplement(Mat A, PetscBool range, PetscInt lw, PetscScalar *work, PetscReal *rwork, Mat *B)
17: {
18: PetscScalar *uwork, *data, *U, ds = 0.;
19: PetscReal *sing;
20: PetscBLASInt bM, bN, lwork, di = 1;
21: PetscInt ulw, i, nr, nc, n;
22: #if PetscDefined(USE_COMPLEX)
23: PetscReal *rwork2;
24: #endif
26: PetscFunctionBegin;
27: PetscCall(MatGetSize(A, &nr, &nc));
28: if (!nr || !nc) PetscFunctionReturn(PETSC_SUCCESS);
30: /* workspace */
31: if (!work) {
32: ulw = PetscMax(PetscMax(1, 5 * PetscMin(nr, nc)), 3 * PetscMin(nr, nc) + PetscMax(nr, nc));
33: PetscCall(PetscMalloc1(ulw, &uwork));
34: } else {
35: ulw = lw;
36: uwork = work;
37: }
38: n = PetscMin(nr, nc);
39: if (!rwork) {
40: PetscCall(PetscMalloc1(n, &sing));
41: } else {
42: sing = rwork;
43: }
45: /* SVD */
46: PetscCall(PetscMalloc1(nr * nr, &U));
47: PetscCall(PetscBLASIntCast(nr, &bM));
48: PetscCall(PetscBLASIntCast(nc, &bN));
49: PetscCall(PetscBLASIntCast(ulw, &lwork));
50: PetscCall(MatDenseGetArray(A, &data));
51: PetscCall(PetscFPTrapPush(PETSC_FP_TRAP_OFF));
52: #if !PetscDefined(USE_COMPLEX)
53: PetscCallLAPACKInfo("LAPACKgesvd", LAPACKgesvd_("A", "N", &bM, &bN, data, &bM, sing, U, &bM, &ds, &di, uwork, &lwork, &info));
54: #else
55: PetscCall(PetscMalloc1(5 * n, &rwork2));
56: PetscCallLAPACKInfo("LAPACKgesvd", LAPACKgesvd_("A", "N", &bM, &bN, data, &bM, sing, U, &bM, &ds, &di, uwork, &lwork, rwork2, &info));
57: PetscCall(PetscFree(rwork2));
58: #endif
59: PetscCall(PetscFPTrapPop());
60: PetscCall(MatDenseRestoreArray(A, &data));
61: for (i = 0; i < n; i++)
62: if (sing[i] < PETSC_SMALL) break;
63: if (!rwork) PetscCall(PetscFree(sing));
64: if (!work) PetscCall(PetscFree(uwork));
65: /* create B */
66: if (!range) {
67: PetscCall(MatCreateSeqDense(PETSC_COMM_SELF, nr, nr - i, NULL, B));
68: PetscCall(MatDenseGetArray(*B, &data));
69: PetscCall(PetscArraycpy(data, U + nr * i, (nr - i) * nr));
70: } else {
71: PetscCall(MatCreateSeqDense(PETSC_COMM_SELF, nr, i, NULL, B));
72: PetscCall(MatDenseGetArray(*B, &data));
73: PetscCall(PetscArraycpy(data, U, i * nr));
74: }
75: PetscCall(MatDenseRestoreArray(*B, &data));
76: PetscCall(PetscFree(U));
77: PetscFunctionReturn(PETSC_SUCCESS);
78: }
80: /* TODO REMOVE */
81: #if defined(PRINT_GDET)
82: static int inc = 0;
83: static int lev = 0;
84: #endif
86: static PetscErrorCode PCBDDCComputeNedelecChangeEdge(Mat lG, IS edge, IS extrow, IS extcol, IS corners, PetscBool check, Mat *Gins, Mat *GKins, PetscScalar cvals[2], PetscScalar *work, PetscReal *rwork)
87: {
88: Mat GE, GEd;
89: PetscInt rsize, csize, esize, ncomp;
90: PetscScalar *ptr;
92: PetscFunctionBegin;
93: PetscCall(ISGetSize(edge, &esize));
94: if (!esize) PetscFunctionReturn(PETSC_SUCCESS);
95: PetscCall(ISGetSize(extrow, &rsize));
96: PetscCall(ISGetSize(extcol, &csize));
98: /* gradients */
99: ptr = work + 5 * esize;
100: PetscCall(MatCreateSubMatrix(lG, extrow, extcol, MAT_INITIAL_MATRIX, &GE));
101: PetscCall(MatCreateSeqDense(PETSC_COMM_SELF, rsize, csize, ptr, Gins));
102: PetscCall(MatConvert(GE, MATSEQDENSE, MAT_REUSE_MATRIX, Gins));
103: PetscCall(MatDestroy(&GE));
105: /* constants */
106: ptr += rsize * csize;
107: PetscCall(MatCreateSeqDense(PETSC_COMM_SELF, esize, csize, ptr, &GEd));
108: PetscCall(MatCreateSubMatrix(lG, edge, extcol, MAT_INITIAL_MATRIX, &GE));
109: PetscCall(MatConvert(GE, MATSEQDENSE, MAT_REUSE_MATRIX, &GEd));
110: PetscCall(MatDestroy(&GE));
111: PetscCall(MatDenseOrthogonalRangeOrComplement(GEd, PETSC_FALSE, 5 * esize, work, rwork, GKins));
112: PetscCall(MatGetSize(*GKins, NULL, &ncomp));
113: PetscCheck(!corners || ncomp == 1, PETSC_COMM_SELF, PETSC_ERR_SUP, "Cannot generate the coarse discrete gradient with complement dimension %" PetscInt_FMT, ncomp);
114: if (check) {
115: const PetscScalar *phi;
116: PetscScalar *orth;
117: PetscReal bnorm2 = 0.0, tol = 100.0 * PETSC_SQRT_MACHINE_EPSILON;
118: PetscInt lda;
120: PetscCall(PetscCalloc1(csize, &orth));
121: PetscCall(MatCreateSubMatrix(lG, edge, extcol, MAT_INITIAL_MATRIX, &GE));
122: PetscCall(MatDenseGetLDA(*GKins, &lda));
123: PetscCall(MatDenseGetArrayRead(*GKins, &phi));
124: for (PetscInt i = 0; i < esize; i++) {
125: const PetscScalar *v;
126: const PetscInt *cols;
127: PetscInt nz;
129: PetscCall(MatGetRow(GE, i, &nz, &cols, &v));
130: for (PetscInt j = 0; j < nz; j++) bnorm2 += PetscSqr(PetscAbsScalar(v[j]));
131: PetscCall(MatRestoreRow(GE, i, &nz, &cols, &v));
132: }
133: for (PetscInt k = 0; k < ncomp; k++) {
134: PetscReal norm2 = 0.0, orth2 = 0.0;
136: PetscCall(PetscArrayzero(orth, csize));
137: for (PetscInt i = 0; i < esize; i++) {
138: const PetscScalar *v;
139: const PetscInt *cols;
140: PetscInt nz;
142: norm2 += PetscSqr(PetscAbsScalar(phi[i + k * lda]));
143: PetscCall(MatGetRow(GE, i, &nz, &cols, &v));
144: for (PetscInt j = 0; j < nz; j++) orth[cols[j]] += PetscConj(phi[i + k * lda]) * v[j];
145: PetscCall(MatRestoreRow(GE, i, &nz, &cols, &v));
146: }
147: for (PetscInt j = 0; j < csize; j++) orth2 += PetscSqr(PetscAbsScalar(orth[j]));
148: PetscCheck(PetscAbsReal(PetscSqrtReal(norm2) - PetscRealConstant(1.0)) <= tol, PETSC_COMM_SELF, PETSC_ERR_PLIB, "Nedelec complement column %" PetscInt_FMT " has norm %g", k, (double)PetscSqrtReal(norm2));
149: PetscCheck(PetscSqrtReal(orth2) <= tol * PetscMax(1.0, PetscSqrtReal(bnorm2)), PETSC_COMM_SELF, PETSC_ERR_PLIB, "Nedelec complement column %" PetscInt_FMT " is not orthogonal to the edge gradient space: residual norm %g", k, (double)PetscSqrtReal(orth2));
150: }
151: PetscCall(MatDenseRestoreArrayRead(*GKins, &phi));
152: PetscCall(PetscFree(orth));
153: PetscCall(MatDestroy(&GE));
154: }
155: PetscCall(MatDestroy(&GEd));
157: if (corners) {
158: Mat GEc;
159: const PetscScalar *gvals, *phi;
160: PetscScalar phase;
161: PetscReal scale;
162: PetscInt ldg;
164: PetscCall(MatCreateSubMatrix(lG, edge, corners, MAT_INITIAL_MATRIX, &GEc));
165: PetscCall(MatConvert(GEc, MATSEQDENSE, MAT_INITIAL_MATRIX, &GEd));
166: PetscCall(MatDenseGetLDA(GEd, &ldg));
167: PetscCall(MatDenseGetArrayRead(GEd, &gvals));
168: PetscCall(MatDenseGetArrayRead(*GKins, &phi));
169: cvals[0] = cvals[1] = 0.0;
170: for (PetscInt i = 0; i < esize; i++) {
171: cvals[0] += PetscConj(phi[i]) * gvals[i];
172: cvals[1] += PetscConj(phi[i]) * gvals[i + ldg];
173: }
174: PetscCall(MatDenseRestoreArrayRead(*GKins, &phi));
175: PetscCall(MatDenseRestoreArrayRead(GEd, &gvals));
177: /* T maps new coefficients to old coefficients. Since [G_EI, Phi_E] is the edge block of T,
178: the Phi_E coordinate of a gradient is Phi_E^* G when Phi_E is a unit orthogonal complement. */
179: scale = PetscAbsScalar(cvals[0]);
180: PetscCheck(scale > PETSC_SMALL, PETSC_COMM_SELF, PETSC_ERR_PLIB, "Zero coarse discrete-gradient coefficient at the first edge endpoint");
181: PetscCheck(PetscAbsScalar(cvals[1]) > PETSC_SMALL, PETSC_COMM_SELF, PETSC_ERR_PLIB, "Zero coarse discrete-gradient coefficient at the second edge endpoint");
182: /* Remove the arbitrary SVD phase. The endpoints are sorted by the current-level global
183: numbering before this call, so applying this convention recursively orients every propagated coarse edge. */
184: phase = -cvals[0] / scale;
185: PetscCall(MatScale(*GKins, phase));
186: cvals[0] /= phase;
187: cvals[1] /= phase;
188: #if defined(PRINT_GDET)
189: {
190: Mat Gproj;
191: PetscViewer viewer;
192: char filename[256];
194: PetscCall(PetscSNPrintf(filename, PETSC_STATIC_ARRAY_LENGTH(filename), "Gdet_l%d_r%d_cc%d.m", lev, PetscGlobalRank, inc++));
195: PetscCall(PetscViewerASCIIOpen(PETSC_COMM_SELF, filename, &viewer));
196: PetscCall(PetscViewerPushFormat(viewer, PETSC_VIEWER_ASCII_MATLAB));
197: PetscCall(PetscObjectSetName((PetscObject)GEc, "GEc"));
198: PetscCall(MatView(GEc, viewer));
199: PetscCall(PetscObjectSetName((PetscObject)*GKins, "GK"));
200: PetscCall(MatView(*GKins, viewer));
201: PetscCall(MatCreateSeqDense(PETSC_COMM_SELF, 1, 2, cvals, &Gproj));
202: PetscCall(PetscObjectSetName((PetscObject)Gproj, "Gproj"));
203: PetscCall(MatView(Gproj, viewer));
204: PetscCall(MatDestroy(&Gproj));
205: PetscCall(PetscViewerDestroy(&viewer));
206: }
207: #endif
208: PetscCall(MatDestroy(&GEd));
209: PetscCall(MatDestroy(&GEc));
210: }
211: PetscFunctionReturn(PETSC_SUCCESS);
212: }
214: static PetscErrorCode PCBDDCCheckNedelecCoarseGradient_Private(Mat G, PetscInt nedges, const PetscInt edge_rows[], const PetscScalar edge_vals[])
215: {
216: ISLocalToGlobalMapping rl2g, cl2g;
217: PetscSF sf;
218: PetscScalar *vals, *root_vals, *ref_vals;
219: PetscReal tol = 100.0 * PETSC_SQRT_MACHINE_EPSILON;
220: PetscInt *rows, *cols, *grows, *gcols, *root_cols, *ref_cols;
221: PetscInt i, j, nactive, nroots;
223: PetscFunctionBegin;
224: for (i = 0, nactive = 0; i < nedges; i++)
225: if (edge_rows[i] >= 0) nactive++;
227: PetscCall(PetscMalloc4(nactive, &rows, nactive, &grows, 2 * nactive, &cols, 2 * nactive, &gcols));
228: PetscCall(PetscMalloc3(2 * nactive, &vals, 2 * nactive, &ref_vals, 2 * nactive, &ref_cols));
229: for (i = 0, nactive = 0; i < nedges; i++) {
230: if (edge_rows[i] < 0) continue;
231: rows[nactive] = edge_rows[i];
232: cols[2 * nactive] = 2 * i;
233: cols[2 * nactive + 1] = 2 * i + 1;
234: vals[2 * nactive] = edge_vals[2 * i];
235: vals[2 * nactive + 1] = edge_vals[2 * i + 1];
236: nactive++;
237: }
238: PetscCall(MatGetLocalToGlobalMapping(G, &rl2g, &cl2g));
239: PetscCall(ISLocalToGlobalMappingApply(rl2g, nactive, rows, grows));
240: PetscCall(ISLocalToGlobalMappingApply(cl2g, 2 * nactive, cols, gcols));
242: nroots = G->rmap->n;
243: PetscCall(PetscMalloc2(2 * nroots, &root_vals, 2 * nroots, &root_cols));
244: PetscCall(PetscSFCreate(PetscObjectComm((PetscObject)G), &sf));
245: PetscCall(PetscSFSetGraphLayout(sf, G->rmap, nactive, NULL, PETSC_USE_POINTER, grows));
246: PetscCall(PetscSFReduceBegin(sf, MPIU_2INT, gcols, root_cols, MPI_REPLACE));
247: PetscCall(PetscSFReduceEnd(sf, MPIU_2INT, gcols, root_cols, MPI_REPLACE));
248: PetscCall(PetscSFReduceBegin(sf, MPIU_2SCALAR, vals, root_vals, MPI_REPLACE));
249: PetscCall(PetscSFReduceEnd(sf, MPIU_2SCALAR, vals, root_vals, MPI_REPLACE));
250: PetscCall(PetscSFBcastBegin(sf, MPIU_2INT, root_cols, ref_cols, MPI_REPLACE));
251: PetscCall(PetscSFBcastEnd(sf, MPIU_2INT, root_cols, ref_cols, MPI_REPLACE));
252: PetscCall(PetscSFBcastBegin(sf, MPIU_2SCALAR, root_vals, ref_vals, MPI_REPLACE));
253: PetscCall(PetscSFBcastEnd(sf, MPIU_2SCALAR, root_vals, ref_vals, MPI_REPLACE));
254: PetscCall(PetscSFDestroy(&sf));
256: for (i = 0; i < nactive; i++) {
257: for (j = 0; j < 2; j++) {
258: PetscReal scale = PetscMax(PetscAbsScalar(vals[2 * i + j]), PetscAbsScalar(ref_vals[2 * i + j]));
260: PetscCheck(gcols[2 * i + j] == ref_cols[2 * i + j], PETSC_COMM_SELF, PETSC_ERR_PLIB, "Inconsistent endpoint %" PetscInt_FMT " for shared coarse edge row %" PetscInt_FMT ": %" PetscInt_FMT " != %" PetscInt_FMT, j, grows[i], gcols[2 * i + j], ref_cols[2 * i + j]);
261: PetscCheck(PetscAbsScalar(vals[2 * i + j] - ref_vals[2 * i + j]) <= tol * scale, PETSC_COMM_SELF, PETSC_ERR_PLIB, "Inconsistent coefficient %" PetscInt_FMT " for shared coarse edge row %" PetscInt_FMT ": difference %g", j, grows[i], (double)PetscAbsScalar(vals[2 * i + j] - ref_vals[2 * i + j]));
262: }
263: }
264: PetscCall(PetscFree2(root_vals, root_cols));
265: PetscCall(PetscFree3(vals, ref_vals, ref_cols));
266: PetscCall(PetscFree4(rows, grows, cols, gcols));
267: PetscFunctionReturn(PETSC_SUCCESS);
268: }
270: static PetscErrorCode PCBDDCViewNedelecCoarseGradientNullSpace_Private(PC pc, PetscSF sf, PetscInt nv, PetscInt nedges, const PetscInt edge_rows[], const PetscInt corners[], const PetscScalar edge_vals[], PetscBool has_const, PetscInt nvecs, const Vec vecs[])
271: {
272: PC_BDDC *pcbddc = (PC_BDDC *)pc->data;
273: PetscScalar *lvals;
274: PetscInt i, k, nnull = nvecs + (has_const ? 1 : 0);
276: PetscFunctionBegin;
277: PetscCall(PetscMalloc1(nv, &lvals));
278: for (k = 0; k < nnull; k++) {
279: PetscReal max_abs = 0.0, max_rel = 0.0;
281: if (has_const && !k)
282: for (i = 0; i < nv; i++) lvals[i] = 1.0;
283: else {
284: const PetscScalar *gvals;
285: PetscInt v = k - (has_const ? 1 : 0);
287: PetscCall(VecGetArrayRead(vecs[v], &gvals));
288: PetscCall(PetscSFBcastBegin(sf, MPIU_SCALAR, gvals, lvals, MPI_REPLACE));
289: PetscCall(PetscSFBcastEnd(sf, MPIU_SCALAR, gvals, lvals, MPI_REPLACE));
290: PetscCall(VecRestoreArrayRead(vecs[v], &gvals));
291: }
292: for (i = 0; i < nedges; i++) {
293: PetscScalar z0, z1;
294: PetscReal res, scale;
296: if (edge_rows[i] < 0) continue;
297: z0 = lvals[corners[2 * i]];
298: z1 = lvals[corners[2 * i + 1]];
299: res = PetscAbsScalar(edge_vals[2 * i] * z0 + edge_vals[2 * i + 1] * z1);
300: scale = PetscAbsScalar(edge_vals[2 * i] * z0) + PetscAbsScalar(edge_vals[2 * i + 1] * z1);
301: max_abs = PetscMax(max_abs, res);
302: max_rel = PetscMax(max_rel, res / PetscMax(scale, PETSC_SMALL));
303: }
304: if (has_const && !k) PetscCall(PetscViewerASCIISynchronizedPrintf(pcbddc->dbg_viewer, "Subdomain %04d coarse discrete gradient nullspace constant error: absolute %1.14e, relative %1.14e\n", PetscGlobalRank, (double)max_abs, (double)max_rel));
305: else
306: PetscCall(PetscViewerASCIISynchronizedPrintf(pcbddc->dbg_viewer, "Subdomain %04d coarse discrete gradient nullspace vector %" PetscInt_FMT " error: absolute %1.14e, relative %1.14e\n", PetscGlobalRank, k - (has_const ? 1 : 0), (double)max_abs, (double)max_rel));
307: }
308: PetscCall(PetscViewerFlush(pcbddc->dbg_viewer));
309: PetscCall(PetscFree(lvals));
310: PetscFunctionReturn(PETSC_SUCCESS);
311: }
313: static PetscErrorCode MatAIJExtractRows(Mat, IS, Mat *);
315: PetscErrorCode PCBDDCNedelecSupport(PC pc)
316: {
317: PC_BDDC *pcbddc = (PC_BDDC *)pc->data;
318: Mat_IS *matis = (Mat_IS *)pc->pmat->data;
319: Mat G, T, conn, lG, lGt, lGis, lGall, lGe, lGinit;
320: MatNullSpace nnsp;
321: VecScatter nnsp_vscat = NULL;
322: PetscSF sfv;
323: ISLocalToGlobalMapping el2g, vl2g, fl2g, al2g;
324: MPI_Comm comm;
325: IS lned, primals, allprimals, nedfieldlocal, elements_corners = NULL, nedclocal = NULL;
326: IS *eedges, *extrows, *extcols, *alleedges, *dofsfields = NULL, *odofsfields = NULL;
327: PetscBT btv, bte, btvc, btb, btbd, btvcand, btvi, btee, bter;
328: PetscScalar *vals, *work, *cedgevals = NULL;
329: PetscReal *rwork;
330: const PetscInt *idxs, *ii, *jj, *iit, *jjt;
331: const Vec *nnsp_vecs = NULL;
332: PetscInt ne, nv, Lv, order, n, field;
333: PetscInt i, j, extmem, cum, maxsize, nee;
334: PetscInt ondofsfields = 0, nnsp_nvecs = 0;
335: PetscInt *extrow, *extrowcum, *marks, *vmarks, *gidxs;
336: PetscInt *sfvleaves, *sfvroots;
337: PetscInt *corners, *cedges;
338: PetscInt *ecount, **eneighs, *vcount, **vneighs;
339: PetscInt *emarks;
340: PetscBool print, eerr, done, lrc[2], conforming, global, setprimal, nnsp_has_const = PETSC_FALSE;
342: PetscFunctionBegin;
343: /* If the discrete gradient is defined for a subset of dofs and global is true,
344: it assumes G is given in global ordering for all the dofs.
345: Otherwise, the ordering is global for the Nedelec field */
346: order = pcbddc->nedorder;
347: conforming = pcbddc->conforming;
348: field = pcbddc->nedfield;
349: global = pcbddc->nedglobal;
350: setprimal = PETSC_FALSE;
351: print = PETSC_FALSE;
353: /* Command line customization */
354: PetscOptionsBegin(PetscObjectComm((PetscObject)pc), ((PetscObject)pc)->prefix, "BDDC Nedelec options", "PC");
355: PetscCall(PetscOptionsBool("-pc_bddc_nedelec_field_primal", "All edge dofs set as primals: Toselli's algorithm C", NULL, setprimal, &setprimal, NULL));
356: /* print debug info and adaptive order TODO: to be removed */
357: PetscCall(PetscOptionsInt("-pc_bddc_nedelec_order", "Test variable order code (to be removed)", NULL, order, &order, NULL));
358: PetscCall(PetscOptionsBool("-pc_bddc_nedelec_print", "Print debug info", NULL, print, &print, NULL));
359: PetscOptionsEnd();
361: /* Return if there are no edges in the decomposition */
362: PetscCall(MatISGetLocalToGlobalMapping(pc->pmat, &al2g, NULL));
363: PetscCall(ISLocalToGlobalMappingGetSize(al2g, &n));
364: PetscCall(PetscObjectGetComm((PetscObject)pc, &comm));
365: PetscCall(VecGetArrayRead(matis->counter, (const PetscScalar **)&vals));
366: lrc[0] = PETSC_FALSE;
367: for (i = 0; i < n; i++) {
368: if (PetscRealPart(vals[i]) > 2.) {
369: lrc[0] = PETSC_TRUE;
370: break;
371: }
372: }
373: PetscCall(VecRestoreArrayRead(matis->counter, (const PetscScalar **)&vals));
374: lrc[1] = lrc[0];
375: PetscCallMPI(MPIU_Allreduce(MPI_IN_PLACE, &lrc[1], 1, MPI_C_BOOL, MPI_LOR, comm));
376: if (!lrc[1]) PetscFunctionReturn(PETSC_SUCCESS);
378: /* Share user vertices before expanding them to all dofs on the same mesh edge. */
379: if (pcbddc->user_primal_vertices_local && !pcbddc->user_primal_vertices) PetscCall(PCBDDCConsistencyCheckIS(pc, MPI_LOR, &pcbddc->user_primal_vertices_local));
381: /* Get Nedelec field */
382: PetscCheck(!pcbddc->n_ISForDofsLocal || field < pcbddc->n_ISForDofsLocal, comm, PETSC_ERR_USER, "Invalid field for Nedelec %" PetscInt_FMT ": number of fields is %" PetscInt_FMT, field, pcbddc->n_ISForDofsLocal);
383: if (pcbddc->n_ISForDofsLocal && field >= 0) {
384: PetscCall(PetscObjectReference((PetscObject)pcbddc->ISForDofsLocal[field]));
385: nedfieldlocal = pcbddc->ISForDofsLocal[field];
386: PetscCall(ISGetLocalSize(nedfieldlocal, &ne));
387: } else if (!pcbddc->n_ISForDofsLocal && field != PETSC_DECIDE) {
388: ne = n;
389: nedfieldlocal = NULL;
390: global = PETSC_TRUE;
391: } else if (field == PETSC_DECIDE) {
392: PetscInt rst, ren, *idx;
393: PetscBool congruent;
395: PetscCheck(global, comm, PETSC_ERR_ARG_INCOMP, "Automatic Nedelec field detection requires the discrete gradient in the global ordering for all dofs");
396: PetscCall(PetscLayoutCompare(pcbddc->discretegradient->rmap, pc->pmat->rmap, &congruent));
397: PetscCheck(congruent, comm, PETSC_ERR_ARG_INCOMP, "The discrete gradient and preconditioning matrix must have congruent row layouts for automatic Nedelec field detection");
398: PetscCall(PetscArrayzero(matis->sf_leafdata, n));
399: PetscCall(PetscArrayzero(matis->sf_rootdata, pc->pmat->rmap->n));
400: PetscCall(MatGetOwnershipRange(pcbddc->discretegradient, &rst, &ren));
401: for (i = rst; i < ren; i++) {
402: PetscInt nc;
404: PetscCall(MatGetRow(pcbddc->discretegradient, i, &nc, NULL, NULL));
405: if (nc > 1) matis->sf_rootdata[i - rst] = 1;
406: PetscCall(MatRestoreRow(pcbddc->discretegradient, i, &nc, NULL, NULL));
407: }
408: PetscCall(PetscSFBcastBegin(matis->sf, MPIU_INT, matis->sf_rootdata, matis->sf_leafdata, MPI_REPLACE));
409: PetscCall(PetscSFBcastEnd(matis->sf, MPIU_INT, matis->sf_rootdata, matis->sf_leafdata, MPI_REPLACE));
410: PetscCall(PetscMalloc1(n, &idx));
411: for (i = 0, ne = 0; i < n; i++)
412: if (matis->sf_leafdata[i]) idx[ne++] = i;
413: PetscCall(ISCreateGeneral(comm, ne, idx, PETSC_OWN_POINTER, &nedfieldlocal));
414: } else SETERRQ(comm, PETSC_ERR_USER, "The Nedelec field has to be specified when multiple fields are present");
416: /* Sanity checks */
417: PetscCheck(order || conforming, comm, PETSC_ERR_SUP, "Variable order and non-conforming spaces are not supported at the same time");
418: PetscCheck(!pcbddc->user_ChangeOfBasisMatrix, comm, PETSC_ERR_SUP, "Cannot generate Nedelec support with user defined change of basis");
419: PetscCheck(!order || (ne % order == 0), PETSC_COMM_SELF, PETSC_ERR_USER, "The number of local edge dofs %" PetscInt_FMT " is not a multiple of the order %" PetscInt_FMT, ne, order);
421: /* Just set primal dofs and return */
422: if (setprimal) {
423: IS enedfieldlocal;
424: PetscInt *eidxs;
426: PetscCall(PetscMalloc1(ne, &eidxs));
427: PetscCall(VecGetArrayRead(matis->counter, (const PetscScalar **)&vals));
428: if (nedfieldlocal) {
429: PetscCall(ISGetIndices(nedfieldlocal, &idxs));
430: for (i = 0, cum = 0; i < ne; i++) {
431: if (PetscRealPart(vals[idxs[i]]) > 2.) eidxs[cum++] = idxs[i];
432: }
433: PetscCall(ISRestoreIndices(nedfieldlocal, &idxs));
434: } else {
435: for (i = 0, cum = 0; i < ne; i++) {
436: if (PetscRealPart(vals[i]) > 2.) eidxs[cum++] = i;
437: }
438: }
439: PetscCall(VecRestoreArrayRead(matis->counter, (const PetscScalar **)&vals));
440: PetscCall(ISCreateGeneral(comm, cum, eidxs, PETSC_COPY_VALUES, &enedfieldlocal));
441: PetscCall(PCBDDCAddPrimalVerticesLocalIS(pc, enedfieldlocal));
442: PetscCall(PetscFree(eidxs));
443: PetscCall(ISDestroy(&nedfieldlocal));
444: PetscCall(ISDestroy(&enedfieldlocal));
445: PetscFunctionReturn(PETSC_SUCCESS);
446: }
448: /* Compute some l2g maps */
449: if (nedfieldlocal) {
450: IS is;
452: /* need to map from the local Nedelec field to local numbering */
453: PetscCall(ISLocalToGlobalMappingCreateIS(nedfieldlocal, &fl2g));
454: /* need to map from the local Nedelec field to global numbering for the whole dofs*/
455: PetscCall(ISLocalToGlobalMappingApplyIS(al2g, nedfieldlocal, &is));
456: PetscCall(ISLocalToGlobalMappingCreateIS(is, &al2g));
457: /* need to map from the local Nedelec field to global numbering (for Nedelec only) */
458: if (global) {
459: PetscCall(PetscObjectReference((PetscObject)al2g));
460: el2g = al2g;
461: } else {
462: IS gis;
464: PetscCall(ISRenumber(is, NULL, NULL, &gis));
465: PetscCall(ISLocalToGlobalMappingCreateIS(gis, &el2g));
466: PetscCall(ISDestroy(&gis));
467: }
468: PetscCall(ISDestroy(&is));
469: } else {
470: /* one ref for the destruction of al2g, one for el2g */
471: PetscCall(PetscObjectReference((PetscObject)al2g));
472: PetscCall(PetscObjectReference((PetscObject)al2g));
473: el2g = al2g;
474: fl2g = NULL;
475: }
477: /* Use the inferred field to keep the graph analysis separated from the complementary dofs */
478: if (field == PETSC_DECIDE) {
479: ondofsfields = pcbddc->n_ISForDofsLocal;
480: odofsfields = pcbddc->ISForDofsLocal;
481: PetscCall(PetscMalloc1(ondofsfields + 1, &dofsfields));
482: PetscCall(PetscArraycpy(dofsfields, odofsfields, ondofsfields));
483: dofsfields[ondofsfields] = nedfieldlocal;
484: pcbddc->n_ISForDofsLocal = ondofsfields + 1;
485: pcbddc->ISForDofsLocal = dofsfields;
486: }
488: /* Start communication to drop connections for interior edges (for cc analysis only) */
489: PetscCall(PetscArrayzero(matis->sf_leafdata, n));
490: PetscCall(PetscArrayzero(matis->sf_rootdata, pc->pmat->rmap->n));
491: if (nedfieldlocal) {
492: PetscCall(ISGetIndices(nedfieldlocal, &idxs));
493: for (i = 0; i < ne; i++) matis->sf_leafdata[idxs[i]] = 1;
494: PetscCall(ISRestoreIndices(nedfieldlocal, &idxs));
495: } else {
496: for (i = 0; i < ne; i++) matis->sf_leafdata[i] = 1;
497: }
498: PetscCall(PetscSFReduceBegin(matis->sf, MPIU_INT, matis->sf_leafdata, matis->sf_rootdata, MPI_SUM));
499: PetscCall(PetscSFReduceEnd(matis->sf, MPIU_INT, matis->sf_leafdata, matis->sf_rootdata, MPI_SUM));
501: /* There's no way to detect all possible corner candidates in a element-by-element case in a pure algebraic setting
502: Firedrake attaches a index set to identify them upfront. If it is present, we assume we are in such a case */
503: if (matis->allow_repeated) PetscCall(PetscObjectQuery((PetscObject)pcbddc->discretegradient, "_elements_corners", (PetscObject *)&elements_corners));
505: /* drop connections with interior edges to avoid unneeded communications and memory movements */
506: PetscCall(MatViewFromOptions(pcbddc->discretegradient, (PetscObject)pc, "-pc_bddc_discrete_gradient_view"));
507: PetscCall(MatDuplicate(pcbddc->discretegradient, MAT_COPY_VALUES, &G));
508: PetscCall(MatSetOption(G, MAT_KEEP_NONZERO_PATTERN, PETSC_FALSE));
509: if (global) {
510: PetscInt rst;
512: PetscCall(MatGetOwnershipRange(G, &rst, NULL));
513: for (i = 0, cum = 0; i < pc->pmat->rmap->n; i++) {
514: if (matis->sf_rootdata[i] < 2) matis->sf_rootdata[cum++] = i + rst;
515: }
516: PetscCall(MatSetOption(G, MAT_NO_OFF_PROC_ZERO_ROWS, PETSC_TRUE));
517: PetscCall(MatZeroRows(G, cum, matis->sf_rootdata, 0., NULL, NULL));
518: } else {
519: PetscInt *tbz;
521: PetscCall(PetscMalloc1(ne, &tbz));
522: PetscCall(PetscSFBcastBegin(matis->sf, MPIU_INT, matis->sf_rootdata, matis->sf_leafdata, MPI_REPLACE));
523: PetscCall(PetscSFBcastEnd(matis->sf, MPIU_INT, matis->sf_rootdata, matis->sf_leafdata, MPI_REPLACE));
524: PetscCall(ISGetIndices(nedfieldlocal, &idxs));
525: for (i = 0, cum = 0; i < ne; i++)
526: if (matis->sf_leafdata[idxs[i]] == 1) tbz[cum++] = i;
527: PetscCall(ISRestoreIndices(nedfieldlocal, &idxs));
528: PetscCall(ISLocalToGlobalMappingApply(el2g, cum, tbz, tbz));
529: PetscCall(MatZeroRows(G, cum, tbz, 0., NULL, NULL));
530: PetscCall(PetscFree(tbz));
531: }
533: /* Extract subdomain relevant rows of G */
534: PetscCall(ISLocalToGlobalMappingGetIndices(el2g, &idxs));
535: PetscCall(ISCreateGeneral(comm, ne, idxs, PETSC_USE_POINTER, &lned));
536: PetscCall(MatAIJExtractRows(G, lned, &lGall));
537: /* PetscCall(MatCreateSubMatrix(G, lned, NULL, MAT_INITIAL_MATRIX, &lGall)); */
538: PetscCall(ISLocalToGlobalMappingRestoreIndices(el2g, &idxs));
539: PetscCall(ISDestroy(&lned));
540: PetscCall(MatConvert(lGall, MATIS, MAT_INITIAL_MATRIX, &lGis));
541: PetscCall(MatDestroy(&lGall));
542: PetscCall(MatISGetLocalMat(lGis, &lG));
543: if (matis->allow_repeated) { /* multi-element support */
544: Mat *lGn, B;
545: IS *is_rows, *tcols, tmap, nmap;
546: PetscInt subnv;
547: const PetscInt *subvidxs;
548: ISLocalToGlobalMapping mapn;
550: PetscCall(PetscCalloc1(pcbddc->n_local_subs * pcbddc->n_local_subs, &lGn));
551: PetscCall(PetscMalloc1(pcbddc->n_local_subs, &is_rows));
552: PetscCall(PetscMalloc1(pcbddc->n_local_subs, &tcols));
553: for (PetscInt i = 0; i < pcbddc->n_local_subs; i++) {
554: if (fl2g) PetscCall(ISGlobalToLocalMappingApplyIS(fl2g, IS_GTOLM_DROP, pcbddc->local_subs[i], &is_rows[i]));
555: else {
556: PetscCall(PetscObjectReference((PetscObject)pcbddc->local_subs[i]));
557: is_rows[i] = pcbddc->local_subs[i];
558: }
559: PetscCall(MatCreateSubMatrix(lG, is_rows[i], NULL, MAT_INITIAL_MATRIX, &lGn[i * (1 + pcbddc->n_local_subs)]));
560: PetscCall(MatSeqAIJCompactOutExtraColumns_SeqAIJ(lGn[i * (1 + pcbddc->n_local_subs)], &mapn));
561: PetscCall(ISLocalToGlobalMappingGetSize(mapn, &subnv));
562: PetscCall(ISLocalToGlobalMappingGetIndices(mapn, &subvidxs));
563: PetscCall(ISCreateGeneral(PETSC_COMM_SELF, subnv, subvidxs, PETSC_COPY_VALUES, &tcols[i]));
564: PetscCall(ISLocalToGlobalMappingRestoreIndices(mapn, &subvidxs));
565: PetscCall(ISLocalToGlobalMappingDestroy(&mapn));
566: }
568: /* Create new MATIS with repeated vertices */
569: PetscCall(MatCreate(comm, &B));
570: PetscCall(MatSetSizes(B, lGis->rmap->n, lGis->cmap->n, lGis->rmap->N, lGis->cmap->N));
571: PetscCall(MatSetType(B, MATIS));
572: PetscCall(MatISSetAllowRepeated(B, PETSC_TRUE));
573: PetscCall(ISConcatenate(PETSC_COMM_SELF, pcbddc->n_local_subs, tcols, &tmap));
574: PetscCall(ISLocalToGlobalMappingApplyIS(lGis->cmap->mapping, tmap, &nmap));
575: PetscCall(ISDestroy(&tmap));
576: PetscCall(ISGetLocalSize(nmap, &subnv));
577: PetscCall(ISGetIndices(nmap, &subvidxs));
578: PetscCall(ISCreateGeneral(comm, subnv, subvidxs, PETSC_USE_POINTER, &tmap));
579: PetscCall(ISRestoreIndices(nmap, &subvidxs));
580: PetscCall(ISLocalToGlobalMappingCreateIS(tmap, &mapn));
581: PetscCall(ISDestroy(&tmap));
582: PetscCall(ISDestroy(&nmap));
583: PetscCall(MatSetLocalToGlobalMapping(B, lGis->rmap->mapping, mapn));
584: PetscCall(ISLocalToGlobalMappingDestroy(&mapn));
585: PetscCall(MatCreateNest(PETSC_COMM_SELF, pcbddc->n_local_subs, is_rows, pcbddc->n_local_subs, NULL, lGn, &lG));
586: for (PetscInt i = 0; i < pcbddc->n_local_subs; i++) {
587: PetscCall(MatDestroy(&lGn[i * (1 + pcbddc->n_local_subs)]));
588: PetscCall(ISDestroy(&is_rows[i]));
589: PetscCall(ISDestroy(&tcols[i]));
590: }
591: PetscCall(MatConvert(lG, MATSEQAIJ, MAT_INPLACE_MATRIX, &lG));
592: PetscCall(PetscFree(lGn));
593: PetscCall(PetscFree(is_rows));
594: PetscCall(PetscFree(tcols));
595: PetscCall(MatISSetLocalMat(B, lG));
596: PetscCall(MatDestroy(&lG));
598: PetscCall(MatDestroy(&lGis));
599: lGis = B;
601: lGis->assembled = PETSC_TRUE;
602: }
603: PetscCall(MatViewFromOptions(lGis, (PetscObject)pc, "-pc_bddc_nedelec_init_G_view"));
605: /* SF for nodal dofs communications */
606: PetscCall(MatGetLocalSize(G, NULL, &Lv));
607: PetscCall(MatISGetLocalToGlobalMapping(lGis, NULL, &vl2g));
608: PetscCall(PetscObjectReference((PetscObject)vl2g));
609: PetscCall(ISLocalToGlobalMappingGetSize(vl2g, &nv));
610: PetscCall(PetscSFCreate(comm, &sfv));
611: PetscCall(ISLocalToGlobalMappingGetIndices(vl2g, &idxs));
612: PetscCall(PetscSFSetGraphLayout(sfv, lGis->cmap, nv, NULL, PETSC_OWN_POINTER, idxs));
613: PetscCall(ISLocalToGlobalMappingRestoreIndices(vl2g, &idxs));
615: if (elements_corners) {
616: IS tmp;
617: Vec global, local;
618: Mat_IS *tGis = (Mat_IS *)lGis->data;
620: PetscCall(MatCreateVecs(lGis, &global, NULL));
621: PetscCall(MatCreateVecs(tGis->A, &local, NULL));
622: PetscCall(PCBDDCGlobalToLocal(tGis->cctx, global, local, elements_corners, &tmp));
623: PetscCall(VecDestroy(&global));
624: PetscCall(VecDestroy(&local));
625: elements_corners = tmp;
626: }
628: /* Destroy temporary G */
629: PetscCall(MatISGetLocalMat(lGis, &lG));
630: PetscCall(PetscObjectReference((PetscObject)lG));
631: PetscCall(MatDestroy(&G));
632: PetscCall(MatDestroy(&lGis));
634: if (print) {
635: PetscCall(PetscObjectSetName((PetscObject)lG, "initial_lG"));
636: PetscCall(MatView(lG, NULL));
637: }
639: /* Save lG for values insertion in change of basis */
640: PetscCall(MatDuplicate(lG, MAT_COPY_VALUES, &lGinit));
642: /* Analyze the edge-nodes connections (duplicate lG) */
643: PetscCall(MatDuplicate(lG, MAT_COPY_VALUES, &lGe));
644: PetscCall(MatSetOption(lGe, MAT_KEEP_NONZERO_PATTERN, PETSC_FALSE));
645: PetscCall(PetscBTCreate(nv, &btv));
646: PetscCall(PetscBTCreate(ne, &bte));
647: PetscCall(PetscBTCreate(ne, &btb));
648: PetscCall(PetscBTCreate(ne, &btbd));
649: /* need to import the boundary specification to ensure the
650: proper detection of coarse edges' endpoints */
651: if (pcbddc->DirichletBoundariesLocal) {
652: IS is;
654: if (fl2g) PetscCall(ISGlobalToLocalMappingApplyIS(fl2g, IS_GTOLM_MASK, pcbddc->DirichletBoundariesLocal, &is));
655: else is = pcbddc->DirichletBoundariesLocal;
656: PetscCall(ISGetLocalSize(is, &cum));
657: PetscCall(ISGetIndices(is, &idxs));
658: for (i = 0; i < cum; i++) {
659: if (idxs[i] >= 0 && idxs[i] < ne) {
660: PetscCall(PetscBTSet(btb, idxs[i]));
661: PetscCall(PetscBTSet(btbd, idxs[i]));
662: }
663: }
664: PetscCall(ISRestoreIndices(is, &idxs));
665: if (fl2g) PetscCall(ISDestroy(&is));
666: }
667: if (pcbddc->NeumannBoundariesLocal) {
668: IS is;
670: if (fl2g) PetscCall(ISGlobalToLocalMappingApplyIS(fl2g, IS_GTOLM_MASK, pcbddc->NeumannBoundariesLocal, &is));
671: else is = pcbddc->NeumannBoundariesLocal;
672: PetscCall(ISGetLocalSize(is, &cum));
673: PetscCall(ISGetIndices(is, &idxs));
674: for (i = 0; i < cum; i++) {
675: if (idxs[i] >= 0 && idxs[i] < ne) PetscCall(PetscBTSet(btb, idxs[i]));
676: }
677: PetscCall(ISRestoreIndices(is, &idxs));
678: if (fl2g) PetscCall(ISDestroy(&is));
679: }
681: /* Count neighs per dof */
682: PetscCall(ISLocalToGlobalMappingGetNodeInfo(el2g, NULL, &ecount, NULL));
683: PetscCall(ISLocalToGlobalMappingGetNodeInfo(vl2g, NULL, &vcount, NULL));
685: /* need to remove coarse faces' dofs and coarse edges' dirichlet dofs
686: for proper detection of coarse edges' endpoints */
687: PetscCall(PetscBTCreate(ne, &btee));
688: for (i = 0; i < ne; i++) {
689: if ((ecount[i] > 2 && !PetscBTLookup(btbd, i)) || (ecount[i] == 2 && PetscBTLookup(btb, i))) PetscCall(PetscBTSet(btee, i));
690: }
691: PetscCall(PetscMalloc1(ne, &marks));
692: if (!conforming || pcbddc->user_primal_vertices_local) {
693: PetscCall(MatTranspose(lGe, MAT_INITIAL_MATRIX, &lGt));
694: PetscCall(MatGetRowIJ(lGt, 0, PETSC_FALSE, PETSC_FALSE, &i, &iit, &jjt, &done));
695: }
696: PetscCall(MatGetRowIJ(lGe, 0, PETSC_FALSE, PETSC_FALSE, &i, &ii, &jj, &done));
697: /* handle user defined primal dofs */
698: if (pcbddc->user_primal_vertices_local) {
699: IS is;
700: PetscInt np;
701: PetscInt *tmarks;
703: if (fl2g) PetscCall(ISGlobalToLocalMappingApplyIS(fl2g, IS_GTOLM_DROP, pcbddc->user_primal_vertices_local, &is));
704: else {
705: is = pcbddc->user_primal_vertices_local;
706: PetscCall(PetscObjectReference((PetscObject)is));
707: }
708: PetscCall(PetscCalloc1(ne, &tmarks));
709: PetscCall(ISGetLocalSize(is, &np));
710: PetscCall(ISGetIndices(is, &idxs));
711: /* dofs on the same mesh edge share more than one nodal dof. */
712: for (i = 0; i < np; i++) {
713: PetscInt e = idxs[i];
715: if (e < 0 || e >= ne || PetscBTLookup(bte, e)) continue;
716: PetscCall(PetscBTSet(bte, e));
717: for (j = ii[e]; j < ii[e + 1]; j++) {
718: PetscInt v = jj[j];
720: for (PetscInt k = iit[v]; k < iit[v + 1]; k++)
721: if (++tmarks[jjt[k]] == 2) PetscCall(PetscBTSet(bte, jjt[k]));
722: }
723: for (j = ii[e]; j < ii[e + 1]; j++) {
724: PetscInt v = jj[j];
726: for (PetscInt k = iit[v]; k < iit[v + 1]; k++) tmarks[jjt[k]] = 0;
727: }
728: }
729: PetscCall(ISRestoreIndices(is, &idxs));
730: PetscCall(ISDestroy(&is));
731: PetscCall(PetscFree(tmarks));
732: }
733: PetscCall(MatSeqAIJGetArray(lGe, &vals));
734: cum = 0;
735: for (i = 0; i < ne; i++) {
736: /* remove complete primal mesh edges before identifying corners and splitpoints. */
737: if (PetscBTLookup(bte, i)) {
738: marks[cum++] = i;
739: for (j = ii[i]; j < ii[i + 1]; j++) PetscCall(PetscBTSet(btv, jj[j]));
740: continue;
741: }
742: /* eliminate rows corresponding to edge dofs belonging to coarse faces */
743: if (!PetscBTLookup(btee, i)) {
744: marks[cum++] = i;
745: continue;
746: }
747: /* set badly connected edge dofs as primal */
748: if (!conforming) {
749: if (ii[i + 1] - ii[i] != order + 1) { /* every row of G on the coarse edge should list order+1 nodal dofs */
750: marks[cum++] = i;
751: PetscCall(PetscBTSet(bte, i));
752: for (j = ii[i]; j < ii[i + 1]; j++) PetscCall(PetscBTSet(btv, jj[j]));
753: } else {
754: /* every edge dofs should be connected through a certain number of nodal dofs
755: to other edge dofs belonging to coarse edges
756: - at most 2 endpoints
757: - order-1 interior nodal dofs
758: - no undefined nodal dofs (nconn < order)
759: */
760: PetscInt ends = 0, ints = 0, undef = 0;
761: for (j = ii[i]; j < ii[i + 1]; j++) {
762: PetscInt v = jj[j], k;
763: PetscInt nconn = iit[v + 1] - iit[v];
764: for (k = iit[v]; k < iit[v + 1]; k++)
765: if (!PetscBTLookup(btee, jjt[k])) nconn--;
766: if (nconn > order) ends++;
767: else if (nconn == order) ints++;
768: else undef++;
769: }
770: if (undef || ends > 2 || ints != order - 1) {
771: marks[cum++] = i;
772: PetscCall(PetscBTSet(bte, i));
773: for (j = ii[i]; j < ii[i + 1]; j++) PetscCall(PetscBTSet(btv, jj[j]));
774: }
775: }
776: }
777: /* We assume the order on the element edge is ii[i+1]-ii[i]-1 */
778: if (!order && ii[i + 1] != ii[i]) {
779: PetscScalar val = 1. / (ii[i + 1] - ii[i] - 1);
780: for (j = ii[i]; j < ii[i + 1]; j++) vals[j] = val;
781: }
782: }
783: PetscCall(PetscBTDestroy(&btee));
784: PetscCall(MatSeqAIJRestoreArray(lGe, &vals));
785: PetscCall(MatRestoreRowIJ(lGe, 0, PETSC_FALSE, PETSC_FALSE, &i, &ii, &jj, &done));
786: if (!conforming || pcbddc->user_primal_vertices_local) {
787: PetscCall(MatRestoreRowIJ(lGt, 0, PETSC_FALSE, PETSC_FALSE, &i, &iit, &jjt, &done));
788: PetscCall(MatDestroy(&lGt));
789: }
790: PetscCall(MatZeroRows(lGe, cum, marks, 0., NULL, NULL));
792: /* identify splitpoints and corner candidates */
793: PetscCall(PetscMalloc2(nv, &sfvleaves, Lv, &sfvroots));
794: PetscCall(PetscBTCreate(nv, &btvcand));
795: if (elements_corners) {
796: PetscCall(ISGetLocalSize(elements_corners, &cum));
797: PetscCall(ISGetIndices(elements_corners, &idxs));
798: for (i = 0; i < cum; i++) PetscCall(PetscBTSet(btvcand, idxs[i]));
799: PetscCall(ISRestoreIndices(elements_corners, &idxs));
800: }
802: if (matis->allow_repeated) { /* assign a uniq global id to edge local subsets and communicate it with nodal space */
803: PetscSF emlsf, vmlsf;
804: PetscInt *eleaves, *vleaves, *meleaves, *mvleaves;
805: PetscInt cum_subs = 0, n_subs = pcbddc->n_local_subs, bs, emnr, emnl, vmnr, vmnl;
807: PetscCall(ISLocalToGlobalMappingGetBlockSize(el2g, &bs));
808: PetscCheck(bs == 1, comm, PETSC_ERR_SUP, "Not coded");
809: PetscCall(ISLocalToGlobalMappingGetBlockSize(vl2g, &bs));
810: PetscCheck(bs == 1, comm, PETSC_ERR_SUP, "Not coded");
812: PetscCall(ISLocalToGlobalMappingGetBlockMultiLeavesSF(el2g, &emlsf));
813: PetscCall(ISLocalToGlobalMappingGetBlockMultiLeavesSF(vl2g, &vmlsf));
815: PetscCall(PetscSFGetGraph(emlsf, &emnr, &emnl, NULL, NULL));
816: for (i = 0, j = 0; i < ne; i++) j += ecount[i];
817: PetscCheck(emnr == ne, PETSC_COMM_SELF, PETSC_ERR_PLIB, "Invalid number of roots in edge multi-leaves SF %" PetscInt_FMT " != %" PetscInt_FMT, emnr, ne);
818: PetscCheck(emnl == j, PETSC_COMM_SELF, PETSC_ERR_PLIB, "Invalid number of leaves in edge multi-leaves SF %" PetscInt_FMT " != %" PetscInt_FMT, emnl, j);
820: PetscCall(PetscSFGetGraph(vmlsf, &vmnr, &vmnl, NULL, NULL));
821: for (i = 0, j = 0; i < nv; i++) j += vcount[i];
822: PetscCheck(vmnr == nv, PETSC_COMM_SELF, PETSC_ERR_PLIB, "Invalid number of roots in nodal multi-leaves SF %" PetscInt_FMT " != %" PetscInt_FMT, vmnr, nv);
823: PetscCheck(vmnl == j, PETSC_COMM_SELF, PETSC_ERR_PLIB, "Invalid number of leaves in nodal multi-leaves SF %" PetscInt_FMT " != %" PetscInt_FMT, vmnl, j);
825: PetscCall(PetscMalloc1(ne, &eleaves));
826: PetscCall(PetscMalloc1(nv, &vleaves));
827: for (i = 0; i < ne; i++) eleaves[i] = PETSC_INT_MAX;
828: for (i = 0; i < nv; i++) vleaves[i] = PETSC_INT_MAX;
829: PetscCall(PetscMalloc1(emnl, &meleaves));
830: PetscCall(PetscMalloc1(vmnl, &mvleaves));
832: PetscCallMPI(MPI_Exscan(&n_subs, &cum_subs, 1, MPIU_INT, MPI_SUM, comm));
833: PetscCall(MatGetRowIJ(lGinit, 0, PETSC_FALSE, PETSC_FALSE, &i, &ii, &jj, &done));
834: for (i = 0; i < n_subs; i++) {
835: IS sub;
836: const PetscInt *idxs;
837: const PetscInt subid = cum_subs + i;
838: PetscInt ns;
840: if (fl2g) PetscCall(ISGlobalToLocalMappingApplyIS(fl2g, IS_GTOLM_DROP, pcbddc->local_subs[i], &sub));
841: else {
842: PetscCall(PetscObjectReference((PetscObject)pcbddc->local_subs[i]));
843: sub = pcbddc->local_subs[i];
844: }
845: PetscCall(ISGetLocalSize(sub, &ns));
846: PetscCall(ISGetIndices(sub, &idxs));
847: for (j = 0; j < ns; j++) {
848: const PetscInt e = idxs[j];
850: eleaves[e] = subid;
851: for (PetscInt k = ii[e]; k < ii[e + 1]; k++) vleaves[jj[k]] = subid;
852: }
853: PetscCall(ISRestoreIndices(sub, &idxs));
854: PetscCall(ISDestroy(&sub));
855: }
856: PetscCall(MatRestoreRowIJ(lGinit, 0, PETSC_FALSE, PETSC_FALSE, &i, &ii, &jj, &done));
857: PetscCall(PetscSFBcastBegin(emlsf, MPIU_INT, eleaves, meleaves, MPI_REPLACE));
858: PetscCall(PetscSFBcastEnd(emlsf, MPIU_INT, eleaves, meleaves, MPI_REPLACE));
859: PetscCall(PetscSFBcastBegin(vmlsf, MPIU_INT, vleaves, mvleaves, MPI_REPLACE));
860: PetscCall(PetscSFBcastEnd(vmlsf, MPIU_INT, vleaves, mvleaves, MPI_REPLACE));
861: PetscCall(PetscFree(eleaves));
862: PetscCall(PetscFree(vleaves));
864: PetscCall(PetscMalloc1(ne + 1, &eneighs));
865: eneighs[0] = meleaves;
866: for (i = 0; i < ne; i++) {
867: PetscCall(PetscSortInt(ecount[i], eneighs[i]));
868: eneighs[i + 1] = eneighs[i] + ecount[i];
869: }
870: PetscCall(PetscMalloc1(nv + 1, &vneighs));
871: vneighs[0] = mvleaves;
872: for (i = 0; i < nv; i++) {
873: PetscCall(PetscSortInt(vcount[i], vneighs[i]));
874: vneighs[i + 1] = vneighs[i] + vcount[i];
875: }
876: } else {
877: PetscCall(ISLocalToGlobalMappingGetNodeInfo(el2g, NULL, NULL, &eneighs));
878: PetscCall(ISLocalToGlobalMappingGetNodeInfo(vl2g, NULL, NULL, &vneighs));
879: }
881: PetscCall(MatTranspose(lGe, MAT_INITIAL_MATRIX, &lGt));
882: if (print) {
883: PetscCall(PetscObjectSetName((PetscObject)lGe, "edgerestr_lG"));
884: PetscCall(MatView(lGe, NULL));
885: PetscCall(PetscObjectSetName((PetscObject)lGt, "edgerestr_lGt"));
886: PetscCall(MatView(lGt, NULL));
887: }
888: PetscCall(MatGetRowIJ(lGt, 0, PETSC_FALSE, PETSC_FALSE, &i, &ii, &jj, &done));
889: PetscCall(MatSeqAIJGetArray(lGt, &vals));
890: for (i = 0; i < nv; i++) {
891: PetscInt ord = order, test = ii[i + 1] - ii[i], vc = vcount[i];
892: PetscBool sneighs = PETSC_TRUE, bdir = PETSC_FALSE;
893: if (!order) { /* variable order */
894: PetscReal vorder = 0.;
896: for (j = ii[i]; j < ii[i + 1]; j++) vorder += PetscRealPart(vals[j]);
897: test = PetscFloorReal(vorder + 10. * PETSC_SQRT_MACHINE_EPSILON);
898: PetscCheck(vorder - test <= PETSC_SQRT_MACHINE_EPSILON, PETSC_COMM_SELF, PETSC_ERR_PLIB, "Unexpected value for vorder: %g (%" PetscInt_FMT ")", (double)vorder, test);
899: ord = 1;
900: }
901: for (j = ii[i]; j < ii[i + 1] && sneighs; j++) {
902: const PetscInt e = jj[j];
904: if (PetscBTLookup(btbd, e)) {
905: bdir = PETSC_TRUE;
906: break;
907: }
908: if (vc != ecount[e]) {
909: sneighs = PETSC_FALSE;
910: } else {
911: const PetscInt *vn = vneighs[i], *en = eneighs[e];
913: for (PetscInt k = 0; k < vc; k++) {
914: if (vn[k] != en[k]) {
915: sneighs = PETSC_FALSE;
916: break;
917: }
918: }
919: }
920: }
921: if (elements_corners) test = 0;
922: if (!sneighs || test >= 3 * ord || bdir) { /* splitpoints */
923: if (print) PetscCall(PetscPrintf(PETSC_COMM_SELF, "SPLITPOINT %" PetscInt_FMT " (%s %s %s)\n", i, PetscBools[!sneighs], PetscBools[test >= 3 * ord], PetscBools[bdir]));
924: PetscCall(PetscBTSet(btv, i));
925: } else if (test == ord) {
926: if (order == 1 || (!order && ii[i + 1] - ii[i] == 1)) {
927: if (print) PetscCall(PetscPrintf(PETSC_COMM_SELF, "ENDPOINT %" PetscInt_FMT "\n", i));
928: PetscCall(PetscBTSet(btv, i));
929: } else if (!elements_corners) {
930: if (print) PetscCall(PetscPrintf(PETSC_COMM_SELF, "CORNER CANDIDATE %" PetscInt_FMT "\n", i));
931: PetscCall(PetscBTSet(btvcand, i));
932: }
933: }
934: }
935: PetscCall(PetscBTDestroy(&btbd));
937: /* a candidate is valid if it is connected to another candidate via a non-primal edge dof */
938: if (order != 1) {
939: if (print) PetscCall(PetscPrintf(PETSC_COMM_SELF, "INSPECTING CANDIDATES\n"));
940: PetscCall(MatGetRowIJ(lGe, 0, PETSC_FALSE, PETSC_FALSE, &i, &iit, &jjt, &done));
941: for (i = 0; i < nv; i++) {
942: if (PetscBTLookup(btvcand, i)) {
943: PetscBool found = PETSC_FALSE;
944: for (j = ii[i]; j < ii[i + 1] && !found; j++) {
945: PetscInt k, e = jj[j];
946: if (PetscBTLookup(bte, e)) continue;
947: for (k = iit[e]; k < iit[e + 1]; k++) {
948: PetscInt v = jjt[k];
949: if (v != i && PetscBTLookup(btvcand, v)) {
950: found = PETSC_TRUE;
951: break;
952: }
953: }
954: }
955: if (!found) {
956: if (print) PetscCall(PetscPrintf(PETSC_COMM_SELF, " CANDIDATE %" PetscInt_FMT " CLEARED\n", i));
957: PetscCall(PetscBTClear(btvcand, i));
958: } else {
959: if (print) PetscCall(PetscPrintf(PETSC_COMM_SELF, " CANDIDATE %" PetscInt_FMT " ACCEPTED\n", i));
960: }
961: }
962: }
963: PetscCall(MatRestoreRowIJ(lGe, 0, PETSC_FALSE, PETSC_FALSE, &i, &iit, &jjt, &done));
964: }
965: PetscCall(MatSeqAIJRestoreArray(lGt, &vals));
966: PetscCall(MatRestoreRowIJ(lGt, 0, PETSC_FALSE, PETSC_FALSE, &i, &ii, &jj, &done));
967: PetscCall(MatDestroy(&lGe));
969: /* Get the local G^T explicitly */
970: PetscCall(MatDestroy(&lGt));
971: PetscCall(MatTranspose(lG, MAT_INITIAL_MATRIX, &lGt));
972: PetscCall(MatSetOption(lGt, MAT_KEEP_NONZERO_PATTERN, PETSC_FALSE));
974: /* Mark shared nodal dofs */
975: PetscCall(PetscBTCreate(nv, &btvi));
976: for (i = 0; i < nv; i++) {
977: if (vcount[i] > 1) PetscCall(PetscBTSet(btvi, i));
978: }
980: if (matis->allow_repeated) {
981: PetscCall(PetscFree(eneighs[0]));
982: PetscCall(PetscFree(vneighs[0]));
983: PetscCall(PetscFree(eneighs));
984: PetscCall(PetscFree(vneighs));
985: }
986: PetscCall(ISLocalToGlobalMappingRestoreNodeInfo(el2g, NULL, &ecount, &eneighs));
987: PetscCall(ISLocalToGlobalMappingRestoreNodeInfo(vl2g, NULL, &vcount, &vneighs));
989: /* communicate corners and splitpoints */
990: PetscCall(PetscMalloc1(nv, &vmarks));
991: PetscCall(PetscArrayzero(sfvleaves, nv));
992: PetscCall(PetscArrayzero(sfvroots, Lv));
993: for (i = 0; i < nv; i++)
994: if (PetscUnlikely(PetscBTLookup(btv, i))) sfvleaves[i] = 1;
996: if (print) {
997: IS tbz;
999: cum = 0;
1000: for (i = 0; i < nv; i++)
1001: if (sfvleaves[i]) vmarks[cum++] = i;
1003: PetscCall(ISCreateGeneral(PETSC_COMM_SELF, cum, vmarks, PETSC_COPY_VALUES, &tbz));
1004: PetscCall(PetscObjectSetName((PetscObject)tbz, "corners_to_be_zeroed_local"));
1005: PetscCall(ISView(tbz, NULL));
1006: PetscCall(ISDestroy(&tbz));
1007: }
1009: PetscCall(PetscSFReduceBegin(sfv, MPIU_INT, sfvleaves, sfvroots, MPI_SUM));
1010: PetscCall(PetscSFReduceEnd(sfv, MPIU_INT, sfvleaves, sfvroots, MPI_SUM));
1011: PetscCall(PetscSFBcastBegin(sfv, MPIU_INT, sfvroots, sfvleaves, MPI_REPLACE));
1012: PetscCall(PetscSFBcastEnd(sfv, MPIU_INT, sfvroots, sfvleaves, MPI_REPLACE));
1014: /* Zero rows of lGt corresponding to identified corners
1015: and interior nodal dofs */
1016: cum = 0;
1017: for (i = 0; i < nv; i++) {
1018: if (sfvleaves[i]) {
1019: vmarks[cum++] = i;
1020: PetscCall(PetscBTSet(btv, i));
1021: } else if (!PetscBTLookup(btvi, i)) vmarks[cum++] = i;
1022: }
1023: PetscCall(PetscBTDestroy(&btvi));
1024: if (print) {
1025: IS tbz;
1027: PetscCall(ISCreateGeneral(PETSC_COMM_SELF, cum, vmarks, PETSC_COPY_VALUES, &tbz));
1028: PetscCall(PetscObjectSetName((PetscObject)tbz, "corners_to_be_zeroed_with_interior"));
1029: PetscCall(ISView(tbz, NULL));
1030: PetscCall(ISDestroy(&tbz));
1031: }
1032: PetscCall(MatZeroRows(lGt, cum, vmarks, 0., NULL, NULL));
1033: PetscCall(PetscFree(vmarks));
1034: PetscCall(PetscFree2(sfvleaves, sfvroots));
1036: /* Recompute G */
1037: PetscCall(MatDestroy(&lG));
1038: PetscCall(MatTranspose(lGt, MAT_INITIAL_MATRIX, &lG));
1039: if (print) {
1040: PetscCall(PetscObjectSetName((PetscObject)lG, "used_lG"));
1041: PetscCall(MatView(lG, NULL));
1042: PetscCall(PetscObjectSetName((PetscObject)lGt, "used_lGt"));
1043: PetscCall(MatView(lGt, NULL));
1044: }
1046: /* Get primal dofs (if any) */
1047: cum = 0;
1048: for (i = 0; i < ne; i++) {
1049: if (PetscUnlikely(PetscBTLookup(bte, i))) marks[cum++] = i;
1050: }
1051: if (fl2g) PetscCall(ISLocalToGlobalMappingApply(fl2g, cum, marks, marks));
1052: PetscCall(ISCreateGeneral(comm, cum, marks, PETSC_COPY_VALUES, &primals));
1053: if (print) {
1054: PetscCall(PetscObjectSetName((PetscObject)primals, "prescribed_primal_dofs"));
1055: PetscCall(ISView(primals, NULL));
1056: }
1057: PetscCall(PetscBTDestroy(&bte));
1058: PetscCall(PCBDDCAddPrimalVerticesLocalIS(pc, primals));
1059: PetscCall(ISDestroy(&primals));
1061: /* Compute edge connectivity */
1062: PetscCall(PetscObjectSetOptionsPrefix((PetscObject)lG, "econn_"));
1064: /* Symbolic conn = lG*lGt */
1065: if (!elements_corners) { /* if present, we assume we are in the element-by-element case and the CSR graph is not needed */
1066: PetscCall(MatProductCreate(lG, lGt, NULL, &conn));
1067: PetscCall(MatSetOption(conn, MAT_STRUCTURE_ONLY, PETSC_TRUE));
1068: PetscCall(MatProductSetType(conn, MATPRODUCT_AB));
1069: PetscCall(MatProductSetAlgorithm(conn, "default"));
1070: PetscCall(MatProductSetFill(conn, PETSC_DEFAULT));
1071: PetscCall(PetscObjectSetOptionsPrefix((PetscObject)conn, "econn_"));
1072: PetscCall(MatProductSetFromOptions(conn));
1073: PetscCall(MatProductSymbolic(conn));
1074: PetscCall(MatGetRowIJ(conn, 0, PETSC_FALSE, PETSC_FALSE, &i, &ii, &jj, &done));
1075: if (fl2g) {
1076: PetscBT btf;
1077: PetscInt *iia, *jja, *iiu, *jju;
1078: PetscBool rest = PETSC_FALSE, free = PETSC_FALSE;
1080: /* create CSR for all local dofs */
1081: PetscCall(PetscMalloc1(n + 1, &iia));
1082: if (pcbddc->mat_graph->nvtxs_csr) { /* the user has passed in a CSR graph */
1083: PetscCheck(pcbddc->mat_graph->nvtxs_csr == n, PETSC_COMM_SELF, PETSC_ERR_USER, "Invalid size of CSR graph %" PetscInt_FMT ". Should be %" PetscInt_FMT, pcbddc->mat_graph->nvtxs_csr, n);
1084: iiu = pcbddc->mat_graph->xadj;
1085: jju = pcbddc->mat_graph->adjncy;
1086: } else if (pcbddc->use_local_adj) {
1087: rest = PETSC_TRUE;
1088: PetscCall(MatGetRowIJ(matis->A, 0, PETSC_TRUE, PETSC_FALSE, &i, (const PetscInt **)&iiu, (const PetscInt **)&jju, &done));
1089: } else {
1090: free = PETSC_TRUE;
1091: PetscCall(PetscMalloc2(n + 1, &iiu, n, &jju));
1092: iiu[0] = 0;
1093: for (i = 0; i < n; i++) {
1094: iiu[i + 1] = i + 1;
1095: jju[i] = -1;
1096: }
1097: }
1099: /* import sizes of CSR */
1100: iia[0] = 0;
1101: for (i = 0; i < n; i++) iia[i + 1] = iiu[i + 1] - iiu[i];
1103: /* overwrite entries corresponding to the Nedelec field */
1104: PetscCall(PetscBTCreate(n, &btf));
1105: PetscCall(ISGetIndices(nedfieldlocal, &idxs));
1106: for (i = 0; i < ne; i++) {
1107: PetscCall(PetscBTSet(btf, idxs[i]));
1108: iia[idxs[i] + 1] = ii[i + 1] - ii[i];
1109: }
1111: /* iia in CSR */
1112: for (i = 0; i < n; i++) iia[i + 1] += iia[i];
1114: /* jja in CSR */
1115: PetscCall(PetscMalloc1(iia[n], &jja));
1116: for (i = 0; i < n; i++)
1117: if (!PetscBTLookup(btf, i))
1118: for (j = 0; j < iiu[i + 1] - iiu[i]; j++) jja[iia[i] + j] = jju[iiu[i] + j];
1120: /* map edge dofs connectivity */
1121: if (jj) {
1122: PetscCall(ISLocalToGlobalMappingApply(fl2g, ii[ne], jj, (PetscInt *)jj));
1123: for (i = 0; i < ne; i++) {
1124: PetscInt e = idxs[i];
1125: for (j = 0; j < ii[i + 1] - ii[i]; j++) jja[iia[e] + j] = jj[ii[i] + j];
1126: }
1127: }
1128: PetscCall(ISRestoreIndices(nedfieldlocal, &idxs));
1129: PetscCall(PCBDDCSetLocalAdjacencyGraph(pc, n, iia, jja, PETSC_OWN_POINTER));
1130: if (rest) PetscCall(MatRestoreRowIJ(matis->A, 0, PETSC_TRUE, PETSC_FALSE, &i, (const PetscInt **)&iiu, (const PetscInt **)&jju, &done));
1131: if (free) PetscCall(PetscFree2(iiu, jju));
1132: PetscCall(PetscBTDestroy(&btf));
1133: } else {
1134: PetscCall(PCBDDCSetLocalAdjacencyGraph(pc, n, ii, jj, PETSC_COPY_VALUES));
1135: }
1136: PetscCall(MatRestoreRowIJ(conn, 0, PETSC_FALSE, PETSC_FALSE, &i, &ii, &jj, &done));
1137: PetscCall(MatDestroy(&conn));
1138: }
1140: /* Analyze interface for edge dofs */
1141: PetscCall(PCBDDCAnalyzeInterface(pc));
1142: pcbddc->mat_graph->twodim = PETSC_FALSE;
1144: /* Get coarse edges in the edge space */
1145: PetscCall(PCBDDCGraphGetCandidatesIS(pcbddc->mat_graph, NULL, NULL, &nee, &alleedges, &allprimals));
1147: if (fl2g) {
1148: PetscCall(ISGlobalToLocalMappingApplyIS(fl2g, IS_GTOLM_DROP, allprimals, &primals));
1149: PetscCall(PetscMalloc1(nee, &eedges));
1150: for (i = 0; i < nee; i++) {
1151: PetscInt an, ln;
1153: PetscCall(ISGlobalToLocalMappingApplyIS(fl2g, IS_GTOLM_DROP, alleedges[i], &eedges[i]));
1154: PetscCall(ISGetLocalSize(alleedges[i], &an));
1155: PetscCall(ISGetLocalSize(eedges[i], &ln));
1156: PetscCheck(an == ln || ln == 0, PETSC_COMM_SELF, PETSC_ERR_PLIB, "Unexpected size edge %" PetscInt_FMT ": %" PetscInt_FMT " != %" PetscInt_FMT, i, an, ln);
1157: }
1158: } else {
1159: eedges = alleedges;
1160: primals = allprimals;
1161: }
1163: /* Mark fine edge dofs with their coarse edge id */
1164: PetscCall(PetscArrayzero(marks, ne));
1165: PetscCall(ISGetLocalSize(primals, &cum));
1166: PetscCall(ISGetIndices(primals, &idxs));
1167: for (i = 0; i < cum; i++) marks[idxs[i]] = nee + 1;
1168: PetscCall(ISRestoreIndices(primals, &idxs));
1169: if (print) {
1170: PetscCall(PetscObjectSetName((PetscObject)primals, "obtained_primal_dofs"));
1171: PetscCall(ISView(primals, NULL));
1172: }
1174: maxsize = 0;
1175: for (i = 0; i < nee; i++) {
1176: PetscInt size, mark = i + 1;
1178: PetscCall(ISGetLocalSize(eedges[i], &size));
1179: PetscCall(ISGetIndices(eedges[i], &idxs));
1180: for (j = 0; j < size; j++) marks[idxs[j]] = mark;
1181: PetscCall(ISRestoreIndices(eedges[i], &idxs));
1182: maxsize = PetscMax(maxsize, size);
1183: }
1185: /* Find coarse edge endpoints */
1186: PetscCall(MatGetRowIJ(lG, 0, PETSC_FALSE, PETSC_FALSE, &i, &ii, &jj, &done));
1187: PetscCall(MatGetRowIJ(lGt, 0, PETSC_FALSE, PETSC_FALSE, &i, &iit, &jjt, &done));
1188: for (i = 0; i < nee; i++) {
1189: PetscInt mark = i + 1, size;
1191: PetscCall(ISGetLocalSize(eedges[i], &size));
1192: if (!size && nedfieldlocal) continue;
1193: PetscCheck(size, PETSC_COMM_SELF, PETSC_ERR_PLIB, "Unexpected zero sized edge %" PetscInt_FMT, i);
1194: PetscCall(ISGetIndices(eedges[i], &idxs));
1195: if (print) {
1196: PetscCall(PetscPrintf(PETSC_COMM_SELF, "ENDPOINTS ANALYSIS EDGE %" PetscInt_FMT "\n", i));
1197: PetscCall(ISView(eedges[i], NULL));
1198: }
1199: for (j = 0; j < size; j++) {
1200: PetscInt k, ee = idxs[j];
1201: if (print) PetscCall(PetscPrintf(PETSC_COMM_SELF, " idx %" PetscInt_FMT "\n", ee));
1202: for (k = ii[ee]; k < ii[ee + 1]; k++) {
1203: if (print) PetscCall(PetscPrintf(PETSC_COMM_SELF, " inspect %" PetscInt_FMT "\n", jj[k]));
1204: if (PetscBTLookup(btv, jj[k])) {
1205: if (print) PetscCall(PetscPrintf(PETSC_COMM_SELF, " corner found (already set) %" PetscInt_FMT "\n", jj[k]));
1206: } else if (PetscBTLookup(btvcand, jj[k])) { /* is it ok? */
1207: PetscBool corner = PETSC_FALSE;
1208: for (PetscInt k2 = iit[jj[k]]; k2 < iit[jj[k] + 1]; k2++) {
1209: if (print) PetscCall(PetscPrintf(PETSC_COMM_SELF, " INSPECTING %" PetscInt_FMT ": mark %" PetscInt_FMT " (ref mark %" PetscInt_FMT "), boundary %d\n", jjt[k2], marks[jjt[k2]], mark, (int)!!PetscBTLookup(btb, jjt[k2])));
1210: /* it's a corner if either is connected with an edge dof belonging to a different cc or
1211: if the edge dof lie on the natural part of the boundary */
1212: if ((marks[jjt[k2]] && marks[jjt[k2]] != mark) || (!marks[jjt[k2]] && PetscBTLookup(btb, jjt[k2]))) {
1213: corner = PETSC_TRUE;
1214: break;
1215: }
1216: }
1217: if (corner) { /* found the nodal dof corresponding to the endpoint of the edge */
1218: if (print) PetscCall(PetscPrintf(PETSC_COMM_SELF, " corner found %" PetscInt_FMT "\n", jj[k]));
1219: PetscCall(PetscBTSet(btv, jj[k]));
1220: } else {
1221: if (print) PetscCall(PetscPrintf(PETSC_COMM_SELF, " no corners found\n"));
1222: }
1223: }
1224: }
1225: }
1226: PetscCall(ISRestoreIndices(eedges[i], &idxs));
1227: }
1228: PetscCall(MatRestoreRowIJ(lGt, 0, PETSC_FALSE, PETSC_FALSE, &i, &iit, &jjt, &done));
1229: PetscCall(MatRestoreRowIJ(lG, 0, PETSC_FALSE, PETSC_FALSE, &i, &ii, &jj, &done));
1230: PetscCall(PetscBTDestroy(&btb));
1232: /* Reset marked primal dofs */
1233: PetscCall(ISGetLocalSize(primals, &cum));
1234: PetscCall(ISGetIndices(primals, &idxs));
1235: for (i = 0; i < cum; i++) marks[idxs[i]] = 0;
1236: PetscCall(ISRestoreIndices(primals, &idxs));
1238: /* Now use the initial lG */
1239: PetscCall(MatDestroy(&lG));
1240: PetscCall(MatDestroy(&lGt));
1241: lG = lGinit;
1242: PetscCall(MatTranspose(lG, MAT_INITIAL_MATRIX, &lGt));
1244: /* Compute extended cols indices */
1245: PetscCall(PetscBTCreate(nv, &btvc));
1246: PetscCall(PetscBTCreate(nee, &bter));
1247: PetscCall(MatGetRowIJ(lG, 0, PETSC_FALSE, PETSC_FALSE, &i, &ii, &jj, &done));
1248: PetscCall(MatSeqAIJGetMaxRowNonzeros(lG, &i));
1249: i *= maxsize;
1250: PetscCall(PetscCalloc1(nee, &extcols));
1251: PetscCall(PetscMalloc2(i, &extrow, i, &gidxs));
1252: eerr = PETSC_FALSE;
1253: for (i = 0; i < nee; i++) {
1254: PetscInt size, found = 0;
1256: cum = 0;
1257: PetscCall(ISGetLocalSize(eedges[i], &size));
1258: if (!size && nedfieldlocal) continue;
1259: PetscCheck(size, PETSC_COMM_SELF, PETSC_ERR_PLIB, "Unexpected zero sized edge %" PetscInt_FMT, i);
1260: PetscCall(ISGetIndices(eedges[i], &idxs));
1261: PetscCall(PetscBTMemzero(nv, btvc));
1262: for (j = 0; j < size; j++) {
1263: PetscInt k, ee = idxs[j];
1264: for (k = ii[ee]; k < ii[ee + 1]; k++) {
1265: PetscInt vv = jj[k];
1266: if (!PetscBTLookup(btv, vv)) extrow[cum++] = vv;
1267: else if (!PetscBTLookupSet(btvc, vv)) found++;
1268: }
1269: }
1270: PetscCall(ISRestoreIndices(eedges[i], &idxs));
1271: PetscCall(PetscSortRemoveDupsInt(&cum, extrow));
1272: PetscCall(ISLocalToGlobalMappingApply(vl2g, cum, extrow, gidxs));
1273: PetscCall(PetscSortIntWithArray(cum, gidxs, extrow));
1274: PetscCall(ISCreateGeneral(PETSC_COMM_SELF, cum, extrow, PETSC_COPY_VALUES, &extcols[i]));
1275: /* it may happen that endpoints are not defined at this point
1276: if it is the case, mark this edge for a second pass */
1277: if (cum != size - 1 || found != 2) {
1278: PetscCall(PetscBTSet(bter, i));
1279: if (print) {
1280: PetscCall(PetscObjectSetName((PetscObject)eedges[i], "error_edge"));
1281: PetscCall(ISView(eedges[i], NULL));
1282: PetscCall(PetscObjectSetName((PetscObject)extcols[i], "error_extcol"));
1283: PetscCall(ISView(extcols[i], NULL));
1284: }
1285: eerr = PETSC_TRUE;
1286: }
1287: }
1288: /* PetscCheck(!eerr,PETSC_COMM_SELF,PETSC_ERR_PLIB,"Unexpected SIZE OF EDGE > EXTCOL FIRST PASS"); */
1289: PetscCallMPI(MPIU_Allreduce(&eerr, &done, 1, MPI_C_BOOL, MPI_LOR, comm));
1290: if (done) {
1291: PetscInt *newprimals;
1293: PetscCall(PetscMalloc1(ne, &newprimals));
1294: PetscCall(ISGetLocalSize(primals, &cum));
1295: PetscCall(ISGetIndices(primals, &idxs));
1296: PetscCall(PetscArraycpy(newprimals, idxs, cum));
1297: PetscCall(ISRestoreIndices(primals, &idxs));
1298: PetscCall(MatGetRowIJ(lGt, 0, PETSC_FALSE, PETSC_FALSE, &i, &iit, &jjt, &done));
1299: if (print) PetscCall(PetscPrintf(PETSC_COMM_SELF, "DOING SECOND PASS (eerr %s)\n", PetscBools[eerr]));
1300: for (i = 0; i < nee; i++) {
1301: PetscBool has_candidates = PETSC_FALSE;
1302: if (PetscBTLookup(bter, i)) {
1303: PetscInt size, mark = i + 1;
1305: PetscCall(ISGetLocalSize(eedges[i], &size));
1306: PetscCall(ISGetIndices(eedges[i], &idxs));
1307: /* for (j=0;j<size;j++) newprimals[cum++] = idxs[j]; */
1308: for (j = 0; j < size; j++) {
1309: PetscInt k, ee = idxs[j];
1310: if (print) PetscCall(PetscPrintf(PETSC_COMM_SELF, "Inspecting edge dof %" PetscInt_FMT " [%" PetscInt_FMT " %" PetscInt_FMT ")\n", ee, ii[ee], ii[ee + 1]));
1311: for (k = ii[ee]; k < ii[ee + 1]; k++) {
1312: /* set all candidates located on the edge as corners */
1313: if (PetscBTLookup(btvcand, jj[k])) {
1314: PetscInt k2, vv = jj[k];
1315: has_candidates = PETSC_TRUE;
1316: if (print) PetscCall(PetscPrintf(PETSC_COMM_SELF, " Candidate set to vertex %" PetscInt_FMT "\n", vv));
1317: PetscCall(PetscBTSet(btv, vv));
1318: /* set all edge dofs connected to candidate as primals */
1319: for (k2 = iit[vv]; k2 < iit[vv + 1]; k2++) {
1320: if (marks[jjt[k2]] == mark) {
1321: PetscInt k3, ee2 = jjt[k2];
1322: if (print) PetscCall(PetscPrintf(PETSC_COMM_SELF, " Connected edge dof set to primal %" PetscInt_FMT "\n", ee2));
1323: newprimals[cum++] = ee2;
1324: marks[ee2] = 0;
1325: /* finally set the new corners */
1326: for (k3 = ii[ee2]; k3 < ii[ee2 + 1]; k3++) {
1327: if (print) PetscCall(PetscPrintf(PETSC_COMM_SELF, " Connected nodal dof set to vertex %" PetscInt_FMT "\n", jj[k3]));
1328: PetscCall(PetscBTSet(btv, jj[k3]));
1329: }
1330: }
1331: }
1332: } else {
1333: if (print) PetscCall(PetscPrintf(PETSC_COMM_SELF, " Not a candidate vertex %" PetscInt_FMT "\n", jj[k]));
1334: }
1335: }
1336: }
1337: if (!has_candidates) { /* circular edge */
1338: PetscInt k, ee = idxs[0], *tmarks;
1340: PetscCall(PetscCalloc1(ne, &tmarks));
1341: if (print) PetscCall(PetscPrintf(PETSC_COMM_SELF, " Circular edge %" PetscInt_FMT "\n", i));
1342: for (k = ii[ee]; k < ii[ee + 1]; k++) {
1343: if (print) PetscCall(PetscPrintf(PETSC_COMM_SELF, " Set to corner %" PetscInt_FMT "\n", jj[k]));
1344: PetscCall(PetscBTSet(btv, jj[k]));
1345: for (PetscInt k2 = iit[jj[k]]; k2 < iit[jj[k] + 1]; k2++) tmarks[jjt[k2]]++;
1346: }
1347: for (j = 0; j < size; j++) {
1348: if (tmarks[idxs[j]] > 1) {
1349: if (print) PetscCall(PetscPrintf(PETSC_COMM_SELF, " Edge dof set to primal %" PetscInt_FMT "\n", idxs[j]));
1350: newprimals[cum++] = idxs[j];
1351: }
1352: }
1353: PetscCall(PetscFree(tmarks));
1354: }
1355: PetscCall(ISRestoreIndices(eedges[i], &idxs));
1356: }
1357: PetscCall(ISDestroy(&extcols[i]));
1358: }
1359: PetscCall(PetscFree(extcols));
1360: PetscCall(MatRestoreRowIJ(lGt, 0, PETSC_FALSE, PETSC_FALSE, &i, &iit, &jjt, &done));
1361: PetscCall(PetscSortRemoveDupsInt(&cum, newprimals));
1362: if (fl2g) {
1363: PetscCall(ISLocalToGlobalMappingApply(fl2g, cum, newprimals, newprimals));
1364: PetscCall(ISDestroy(&primals));
1365: for (i = 0; i < nee; i++) PetscCall(ISDestroy(&eedges[i]));
1366: PetscCall(PetscFree(eedges));
1367: }
1368: PetscCall(PCBDDCGraphRestoreCandidatesIS(pcbddc->mat_graph, NULL, NULL, &nee, &alleedges, &allprimals));
1369: PetscCall(ISCreateGeneral(comm, cum, newprimals, PETSC_COPY_VALUES, &primals));
1370: PetscCall(PetscFree(newprimals));
1371: PetscCall(PCBDDCAddPrimalVerticesLocalIS(pc, primals));
1372: PetscCall(ISDestroy(&primals));
1373: PetscCall(PCBDDCAnalyzeInterface(pc));
1374: pcbddc->mat_graph->twodim = PETSC_FALSE;
1375: PetscCall(PCBDDCGraphGetCandidatesIS(pcbddc->mat_graph, NULL, NULL, &nee, &alleedges, &allprimals));
1376: if (fl2g) {
1377: PetscCall(ISGlobalToLocalMappingApplyIS(fl2g, IS_GTOLM_DROP, allprimals, &primals));
1378: PetscCall(PetscMalloc1(nee, &eedges));
1379: for (i = 0; i < nee; i++) {
1380: PetscInt an, ln;
1382: PetscCall(ISGlobalToLocalMappingApplyIS(fl2g, IS_GTOLM_DROP, alleedges[i], &eedges[i]));
1383: PetscCall(ISGetLocalSize(alleedges[i], &an));
1384: PetscCall(ISGetLocalSize(eedges[i], &ln));
1385: PetscCheck(an == ln || ln == 0, PETSC_COMM_SELF, PETSC_ERR_PLIB, "Unexpected size edge %" PetscInt_FMT ": %" PetscInt_FMT " != %" PetscInt_FMT, i, an, ln);
1386: }
1387: } else {
1388: eedges = alleedges;
1389: primals = allprimals;
1390: }
1391: PetscCall(PetscCalloc1(nee, &extcols));
1393: /* Mark again */
1394: PetscCall(PetscArrayzero(marks, ne));
1395: for (i = 0; i < nee; i++) {
1396: PetscInt size, mark = i + 1;
1398: PetscCall(ISGetLocalSize(eedges[i], &size));
1399: PetscCall(ISGetIndices(eedges[i], &idxs));
1400: for (j = 0; j < size; j++) marks[idxs[j]] = mark;
1401: PetscCall(ISRestoreIndices(eedges[i], &idxs));
1402: }
1403: if (print) {
1404: PetscCall(PetscObjectSetName((PetscObject)primals, "obtained_primal_dofs_secondpass"));
1405: PetscCall(ISView(primals, NULL));
1406: }
1408: /* Recompute extended cols */
1409: eerr = PETSC_FALSE;
1410: for (i = 0; i < nee; i++) {
1411: PetscInt size;
1413: cum = 0;
1414: PetscCall(ISGetLocalSize(eedges[i], &size));
1415: if (!size && nedfieldlocal) continue;
1416: PetscCheck(size, PETSC_COMM_SELF, PETSC_ERR_PLIB, "Unexpected zero sized edge %" PetscInt_FMT, i);
1417: PetscCall(ISGetIndices(eedges[i], &idxs));
1418: for (j = 0; j < size; j++) {
1419: PetscInt k, ee = idxs[j];
1420: for (k = ii[ee]; k < ii[ee + 1]; k++)
1421: if (!PetscBTLookup(btv, jj[k])) extrow[cum++] = jj[k];
1422: }
1423: PetscCall(ISRestoreIndices(eedges[i], &idxs));
1424: PetscCall(PetscSortRemoveDupsInt(&cum, extrow));
1425: PetscCall(ISLocalToGlobalMappingApply(vl2g, cum, extrow, gidxs));
1426: PetscCall(PetscSortIntWithArray(cum, gidxs, extrow));
1427: PetscCall(ISCreateGeneral(PETSC_COMM_SELF, cum, extrow, PETSC_COPY_VALUES, &extcols[i]));
1428: if (cum != size - 1) {
1429: if (print) {
1430: PetscCall(PetscObjectSetName((PetscObject)eedges[i], "error_edge_secondpass"));
1431: PetscCall(ISView(eedges[i], NULL));
1432: PetscCall(PetscObjectSetName((PetscObject)extcols[i], "error_extcol_secondpass"));
1433: PetscCall(ISView(extcols[i], NULL));
1434: }
1435: eerr = PETSC_TRUE;
1436: }
1437: }
1438: }
1439: PetscCall(MatRestoreRowIJ(lG, 0, PETSC_FALSE, PETSC_FALSE, &i, &ii, &jj, &done));
1440: PetscCall(PetscFree2(extrow, gidxs));
1441: PetscCall(PetscBTDestroy(&bter));
1442: if (print) PetscCall(PCBDDCGraphASCIIView(pcbddc->mat_graph, 5, PETSC_VIEWER_STDOUT_SELF));
1443: /* an error should not occur at this point */
1444: PetscCheck(!eerr, PETSC_COMM_SELF, PETSC_ERR_PLIB, "Unexpected SIZE OF EDGE > EXTCOL SECOND PASS");
1446: /* Check the number of endpoints */
1447: PetscCall(MatGetRowIJ(lG, 0, PETSC_FALSE, PETSC_FALSE, &i, &ii, &jj, &done));
1448: PetscCall(PetscMalloc1(2 * nee, &corners));
1449: PetscCall(PetscMalloc1(nee, &cedges));
1450: for (i = 0; i < nee; i++) {
1451: PetscInt size, found = 0, gc[2];
1453: /* init with defaults */
1454: cedges[i] = corners[i * 2] = corners[i * 2 + 1] = -1;
1455: PetscCall(ISGetLocalSize(eedges[i], &size));
1456: if (!size && nedfieldlocal) continue;
1457: PetscCheck(size, PETSC_COMM_SELF, PETSC_ERR_PLIB, "Unexpected zero sized edge %" PetscInt_FMT, i);
1458: PetscCall(ISGetIndices(eedges[i], &idxs));
1459: PetscCall(PetscBTMemzero(nv, btvc));
1460: for (j = 0; j < size; j++) {
1461: PetscInt k, ee = idxs[j];
1462: for (k = ii[ee]; k < ii[ee + 1]; k++) {
1463: PetscInt vv = jj[k];
1464: if (PetscBTLookup(btv, vv) && !PetscBTLookupSet(btvc, vv)) {
1465: PetscCheck(found != 2, PETSC_COMM_SELF, PETSC_ERR_PLIB, "Found more than two corners for edge %" PetscInt_FMT, i);
1466: corners[i * 2 + found++] = vv;
1467: }
1468: }
1469: }
1470: if (found != 2) {
1471: PetscInt e;
1472: if (fl2g) PetscCall(ISLocalToGlobalMappingApply(fl2g, 1, idxs, &e));
1473: else e = idxs[0];
1474: SETERRQ(PETSC_COMM_SELF, PETSC_ERR_PLIB, "Found %" PetscInt_FMT " corners for edge %" PetscInt_FMT " (astart %" PetscInt_FMT ", estart %" PetscInt_FMT ")", found, i, e, idxs[0]);
1475: }
1477: /* get primal dof index on this coarse edge */
1478: PetscCall(ISLocalToGlobalMappingApply(vl2g, 2, corners + 2 * i, gc));
1479: if (gc[0] > gc[1]) {
1480: PetscInt swap = corners[2 * i];
1481: corners[2 * i] = corners[2 * i + 1];
1482: corners[2 * i + 1] = swap;
1483: }
1484: cedges[i] = idxs[size - 1];
1485: PetscCall(ISRestoreIndices(eedges[i], &idxs));
1486: if (print) PetscCall(PetscPrintf(PETSC_COMM_SELF, "EDGE %" PetscInt_FMT ": ce %" PetscInt_FMT ", corners (%" PetscInt_FMT ",%" PetscInt_FMT ")\n", i, cedges[i], corners[2 * i], corners[2 * i + 1]));
1487: }
1488: PetscCall(MatRestoreRowIJ(lG, 0, PETSC_FALSE, PETSC_FALSE, &i, &ii, &jj, &done));
1489: PetscCall(PetscBTDestroy(&btvc));
1491: if (pcbddc->dbg_flag > 0) {
1492: /* Inspects columns of lG (rows of lGt) and make sure the change of basis will
1493: not interfere with neighboring coarse edges */
1494: PetscCall(PetscMalloc1(nee + 1, &emarks));
1495: PetscCall(MatGetRowIJ(lGt, 0, PETSC_FALSE, PETSC_FALSE, &i, &ii, &jj, &done));
1496: for (i = 0; i < nv; i++) {
1497: PetscInt emax = 0, eemax = 0;
1499: if (ii[i + 1] == ii[i] || PetscBTLookup(btv, i)) continue;
1500: PetscCall(PetscArrayzero(emarks, nee + 1));
1501: for (j = ii[i]; j < ii[i + 1]; j++) emarks[marks[jj[j]]]++;
1502: for (j = 1; j < nee + 1; j++) {
1503: if (emax < emarks[j]) {
1504: emax = emarks[j];
1505: eemax = j;
1506: }
1507: }
1508: /* not relevant for edges */
1509: if (!eemax) continue;
1511: for (j = ii[i]; j < ii[i + 1]; j++) {
1512: PetscCheck(!marks[jj[j]] || marks[jj[j]] == eemax, PETSC_COMM_SELF, PETSC_ERR_SUP, "Found 2 coarse edges (id %" PetscInt_FMT " and %" PetscInt_FMT ") connected through the %" PetscInt_FMT " nodal dof at edge dof %" PetscInt_FMT, marks[jj[j]] - 1, eemax, i, jj[j]);
1513: }
1514: }
1515: PetscCall(PetscFree(emarks));
1516: PetscCall(MatRestoreRowIJ(lGt, 0, PETSC_FALSE, PETSC_FALSE, &i, &ii, &jj, &done));
1517: }
1519: /* Compute extended rows indices for edge blocks of the change of basis */
1520: PetscCall(MatGetRowIJ(lGt, 0, PETSC_FALSE, PETSC_FALSE, &i, &ii, &jj, &done));
1521: PetscCall(MatSeqAIJGetMaxRowNonzeros(lGt, &extmem));
1522: extmem *= maxsize;
1523: PetscCall(PetscMalloc1(extmem * nee, &extrow));
1524: PetscCall(PetscMalloc1(nee, &extrows));
1525: PetscCall(PetscCalloc1(nee, &extrowcum));
1526: for (i = 0; i < nv; i++) {
1527: PetscInt mark = 0, size, start;
1529: if (ii[i + 1] == ii[i] || PetscBTLookup(btv, i)) continue;
1530: for (j = ii[i]; j < ii[i + 1]; j++)
1531: if (marks[jj[j]] && !mark) mark = marks[jj[j]];
1533: /* not relevant */
1534: if (!mark) continue;
1536: /* import extended row */
1537: mark--;
1538: start = mark * extmem + extrowcum[mark];
1539: size = ii[i + 1] - ii[i];
1540: PetscCheck(extrowcum[mark] + size <= extmem, PETSC_COMM_SELF, PETSC_ERR_PLIB, "Not enough memory allocated %" PetscInt_FMT " > %" PetscInt_FMT, extrowcum[mark] + size, extmem);
1541: PetscCall(PetscArraycpy(extrow + start, jj + ii[i], size));
1542: extrowcum[mark] += size;
1543: }
1544: PetscCall(MatRestoreRowIJ(lGt, 0, PETSC_FALSE, PETSC_FALSE, &i, &ii, &jj, &done));
1545: PetscCall(MatDestroy(&lGt));
1546: PetscCall(PetscFree(marks));
1548: /* Compress extrows */
1549: cum = 0;
1550: for (i = 0; i < nee; i++) {
1551: PetscInt size = extrowcum[i];
1552: PetscInt *start = PetscSafePointerPlusOffset(extrow, i * extmem);
1554: PetscCall(PetscSortRemoveDupsInt(&size, start));
1555: PetscCall(ISCreateGeneral(PETSC_COMM_SELF, size, start, PETSC_USE_POINTER, &extrows[i]));
1556: cum = PetscMax(cum, size);
1557: }
1558: PetscCall(PetscFree(extrowcum));
1559: PetscCall(PetscBTDestroy(&btv));
1560: PetscCall(PetscBTDestroy(&btvcand));
1562: /* Workspace for lapack inner calls and VecSetValues */
1563: PetscCall(PetscMalloc2((5 + cum + maxsize) * maxsize, &work, maxsize, &rwork));
1565: /* Create change of basis matrix (no preallocation) */
1566: PetscCall(MatCreate(comm, &T));
1567: PetscCall(MatSetLayouts(T, pc->mat->rmap, pc->mat->cmap));
1568: PetscCall(MatSetType(T, MATAIJ));
1569: PetscCall(MatSetLocalToGlobalMapping(T, al2g, al2g));
1570: PetscCall(MatSetOption(T, MAT_ROW_ORIENTED, PETSC_FALSE));
1571: PetscCall(MatSetOption(T, MAT_IGNORE_ZERO_ENTRIES, PETSC_TRUE));
1572: //PetscCall(MatSeqAIJSetPreallocation(T, maxsize, NULL));
1573: //PetscCall(MatMPIAIJSetPreallocation(T, maxsize, NULL, maxsize, NULL));
1574: //PetscCall(MatSetOption(T, MAT_NEW_NONZERO_ALLOCATION_ERR, PETSC_FALSE));
1576: /* Defaults to identity */
1577: {
1578: Vec w;
1579: const PetscScalar *wa;
1581: PetscCall(MatCreateVecs(T, &w, NULL));
1582: PetscCall(VecSetLocalToGlobalMapping(w, al2g));
1583: PetscCall(VecSet(w, 1.0));
1584: for (i = 0; i < nee; i++) {
1585: const PetscInt *idxs;
1586: PetscInt nl;
1588: PetscCall(ISGetLocalSize(eedges[i], &nl));
1589: PetscCall(ISGetIndices(eedges[i], &idxs));
1590: PetscCall(VecSetValuesLocal(w, nl, idxs, NULL, INSERT_VALUES));
1591: PetscCall(ISRestoreIndices(eedges[i], &idxs));
1592: }
1593: PetscCall(VecAssemblyBegin(w));
1594: PetscCall(VecAssemblyEnd(w));
1595: PetscCall(VecGetArrayRead(w, &wa));
1596: for (i = T->rmap->rstart; i < T->rmap->rend; i++)
1597: if (PetscAbsScalar(wa[i - T->rmap->rstart])) PetscCall(MatSetValue(T, i, i, 1.0, INSERT_VALUES));
1598: PetscCall(VecRestoreArrayRead(w, &wa));
1599: PetscCall(VecDestroy(&w));
1600: }
1602: /* Create discrete gradient for the coarser level if needed */
1603: PetscCall(MatDestroy(&pcbddc->nedcG));
1604: if (pcbddc->current_level < pcbddc->max_levels) {
1605: ISLocalToGlobalMapping cvl2g;
1606: IS wis, gwis;
1607: PetscInt cnv;
1609: PetscCall(ISCreateGeneral(comm, nee, cedges, PETSC_COPY_VALUES, &wis));
1610: if (fl2g) PetscCall(ISLocalToGlobalMappingApplyIS(fl2g, wis, &nedclocal));
1611: else {
1612: PetscCall(PetscObjectReference((PetscObject)wis));
1613: nedclocal = wis;
1614: }
1615: PetscCall(ISDestroy(&wis));
1617: PetscCall(ISCreateGeneral(comm, 2 * nee, corners, PETSC_USE_POINTER, &wis));
1618: PetscCall(ISLocalToGlobalMappingApplyIS(vl2g, wis, &gwis));
1619: PetscCall(ISDestroy(&wis));
1620: PetscCall(ISRenumber(gwis, NULL, &cnv, &wis));
1621: PetscCall(ISLocalToGlobalMappingCreateIS(wis, &cvl2g));
1622: PetscCall(ISDestroy(&wis));
1623: PetscCall(ISDestroy(&gwis));
1625: PetscCall(MatCreate(comm, &pcbddc->nedcG));
1626: PetscCall(MatSetSizes(pcbddc->nedcG, PETSC_DECIDE, PETSC_DECIDE, pc->pmat->rmap->N, cnv));
1627: PetscCall(MatSetType(pcbddc->nedcG, MATAIJ));
1628: PetscCall(MatSeqAIJSetPreallocation(pcbddc->nedcG, 2, NULL));
1629: PetscCall(MatMPIAIJSetPreallocation(pcbddc->nedcG, 2, NULL, 2, NULL));
1630: PetscCall(MatSetLocalToGlobalMapping(pcbddc->nedcG, al2g, cvl2g));
1631: PetscCall(ISLocalToGlobalMappingDestroy(&cvl2g));
1632: if (pcbddc->dbg_flag > 0) PetscCall(PetscCalloc1(2 * nee, &cedgevals));
1633: }
1635: PetscCall(MatGetNullSpace(pcbddc->discretegradient, &nnsp));
1636: if (nnsp) PetscCall(MatNullSpaceGetVecs(nnsp, &nnsp_has_const, &nnsp_nvecs, &nnsp_vecs));
1637: if (nnsp_has_const || nnsp_nvecs) { /* create scatter to import edge constraints */
1638: IS allextcols, gallextcols, galleedges, is_E_to_zero;
1639: Vec E, V;
1640: PetscInt *eedgesidxs;
1641: const PetscScalar *evals;
1643: PetscCall(MatCreateVecs(pc->pmat, &E, NULL));
1644: PetscCall(MatCreateVecs(pcbddc->discretegradient, &V, NULL));
1645: PetscCall(ISConcatenate(PETSC_COMM_SELF, nee, extcols, &allextcols));
1646: cum = 0;
1647: for (i = 0; i < nee; i++) {
1648: PetscInt j;
1650: PetscCall(ISGetLocalSize(eedges[i], &j));
1651: /* Coarse edges of complementary fields have no Nedelec dofs. */
1652: if (!j && nedfieldlocal) continue;
1653: PetscCheck(j, PETSC_COMM_SELF, PETSC_ERR_PLIB, "Zero sized edge %" PetscInt_FMT, i);
1654: cum += j - 1;
1655: }
1656: PetscCall(PetscMalloc1(PetscMax(cum, pc->pmat->rmap->n), &eedgesidxs));
1657: cum = 0;
1658: for (i = 0; i < nee; i++) {
1659: const PetscInt *idxs;
1660: PetscInt j;
1662: PetscCall(ISGetLocalSize(eedges[i], &j));
1663: if (!j && nedfieldlocal) continue;
1664: PetscCall(ISGetIndices(eedges[i], &idxs));
1665: PetscCall(PetscArraycpy(eedgesidxs + cum, idxs, j - 1)); /* last on the edge is primal */
1666: PetscCall(ISRestoreIndices(eedges[i], &idxs));
1667: cum += j - 1;
1668: }
1669: PetscCall(ISLocalToGlobalMappingApply(al2g, cum, eedgesidxs, eedgesidxs));
1670: PetscCall(ISCreateGeneral(PETSC_COMM_SELF, cum, eedgesidxs, PETSC_USE_POINTER, &galleedges));
1671: PetscCall(ISLocalToGlobalMappingApplyIS(vl2g, allextcols, &gallextcols));
1672: PetscCall(VecScatterCreate(V, gallextcols, E, galleedges, &nnsp_vscat));
1673: PetscCall(ISDestroy(&allextcols));
1674: PetscCall(ISDestroy(&gallextcols));
1675: PetscCall(ISDestroy(&galleedges));
1677: /* identify dofs we must zero if importing user-defined near nullspace from pmat */
1678: PetscCall(VecSet(E, 1.0));
1679: PetscCall(VecSetValues(E, cum, eedgesidxs, NULL, INSERT_VALUES));
1680: PetscCall(VecAssemblyBegin(E));
1681: PetscCall(VecAssemblyEnd(E));
1682: PetscCall(VecGetArrayRead(E, &evals));
1683: for (i = 0, cum = 0; i < pc->pmat->rmap->n; i++)
1684: if (evals[i] == 0.0) eedgesidxs[cum++] = i + pc->pmat->rmap->rstart;
1685: PetscCall(VecRestoreArrayRead(E, &evals));
1686: PetscCall(ISCreateGeneral(PetscObjectComm((PetscObject)E), cum, eedgesidxs, PETSC_COPY_VALUES, &is_E_to_zero));
1687: PetscCall(PetscFree(eedgesidxs));
1689: PetscCall(PetscObjectCompose((PetscObject)nnsp_vscat, "__V_Vec", (PetscObject)V));
1690: PetscCall(PetscObjectCompose((PetscObject)nnsp_vscat, "__E_Vec", (PetscObject)E));
1691: PetscCall(PetscObjectCompose((PetscObject)nnsp_vscat, "__E_zero", (PetscObject)is_E_to_zero));
1692: PetscCall(ISDestroy(&is_E_to_zero));
1693: PetscCall(VecDestroy(&V));
1694: PetscCall(VecDestroy(&E));
1695: }
1696: #if defined(PRINT_GDET)
1697: inc = 0;
1698: lev = pcbddc->current_level;
1699: #endif
1701: /* Insert values in the change of basis matrix */
1702: for (i = 0; i < nee; i++) {
1703: Mat Gins = NULL, GKins = NULL;
1704: IS cornersis = NULL;
1705: PetscScalar cvals[2];
1707: if (pcbddc->nedcG) PetscCall(ISCreateGeneral(PETSC_COMM_SELF, 2, corners + 2 * i, PETSC_USE_POINTER, &cornersis));
1708: PetscCall(PCBDDCComputeNedelecChangeEdge(lG, eedges[i], extrows[i], extcols[i], cornersis, pcbddc->dbg_flag > 0, &Gins, &GKins, cvals, work, rwork));
1709: if (Gins && GKins) {
1710: const PetscScalar *data;
1711: const PetscInt *rows, *cols;
1712: PetscInt nrh, nch, nrc, ncc;
1714: PetscCall(ISGetIndices(eedges[i], &cols));
1715: /* H1 */
1716: PetscCall(ISGetIndices(extrows[i], &rows));
1717: PetscCall(MatGetSize(Gins, &nrh, &nch));
1718: PetscCall(MatDenseGetArrayRead(Gins, &data));
1719: PetscCall(MatSetValuesLocal(T, nrh, rows, nch, cols, data, INSERT_VALUES));
1720: PetscCall(MatDenseRestoreArrayRead(Gins, &data));
1721: PetscCall(ISRestoreIndices(extrows[i], &rows));
1722: /* complement */
1723: PetscCall(MatGetSize(GKins, &nrc, &ncc));
1724: PetscCheck(ncc, PETSC_COMM_SELF, PETSC_ERR_PLIB, "Constant function has not been generated for coarse edge %" PetscInt_FMT, i);
1725: PetscCheck(ncc + nch == nrc, PETSC_COMM_SELF, PETSC_ERR_PLIB, "The sum of the number of columns of GKins %" PetscInt_FMT " and Gins %" PetscInt_FMT " does not match %" PetscInt_FMT " for coarse edge %" PetscInt_FMT, ncc, nch, nrc, i);
1726: PetscCheck(ncc == 1 || !pcbddc->nedcG, PETSC_COMM_SELF, PETSC_ERR_SUP, "Cannot generate the coarse discrete gradient for coarse edge %" PetscInt_FMT " with ncc %" PetscInt_FMT, i, ncc);
1727: PetscCall(MatDenseGetArrayRead(GKins, &data));
1728: PetscCall(MatSetValuesLocal(T, nrc, cols, ncc, cols + nch, data, INSERT_VALUES));
1729: PetscCall(MatDenseRestoreArrayRead(GKins, &data));
1731: /* coarse discrete gradient */
1732: if (pcbddc->nedcG) {
1733: PetscInt cols[2];
1735: cols[0] = 2 * i;
1736: cols[1] = 2 * i + 1;
1737: if (cedgevals) PetscCall(PetscArraycpy(cedgevals + 2 * i, cvals, 2));
1738: PetscCall(MatSetValuesLocal(pcbddc->nedcG, 1, cedges + i, 2, cols, cvals, INSERT_VALUES));
1739: }
1740: PetscCall(ISRestoreIndices(eedges[i], &cols));
1741: }
1742: PetscCall(ISDestroy(&extrows[i]));
1743: PetscCall(ISDestroy(&extcols[i]));
1744: PetscCall(ISDestroy(&cornersis));
1745: PetscCall(MatDestroy(&Gins));
1746: PetscCall(MatDestroy(&GKins));
1747: }
1748: if (pcbddc->nedcG && pcbddc->dbg_flag > 0) {
1749: PetscCall(PCBDDCCheckNedelecCoarseGradient_Private(pcbddc->nedcG, nee, cedges, cedgevals));
1750: if (nnsp_has_const || nnsp_nvecs) PetscCall(PCBDDCViewNedelecCoarseGradientNullSpace_Private(pc, sfv, nv, nee, cedges, corners, cedgevals, nnsp_has_const, nnsp_nvecs, nnsp_vecs));
1751: }
1752: PetscCall(PetscFree(cedgevals));
1753: PetscCall(PetscSFDestroy(&sfv));
1755: /* import edge constraints */
1756: if (nnsp_vscat) {
1757: Vec V, E, *quadvecs;
1758: PetscInt nvecs, nvecs_orth;
1759: MatNullSpace onnsp = NULL;
1760: PetscBool onnsp_has_const = PETSC_FALSE;
1761: const Vec *onnsp_vecs = NULL;
1762: PetscInt onnsp_nvecs = 0, new_nnsp_nvecs, old_nnsp_nvecs;
1763: IS is_E_to_zero;
1765: /* import nearnullspace from preconditioning matrix if user-defined */
1766: PetscCall(MatGetNearNullSpace(pc->pmat, &onnsp));
1767: if (onnsp) {
1768: PetscBool isinternal;
1770: PetscCall(PetscStrcmp("_internal_BDDC_nedelec_nnsp", ((PetscObject)onnsp)->name, &isinternal));
1771: if (!isinternal) PetscCall(MatNullSpaceGetVecs(onnsp, &onnsp_has_const, &onnsp_nvecs, &onnsp_vecs));
1772: }
1773: new_nnsp_nvecs = nnsp_nvecs + (nnsp_has_const ? 1 : 0);
1774: old_nnsp_nvecs = onnsp_nvecs + (onnsp_has_const ? 1 : 0);
1775: nvecs = old_nnsp_nvecs + new_nnsp_nvecs;
1776: PetscCall(PetscMalloc1(nvecs, &quadvecs));
1778: PetscCall(PetscObjectQuery((PetscObject)nnsp_vscat, "__V_Vec", (PetscObject *)&V));
1779: PetscCall(PetscObjectQuery((PetscObject)nnsp_vscat, "__E_Vec", (PetscObject *)&E));
1780: PetscCall(PetscObjectQuery((PetscObject)nnsp_vscat, "__E_zero", (PetscObject *)&is_E_to_zero));
1781: for (i = 0; i < nvecs; i++) PetscCall(VecDuplicate(E, &quadvecs[i]));
1782: cum = 0;
1783: if (nnsp_has_const) {
1784: PetscCall(VecSet(V, 1.0));
1785: PetscCall(VecScatterBegin(nnsp_vscat, V, quadvecs[0], INSERT_VALUES, SCATTER_FORWARD));
1786: PetscCall(VecScatterEnd(nnsp_vscat, V, quadvecs[0], INSERT_VALUES, SCATTER_FORWARD));
1787: cum = 1;
1788: }
1789: for (i = 0; i < nnsp_nvecs; i++) {
1790: PetscCall(VecScatterBegin(nnsp_vscat, nnsp_vecs[i], quadvecs[i + cum], INSERT_VALUES, SCATTER_FORWARD));
1791: PetscCall(VecScatterEnd(nnsp_vscat, nnsp_vecs[i], quadvecs[i + cum], INSERT_VALUES, SCATTER_FORWARD));
1792: }
1794: /* Now add old nnsp if present */
1795: cum = 0;
1796: if (onnsp_has_const) {
1797: PetscCall(VecSet(quadvecs[new_nnsp_nvecs], 1.0));
1798: PetscCall(VecISSet(quadvecs[new_nnsp_nvecs], is_E_to_zero, 0));
1799: cum = 1;
1800: }
1801: for (i = 0; i < onnsp_nvecs; i++) {
1802: PetscCall(VecCopy(onnsp_vecs[i], quadvecs[i + cum + new_nnsp_nvecs]));
1803: PetscCall(VecISSet(quadvecs[i + cum + new_nnsp_nvecs], is_E_to_zero, 0));
1804: }
1805: nvecs_orth = nvecs;
1806: PetscCall(PCBDDCOrthonormalizeVecs(&nvecs_orth, quadvecs));
1807: PetscCall(MatNullSpaceCreate(PetscObjectComm((PetscObject)pc), PETSC_FALSE, nvecs_orth, quadvecs, &nnsp));
1808: for (i = 0; i < nvecs; i++) PetscCall(VecDestroy(&quadvecs[i]));
1809: PetscCall(PetscFree(quadvecs));
1810: PetscCall(PetscObjectSetName((PetscObject)nnsp, "_internal_BDDC_nedelec_nnsp"));
1811: PetscCall(MatSetNearNullSpace(pc->pmat, nnsp));
1812: PetscCall(MatNullSpaceDestroy(&nnsp));
1813: }
1814: PetscCall(VecScatterDestroy(&nnsp_vscat));
1815: PetscCall(ISLocalToGlobalMappingDestroy(&vl2g));
1816: PetscCall(ISLocalToGlobalMappingDestroy(&el2g));
1817: PetscCall(ISLocalToGlobalMappingDestroy(&al2g));
1819: /* Start assembling */
1820: PetscCall(MatAssemblyBegin(T, MAT_FINAL_ASSEMBLY));
1821: if (pcbddc->nedcG) PetscCall(MatAssemblyBegin(pcbddc->nedcG, MAT_FINAL_ASSEMBLY));
1823: /* Free */
1824: if (fl2g) {
1825: PetscCall(ISDestroy(&primals));
1826: for (i = 0; i < nee; i++) PetscCall(ISDestroy(&eedges[i]));
1827: PetscCall(PetscFree(eedges));
1828: }
1830: /* hack mat_graph with primal dofs on the coarse edges */
1831: {
1832: PCBDDCGraph graph = pcbddc->mat_graph;
1833: PetscInt *oqueue = graph->queue;
1834: PetscInt *ocptr = graph->cptr;
1835: PetscInt ncc, *idxs;
1837: /* find first primal edge */
1838: if (nedclocal) PetscCall(ISGetIndices(nedclocal, (const PetscInt **)&idxs));
1839: else {
1840: if (fl2g) PetscCall(ISLocalToGlobalMappingApply(fl2g, nee, cedges, cedges));
1841: idxs = cedges;
1842: }
1843: cum = 0;
1844: while (cum < nee && idxs[cum] < 0) cum++;
1846: /* adapt connected components */
1847: PetscCall(PetscMalloc2(graph->nvtxs + 1, &graph->cptr, ocptr[graph->ncc], &graph->queue));
1848: graph->cptr[0] = 0;
1849: for (i = 0, ncc = 0; i < graph->ncc; i++) {
1850: PetscInt lc = ocptr[i + 1] - ocptr[i];
1851: if (cum != nee && oqueue[ocptr[i + 1] - 1] == idxs[cum]) { /* this cc has a primal dof */
1852: graph->cptr[ncc + 1] = graph->cptr[ncc] + 1;
1853: graph->queue[graph->cptr[ncc]] = idxs[cum];
1854: ncc++;
1855: lc--;
1856: cum++;
1857: while (cum < nee && idxs[cum] < 0) cum++;
1858: }
1859: graph->cptr[ncc + 1] = graph->cptr[ncc] + lc;
1860: for (j = 0; j < lc; j++) graph->queue[graph->cptr[ncc] + j] = oqueue[ocptr[i] + j];
1861: ncc++;
1862: }
1863: graph->ncc = ncc;
1864: if (nedclocal) PetscCall(ISRestoreIndices(nedclocal, (const PetscInt **)&idxs));
1865: PetscCall(PetscFree2(ocptr, oqueue));
1866: PetscCheck(cum == nee, PETSC_COMM_SELF, PETSC_ERR_PLIB, "Unexpected number of added primal dofs %" PetscInt_FMT " != %" PetscInt_FMT, cum, nee);
1867: }
1868: PetscCall(ISLocalToGlobalMappingDestroy(&fl2g));
1869: PetscCall(PCBDDCGraphRestoreCandidatesIS(pcbddc->mat_graph, NULL, NULL, &nee, &alleedges, &allprimals));
1870: PetscCall(PCBDDCGraphResetCSR(pcbddc->mat_graph));
1871: if (dofsfields) {
1872: pcbddc->n_ISForDofsLocal = ondofsfields;
1873: pcbddc->ISForDofsLocal = odofsfields;
1874: PetscCall(PetscFree(dofsfields));
1875: }
1877: PetscCall(ISDestroy(&nedfieldlocal));
1878: PetscCall(ISDestroy(&nedclocal));
1879: PetscCall(PetscFree(extrow));
1880: PetscCall(PetscFree2(work, rwork));
1881: PetscCall(PetscFree(corners));
1882: PetscCall(PetscFree(cedges));
1883: PetscCall(PetscFree(extrows));
1884: PetscCall(PetscFree(extcols));
1885: PetscCall(MatDestroy(&lG));
1887: /* Complete assembling */
1888: PetscCall(MatAssemblyEnd(T, MAT_FINAL_ASSEMBLY));
1889: PetscCall(MatViewFromOptions(T, (PetscObject)pc, "-pc_bddc_nedelec_change_view"));
1890: if (pcbddc->nedcG) {
1891: PetscCall(MatAssemblyEnd(pcbddc->nedcG, MAT_FINAL_ASSEMBLY));
1892: PetscCall(MatViewFromOptions(pcbddc->nedcG, (PetscObject)pc, "-pc_bddc_nedelec_coarse_change_view"));
1893: }
1895: PetscCall(ISDestroy(&elements_corners));
1897: /* set change of basis */
1898: PetscCall(PCBDDCSetChangeOfBasisMat(pc, T, PETSC_FALSE));
1899: PetscCall(MatDestroy(&T));
1900: PetscFunctionReturn(PETSC_SUCCESS);
1901: }
1903: /* the near-null space of BDDC carries information on quadrature weights,
1904: and these can be collinear -> so cheat with MatNullSpaceCreate
1905: and create a suitable set of basis vectors first */
1906: PetscErrorCode PCBDDCNullSpaceCreate(MPI_Comm comm, PetscBool has_const, PetscInt nvecs, Vec quad_vecs[], MatNullSpace *nnsp)
1907: {
1908: PetscInt i;
1910: PetscFunctionBegin;
1911: for (i = 0; i < nvecs; i++) {
1912: PetscInt first, last;
1914: PetscCall(VecGetOwnershipRange(quad_vecs[i], &first, &last));
1915: PetscCheck(last - first >= 2 * nvecs || !has_const, PETSC_COMM_SELF, PETSC_ERR_SUP, "Not implemented");
1916: if (i >= first && i < last) {
1917: PetscScalar *data;
1918: PetscCall(VecGetArray(quad_vecs[i], &data));
1919: if (!has_const) {
1920: data[i - first] = 1.;
1921: } else {
1922: data[2 * i - first] = 1. / PetscSqrtReal(2.);
1923: data[2 * i - first + 1] = -1. / PetscSqrtReal(2.);
1924: }
1925: PetscCall(VecRestoreArray(quad_vecs[i], &data));
1926: }
1927: PetscCall(PetscObjectStateIncrease((PetscObject)quad_vecs[i]));
1928: }
1929: PetscCall(MatNullSpaceCreate(comm, has_const, nvecs, quad_vecs, nnsp));
1930: for (i = 0; i < nvecs; i++) { /* reset vectors */
1931: PetscInt first, last;
1932: PetscCall(VecLockReadPop(quad_vecs[i]));
1933: PetscCall(VecGetOwnershipRange(quad_vecs[i], &first, &last));
1934: if (i >= first && i < last) {
1935: PetscScalar *data;
1936: PetscCall(VecGetArray(quad_vecs[i], &data));
1937: if (!has_const) {
1938: data[i - first] = 0.;
1939: } else {
1940: data[2 * i - first] = 0.;
1941: data[2 * i - first + 1] = 0.;
1942: }
1943: PetscCall(VecRestoreArray(quad_vecs[i], &data));
1944: }
1945: PetscCall(PetscObjectStateIncrease((PetscObject)quad_vecs[i]));
1946: PetscCall(VecLockReadPush(quad_vecs[i]));
1947: }
1948: PetscFunctionReturn(PETSC_SUCCESS);
1949: }
1951: static PetscErrorCode PCBDDCComputeLocalFluxWeights(Mat A, Mat divudotp, PetscBool transpose, IS vl2l, Vec *v)
1952: {
1953: Mat loc_divudotp;
1954: Vec p;
1956: PetscFunctionBegin;
1957: PetscCall(MatISGetLocalMat(divudotp, &loc_divudotp));
1958: if (!transpose) PetscCall(MatCreateVecs(loc_divudotp, v, &p));
1959: else PetscCall(MatCreateVecs(loc_divudotp, &p, v));
1960: PetscCall(VecSet(p, 1.));
1961: if (!transpose) PetscCall(MatMultTranspose(loc_divudotp, p, *v));
1962: else PetscCall(MatMult(loc_divudotp, p, *v));
1963: PetscCall(VecDestroy(&p));
1964: if (vl2l) {
1965: Mat lA;
1966: VecScatter sc;
1967: Vec vins;
1969: PetscCall(MatISGetLocalMat(A, &lA));
1970: PetscCall(MatCreateVecs(lA, &vins, NULL));
1971: PetscCall(VecScatterCreate(*v, NULL, vins, vl2l, &sc));
1972: PetscCall(VecScatterBegin(sc, *v, vins, INSERT_VALUES, SCATTER_FORWARD));
1973: PetscCall(VecScatterEnd(sc, *v, vins, INSERT_VALUES, SCATTER_FORWARD));
1974: PetscCall(VecScatterDestroy(&sc));
1975: PetscCall(VecDestroy(v));
1976: *v = vins;
1977: }
1978: PetscFunctionReturn(PETSC_SUCCESS);
1979: }
1981: PetscErrorCode PCBDDCComputeNoNetFlux(Mat A, Mat divudotp, PetscBool transpose, IS vl2l, PCBDDCGraph graph, MatNullSpace *nnsp)
1982: {
1983: Vec v, quad_vec;
1984: ISLocalToGlobalMapping map;
1985: PetscScalar *array;
1987: PetscFunctionBegin;
1988: PetscCall(MatCreateVecs(A, &quad_vec, NULL));
1989: if (!transpose) {
1990: PetscCall(MatISGetLocalToGlobalMapping(A, &map, NULL));
1991: } else {
1992: PetscCall(MatISGetLocalToGlobalMapping(A, NULL, &map));
1993: }
1994: PetscCall(PCBDDCNullSpaceCreate(PetscObjectComm((PetscObject)A), PETSC_FALSE, 1, &quad_vec, nnsp));
1995: PetscCall(VecLockReadPop(quad_vec));
1996: PetscCall(VecSetLocalToGlobalMapping(quad_vec, map));
1998: /* the constant vector is assumed to interpolate the constant on the L2 conforming space */
1999: PetscCall(PCBDDCComputeLocalFluxWeights(A, divudotp, transpose, vl2l, &v));
2001: /* mask summation of interface values */
2002: PetscInt n, *mmask, *mask, *idxs, nmr, nr;
2003: const PetscInt *degree;
2004: PetscSF msf;
2006: PetscCall(VecGetLocalSize(v, &n));
2007: PetscCall(PetscSFGetGraph(graph->interface_subset_sf, &nr, NULL, NULL, NULL));
2008: PetscCall(PetscSFGetMultiSF(graph->interface_subset_sf, &msf));
2009: PetscCall(PetscSFGetGraph(msf, &nmr, NULL, NULL, NULL));
2010: PetscCall(PetscCalloc3(nmr, &mmask, n, &mask, n, &idxs));
2011: PetscCall(PetscSFComputeDegreeBegin(graph->interface_subset_sf, °ree));
2012: PetscCall(PetscSFComputeDegreeEnd(graph->interface_subset_sf, °ree));
2013: for (PetscInt i = 0, c = 0; i < nr; i++) {
2014: mmask[c] = 1;
2015: c += degree[i];
2016: }
2017: PetscCall(PetscSFScatterBegin(graph->interface_subset_sf, MPIU_INT, mmask, mask));
2018: PetscCall(PetscSFScatterEnd(graph->interface_subset_sf, MPIU_INT, mmask, mask));
2019: PetscCall(VecGetArray(v, &array));
2020: for (PetscInt i = 0; i < n; i++) {
2021: array[i] *= mask[i];
2022: idxs[i] = i;
2023: }
2024: PetscCall(VecSetValuesLocal(quad_vec, n, idxs, array, ADD_VALUES));
2025: PetscCall(VecRestoreArray(v, &array));
2026: PetscCall(PetscFree3(mmask, mask, idxs));
2027: PetscCall(VecDestroy(&v));
2028: PetscCall(VecAssemblyBegin(quad_vec));
2029: PetscCall(VecAssemblyEnd(quad_vec));
2030: PetscCall(VecViewFromOptions(quad_vec, NULL, "-pc_bddc_quad_vec_view"));
2031: PetscCall(VecLockReadPush(quad_vec));
2032: PetscCall(VecDestroy(&quad_vec));
2033: PetscFunctionReturn(PETSC_SUCCESS);
2034: }
2036: PetscErrorCode PCBDDCAddPrimalVerticesLocalIS(PC pc, IS primalv)
2037: {
2038: PC_BDDC *pcbddc = (PC_BDDC *)pc->data;
2039: IS newp;
2040: PetscBool isequal = PETSC_FALSE;
2042: PetscFunctionBegin;
2043: if (!primalv) PetscFunctionReturn(PETSC_SUCCESS);
2044: if (pcbddc->user_primal_vertices_local) {
2045: IS list[2];
2047: list[0] = primalv;
2048: list[1] = pcbddc->user_primal_vertices_local;
2049: PetscCall(ISConcatenate(PetscObjectComm((PetscObject)pc), 2, list, &newp));
2050: PetscCall(ISSortRemoveDups(newp));
2051: } else {
2052: PetscCall(PetscObjectReference((PetscObject)primalv));
2053: newp = primalv;
2054: }
2055: // Retaining the global user input skips the consistency check in PCBDDCAnalyzeInterface().
2056: PetscCall(PCBDDCConsistencyCheckIS(pc, MPI_LOR, &newp));
2057: if (pcbddc->user_primal_vertices_local) PetscCall(ISEqual(newp, pcbddc->user_primal_vertices_local, &isequal));
2058: PetscCall(ISDestroy(&pcbddc->user_primal_vertices_local));
2059: pcbddc->user_primal_vertices_local = newp;
2060: if (!isequal) pcbddc->recompute_topography = PETSC_TRUE;
2061: PetscFunctionReturn(PETSC_SUCCESS);
2062: }
2064: static PetscErrorCode func_coords_private(PetscInt dim, PetscReal t, const PetscReal X[], PetscInt Nf, PetscScalar *out, PetscCtx ctx)
2065: {
2066: PetscInt f, *comp = (PetscInt *)ctx;
2068: PetscFunctionBegin;
2069: for (f = 0; f < Nf; f++) out[f] = X[*comp];
2070: PetscFunctionReturn(PETSC_SUCCESS);
2071: }
2073: PetscErrorCode PCBDDCComputeLocalTopologyInfo(PC pc)
2074: {
2075: Vec local, global;
2076: PC_BDDC *pcbddc = (PC_BDDC *)pc->data;
2077: Mat_IS *matis = (Mat_IS *)pc->pmat->data;
2078: PetscBool monolithic = PETSC_FALSE;
2080: PetscFunctionBegin;
2081: PetscOptionsBegin(PetscObjectComm((PetscObject)pc), ((PetscObject)pc)->prefix, "BDDC topology options", "PC");
2082: PetscCall(PetscOptionsBool("-pc_bddc_monolithic", "Discard any information on dofs splitting", NULL, monolithic, &monolithic, NULL));
2083: PetscOptionsEnd();
2084: /* need to convert from global to local topology information and remove references to information in global ordering */
2085: PetscCall(MatCreateVecs(pc->pmat, &global, NULL));
2086: PetscCall(MatCreateVecs(matis->A, &local, NULL));
2087: PetscCall(VecBindToCPU(global, PETSC_TRUE));
2088: PetscCall(VecBindToCPU(local, PETSC_TRUE));
2089: if (monolithic) { /* just get block size to properly compute vertices */
2090: if (pcbddc->vertex_size == 1) PetscCall(MatGetBlockSize(pc->pmat, &pcbddc->vertex_size));
2091: goto boundary;
2092: }
2094: if (pcbddc->user_provided_isfordofs) {
2095: if (pcbddc->n_ISForDofs) {
2096: PetscInt i;
2098: PetscCall(PetscMalloc1(pcbddc->n_ISForDofs, &pcbddc->ISForDofsLocal));
2099: for (i = 0; i < pcbddc->n_ISForDofs; i++) {
2100: PetscInt bs;
2102: PetscCall(PCBDDCGlobalToLocal(matis->rctx, global, local, pcbddc->ISForDofs[i], &pcbddc->ISForDofsLocal[i]));
2103: PetscCall(ISGetBlockSize(pcbddc->ISForDofs[i], &bs));
2104: PetscCall(ISSetBlockSize(pcbddc->ISForDofsLocal[i], bs));
2105: PetscCall(ISDestroy(&pcbddc->ISForDofs[i]));
2106: }
2107: pcbddc->n_ISForDofsLocal = pcbddc->n_ISForDofs;
2108: pcbddc->n_ISForDofs = 0;
2109: PetscCall(PetscFree(pcbddc->ISForDofs));
2110: }
2111: } else {
2112: if (!pcbddc->n_ISForDofsLocal) { /* field split not present */
2113: DM dm;
2115: PetscCall(MatGetDM(pc->pmat, &dm));
2116: if (!dm) PetscCall(PCGetDM(pc, &dm));
2117: if (dm) {
2118: IS *fields;
2119: PetscInt nf, i;
2121: PetscCall(DMCreateFieldDecomposition(dm, &nf, NULL, &fields, NULL));
2122: PetscCall(PetscMalloc1(nf, &pcbddc->ISForDofsLocal));
2123: for (i = 0; i < nf; i++) {
2124: PetscInt bs;
2126: PetscCall(PCBDDCGlobalToLocal(matis->rctx, global, local, fields[i], &pcbddc->ISForDofsLocal[i]));
2127: PetscCall(ISGetBlockSize(fields[i], &bs));
2128: PetscCall(ISSetBlockSize(pcbddc->ISForDofsLocal[i], bs));
2129: PetscCall(ISDestroy(&fields[i]));
2130: }
2131: PetscCall(PetscFree(fields));
2132: pcbddc->n_ISForDofsLocal = nf;
2133: } else { /* See if MATIS has fields attached by the conversion from MatNest */
2134: PetscContainer c;
2136: PetscCall(PetscObjectQuery((PetscObject)pc->pmat, "_convert_nest_lfields", (PetscObject *)&c));
2137: if (c) {
2138: MatISLocalFields lf;
2139: PetscCall(PetscContainerGetPointer(c, &lf));
2140: PetscCall(PCBDDCSetDofsSplittingLocal(pc, lf->nr, lf->rf));
2141: } else { /* fallback, create the default fields if bs > 1 */
2142: PetscInt i, n = matis->A->rmap->n;
2143: PetscCall(MatGetBlockSize(pc->pmat, &i));
2144: if (i > 1) {
2145: pcbddc->n_ISForDofsLocal = i;
2146: PetscCall(PetscMalloc1(pcbddc->n_ISForDofsLocal, &pcbddc->ISForDofsLocal));
2147: for (i = 0; i < pcbddc->n_ISForDofsLocal; i++) PetscCall(ISCreateStride(PetscObjectComm((PetscObject)pc), n / pcbddc->n_ISForDofsLocal, i, pcbddc->n_ISForDofsLocal, &pcbddc->ISForDofsLocal[i]));
2148: }
2149: }
2150: }
2151: } else {
2152: for (PetscInt i = 0; i < pcbddc->n_ISForDofsLocal; i++) PetscCall(PCBDDCConsistencyCheckIS(pc, MPI_LAND, &pcbddc->ISForDofsLocal[i]));
2153: }
2154: }
2156: boundary:
2157: if (!pcbddc->DirichletBoundariesLocal && pcbddc->DirichletBoundaries) PetscCall(PCBDDCGlobalToLocal(matis->rctx, global, local, pcbddc->DirichletBoundaries, &pcbddc->DirichletBoundariesLocal));
2158: else if (pcbddc->DirichletBoundariesLocal) PetscCall(PCBDDCConsistencyCheckIS(pc, MPI_LAND, &pcbddc->DirichletBoundariesLocal));
2160: if (!pcbddc->NeumannBoundariesLocal && pcbddc->NeumannBoundaries) PetscCall(PCBDDCGlobalToLocal(matis->rctx, global, local, pcbddc->NeumannBoundaries, &pcbddc->NeumannBoundariesLocal));
2161: else if (pcbddc->NeumannBoundariesLocal) PetscCall(PCBDDCConsistencyCheckIS(pc, MPI_LOR, &pcbddc->NeumannBoundariesLocal));
2163: if (!pcbddc->user_primal_vertices_local && pcbddc->user_primal_vertices) PetscCall(PCBDDCGlobalToLocal(matis->rctx, global, local, pcbddc->user_primal_vertices, &pcbddc->user_primal_vertices_local));
2165: PetscCall(VecDestroy(&global));
2166: PetscCall(VecDestroy(&local));
2167: /* detect local disconnected subdomains if requested or needed */
2168: if (pcbddc->detect_disconnected || matis->allow_repeated) {
2169: IS primalv = NULL;
2170: PetscInt nel;
2171: PetscBool filter = pcbddc->detect_disconnected_filter;
2173: for (PetscInt i = 0; i < pcbddc->n_local_subs; i++) PetscCall(ISDestroy(&pcbddc->local_subs[i]));
2174: PetscCall(PetscFree(pcbddc->local_subs));
2175: PetscCall(MatGetVariableBlockSizes(matis->A, &nel, NULL));
2176: if (matis->allow_repeated && nel) {
2177: const PetscInt *elsizes;
2179: pcbddc->n_local_subs = nel;
2180: PetscCall(MatGetVariableBlockSizes(matis->A, NULL, &elsizes));
2181: PetscCall(PetscMalloc1(nel, &pcbddc->local_subs));
2182: for (PetscInt i = 0, c = 0; i < nel; i++) {
2183: PetscCall(ISCreateStride(PETSC_COMM_SELF, elsizes[i], c, 1, &pcbddc->local_subs[i]));
2184: c += elsizes[i];
2185: }
2186: } else {
2187: PetscCall(PCBDDCDetectDisconnectedComponents(pc, filter, &pcbddc->n_local_subs, &pcbddc->local_subs, &primalv));
2188: }
2189: PetscCall(PCBDDCAddPrimalVerticesLocalIS(pc, primalv));
2190: PetscCall(ISDestroy(&primalv));
2191: }
2192: /* early stage corner detection */
2193: {
2194: DM dm;
2196: PetscCall(MatGetDM(pc->pmat, &dm));
2197: if (!dm) PetscCall(PCGetDM(pc, &dm));
2198: if (dm) {
2199: PetscBool isda;
2201: PetscCall(PetscObjectTypeCompare((PetscObject)dm, DMDA, &isda));
2202: if (isda) {
2203: ISLocalToGlobalMapping l2l;
2204: IS corners;
2205: Mat lA;
2206: PetscBool gl;
2208: {
2209: Vec cvec;
2210: const PetscScalar *coords;
2211: PetscInt dof, n, cdim;
2212: PetscBool memc = PetscDefined(USE_COMPLEX) ? PETSC_FALSE : PETSC_TRUE;
2214: PetscCall(DMDAGetInfo(dm, NULL, NULL, NULL, NULL, NULL, NULL, NULL, &dof, NULL, NULL, NULL, NULL, NULL));
2215: PetscCall(DMGetCoordinates(dm, &cvec));
2216: PetscCall(VecGetLocalSize(cvec, &n));
2217: PetscCall(VecGetBlockSize(cvec, &cdim));
2218: n /= cdim;
2219: PetscCall(PetscFree(pcbddc->mat_graph->coords));
2220: PetscCall(PetscMalloc1(dof * n * cdim, &pcbddc->mat_graph->coords));
2221: PetscCall(VecGetArrayRead(cvec, &coords));
2222: if (dof != 1) memc = PETSC_FALSE;
2223: if (memc) {
2224: PetscCall(PetscArraycpy(pcbddc->mat_graph->coords, coords, cdim * n * dof));
2225: } else { /* BDDC graph does not use any blocked information, we need to replicate the data */
2226: PetscReal *bcoords = pcbddc->mat_graph->coords;
2227: PetscInt i, b, d;
2229: for (i = 0; i < n; i++) {
2230: for (b = 0; b < dof; b++) {
2231: for (d = 0; d < cdim; d++) bcoords[i * dof * cdim + b * cdim + d] = PetscRealPart(coords[i * cdim + d]);
2232: }
2233: }
2234: }
2235: PetscCall(VecRestoreArrayRead(cvec, &coords));
2236: pcbddc->mat_graph->cdim = cdim;
2237: pcbddc->mat_graph->cnloc = dof * n;
2238: pcbddc->mat_graph->cloc = PETSC_FALSE;
2239: }
2240: PetscCall(DMDAGetSubdomainCornersIS(dm, &corners));
2241: PetscCall(MatISGetLocalMat(pc->pmat, &lA));
2242: PetscCall(MatGetLocalToGlobalMapping(lA, &l2l, NULL));
2243: PetscCall(MatISRestoreLocalMat(pc->pmat, &lA));
2244: gl = (PetscBool)(l2l && corners);
2245: PetscCallMPI(MPIU_Allreduce(MPI_IN_PLACE, &gl, 1, MPI_C_BOOL, MPI_LAND, PetscObjectComm((PetscObject)pc)));
2246: if (gl) { /* From PETSc's DMDA */
2247: const PetscInt *idx;
2248: PetscInt dof, bs, *idxout, n;
2250: PetscCall(DMDAGetInfo(dm, NULL, NULL, NULL, NULL, NULL, NULL, NULL, &dof, NULL, NULL, NULL, NULL, NULL));
2251: PetscCall(ISLocalToGlobalMappingGetBlockSize(l2l, &bs));
2252: PetscCall(ISGetLocalSize(corners, &n));
2253: PetscCall(ISGetIndices(corners, &idx));
2254: if (bs == dof) {
2255: PetscCall(PetscMalloc1(n, &idxout));
2256: PetscCall(ISLocalToGlobalMappingApplyBlock(l2l, n, idx, idxout));
2257: } else { /* the original DMDA local-to-local map have been modified */
2258: PetscInt i;
2260: PetscCall(PetscMalloc1(dof * n, &idxout));
2261: for (i = 0; i < n; i++)
2262: for (PetscInt d = 0; d < dof; d++) idxout[dof * i + d] = dof * idx[i] + d;
2263: PetscCall(ISLocalToGlobalMappingApply(l2l, dof * n, idxout, idxout));
2265: bs = 1;
2266: n *= dof;
2267: }
2268: PetscCall(ISRestoreIndices(corners, &idx));
2269: PetscCall(DMDARestoreSubdomainCornersIS(dm, &corners));
2270: PetscCall(ISCreateBlock(PetscObjectComm((PetscObject)pc), bs, n, idxout, PETSC_OWN_POINTER, &corners));
2271: PetscCall(PCBDDCAddPrimalVerticesLocalIS(pc, corners));
2272: PetscCall(ISDestroy(&corners));
2273: pcbddc->corner_selected = PETSC_TRUE;
2274: pcbddc->corner_selection = PETSC_TRUE;
2275: }
2276: if (corners) PetscCall(DMDARestoreSubdomainCornersIS(dm, &corners));
2277: }
2278: }
2279: }
2280: if (pcbddc->corner_selection && !pcbddc->mat_graph->cdim) {
2281: DM dm;
2283: PetscCall(MatGetDM(pc->pmat, &dm));
2284: if (!dm) PetscCall(PCGetDM(pc, &dm));
2285: if (dm) { /* this can get very expensive, I need to find a faster alternative */
2286: Vec vcoords;
2287: PetscSection section;
2288: PetscReal *coords;
2289: PetscInt d, cdim, nl, nf, **ctxs;
2290: PetscErrorCode (**funcs)(PetscInt, PetscReal, const PetscReal *, PetscInt, PetscScalar *, void *);
2291: /* debug coordinates */
2292: PetscViewer viewer;
2293: PetscBool flg;
2294: PetscViewerFormat format;
2295: const char *prefix;
2297: PetscCall(DMGetCoordinateDim(dm, &cdim));
2298: PetscCall(DMGetLocalSection(dm, §ion));
2299: PetscCall(PetscSectionGetNumFields(section, &nf));
2300: PetscCall(DMCreateGlobalVector(dm, &vcoords));
2301: PetscCall(VecGetLocalSize(vcoords, &nl));
2302: PetscCall(PetscMalloc1(nl * cdim, &coords));
2303: PetscCall(PetscMalloc2(nf, &funcs, nf, &ctxs));
2304: PetscCall(PetscMalloc1(nf, &ctxs[0]));
2305: for (d = 0; d < nf; d++) funcs[d] = func_coords_private;
2306: for (d = 1; d < nf; d++) ctxs[d] = ctxs[d - 1] + 1;
2308: /* debug coordinates */
2309: PetscCall(PCGetOptionsPrefix(pc, &prefix));
2310: PetscCall(PetscOptionsCreateViewer(PetscObjectComm((PetscObject)vcoords), ((PetscObject)vcoords)->options, prefix, "-pc_bddc_coords_vec_view", &viewer, &format, &flg));
2311: if (flg) PetscCall(PetscViewerPushFormat(viewer, format));
2312: for (d = 0; d < cdim; d++) {
2313: const PetscScalar *v;
2314: char name[16];
2316: for (PetscInt i = 0; i < nf; i++) ctxs[i][0] = d;
2317: PetscCall(PetscSNPrintf(name, sizeof(name), "bddc_coords_%" PetscInt_FMT, d));
2318: PetscCall(PetscObjectSetName((PetscObject)vcoords, name));
2319: PetscCall(DMProjectFunction(dm, 0.0, funcs, (void **)ctxs, INSERT_VALUES, vcoords));
2320: if (flg) PetscCall(VecView(vcoords, viewer));
2321: PetscCall(VecGetArrayRead(vcoords, &v));
2322: for (PetscInt i = 0; i < nl; i++) coords[i * cdim + d] = PetscRealPart(v[i]);
2323: PetscCall(VecRestoreArrayRead(vcoords, &v));
2324: }
2325: PetscCall(VecDestroy(&vcoords));
2326: PetscCall(PCSetCoordinates(pc, cdim, nl, coords));
2327: PetscCall(PetscFree(coords));
2328: PetscCall(PetscFree(ctxs[0]));
2329: PetscCall(PetscFree2(funcs, ctxs));
2330: if (flg) {
2331: PetscCall(PetscViewerPopFormat(viewer));
2332: PetscCall(PetscViewerDestroy(&viewer));
2333: }
2334: }
2335: }
2336: PetscFunctionReturn(PETSC_SUCCESS);
2337: }
2339: PetscErrorCode PCBDDCConsistencyCheckIS(PC pc, MPI_Op mop, IS *is)
2340: {
2341: Mat_IS *matis = (Mat_IS *)pc->pmat->data;
2342: IS nis;
2343: const PetscInt *idxs;
2344: PetscInt i, nd, n = matis->A->rmap->n, *nidxs, nnd;
2346: PetscFunctionBegin;
2347: PetscCheck(mop == MPI_LAND || mop == MPI_LOR, PetscObjectComm((PetscObject)pc), PETSC_ERR_SUP, "Supported are MPI_LAND and MPI_LOR");
2348: if (mop == MPI_LAND) {
2349: /* init rootdata with true */
2350: for (i = 0; i < pc->pmat->rmap->n; i++) matis->sf_rootdata[i] = 1;
2351: } else {
2352: PetscCall(PetscArrayzero(matis->sf_rootdata, pc->pmat->rmap->n));
2353: }
2354: PetscCall(PetscArrayzero(matis->sf_leafdata, n));
2355: PetscCall(ISGetLocalSize(*is, &nd));
2356: PetscCall(ISGetIndices(*is, &idxs));
2357: for (i = 0; i < nd; i++)
2358: if (-1 < idxs[i] && idxs[i] < n) matis->sf_leafdata[idxs[i]] = 1;
2359: PetscCall(ISRestoreIndices(*is, &idxs));
2360: PetscCall(PetscSFReduceBegin(matis->sf, MPIU_INT, matis->sf_leafdata, matis->sf_rootdata, mop));
2361: PetscCall(PetscSFReduceEnd(matis->sf, MPIU_INT, matis->sf_leafdata, matis->sf_rootdata, mop));
2362: PetscCall(PetscSFBcastBegin(matis->sf, MPIU_INT, matis->sf_rootdata, matis->sf_leafdata, MPI_REPLACE));
2363: PetscCall(PetscSFBcastEnd(matis->sf, MPIU_INT, matis->sf_rootdata, matis->sf_leafdata, MPI_REPLACE));
2364: if (mop == MPI_LAND) PetscCall(PetscMalloc1(nd, &nidxs));
2365: else PetscCall(PetscMalloc1(n, &nidxs));
2366: for (i = 0, nnd = 0; i < n; i++)
2367: if (matis->sf_leafdata[i]) nidxs[nnd++] = i;
2368: PetscCall(ISCreateGeneral(PetscObjectComm((PetscObject)*is), nnd, nidxs, PETSC_OWN_POINTER, &nis));
2369: PetscCall(ISDestroy(is));
2370: *is = nis;
2371: PetscFunctionReturn(PETSC_SUCCESS);
2372: }
2374: PetscErrorCode PCBDDCBenignRemoveInterior(PC pc, Vec r, Vec z)
2375: {
2376: PC_IS *pcis = (PC_IS *)pc->data;
2377: PC_BDDC *pcbddc = (PC_BDDC *)pc->data;
2379: PetscFunctionBegin;
2380: if (!pcbddc->benign_have_null) PetscFunctionReturn(PETSC_SUCCESS);
2381: if (pcbddc->ChangeOfBasisMatrix) {
2382: Vec swap;
2384: PetscCall(MatMultTranspose(pcbddc->ChangeOfBasisMatrix, r, pcbddc->work_change));
2385: swap = pcbddc->work_change;
2386: pcbddc->work_change = r;
2387: r = swap;
2388: }
2389: PetscCall(VecScatterBegin(pcis->global_to_D, r, pcis->vec1_D, INSERT_VALUES, SCATTER_FORWARD));
2390: PetscCall(VecScatterEnd(pcis->global_to_D, r, pcis->vec1_D, INSERT_VALUES, SCATTER_FORWARD));
2391: PetscCall(PetscLogEventBegin(PC_BDDC_Solves[pcbddc->current_level][0], pc, 0, 0, 0));
2392: PetscCall(KSPSolve(pcbddc->ksp_D, pcis->vec1_D, pcis->vec2_D));
2393: PetscCall(PetscLogEventEnd(PC_BDDC_Solves[pcbddc->current_level][0], pc, 0, 0, 0));
2394: PetscCall(KSPCheckSolve(pcbddc->ksp_D, pc, pcis->vec2_D));
2395: PetscCall(VecSet(z, 0.));
2396: PetscCall(VecScatterBegin(pcis->global_to_D, pcis->vec2_D, z, INSERT_VALUES, SCATTER_REVERSE));
2397: PetscCall(VecScatterEnd(pcis->global_to_D, pcis->vec2_D, z, INSERT_VALUES, SCATTER_REVERSE));
2398: if (pcbddc->ChangeOfBasisMatrix) {
2399: pcbddc->work_change = r;
2400: PetscCall(VecCopy(z, pcbddc->work_change));
2401: PetscCall(MatMult(pcbddc->ChangeOfBasisMatrix, pcbddc->work_change, z));
2402: }
2403: PetscFunctionReturn(PETSC_SUCCESS);
2404: }
2406: static PetscErrorCode PCBDDCBenignMatMult_Private_Private(Mat A, Vec x, Vec y, PetscBool transpose)
2407: {
2408: PCBDDCBenignMatMult_ctx ctx;
2409: PetscBool apply_right, apply_left, reset_x;
2411: PetscFunctionBegin;
2412: PetscCall(MatShellGetContext(A, &ctx));
2413: if (transpose) {
2414: apply_right = ctx->apply_left;
2415: apply_left = ctx->apply_right;
2416: } else {
2417: apply_right = ctx->apply_right;
2418: apply_left = ctx->apply_left;
2419: }
2420: reset_x = PETSC_FALSE;
2421: if (apply_right) {
2422: const PetscScalar *ax;
2423: PetscInt nl, i;
2425: PetscCall(VecGetLocalSize(x, &nl));
2426: PetscCall(VecGetArrayRead(x, &ax));
2427: PetscCall(PetscArraycpy(ctx->work, ax, nl));
2428: PetscCall(VecRestoreArrayRead(x, &ax));
2429: for (i = 0; i < ctx->benign_n; i++) {
2430: PetscScalar sum, val;
2431: const PetscInt *idxs;
2432: PetscInt nz, j;
2433: PetscCall(ISGetLocalSize(ctx->benign_zerodiag_subs[i], &nz));
2434: PetscCall(ISGetIndices(ctx->benign_zerodiag_subs[i], &idxs));
2435: sum = 0.;
2436: if (ctx->apply_p0) {
2437: val = ctx->work[idxs[nz - 1]];
2438: for (j = 0; j < nz - 1; j++) {
2439: sum += ctx->work[idxs[j]];
2440: ctx->work[idxs[j]] += val;
2441: }
2442: } else {
2443: for (j = 0; j < nz - 1; j++) sum += ctx->work[idxs[j]];
2444: }
2445: ctx->work[idxs[nz - 1]] -= sum;
2446: PetscCall(ISRestoreIndices(ctx->benign_zerodiag_subs[i], &idxs));
2447: }
2448: PetscCall(VecPlaceArray(x, ctx->work));
2449: reset_x = PETSC_TRUE;
2450: }
2451: if (transpose) {
2452: PetscCall(MatMultTranspose(ctx->A, x, y));
2453: } else {
2454: PetscCall(MatMult(ctx->A, x, y));
2455: }
2456: if (reset_x) PetscCall(VecResetArray(x));
2457: if (apply_left) {
2458: PetscScalar *ay;
2459: PetscInt i;
2461: PetscCall(VecGetArray(y, &ay));
2462: for (i = 0; i < ctx->benign_n; i++) {
2463: PetscScalar sum, val;
2464: const PetscInt *idxs;
2465: PetscInt nz;
2466: PetscCall(ISGetLocalSize(ctx->benign_zerodiag_subs[i], &nz));
2467: PetscCall(ISGetIndices(ctx->benign_zerodiag_subs[i], &idxs));
2468: val = -ay[idxs[nz - 1]];
2469: if (ctx->apply_p0) {
2470: sum = 0.;
2471: for (PetscInt j = 0; j < nz - 1; j++) {
2472: sum += ay[idxs[j]];
2473: ay[idxs[j]] += val;
2474: }
2475: ay[idxs[nz - 1]] += sum;
2476: } else {
2477: for (PetscInt j = 0; j < nz - 1; j++) ay[idxs[j]] += val;
2478: ay[idxs[nz - 1]] = 0.;
2479: }
2480: PetscCall(ISRestoreIndices(ctx->benign_zerodiag_subs[i], &idxs));
2481: }
2482: PetscCall(VecRestoreArray(y, &ay));
2483: }
2484: PetscFunctionReturn(PETSC_SUCCESS);
2485: }
2487: static PetscErrorCode PCBDDCBenignMatMultTranspose_Private(Mat A, Vec x, Vec y)
2488: {
2489: PetscFunctionBegin;
2490: PetscCall(PCBDDCBenignMatMult_Private_Private(A, x, y, PETSC_TRUE));
2491: PetscFunctionReturn(PETSC_SUCCESS);
2492: }
2494: static PetscErrorCode PCBDDCBenignMatMult_Private(Mat A, Vec x, Vec y)
2495: {
2496: PetscFunctionBegin;
2497: PetscCall(PCBDDCBenignMatMult_Private_Private(A, x, y, PETSC_FALSE));
2498: PetscFunctionReturn(PETSC_SUCCESS);
2499: }
2501: PetscErrorCode PCBDDCBenignShellMat(PC pc, PetscBool restore)
2502: {
2503: PC_IS *pcis = (PC_IS *)pc->data;
2504: PC_BDDC *pcbddc = (PC_BDDC *)pc->data;
2505: PCBDDCBenignMatMult_ctx ctx;
2507: PetscFunctionBegin;
2508: if (!restore) {
2509: Mat A_IB, A_BI;
2510: PetscScalar *work;
2511: PCBDDCReuseSolvers reuse = pcbddc->sub_schurs ? pcbddc->sub_schurs->reuse_solver : NULL;
2513: PetscCheck(!pcbddc->benign_original_mat, PETSC_COMM_SELF, PETSC_ERR_PLIB, "Benign original mat has not been restored");
2514: if (!pcbddc->benign_change || !pcbddc->benign_n || pcbddc->benign_change_explicit) PetscFunctionReturn(PETSC_SUCCESS);
2515: PetscCall(PetscMalloc1(pcis->n, &work));
2516: PetscCall(MatCreate(PETSC_COMM_SELF, &A_IB));
2517: PetscCall(MatSetSizes(A_IB, pcis->n - pcis->n_B, pcis->n_B, PETSC_DECIDE, PETSC_DECIDE));
2518: PetscCall(MatSetType(A_IB, MATSHELL));
2519: PetscCall(MatShellSetOperation(A_IB, MATOP_MULT, (PetscErrorCodeFn *)PCBDDCBenignMatMult_Private));
2520: PetscCall(MatShellSetOperation(A_IB, MATOP_MULT_TRANSPOSE, (PetscErrorCodeFn *)PCBDDCBenignMatMultTranspose_Private));
2521: PetscCall(PetscNew(&ctx));
2522: PetscCall(MatShellSetContext(A_IB, ctx));
2523: ctx->apply_left = PETSC_TRUE;
2524: ctx->apply_right = PETSC_FALSE;
2525: ctx->apply_p0 = PETSC_FALSE;
2526: ctx->benign_n = pcbddc->benign_n;
2527: if (reuse) {
2528: ctx->benign_zerodiag_subs = reuse->benign_zerodiag_subs;
2529: ctx->free = PETSC_FALSE;
2530: } else { /* TODO: could be optimized for successive solves */
2531: ISLocalToGlobalMapping N_to_D;
2532: PetscInt i;
2534: PetscCall(ISLocalToGlobalMappingCreateIS(pcis->is_I_local, &N_to_D));
2535: PetscCall(PetscMalloc1(pcbddc->benign_n, &ctx->benign_zerodiag_subs));
2536: for (i = 0; i < pcbddc->benign_n; i++) PetscCall(ISGlobalToLocalMappingApplyIS(N_to_D, IS_GTOLM_DROP, pcbddc->benign_zerodiag_subs[i], &ctx->benign_zerodiag_subs[i]));
2537: PetscCall(ISLocalToGlobalMappingDestroy(&N_to_D));
2538: ctx->free = PETSC_TRUE;
2539: }
2540: ctx->A = pcis->A_IB;
2541: ctx->work = work;
2542: PetscCall(MatSetUp(A_IB));
2543: PetscCall(MatAssemblyBegin(A_IB, MAT_FINAL_ASSEMBLY));
2544: PetscCall(MatAssemblyEnd(A_IB, MAT_FINAL_ASSEMBLY));
2545: pcis->A_IB = A_IB;
2547: /* A_BI as A_IB^T */
2548: PetscCall(MatCreateTranspose(A_IB, &A_BI));
2549: pcbddc->benign_original_mat = pcis->A_BI;
2550: pcis->A_BI = A_BI;
2551: } else {
2552: if (!pcbddc->benign_original_mat) PetscFunctionReturn(PETSC_SUCCESS);
2553: PetscCall(MatShellGetContext(pcis->A_IB, &ctx));
2554: PetscCall(MatDestroy(&pcis->A_IB));
2555: pcis->A_IB = ctx->A;
2556: ctx->A = NULL;
2557: PetscCall(MatDestroy(&pcis->A_BI));
2558: pcis->A_BI = pcbddc->benign_original_mat;
2559: pcbddc->benign_original_mat = NULL;
2560: if (ctx->free) {
2561: for (PetscInt i = 0; i < ctx->benign_n; i++) PetscCall(ISDestroy(&ctx->benign_zerodiag_subs[i]));
2562: PetscCall(PetscFree(ctx->benign_zerodiag_subs));
2563: }
2564: PetscCall(PetscFree(ctx->work));
2565: PetscCall(PetscFree(ctx));
2566: }
2567: PetscFunctionReturn(PETSC_SUCCESS);
2568: }
2570: /* used just in bddc debug mode */
2571: static PetscErrorCode PCBDDCBenignProject(PC pc, IS is1, IS is2, Mat *B)
2572: {
2573: PC_BDDC *pcbddc = (PC_BDDC *)pc->data;
2574: Mat_IS *matis = (Mat_IS *)pc->pmat->data;
2575: Mat An;
2577: PetscFunctionBegin;
2578: PetscCall(MatPtAP(matis->A, pcbddc->benign_change, MAT_INITIAL_MATRIX, 2.0, &An));
2579: PetscCall(MatZeroRowsColumns(An, pcbddc->benign_n, pcbddc->benign_p0_lidx, 1.0, NULL, NULL));
2580: if (is1) {
2581: PetscCall(MatCreateSubMatrix(An, is1, is2, MAT_INITIAL_MATRIX, B));
2582: PetscCall(MatDestroy(&An));
2583: } else {
2584: *B = An;
2585: }
2586: PetscFunctionReturn(PETSC_SUCCESS);
2587: }
2589: /* TODO: add reuse flag */
2590: PetscErrorCode MatSeqAIJCompress(Mat A, Mat *B)
2591: {
2592: Mat Bt;
2593: PetscScalar *a, *bdata;
2594: const PetscInt *ii, *ij;
2595: PetscInt m, n, i, nnz, *bii, *bij;
2596: PetscBool flg_row;
2598: PetscFunctionBegin;
2599: PetscCall(MatGetSize(A, &n, &m));
2600: PetscCall(MatGetRowIJ(A, 0, PETSC_FALSE, PETSC_FALSE, &n, &ii, &ij, &flg_row));
2601: PetscCall(MatSeqAIJGetArray(A, &a));
2602: nnz = n;
2603: for (i = 0; i < ii[n]; i++) {
2604: if (PetscLikely(PetscAbsScalar(a[i]) > PETSC_SMALL)) nnz++;
2605: }
2606: PetscCall(PetscMalloc1(n + 1, &bii));
2607: PetscCall(PetscMalloc1(nnz, &bij));
2608: PetscCall(PetscMalloc1(nnz, &bdata));
2609: nnz = 0;
2610: bii[0] = 0;
2611: for (i = 0; i < n; i++) {
2612: PetscInt j;
2613: for (j = ii[i]; j < ii[i + 1]; j++) {
2614: PetscScalar entry = a[j];
2615: if (PetscLikely(PetscAbsScalar(entry) > PETSC_SMALL) || (n == m && ij[j] == i)) {
2616: bij[nnz] = ij[j];
2617: bdata[nnz] = entry;
2618: nnz++;
2619: }
2620: }
2621: bii[i + 1] = nnz;
2622: }
2623: PetscCall(MatSeqAIJRestoreArray(A, &a));
2624: PetscCall(MatCreateSeqAIJWithArrays(PetscObjectComm((PetscObject)A), n, m, bii, bij, bdata, &Bt));
2625: PetscCall(MatRestoreRowIJ(A, 0, PETSC_FALSE, PETSC_FALSE, &n, &ii, &ij, &flg_row));
2626: {
2627: Mat_SeqAIJ *b = (Mat_SeqAIJ *)Bt->data;
2628: b->free_a = PETSC_TRUE;
2629: b->free_ij = PETSC_TRUE;
2630: }
2631: if (*B == A) PetscCall(MatDestroy(&A));
2632: *B = Bt;
2633: PetscFunctionReturn(PETSC_SUCCESS);
2634: }
2636: PetscErrorCode PCBDDCDetectDisconnectedComponents(PC pc, PetscBool filter, PetscInt *ncc, IS *cc[], IS *primalv)
2637: {
2638: Mat B = NULL;
2639: DM dm;
2640: IS is_dummy, *cc_n;
2641: ISLocalToGlobalMapping l2gmap_dummy;
2642: PCBDDCGraph graph;
2643: PetscInt *xadj_filtered = NULL, *adjncy_filtered = NULL;
2644: PetscInt i, n;
2645: PetscInt *xadj, *adjncy;
2646: PetscBool isplex = PETSC_FALSE;
2648: PetscFunctionBegin;
2649: if (ncc) *ncc = 0;
2650: if (cc) *cc = NULL;
2651: if (primalv) *primalv = NULL;
2652: PetscCall(PCBDDCGraphCreate(&graph));
2653: PetscCall(MatGetDM(pc->pmat, &dm));
2654: if (!dm) PetscCall(PCGetDM(pc, &dm));
2655: if (dm) PetscCall(PetscObjectTypeCompareAny((PetscObject)dm, &isplex, DMPLEX, DMP4EST, DMP8EST, ""));
2656: if (filter) isplex = PETSC_FALSE;
2658: if (isplex) { /* this code has been modified from plexpartition.c */
2659: PetscInt p, pStart, pEnd, a, adjSize, idx, size, nroots;
2660: PetscInt *adj = NULL;
2661: IS cellNumbering;
2662: const PetscInt *cellNum;
2663: PetscBool useCone, useClosure;
2664: PetscSection section;
2665: PetscSegBuffer adjBuffer;
2666: PetscSF sfPoint;
2668: PetscCall(DMConvert(dm, DMPLEX, &dm));
2669: PetscCall(DMPlexGetHeightStratum(dm, 0, &pStart, &pEnd));
2670: PetscCall(DMGetPointSF(dm, &sfPoint));
2671: PetscCall(PetscSFGetGraph(sfPoint, &nroots, NULL, NULL, NULL));
2672: /* Build adjacency graph via a section/segbuffer */
2673: PetscCall(PetscSectionCreate(PetscObjectComm((PetscObject)dm), §ion));
2674: PetscCall(PetscSectionSetChart(section, pStart, pEnd));
2675: PetscCall(PetscSegBufferCreate(sizeof(PetscInt), 1000, &adjBuffer));
2676: /* Always use FVM adjacency to create partitioner graph */
2677: PetscCall(DMGetBasicAdjacency(dm, &useCone, &useClosure));
2678: PetscCall(DMSetBasicAdjacency(dm, PETSC_TRUE, PETSC_FALSE));
2679: PetscCall(DMPlexGetCellNumbering(dm, &cellNumbering));
2680: PetscCall(ISGetIndices(cellNumbering, &cellNum));
2681: for (n = 0, p = pStart; p < pEnd; p++) {
2682: /* Skip non-owned cells in parallel (ParMETIS expects no overlap) */
2683: if (nroots > 0) {
2684: if (cellNum[p] < 0) continue;
2685: }
2686: adjSize = PETSC_DETERMINE;
2687: PetscCall(DMPlexGetAdjacency(dm, p, &adjSize, &adj));
2688: for (a = 0; a < adjSize; ++a) {
2689: const PetscInt point = adj[a];
2690: if (pStart <= point && point < pEnd) {
2691: PetscInt *PETSC_RESTRICT pBuf;
2692: PetscCall(PetscSectionAddDof(section, p, 1));
2693: PetscCall(PetscSegBufferGetInts(adjBuffer, 1, &pBuf));
2694: *pBuf = point;
2695: }
2696: }
2697: n++;
2698: }
2699: PetscCall(DMSetBasicAdjacency(dm, useCone, useClosure));
2700: /* Derive CSR graph from section/segbuffer */
2701: PetscCall(PetscSectionSetUp(section));
2702: PetscCall(PetscSectionGetStorageSize(section, &size));
2703: PetscCall(PetscMalloc1(n + 1, &xadj));
2704: for (idx = 0, p = pStart; p < pEnd; p++) {
2705: if (nroots > 0) {
2706: if (cellNum[p] < 0) continue;
2707: }
2708: PetscCall(PetscSectionGetOffset(section, p, &xadj[idx++]));
2709: }
2710: xadj[n] = size;
2711: PetscCall(PetscSegBufferExtractAlloc(adjBuffer, &adjncy));
2712: /* Clean up */
2713: PetscCall(PetscSegBufferDestroy(&adjBuffer));
2714: PetscCall(PetscSectionDestroy(§ion));
2715: PetscCall(PetscFree(adj));
2716: graph->xadj = xadj;
2717: graph->adjncy = adjncy;
2718: } else {
2719: Mat A;
2720: PetscBool isseqaij, flg_row;
2722: PetscCall(MatISGetLocalMat(pc->pmat, &A));
2723: if (!A->rmap->N || !A->cmap->N) {
2724: PetscCall(PCBDDCGraphDestroy(&graph));
2725: PetscFunctionReturn(PETSC_SUCCESS);
2726: }
2727: PetscCall(PetscObjectBaseTypeCompare((PetscObject)A, MATSEQAIJ, &isseqaij));
2728: if (!isseqaij && filter) {
2729: PetscBool isseqdense;
2731: PetscCall(PetscObjectTypeCompare((PetscObject)A, MATSEQDENSE, &isseqdense));
2732: if (!isseqdense) {
2733: PetscCall(MatConvert(A, MATSEQAIJ, MAT_INITIAL_MATRIX, &B));
2734: } else { /* TODO: rectangular case and LDA */
2735: PetscScalar *array;
2736: PetscReal chop = 1.e-6;
2738: PetscCall(MatDuplicate(A, MAT_COPY_VALUES, &B));
2739: PetscCall(MatDenseGetArray(B, &array));
2740: PetscCall(MatGetSize(B, &n, NULL));
2741: for (i = 0; i < n; i++) {
2742: for (PetscInt j = i + 1; j < n; j++) {
2743: PetscReal thresh = chop * (PetscAbsScalar(array[i * (n + 1)]) + PetscAbsScalar(array[j * (n + 1)]));
2744: if (PetscAbsScalar(array[i * n + j]) < thresh) array[i * n + j] = 0.;
2745: if (PetscAbsScalar(array[j * n + i]) < thresh) array[j * n + i] = 0.;
2746: }
2747: }
2748: PetscCall(MatDenseRestoreArray(B, &array));
2749: PetscCall(MatConvert(B, MATSEQAIJ, MAT_INPLACE_MATRIX, &B));
2750: }
2751: } else {
2752: PetscCall(PetscObjectReference((PetscObject)A));
2753: B = A;
2754: }
2755: PetscCall(MatGetRowIJ(B, 0, PETSC_TRUE, PETSC_FALSE, &n, (const PetscInt **)&xadj, (const PetscInt **)&adjncy, &flg_row));
2757: /* if filter is true, then removes entries lower than PETSC_SMALL in magnitude */
2758: if (filter) {
2759: PetscScalar *data;
2760: PetscInt cum;
2762: PetscCall(PetscCalloc2(n + 1, &xadj_filtered, xadj[n], &adjncy_filtered));
2763: PetscCall(MatSeqAIJGetArray(B, &data));
2764: cum = 0;
2765: for (i = 0; i < n; i++) {
2766: PetscInt t;
2768: for (PetscInt j = xadj[i]; j < xadj[i + 1]; j++) {
2769: if (PetscUnlikely(PetscAbsScalar(data[j]) < PETSC_SMALL)) continue;
2770: adjncy_filtered[cum + xadj_filtered[i]++] = adjncy[j];
2771: }
2772: t = xadj_filtered[i];
2773: xadj_filtered[i] = cum;
2774: cum += t;
2775: }
2776: PetscCall(MatSeqAIJRestoreArray(B, &data));
2777: graph->xadj = xadj_filtered;
2778: graph->adjncy = adjncy_filtered;
2779: } else {
2780: graph->xadj = xadj;
2781: graph->adjncy = adjncy;
2782: }
2783: }
2784: /* compute local connected components using PCBDDCGraph */
2785: graph->seq_graph = PETSC_TRUE; /* analyze local connected components (i.e. disconnected subdomains) irrespective of dofs count */
2786: PetscCall(ISCreateStride(PETSC_COMM_SELF, n, 0, 1, &is_dummy));
2787: PetscCall(ISLocalToGlobalMappingCreateIS(is_dummy, &l2gmap_dummy));
2788: PetscCall(ISDestroy(&is_dummy));
2789: PetscCall(PCBDDCGraphInit(graph, l2gmap_dummy, n, PETSC_INT_MAX));
2790: PetscCall(ISLocalToGlobalMappingDestroy(&l2gmap_dummy));
2791: PetscCall(PCBDDCGraphSetUp(graph, 1, NULL, NULL, 0, NULL, NULL));
2792: PetscCall(PCBDDCGraphComputeConnectedComponents(graph));
2794: /* partial clean up */
2795: PetscCall(PetscFree2(xadj_filtered, adjncy_filtered));
2796: if (B) {
2797: PetscBool flg_row;
2798: PetscCall(MatRestoreRowIJ(B, 0, PETSC_TRUE, PETSC_FALSE, &n, (const PetscInt **)&xadj, (const PetscInt **)&adjncy, &flg_row));
2799: PetscCall(MatDestroy(&B));
2800: }
2801: if (isplex) {
2802: PetscCall(PetscFree(xadj));
2803: PetscCall(PetscFree(adjncy));
2804: }
2806: /* get back data */
2807: if (isplex) {
2808: if (ncc) *ncc = graph->ncc;
2809: if (cc || primalv) {
2810: Mat A;
2811: PetscBT btv, btvt, btvc;
2812: PetscSection subSection;
2813: PetscInt *ids, cum, cump, *cids, *pids;
2814: PetscInt dim, cStart, cEnd, fStart, fEnd, vStart, vEnd, pStart, pEnd;
2816: PetscCall(DMGetDimension(dm, &dim));
2817: PetscCall(DMPlexGetSubdomainSection(dm, &subSection));
2818: PetscCall(DMPlexGetHeightStratum(dm, 1, &fStart, &fEnd));
2819: PetscCall(DMPlexGetHeightStratum(dm, 0, &cStart, &cEnd));
2820: PetscCall(DMPlexGetDepthStratum(dm, 0, &vStart, &vEnd));
2821: PetscCall(DMPlexGetChart(dm, &pStart, &pEnd));
2822: PetscCall(MatISGetLocalMat(pc->pmat, &A));
2823: PetscCall(PetscMalloc3(A->rmap->n, &ids, graph->ncc + 1, &cids, A->rmap->n, &pids));
2824: PetscCall(PetscBTCreate(A->rmap->n, &btv));
2825: PetscCall(PetscBTCreate(A->rmap->n, &btvt));
2826: PetscCall(PetscBTCreate(pEnd - pStart, &btvc));
2828: /* First see if we find corners for the subdomains, i.e. a vertex
2829: shared by at least dim subdomain boundary faces. This does not
2830: cover all the possible cases with simplices but it is enough
2831: for tensor cells */
2832: if (vStart != fStart && dim <= 3) {
2833: for (PetscInt c = cStart; c < cEnd; c++) {
2834: PetscInt nf, cnt = 0, mcnt = dim, *cfaces;
2835: const PetscInt *faces;
2837: PetscCall(DMPlexGetConeSize(dm, c, &nf));
2838: PetscCall(DMGetWorkArray(dm, nf, MPIU_INT, &cfaces));
2839: PetscCall(DMPlexGetCone(dm, c, &faces));
2840: for (PetscInt f = 0; f < nf; f++) {
2841: PetscInt nc, ff;
2843: PetscCall(DMPlexGetSupportSize(dm, faces[f], &nc));
2844: PetscCall(DMPlexGetTreeParent(dm, faces[f], &ff, NULL));
2845: if (nc == 1 && faces[f] == ff) cfaces[cnt++] = faces[f];
2846: }
2847: if (cnt >= mcnt) {
2848: PetscInt size, *closure = NULL;
2850: PetscCall(DMPlexGetTransitiveClosure(dm, c, PETSC_TRUE, &size, &closure));
2851: for (PetscInt k = 0; k < 2 * size; k += 2) {
2852: PetscInt v = closure[k];
2853: if (v >= vStart && v < vEnd) {
2854: PetscInt vsize, *vclosure = NULL;
2856: cnt = 0;
2857: PetscCall(DMPlexGetTransitiveClosure(dm, v, PETSC_FALSE, &vsize, &vclosure));
2858: for (PetscInt vk = 0; vk < 2 * vsize; vk += 2) {
2859: PetscInt f = vclosure[vk];
2860: if (f >= fStart && f < fEnd) {
2861: PetscInt nc, ff;
2862: PetscBool valid = PETSC_FALSE;
2864: for (PetscInt fk = 0; fk < nf; fk++)
2865: if (f == cfaces[fk]) valid = PETSC_TRUE;
2866: if (!valid) continue;
2867: PetscCall(DMPlexGetSupportSize(dm, f, &nc));
2868: PetscCall(DMPlexGetTreeParent(dm, f, &ff, NULL));
2869: if (nc == 1 && f == ff) cnt++;
2870: }
2871: }
2872: if (cnt >= mcnt) PetscCall(PetscBTSet(btvc, v - pStart));
2873: PetscCall(DMPlexRestoreTransitiveClosure(dm, v, PETSC_FALSE, &vsize, &vclosure));
2874: }
2875: }
2876: PetscCall(DMPlexRestoreTransitiveClosure(dm, c, PETSC_TRUE, &size, &closure));
2877: }
2878: PetscCall(DMRestoreWorkArray(dm, nf, MPIU_INT, &cfaces));
2879: }
2880: }
2882: cids[0] = 0;
2883: for (i = 0, cump = 0, cum = 0; i < graph->ncc; i++) {
2884: PetscCall(PetscBTMemzero(A->rmap->n, btvt));
2885: for (PetscInt j = graph->cptr[i]; j < graph->cptr[i + 1]; j++) {
2886: PetscInt k, size, *closure = NULL, cell = graph->queue[j];
2888: PetscCall(DMPlexGetTransitiveClosure(dm, cell, PETSC_TRUE, &size, &closure));
2889: for (k = 0; k < 2 * size; k += 2) {
2890: PetscInt s, pp, p = closure[k], off, dof, cdof;
2892: PetscCall(PetscSectionGetConstraintDof(subSection, p, &cdof));
2893: PetscCall(PetscSectionGetOffset(subSection, p, &off));
2894: PetscCall(PetscSectionGetDof(subSection, p, &dof));
2895: for (s = 0; s < dof - cdof; s++) {
2896: if (PetscBTLookupSet(btvt, off + s)) continue;
2897: if (PetscBTLookup(btvc, p - pStart)) pids[cump++] = off + s; /* subdomain corner */
2898: else if (!PetscBTLookup(btv, off + s)) ids[cum++] = off + s;
2899: else pids[cump++] = off + s; /* cross-vertex */
2900: }
2901: PetscCall(DMPlexGetTreeParent(dm, p, &pp, NULL));
2902: if (pp != p) {
2903: PetscCall(PetscSectionGetConstraintDof(subSection, pp, &cdof));
2904: PetscCall(PetscSectionGetOffset(subSection, pp, &off));
2905: PetscCall(PetscSectionGetDof(subSection, pp, &dof));
2906: for (s = 0; s < dof - cdof; s++) {
2907: if (PetscBTLookupSet(btvt, off + s)) continue;
2908: if (PetscBTLookup(btvc, pp - pStart)) pids[cump++] = off + s; /* subdomain corner */
2909: else if (!PetscBTLookup(btv, off + s)) ids[cum++] = off + s;
2910: else pids[cump++] = off + s; /* cross-vertex */
2911: }
2912: }
2913: }
2914: PetscCall(DMPlexRestoreTransitiveClosure(dm, cell, PETSC_TRUE, &size, &closure));
2915: }
2916: cids[i + 1] = cum;
2917: /* mark dofs as already assigned */
2918: for (PetscInt j = cids[i]; j < cids[i + 1]; j++) PetscCall(PetscBTSet(btv, ids[j]));
2919: }
2920: if (cc) {
2921: PetscCall(PetscMalloc1(graph->ncc, &cc_n));
2922: for (i = 0; i < graph->ncc; i++) PetscCall(ISCreateGeneral(PETSC_COMM_SELF, cids[i + 1] - cids[i], ids + cids[i], PETSC_COPY_VALUES, &cc_n[i]));
2923: *cc = cc_n;
2924: }
2925: if (primalv) PetscCall(ISCreateGeneral(PetscObjectComm((PetscObject)pc), cump, pids, PETSC_COPY_VALUES, primalv));
2926: PetscCall(PetscFree3(ids, cids, pids));
2927: PetscCall(PetscBTDestroy(&btv));
2928: PetscCall(PetscBTDestroy(&btvt));
2929: PetscCall(PetscBTDestroy(&btvc));
2930: PetscCall(DMDestroy(&dm));
2931: }
2932: } else {
2933: if (ncc) *ncc = graph->ncc;
2934: if (cc) {
2935: PetscCall(PetscMalloc1(graph->ncc, &cc_n));
2936: for (i = 0; i < graph->ncc; i++) PetscCall(ISCreateGeneral(PETSC_COMM_SELF, graph->cptr[i + 1] - graph->cptr[i], graph->queue + graph->cptr[i], PETSC_COPY_VALUES, &cc_n[i]));
2937: *cc = cc_n;
2938: }
2939: }
2940: /* clean up graph */
2941: graph->xadj = NULL;
2942: graph->adjncy = NULL;
2943: PetscCall(PCBDDCGraphDestroy(&graph));
2944: PetscFunctionReturn(PETSC_SUCCESS);
2945: }
2947: PetscErrorCode PCBDDCBenignCheck(PC pc, IS zerodiag)
2948: {
2949: PC_BDDC *pcbddc = (PC_BDDC *)pc->data;
2950: PC_IS *pcis = (PC_IS *)pc->data;
2951: IS dirIS = NULL;
2952: PetscInt i;
2954: PetscFunctionBegin;
2955: PetscCall(PCBDDCGraphGetDirichletDofs(pcbddc->mat_graph, &dirIS));
2956: if (zerodiag) {
2957: Mat A;
2958: Vec vec3_N;
2959: PetscScalar *vals;
2960: const PetscInt *idxs;
2961: PetscInt nz, *count;
2963: /* p0 */
2964: PetscCall(VecSet(pcis->vec1_N, 0.));
2965: PetscCall(PetscMalloc1(pcis->n, &vals));
2966: PetscCall(ISGetLocalSize(zerodiag, &nz));
2967: PetscCall(ISGetIndices(zerodiag, &idxs));
2968: for (i = 0; i < nz; i++) vals[i] = 1.;
2969: PetscCall(VecSetValues(pcis->vec1_N, nz, idxs, vals, INSERT_VALUES));
2970: PetscCall(VecAssemblyBegin(pcis->vec1_N));
2971: PetscCall(VecAssemblyEnd(pcis->vec1_N));
2972: /* v_I */
2973: PetscCall(VecSetRandom(pcis->vec2_N, NULL));
2974: for (i = 0; i < nz; i++) vals[i] = 0.;
2975: PetscCall(VecSetValues(pcis->vec2_N, nz, idxs, vals, INSERT_VALUES));
2976: PetscCall(ISRestoreIndices(zerodiag, &idxs));
2977: PetscCall(ISGetIndices(pcis->is_B_local, &idxs));
2978: for (i = 0; i < pcis->n_B; i++) vals[i] = 0.;
2979: PetscCall(VecSetValues(pcis->vec2_N, pcis->n_B, idxs, vals, INSERT_VALUES));
2980: PetscCall(ISRestoreIndices(pcis->is_B_local, &idxs));
2981: if (dirIS) {
2982: PetscInt n;
2984: PetscCall(ISGetLocalSize(dirIS, &n));
2985: PetscCall(ISGetIndices(dirIS, &idxs));
2986: for (i = 0; i < n; i++) vals[i] = 0.;
2987: PetscCall(VecSetValues(pcis->vec2_N, n, idxs, vals, INSERT_VALUES));
2988: PetscCall(ISRestoreIndices(dirIS, &idxs));
2989: }
2990: PetscCall(VecAssemblyBegin(pcis->vec2_N));
2991: PetscCall(VecAssemblyEnd(pcis->vec2_N));
2992: PetscCall(VecDuplicate(pcis->vec1_N, &vec3_N));
2993: PetscCall(MatISGetLocalMat(pc->pmat, &A));
2994: PetscCall(MatMult(A, pcis->vec1_N, vec3_N));
2995: PetscCall(VecDot(vec3_N, pcis->vec2_N, &vals[0]));
2996: PetscCheck(PetscAbsScalar(vals[0]) <= 1.e-1, PETSC_COMM_SELF, PETSC_ERR_SUP, "Benign trick can not be applied! b(v_I,p_0) = %1.6e (should be numerically 0.)", (double)PetscAbsScalar(vals[0]));
2997: PetscCall(PetscFree(vals));
2998: PetscCall(VecDestroy(&vec3_N));
3000: /* there should not be any pressure dofs lying on the interface */
3001: PetscCall(PetscCalloc1(pcis->n, &count));
3002: PetscCall(ISGetIndices(pcis->is_B_local, &idxs));
3003: for (i = 0; i < pcis->n_B; i++) count[idxs[i]]++;
3004: PetscCall(ISRestoreIndices(pcis->is_B_local, &idxs));
3005: PetscCall(ISGetIndices(zerodiag, &idxs));
3006: for (i = 0; i < nz; i++) PetscCheck(!count[idxs[i]], PETSC_COMM_SELF, PETSC_ERR_SUP, "Benign trick can not be applied! pressure dof %" PetscInt_FMT " is an interface dof", idxs[i]);
3007: PetscCall(ISRestoreIndices(zerodiag, &idxs));
3008: PetscCall(PetscFree(count));
3009: }
3010: PetscCall(ISDestroy(&dirIS));
3012: /* check PCBDDCBenignGetOrSetP0 */
3013: PetscCall(VecSetRandom(pcis->vec1_global, NULL));
3014: for (i = 0; i < pcbddc->benign_n; i++) pcbddc->benign_p0[i] = -PetscGlobalRank - i;
3015: PetscCall(PCBDDCBenignGetOrSetP0(pc, pcis->vec1_global, PETSC_FALSE));
3016: for (i = 0; i < pcbddc->benign_n; i++) pcbddc->benign_p0[i] = 1;
3017: PetscCall(PCBDDCBenignGetOrSetP0(pc, pcis->vec1_global, PETSC_TRUE));
3018: for (i = 0; i < pcbddc->benign_n; i++) {
3019: PetscInt val = PetscRealPart(pcbddc->benign_p0[i]);
3020: PetscCheck(val == -PetscGlobalRank - i, PETSC_COMM_SELF, PETSC_ERR_PLIB, "Error testing PCBDDCBenignGetOrSetP0! Found %g at %" PetscInt_FMT " instead of %g", (double)PetscRealPart(pcbddc->benign_p0[i]), i, (double)(-PetscGlobalRank - i));
3021: }
3022: PetscFunctionReturn(PETSC_SUCCESS);
3023: }
3025: PetscErrorCode PCBDDCBenignDetectSaddlePoint(PC pc, PetscBool reuse, IS *zerodiaglocal)
3026: {
3027: PC_BDDC *pcbddc = (PC_BDDC *)pc->data;
3028: Mat_IS *matis = (Mat_IS *)pc->pmat->data;
3029: IS pressures = NULL, zerodiag = NULL, *bzerodiag = NULL, zerodiag_save, *zerodiag_subs;
3030: PetscInt nz, n, benign_n, bsp = 1;
3031: PetscInt *interior_dofs, n_interior_dofs, nneu;
3032: PetscBool sorted, have_null, has_null_pressures, recompute_zerodiag, checkb;
3034: PetscFunctionBegin;
3035: if (reuse) goto project_b0;
3036: PetscCall(PetscSFDestroy(&pcbddc->benign_sf));
3037: PetscCall(MatDestroy(&pcbddc->benign_B0));
3038: for (n = 0; n < pcbddc->benign_n; n++) PetscCall(ISDestroy(&pcbddc->benign_zerodiag_subs[n]));
3039: PetscCall(PetscFree(pcbddc->benign_zerodiag_subs));
3040: has_null_pressures = PETSC_TRUE;
3041: have_null = PETSC_TRUE;
3042: /* if a local information on dofs is present, gets pressure dofs from command line (uses the last field is not provided)
3043: Without local information, it uses only the zerodiagonal dofs (ok if the pressure block is all zero and it is a scalar field)
3044: Checks if all the pressure dofs in each subdomain have a zero diagonal
3045: If not, a change of basis on pressures is not needed
3046: since the local Schur complements are already SPD
3047: */
3048: if (pcbddc->n_ISForDofsLocal) {
3049: IS iP = NULL;
3050: PetscInt p, *pp;
3051: PetscBool flg, blocked = PETSC_FALSE;
3053: PetscCall(PetscMalloc1(pcbddc->n_ISForDofsLocal, &pp));
3054: n = pcbddc->n_ISForDofsLocal;
3055: PetscOptionsBegin(PetscObjectComm((PetscObject)pc), ((PetscObject)pc)->prefix, "BDDC benign options", "PC");
3056: PetscCall(PetscOptionsIntArray("-pc_bddc_pressure_field", "Field id for pressures", NULL, pp, &n, &flg));
3057: PetscCall(PetscOptionsBool("-pc_bddc_pressure_blocked", "Use blocked pressure fields", NULL, blocked, &blocked, NULL));
3058: PetscOptionsEnd();
3059: if (!flg) {
3060: n = 1;
3061: pp[0] = pcbddc->n_ISForDofsLocal - 1;
3062: }
3064: bsp = 0;
3065: for (p = 0; p < n; p++) {
3066: PetscInt bs = 1;
3068: PetscCheck(pp[p] >= 0 && pp[p] < pcbddc->n_ISForDofsLocal, PetscObjectComm((PetscObject)pc), PETSC_ERR_USER, "Invalid field id for pressures %" PetscInt_FMT, pp[p]);
3069: if (blocked) PetscCall(ISGetBlockSize(pcbddc->ISForDofsLocal[pp[p]], &bs));
3070: bsp += bs;
3071: }
3072: PetscCall(PetscMalloc1(bsp, &bzerodiag));
3073: bsp = 0;
3074: for (p = 0; p < n; p++) {
3075: const PetscInt *idxs;
3076: PetscInt b, bs = 1, npl, *bidxs;
3078: if (blocked) PetscCall(ISGetBlockSize(pcbddc->ISForDofsLocal[pp[p]], &bs));
3079: PetscCall(ISGetLocalSize(pcbddc->ISForDofsLocal[pp[p]], &npl));
3080: PetscCall(ISGetIndices(pcbddc->ISForDofsLocal[pp[p]], &idxs));
3081: PetscCall(PetscMalloc1(npl / bs, &bidxs));
3082: for (b = 0; b < bs; b++) {
3083: PetscInt i;
3085: for (i = 0; i < npl / bs; i++) bidxs[i] = idxs[bs * i + b];
3086: PetscCall(ISCreateGeneral(PETSC_COMM_SELF, npl / bs, bidxs, PETSC_COPY_VALUES, &bzerodiag[bsp]));
3087: bsp++;
3088: }
3089: PetscCall(PetscFree(bidxs));
3090: PetscCall(ISRestoreIndices(pcbddc->ISForDofsLocal[pp[p]], &idxs));
3091: }
3092: PetscCall(ISConcatenate(PETSC_COMM_SELF, bsp, bzerodiag, &pressures));
3094: /* remove zeroed out pressures if we are setting up a BDDC solver for a saddle-point FETI-DP */
3095: PetscCall(PetscObjectQuery((PetscObject)pc, "__KSPFETIDP_lP", (PetscObject *)&iP));
3096: if (iP) {
3097: IS newpressures;
3099: PetscCall(ISDifference(pressures, iP, &newpressures));
3100: PetscCall(ISDestroy(&pressures));
3101: pressures = newpressures;
3102: }
3103: PetscCall(ISSorted(pressures, &sorted));
3104: if (!sorted) PetscCall(ISSort(pressures));
3105: PetscCall(PetscFree(pp));
3106: }
3108: /* pcis has not been setup yet, so get the local size from the subdomain matrix */
3109: PetscCall(MatGetLocalSize(pcbddc->local_mat, &n, NULL));
3110: if (!n) pcbddc->benign_change_explicit = PETSC_TRUE;
3111: PetscCall(MatFindZeroDiagonals(pcbddc->local_mat, &zerodiag));
3112: PetscCall(ISSorted(zerodiag, &sorted));
3113: if (!sorted) PetscCall(ISSort(zerodiag));
3114: PetscCall(PetscObjectReference((PetscObject)zerodiag));
3115: zerodiag_save = zerodiag;
3116: PetscCall(ISGetLocalSize(zerodiag, &nz));
3117: if (!nz) {
3118: if (n) have_null = PETSC_FALSE;
3119: has_null_pressures = PETSC_FALSE;
3120: PetscCall(ISDestroy(&zerodiag));
3121: }
3122: recompute_zerodiag = PETSC_FALSE;
3124: /* in case disconnected subdomains info is present, split the pressures accordingly (otherwise the benign trick could fail) */
3125: zerodiag_subs = NULL;
3126: benign_n = 0;
3127: n_interior_dofs = 0;
3128: interior_dofs = NULL;
3129: nneu = 0;
3130: if (pcbddc->NeumannBoundariesLocal) PetscCall(ISGetLocalSize(pcbddc->NeumannBoundariesLocal, &nneu));
3131: checkb = (PetscBool)(!pcbddc->NeumannBoundariesLocal || pcbddc->current_level);
3132: if (checkb) { /* need to compute interior nodes */
3133: PetscInt n, i;
3134: PetscInt *count;
3135: ISLocalToGlobalMapping mapping;
3137: PetscCall(MatISGetLocalToGlobalMapping(pc->pmat, &mapping, NULL));
3138: PetscCall(ISLocalToGlobalMappingGetNodeInfo(mapping, &n, &count, NULL));
3139: PetscCall(PetscMalloc1(n, &interior_dofs));
3140: for (i = 0; i < n; i++)
3141: if (count[i] < 2) interior_dofs[n_interior_dofs++] = i;
3142: PetscCall(ISLocalToGlobalMappingRestoreNodeInfo(mapping, &n, &count, NULL));
3143: }
3144: if (has_null_pressures) {
3145: IS *subs;
3146: PetscInt nsubs, i, j, nl;
3147: const PetscInt *idxs;
3148: PetscScalar *array;
3149: Vec *work;
3151: subs = pcbddc->local_subs;
3152: nsubs = pcbddc->n_local_subs;
3153: /* these vectors are needed to check if the constant on pressures is in the kernel of the local operator B (i.e. B(v_I,p0) should be zero) */
3154: if (checkb) {
3155: PetscCall(VecDuplicateVecs(matis->y, 2, &work));
3156: PetscCall(ISGetLocalSize(zerodiag, &nl));
3157: PetscCall(ISGetIndices(zerodiag, &idxs));
3158: /* work[0] = 1_p */
3159: PetscCall(VecGetArray(work[0], &array));
3160: for (j = 0; j < nl; j++) array[idxs[j]] = 1.;
3161: PetscCall(VecRestoreArray(work[0], &array));
3162: /* work[0] = 1_v */
3163: PetscCall(VecSet(work[1], 1.));
3164: PetscCall(VecGetArray(work[1], &array));
3165: for (j = 0; j < nl; j++) array[idxs[j]] = 0.;
3166: PetscCall(VecRestoreArray(work[1], &array));
3167: PetscCall(ISRestoreIndices(zerodiag, &idxs));
3168: }
3170: if (nsubs > 1 || bsp > 1) {
3171: IS *is;
3172: PetscInt totb;
3174: totb = bsp;
3175: is = bsp > 1 ? bzerodiag : &zerodiag;
3176: nsubs = PetscMax(nsubs, 1);
3177: PetscCall(PetscCalloc1(nsubs * totb, &zerodiag_subs));
3178: for (PetscInt b = 0; b < totb; b++) {
3179: for (i = 0; i < nsubs; i++) {
3180: ISLocalToGlobalMapping l2g;
3181: IS t_zerodiag_subs;
3182: PetscInt nl;
3184: if (subs) {
3185: PetscCall(ISLocalToGlobalMappingCreateIS(subs[i], &l2g));
3186: } else {
3187: IS tis;
3189: PetscCall(MatGetLocalSize(pcbddc->local_mat, &nl, NULL));
3190: PetscCall(ISCreateStride(PETSC_COMM_SELF, nl, 0, 1, &tis));
3191: PetscCall(ISLocalToGlobalMappingCreateIS(tis, &l2g));
3192: PetscCall(ISDestroy(&tis));
3193: }
3194: PetscCall(ISGlobalToLocalMappingApplyIS(l2g, IS_GTOLM_DROP, is[b], &t_zerodiag_subs));
3195: PetscCall(ISGetLocalSize(t_zerodiag_subs, &nl));
3196: if (nl) {
3197: PetscBool valid = PETSC_TRUE;
3199: if (checkb) {
3200: PetscCall(VecSet(matis->x, 0));
3201: PetscCall(ISGetLocalSize(subs[i], &nl));
3202: PetscCall(ISGetIndices(subs[i], &idxs));
3203: PetscCall(VecGetArray(matis->x, &array));
3204: for (j = 0; j < nl; j++) array[idxs[j]] = 1.;
3205: PetscCall(VecRestoreArray(matis->x, &array));
3206: PetscCall(ISRestoreIndices(subs[i], &idxs));
3207: PetscCall(VecPointwiseMult(matis->x, work[0], matis->x));
3208: PetscCall(MatMult(matis->A, matis->x, matis->y));
3209: PetscCall(VecPointwiseMult(matis->y, work[1], matis->y));
3210: PetscCall(VecGetArray(matis->y, &array));
3211: for (j = 0; j < n_interior_dofs; j++) {
3212: if (PetscAbsScalar(array[interior_dofs[j]]) > PETSC_SMALL) {
3213: valid = PETSC_FALSE;
3214: break;
3215: }
3216: }
3217: PetscCall(VecRestoreArray(matis->y, &array));
3218: }
3219: if (valid && nneu) {
3220: const PetscInt *idxs;
3221: PetscInt nzb;
3223: PetscCall(ISGetIndices(pcbddc->NeumannBoundariesLocal, &idxs));
3224: PetscCall(ISGlobalToLocalMappingApply(l2g, IS_GTOLM_DROP, nneu, idxs, &nzb, NULL));
3225: PetscCall(ISRestoreIndices(pcbddc->NeumannBoundariesLocal, &idxs));
3226: if (nzb) valid = PETSC_FALSE;
3227: }
3228: if (valid && pressures) {
3229: IS t_pressure_subs, tmp;
3230: PetscInt i1, i2;
3232: PetscCall(ISGlobalToLocalMappingApplyIS(l2g, IS_GTOLM_DROP, pressures, &t_pressure_subs));
3233: PetscCall(ISEmbed(t_zerodiag_subs, t_pressure_subs, PETSC_TRUE, &tmp));
3234: PetscCall(ISGetLocalSize(tmp, &i1));
3235: PetscCall(ISGetLocalSize(t_zerodiag_subs, &i2));
3236: if (i2 != i1) valid = PETSC_FALSE;
3237: PetscCall(ISDestroy(&t_pressure_subs));
3238: PetscCall(ISDestroy(&tmp));
3239: }
3240: if (valid) {
3241: PetscCall(ISLocalToGlobalMappingApplyIS(l2g, t_zerodiag_subs, &zerodiag_subs[benign_n]));
3242: benign_n++;
3243: } else recompute_zerodiag = PETSC_TRUE;
3244: }
3245: PetscCall(ISDestroy(&t_zerodiag_subs));
3246: PetscCall(ISLocalToGlobalMappingDestroy(&l2g));
3247: }
3248: }
3249: } else { /* there's just one subdomain (or zero if they have not been detected */
3250: PetscBool valid = PETSC_TRUE;
3252: if (nneu) valid = PETSC_FALSE;
3253: if (valid && pressures) PetscCall(ISEqual(pressures, zerodiag, &valid));
3254: if (valid && checkb) {
3255: PetscCall(MatMult(matis->A, work[0], matis->x));
3256: PetscCall(VecPointwiseMult(matis->x, work[1], matis->x));
3257: PetscCall(VecGetArray(matis->x, &array));
3258: for (j = 0; j < n_interior_dofs; j++) {
3259: if (PetscAbsScalar(array[interior_dofs[j]]) > PETSC_SMALL) {
3260: valid = PETSC_FALSE;
3261: break;
3262: }
3263: }
3264: PetscCall(VecRestoreArray(matis->x, &array));
3265: }
3266: if (valid) {
3267: benign_n = 1;
3268: PetscCall(PetscMalloc1(benign_n, &zerodiag_subs));
3269: PetscCall(PetscObjectReference((PetscObject)zerodiag));
3270: zerodiag_subs[0] = zerodiag;
3271: }
3272: }
3273: if (checkb) PetscCall(VecDestroyVecs(2, &work));
3274: }
3275: PetscCall(PetscFree(interior_dofs));
3277: if (!benign_n) {
3278: PetscInt n;
3280: PetscCall(ISDestroy(&zerodiag));
3281: recompute_zerodiag = PETSC_FALSE;
3282: PetscCall(MatGetLocalSize(pcbddc->local_mat, &n, NULL));
3283: if (n) have_null = PETSC_FALSE;
3284: }
3286: /* final check for null pressures */
3287: if (zerodiag && pressures) PetscCall(ISEqual(pressures, zerodiag, &have_null));
3289: if (recompute_zerodiag) {
3290: PetscCall(ISDestroy(&zerodiag));
3291: if (benign_n == 1) {
3292: PetscCall(PetscObjectReference((PetscObject)zerodiag_subs[0]));
3293: zerodiag = zerodiag_subs[0];
3294: } else {
3295: PetscInt i, nzn, *new_idxs;
3297: nzn = 0;
3298: for (i = 0; i < benign_n; i++) {
3299: PetscInt ns;
3300: PetscCall(ISGetLocalSize(zerodiag_subs[i], &ns));
3301: nzn += ns;
3302: }
3303: PetscCall(PetscMalloc1(nzn, &new_idxs));
3304: nzn = 0;
3305: for (i = 0; i < benign_n; i++) {
3306: PetscInt ns, *idxs;
3307: PetscCall(ISGetLocalSize(zerodiag_subs[i], &ns));
3308: PetscCall(ISGetIndices(zerodiag_subs[i], (const PetscInt **)&idxs));
3309: PetscCall(PetscArraycpy(new_idxs + nzn, idxs, ns));
3310: PetscCall(ISRestoreIndices(zerodiag_subs[i], (const PetscInt **)&idxs));
3311: nzn += ns;
3312: }
3313: PetscCall(PetscSortInt(nzn, new_idxs));
3314: PetscCall(ISCreateGeneral(PETSC_COMM_SELF, nzn, new_idxs, PETSC_OWN_POINTER, &zerodiag));
3315: }
3316: have_null = PETSC_FALSE;
3317: }
3319: /* determines if the coarse solver will be singular or not */
3320: PetscCallMPI(MPIU_Allreduce(&have_null, &pcbddc->benign_null, 1, MPI_C_BOOL, MPI_LAND, PetscObjectComm((PetscObject)pc)));
3322: /* Prepare matrix to compute no-net-flux */
3323: if (pcbddc->compute_nonetflux && !pcbddc->divudotp) {
3324: Mat A, loc_divudotp;
3325: ISLocalToGlobalMapping rl2g, cl2g, l2gmap;
3326: IS row, col, isused = NULL;
3327: PetscInt M, N, n, st, n_isused;
3329: if (pressures) {
3330: isused = pressures;
3331: } else {
3332: isused = zerodiag_save;
3333: }
3334: PetscCall(MatISGetLocalToGlobalMapping(pc->pmat, &l2gmap, NULL));
3335: PetscCall(MatISGetLocalMat(pc->pmat, &A));
3336: PetscCall(MatGetLocalSize(A, &n, NULL));
3337: PetscCheck(isused || (n == 0), PETSC_COMM_SELF, PETSC_ERR_USER, "Don't know how to extract div u dot p! Please provide the pressure field");
3338: n_isused = 0;
3339: if (isused) PetscCall(ISGetLocalSize(isused, &n_isused));
3340: PetscCallMPI(MPI_Scan(&n_isused, &st, 1, MPIU_INT, MPI_SUM, PetscObjectComm((PetscObject)pc)));
3341: st = st - n_isused;
3342: if (n) {
3343: const PetscInt *gidxs;
3345: PetscCall(MatCreateSubMatrix(A, isused, NULL, MAT_INITIAL_MATRIX, &loc_divudotp));
3346: PetscCall(ISLocalToGlobalMappingGetIndices(l2gmap, &gidxs));
3347: /* TODO: extend ISCreateStride with st = PETSC_DECIDE */
3348: PetscCall(ISCreateStride(PetscObjectComm((PetscObject)pc), n_isused, st, 1, &row));
3349: PetscCall(ISCreateGeneral(PetscObjectComm((PetscObject)pc), n, gidxs, PETSC_COPY_VALUES, &col));
3350: PetscCall(ISLocalToGlobalMappingRestoreIndices(l2gmap, &gidxs));
3351: } else {
3352: PetscCall(MatCreateSeqAIJ(PETSC_COMM_SELF, 0, 0, 1, NULL, &loc_divudotp));
3353: PetscCall(ISCreateStride(PetscObjectComm((PetscObject)pc), n_isused, st, 1, &row));
3354: PetscCall(ISCreateGeneral(PetscObjectComm((PetscObject)pc), 0, NULL, PETSC_COPY_VALUES, &col));
3355: }
3356: PetscCall(MatGetSize(pc->pmat, NULL, &N));
3357: PetscCall(ISGetSize(row, &M));
3358: PetscCall(ISLocalToGlobalMappingCreateIS(row, &rl2g));
3359: PetscCall(ISLocalToGlobalMappingCreateIS(col, &cl2g));
3360: PetscCall(ISDestroy(&row));
3361: PetscCall(ISDestroy(&col));
3362: PetscCall(MatCreate(PetscObjectComm((PetscObject)pc), &pcbddc->divudotp));
3363: PetscCall(MatSetType(pcbddc->divudotp, MATIS));
3364: PetscCall(MatSetSizes(pcbddc->divudotp, PETSC_DECIDE, PETSC_DECIDE, M, N));
3365: PetscCall(MatSetLocalToGlobalMapping(pcbddc->divudotp, rl2g, cl2g));
3366: PetscCall(ISLocalToGlobalMappingDestroy(&rl2g));
3367: PetscCall(ISLocalToGlobalMappingDestroy(&cl2g));
3368: PetscCall(MatISSetLocalMat(pcbddc->divudotp, loc_divudotp));
3369: PetscCall(MatDestroy(&loc_divudotp));
3370: PetscCall(MatAssemblyBegin(pcbddc->divudotp, MAT_FINAL_ASSEMBLY));
3371: PetscCall(MatAssemblyEnd(pcbddc->divudotp, MAT_FINAL_ASSEMBLY));
3372: }
3373: PetscCall(ISDestroy(&zerodiag_save));
3374: PetscCall(ISDestroy(&pressures));
3375: if (bzerodiag) {
3376: PetscInt i;
3378: for (i = 0; i < bsp; i++) PetscCall(ISDestroy(&bzerodiag[i]));
3379: PetscCall(PetscFree(bzerodiag));
3380: }
3381: pcbddc->benign_n = benign_n;
3382: pcbddc->benign_zerodiag_subs = zerodiag_subs;
3384: /* determines if the problem has subdomains with 0 pressure block */
3385: have_null = (PetscBool)(!!pcbddc->benign_n);
3386: PetscCallMPI(MPIU_Allreduce(&have_null, &pcbddc->benign_have_null, 1, MPI_C_BOOL, MPI_LOR, PetscObjectComm((PetscObject)pc)));
3388: project_b0:
3389: PetscCall(MatGetLocalSize(pcbddc->local_mat, &n, NULL));
3390: /* change of basis and p0 dofs */
3391: if (pcbddc->benign_n) {
3392: PetscInt i, s, *nnz;
3394: /* local change of basis for pressures */
3395: PetscCall(MatDestroy(&pcbddc->benign_change));
3396: PetscCall(MatCreate(PetscObjectComm((PetscObject)pcbddc->local_mat), &pcbddc->benign_change));
3397: PetscCall(MatSetType(pcbddc->benign_change, MATAIJ));
3398: PetscCall(MatSetSizes(pcbddc->benign_change, n, n, PETSC_DECIDE, PETSC_DECIDE));
3399: PetscCall(PetscMalloc1(n, &nnz));
3400: for (i = 0; i < n; i++) nnz[i] = 1; /* defaults to identity */
3401: for (i = 0; i < pcbddc->benign_n; i++) {
3402: const PetscInt *idxs;
3403: PetscInt nzs;
3405: PetscCall(ISGetLocalSize(pcbddc->benign_zerodiag_subs[i], &nzs));
3406: PetscCall(ISGetIndices(pcbddc->benign_zerodiag_subs[i], &idxs));
3407: for (PetscInt j = 0; j < nzs - 1; j++) nnz[idxs[j]] = 2; /* change on pressures */
3408: nnz[idxs[nzs - 1]] = nzs; /* last local pressure dof in subdomain */
3409: PetscCall(ISRestoreIndices(pcbddc->benign_zerodiag_subs[i], &idxs));
3410: }
3411: PetscCall(MatSeqAIJSetPreallocation(pcbddc->benign_change, 0, nnz));
3412: PetscCall(MatSetOption(pcbddc->benign_change, MAT_NEW_NONZERO_ALLOCATION_ERR, PETSC_TRUE));
3413: PetscCall(PetscFree(nnz));
3414: /* set identity by default */
3415: for (i = 0; i < n; i++) PetscCall(MatSetValue(pcbddc->benign_change, i, i, 1., INSERT_VALUES));
3416: PetscCall(PetscFree3(pcbddc->benign_p0_lidx, pcbddc->benign_p0_gidx, pcbddc->benign_p0));
3417: PetscCall(PetscMalloc3(pcbddc->benign_n, &pcbddc->benign_p0_lidx, pcbddc->benign_n, &pcbddc->benign_p0_gidx, pcbddc->benign_n, &pcbddc->benign_p0));
3418: /* set change on pressures */
3419: for (s = 0; s < pcbddc->benign_n; s++) {
3420: PetscScalar *array;
3421: const PetscInt *idxs;
3422: PetscInt nzs;
3424: PetscCall(ISGetLocalSize(pcbddc->benign_zerodiag_subs[s], &nzs));
3425: PetscCall(ISGetIndices(pcbddc->benign_zerodiag_subs[s], &idxs));
3426: for (i = 0; i < nzs - 1; i++) {
3427: PetscScalar vals[2];
3428: PetscInt cols[2];
3430: cols[0] = idxs[i];
3431: cols[1] = idxs[nzs - 1];
3432: vals[0] = 1.;
3433: vals[1] = 1.;
3434: PetscCall(MatSetValues(pcbddc->benign_change, 1, cols, 2, cols, vals, INSERT_VALUES));
3435: }
3436: PetscCall(PetscMalloc1(nzs, &array));
3437: for (i = 0; i < nzs - 1; i++) array[i] = -1.;
3438: array[nzs - 1] = 1.;
3439: PetscCall(MatSetValues(pcbddc->benign_change, 1, idxs + nzs - 1, nzs, idxs, array, INSERT_VALUES));
3440: /* store local idxs for p0 */
3441: pcbddc->benign_p0_lidx[s] = idxs[nzs - 1];
3442: PetscCall(ISRestoreIndices(pcbddc->benign_zerodiag_subs[s], &idxs));
3443: PetscCall(PetscFree(array));
3444: }
3445: PetscCall(MatAssemblyBegin(pcbddc->benign_change, MAT_FINAL_ASSEMBLY));
3446: PetscCall(MatAssemblyEnd(pcbddc->benign_change, MAT_FINAL_ASSEMBLY));
3448: /* project if needed */
3449: if (pcbddc->benign_change_explicit) {
3450: Mat M;
3452: PetscCall(MatPtAP(pcbddc->local_mat, pcbddc->benign_change, MAT_INITIAL_MATRIX, 2.0, &M));
3453: PetscCall(MatDestroy(&pcbddc->local_mat));
3454: PetscCall(MatSeqAIJCompress(M, &pcbddc->local_mat));
3455: PetscCall(MatDestroy(&M));
3456: }
3457: /* store global idxs for p0 */
3458: PetscCall(ISLocalToGlobalMappingApply(matis->rmapping, pcbddc->benign_n, pcbddc->benign_p0_lidx, pcbddc->benign_p0_gidx));
3459: }
3460: *zerodiaglocal = zerodiag;
3461: PetscFunctionReturn(PETSC_SUCCESS);
3462: }
3464: PetscErrorCode PCBDDCBenignGetOrSetP0(PC pc, Vec v, PetscBool get)
3465: {
3466: PC_BDDC *pcbddc = (PC_BDDC *)pc->data;
3467: PetscScalar *array;
3469: PetscFunctionBegin;
3470: if (!pcbddc->benign_sf) {
3471: PetscCall(PetscSFCreate(PetscObjectComm((PetscObject)pc), &pcbddc->benign_sf));
3472: PetscCall(PetscSFSetGraphLayout(pcbddc->benign_sf, pc->pmat->rmap, pcbddc->benign_n, NULL, PETSC_OWN_POINTER, pcbddc->benign_p0_gidx));
3473: }
3474: if (get) {
3475: PetscCall(VecGetArrayRead(v, (const PetscScalar **)&array));
3476: PetscCall(PetscSFBcastBegin(pcbddc->benign_sf, MPIU_SCALAR, array, pcbddc->benign_p0, MPI_REPLACE));
3477: PetscCall(PetscSFBcastEnd(pcbddc->benign_sf, MPIU_SCALAR, array, pcbddc->benign_p0, MPI_REPLACE));
3478: PetscCall(VecRestoreArrayRead(v, (const PetscScalar **)&array));
3479: } else {
3480: PetscCall(VecGetArray(v, &array));
3481: PetscCall(PetscSFReduceBegin(pcbddc->benign_sf, MPIU_SCALAR, pcbddc->benign_p0, array, MPI_REPLACE));
3482: PetscCall(PetscSFReduceEnd(pcbddc->benign_sf, MPIU_SCALAR, pcbddc->benign_p0, array, MPI_REPLACE));
3483: PetscCall(VecRestoreArray(v, &array));
3484: }
3485: PetscFunctionReturn(PETSC_SUCCESS);
3486: }
3488: PetscErrorCode PCBDDCBenignPopOrPushB0(PC pc, PetscBool pop)
3489: {
3490: PC_BDDC *pcbddc = (PC_BDDC *)pc->data;
3492: PetscFunctionBegin;
3493: /* TODO: add error checking
3494: - avoid nested pop (or push) calls.
3495: - cannot push before pop.
3496: - cannot call this if pcbddc->local_mat is NULL
3497: */
3498: if (!pcbddc->benign_n) PetscFunctionReturn(PETSC_SUCCESS);
3499: if (pop) {
3500: if (pcbddc->benign_change_explicit) {
3501: IS is_p0;
3502: MatReuse reuse;
3504: /* extract B_0 */
3505: reuse = MAT_INITIAL_MATRIX;
3506: if (pcbddc->benign_B0) reuse = MAT_REUSE_MATRIX;
3507: PetscCall(ISCreateGeneral(PETSC_COMM_SELF, pcbddc->benign_n, pcbddc->benign_p0_lidx, PETSC_COPY_VALUES, &is_p0));
3508: PetscCall(MatCreateSubMatrix(pcbddc->local_mat, is_p0, NULL, reuse, &pcbddc->benign_B0));
3509: /* remove rows and cols from local problem */
3510: PetscCall(MatSetOption(pcbddc->local_mat, MAT_KEEP_NONZERO_PATTERN, PETSC_TRUE));
3511: PetscCall(MatSetOption(pcbddc->local_mat, MAT_NEW_NONZERO_LOCATION_ERR, PETSC_FALSE));
3512: PetscCall(MatZeroRowsColumnsIS(pcbddc->local_mat, is_p0, 1.0, NULL, NULL));
3513: PetscCall(ISDestroy(&is_p0));
3514: } else {
3515: Mat_IS *matis = (Mat_IS *)pc->pmat->data;
3516: PetscScalar *vals;
3517: PetscInt i, n, *idxs_ins;
3519: PetscCall(VecGetLocalSize(matis->y, &n));
3520: PetscCall(PetscMalloc2(n, &idxs_ins, n, &vals));
3521: if (!pcbddc->benign_B0) {
3522: PetscInt *nnz;
3523: PetscCall(MatCreate(PetscObjectComm((PetscObject)pcbddc->local_mat), &pcbddc->benign_B0));
3524: PetscCall(MatSetType(pcbddc->benign_B0, MATAIJ));
3525: PetscCall(MatSetSizes(pcbddc->benign_B0, pcbddc->benign_n, n, PETSC_DECIDE, PETSC_DECIDE));
3526: PetscCall(PetscMalloc1(pcbddc->benign_n, &nnz));
3527: for (i = 0; i < pcbddc->benign_n; i++) {
3528: PetscCall(ISGetLocalSize(pcbddc->benign_zerodiag_subs[i], &nnz[i]));
3529: nnz[i] = n - nnz[i];
3530: }
3531: PetscCall(MatSeqAIJSetPreallocation(pcbddc->benign_B0, 0, nnz));
3532: PetscCall(MatSetOption(pcbddc->benign_B0, MAT_NEW_NONZERO_ALLOCATION_ERR, PETSC_TRUE));
3533: PetscCall(PetscFree(nnz));
3534: }
3536: for (i = 0; i < pcbddc->benign_n; i++) {
3537: PetscScalar *array;
3538: PetscInt *idxs, j, nz, cum;
3540: PetscCall(VecSet(matis->x, 0.));
3541: PetscCall(ISGetLocalSize(pcbddc->benign_zerodiag_subs[i], &nz));
3542: PetscCall(ISGetIndices(pcbddc->benign_zerodiag_subs[i], (const PetscInt **)&idxs));
3543: for (j = 0; j < nz; j++) vals[j] = 1.;
3544: PetscCall(VecSetValues(matis->x, nz, idxs, vals, INSERT_VALUES));
3545: PetscCall(VecAssemblyBegin(matis->x));
3546: PetscCall(VecAssemblyEnd(matis->x));
3547: PetscCall(VecSet(matis->y, 0.));
3548: PetscCall(MatMult(matis->A, matis->x, matis->y));
3549: PetscCall(VecGetArray(matis->y, &array));
3550: cum = 0;
3551: for (j = 0; j < n; j++) {
3552: if (PetscUnlikely(PetscAbsScalar(array[j]) > PETSC_SMALL)) {
3553: vals[cum] = array[j];
3554: idxs_ins[cum] = j;
3555: cum++;
3556: }
3557: }
3558: PetscCall(MatSetValues(pcbddc->benign_B0, 1, &i, cum, idxs_ins, vals, INSERT_VALUES));
3559: PetscCall(VecRestoreArray(matis->y, &array));
3560: PetscCall(ISRestoreIndices(pcbddc->benign_zerodiag_subs[i], (const PetscInt **)&idxs));
3561: }
3562: PetscCall(MatAssemblyBegin(pcbddc->benign_B0, MAT_FINAL_ASSEMBLY));
3563: PetscCall(MatAssemblyEnd(pcbddc->benign_B0, MAT_FINAL_ASSEMBLY));
3564: PetscCall(PetscFree2(idxs_ins, vals));
3565: }
3566: } else { /* push */
3568: PetscCheck(pcbddc->benign_change_explicit, PETSC_COMM_SELF, PETSC_ERR_PLIB, "Cannot push B0!");
3569: for (PetscInt i = 0; i < pcbddc->benign_n; i++) {
3570: PetscScalar *B0_vals;
3571: PetscInt *B0_cols, B0_ncol;
3573: PetscCall(MatGetRow(pcbddc->benign_B0, i, &B0_ncol, (const PetscInt **)&B0_cols, (const PetscScalar **)&B0_vals));
3574: PetscCall(MatSetValues(pcbddc->local_mat, 1, pcbddc->benign_p0_lidx + i, B0_ncol, B0_cols, B0_vals, INSERT_VALUES));
3575: PetscCall(MatSetValues(pcbddc->local_mat, B0_ncol, B0_cols, 1, pcbddc->benign_p0_lidx + i, B0_vals, INSERT_VALUES));
3576: PetscCall(MatSetValue(pcbddc->local_mat, pcbddc->benign_p0_lidx[i], pcbddc->benign_p0_lidx[i], 0.0, INSERT_VALUES));
3577: PetscCall(MatRestoreRow(pcbddc->benign_B0, i, &B0_ncol, (const PetscInt **)&B0_cols, (const PetscScalar **)&B0_vals));
3578: }
3579: PetscCall(MatAssemblyBegin(pcbddc->local_mat, MAT_FINAL_ASSEMBLY));
3580: PetscCall(MatAssemblyEnd(pcbddc->local_mat, MAT_FINAL_ASSEMBLY));
3581: }
3582: PetscFunctionReturn(PETSC_SUCCESS);
3583: }
3585: PetscErrorCode PCBDDCAdaptiveSelection(PC pc)
3586: {
3587: PC_BDDC *pcbddc = (PC_BDDC *)pc->data;
3588: PCBDDCSubSchurs sub_schurs = pcbddc->sub_schurs;
3589: PetscBLASInt B_neigs, B_lwork;
3590: PetscBLASInt *B_iwork, *B_ifail;
3591: PetscScalar *work, lwork;
3592: PetscScalar *St, *S, *eigv;
3593: PetscScalar *Sarray, *Starray;
3594: PetscReal *eigs, thresh, lthresh, uthresh;
3595: PetscInt i, nmax, nmin, nv, cum, mss, cum2, cumarray, maxneigs;
3596: PetscBool allocated_S_St, upart;
3597: #if PetscDefined(USE_COMPLEX)
3598: PetscReal *rwork;
3599: #endif
3601: PetscFunctionBegin;
3602: if (!pcbddc->adaptive_selection) PetscFunctionReturn(PETSC_SUCCESS);
3603: PetscCheck(sub_schurs, PETSC_COMM_SELF, PETSC_ERR_PLIB, "Adaptive selection of constraints requires SubSchurs data");
3604: PetscCheck(sub_schurs->schur_explicit || !sub_schurs->n_subs, PetscObjectComm((PetscObject)pc), PETSC_ERR_SUP, "Adaptive selection of constraints requires MUMPS and/or MKL_CPARDISO");
3605: PetscCheck(!sub_schurs->n_subs || sub_schurs->is_symmetric, PETSC_COMM_SELF, PETSC_ERR_SUP, "Adaptive selection not yet implemented for this matrix pencil (herm %d, symm %d, posdef %d)", sub_schurs->is_hermitian, sub_schurs->is_symmetric,
3606: sub_schurs->is_posdef);
3607: PetscCall(PetscLogEventBegin(PC_BDDC_AdaptiveSetUp[pcbddc->current_level], pc, 0, 0, 0));
3609: if (pcbddc->dbg_flag) {
3610: if (!pcbddc->dbg_viewer) pcbddc->dbg_viewer = PETSC_VIEWER_STDOUT_(PetscObjectComm((PetscObject)pc));
3611: PetscCall(PetscViewerFlush(pcbddc->dbg_viewer));
3612: PetscCall(PetscViewerASCIIPrintf(pcbddc->dbg_viewer, "--------------------------------------------------\n"));
3613: PetscCall(PetscViewerASCIIPrintf(pcbddc->dbg_viewer, "Check adaptive selection of constraints\n"));
3614: PetscCall(PetscViewerASCIIPushSynchronized(pcbddc->dbg_viewer));
3615: }
3617: if (pcbddc->dbg_flag) PetscCall(PetscViewerASCIISynchronizedPrintf(pcbddc->dbg_viewer, "Subdomain %04d cc %" PetscInt_FMT " (%d,%d).\n", PetscGlobalRank, sub_schurs->n_subs, sub_schurs->is_hermitian, sub_schurs->is_posdef));
3619: /* max size of subsets */
3620: mss = 0;
3621: for (i = 0; i < sub_schurs->n_subs; i++) {
3622: PetscInt subset_size;
3624: PetscCall(ISGetLocalSize(sub_schurs->is_subs[i], &subset_size));
3625: mss = PetscMax(mss, subset_size);
3626: }
3628: /* min/max and threshold */
3629: nmax = pcbddc->adaptive_nmax > 0 ? pcbddc->adaptive_nmax : mss;
3630: nmin = pcbddc->adaptive_nmin > 0 ? pcbddc->adaptive_nmin : 0;
3631: nmax = PetscMax(nmin, nmax);
3632: allocated_S_St = PETSC_FALSE;
3633: if (nmin || !sub_schurs->is_posdef) { /* XXX */
3634: allocated_S_St = PETSC_TRUE;
3635: }
3637: /* allocate lapack workspace */
3638: cum = cum2 = 0;
3639: maxneigs = 0;
3640: for (i = 0; i < sub_schurs->n_subs; i++) {
3641: PetscInt n, subset_size;
3643: PetscCall(ISGetLocalSize(sub_schurs->is_subs[i], &subset_size));
3644: n = PetscMin(subset_size, nmax);
3645: cum += subset_size;
3646: cum2 += subset_size * n;
3647: maxneigs = PetscMax(maxneigs, n);
3648: }
3649: lwork = 0;
3650: if (mss) {
3651: PetscScalar sdummy = 0.;
3652: PetscBLASInt B_itype = 1;
3653: PetscBLASInt B_N, idummy = 0;
3654: PetscReal rdummy = 0., zero = 0.0;
3655: PetscReal eps = 0.0; /* dlamch? */
3657: PetscCheck(sub_schurs->is_symmetric, PETSC_COMM_SELF, PETSC_ERR_SUP, "Not yet implemented");
3658: PetscCall(PetscBLASIntCast(mss, &B_N));
3659: B_lwork = -1;
3660: /* some implementations may complain about NULL pointers, even if we are querying */
3661: S = &sdummy;
3662: St = &sdummy;
3663: eigs = &rdummy;
3664: eigv = &sdummy;
3665: B_iwork = &idummy;
3666: B_ifail = &idummy;
3667: #if PetscDefined(USE_COMPLEX)
3668: rwork = &rdummy;
3669: #endif
3670: thresh = 1.0;
3671: PetscCall(PetscFPTrapPush(PETSC_FP_TRAP_OFF));
3672: #if PetscDefined(USE_COMPLEX)
3673: PetscCallLAPACKInfo("LAPACKsygvx", LAPACKsygvx_(&B_itype, "V", "V", "L", &B_N, St, &B_N, S, &B_N, &zero, &thresh, B_iwork, B_iwork, &eps, &B_neigs, eigs, eigv, &B_N, &lwork, &B_lwork, rwork, B_iwork, B_ifail, &info));
3674: #else
3675: PetscCallLAPACKInfo("LAPACKsygvx", LAPACKsygvx_(&B_itype, "V", "V", "L", &B_N, St, &B_N, S, &B_N, &zero, &thresh, B_iwork, B_iwork, &eps, &B_neigs, eigs, eigv, &B_N, &lwork, &B_lwork, B_iwork, B_ifail, &info));
3676: #endif
3677: PetscCall(PetscFPTrapPop());
3678: }
3680: nv = 0;
3681: if (sub_schurs->is_vertices && pcbddc->use_vertices) { /* complement set of active subsets, each entry is a vertex (boundary made by active subsets, vertices and dirichlet dofs) */
3682: PetscCall(ISGetLocalSize(sub_schurs->is_vertices, &nv));
3683: }
3684: PetscCall(PetscBLASIntCast((PetscInt)PetscRealPart(lwork), &B_lwork));
3685: if (allocated_S_St) PetscCall(PetscMalloc2(mss * mss, &S, mss * mss, &St));
3686: PetscCall(PetscMalloc5(mss * mss, &eigv, mss, &eigs, B_lwork, &work, 5 * mss, &B_iwork, mss, &B_ifail));
3687: #if PetscDefined(USE_COMPLEX)
3688: PetscCall(PetscMalloc1(7 * mss, &rwork));
3689: #endif
3690: PetscCall(PetscMalloc5(nv + sub_schurs->n_subs, &pcbddc->adaptive_constraints_n, nv + sub_schurs->n_subs + 1, &pcbddc->adaptive_constraints_idxs_ptr, nv + sub_schurs->n_subs + 1, &pcbddc->adaptive_constraints_data_ptr, nv + cum, &pcbddc->adaptive_constraints_idxs, nv + cum2,
3691: &pcbddc->adaptive_constraints_data));
3692: PetscCall(PetscArrayzero(pcbddc->adaptive_constraints_n, nv + sub_schurs->n_subs));
3694: maxneigs = 0;
3695: cum = cumarray = 0;
3696: pcbddc->adaptive_constraints_idxs_ptr[0] = 0;
3697: pcbddc->adaptive_constraints_data_ptr[0] = 0;
3698: if (sub_schurs->is_vertices && pcbddc->use_vertices) {
3699: const PetscInt *idxs;
3701: PetscCall(ISGetIndices(sub_schurs->is_vertices, &idxs));
3702: for (cum = 0; cum < nv; cum++) {
3703: pcbddc->adaptive_constraints_n[cum] = 1;
3704: pcbddc->adaptive_constraints_idxs[cum] = idxs[cum];
3705: pcbddc->adaptive_constraints_data[cum] = 1.0;
3706: pcbddc->adaptive_constraints_idxs_ptr[cum + 1] = pcbddc->adaptive_constraints_idxs_ptr[cum] + 1;
3707: pcbddc->adaptive_constraints_data_ptr[cum + 1] = pcbddc->adaptive_constraints_data_ptr[cum] + 1;
3708: }
3709: PetscCall(ISRestoreIndices(sub_schurs->is_vertices, &idxs));
3710: }
3712: if (mss) { /* multilevel */
3713: if (sub_schurs->gdsw) {
3714: PetscCall(MatSeqAIJGetArray(sub_schurs->sum_S_Ej_all, &Sarray));
3715: PetscCall(MatSeqAIJGetArray(sub_schurs->sum_S_Ej_tilda_all, &Starray));
3716: } else {
3717: PetscCall(MatSeqAIJGetArray(sub_schurs->sum_S_Ej_inv_all, &Sarray));
3718: PetscCall(MatSeqAIJGetArray(sub_schurs->sum_S_Ej_tilda_all, &Starray));
3719: }
3720: }
3722: lthresh = pcbddc->adaptive_threshold[0];
3723: uthresh = pcbddc->adaptive_threshold[1];
3724: upart = pcbddc->use_deluxe_scaling;
3725: for (i = 0; i < sub_schurs->n_subs; i++) {
3726: const PetscInt *idxs;
3727: PetscReal upper, lower;
3728: PetscInt j, subset_size, eigs_start = 0;
3729: PetscBLASInt B_N;
3730: PetscBool same_data = PETSC_FALSE;
3731: PetscBool scal = PETSC_FALSE;
3733: if (upart) {
3734: upper = PETSC_MAX_REAL;
3735: lower = uthresh;
3736: } else {
3737: if (sub_schurs->gdsw) {
3738: upper = uthresh;
3739: lower = PETSC_MIN_REAL;
3740: } else {
3741: PetscCheck(sub_schurs->is_posdef, PETSC_COMM_SELF, PETSC_ERR_SUP, "Not yet implemented without deluxe scaling");
3742: upper = 1. / uthresh;
3743: lower = 0.;
3744: }
3745: }
3746: PetscCall(ISGetLocalSize(sub_schurs->is_subs[i], &subset_size));
3747: PetscCall(ISGetIndices(sub_schurs->is_subs[i], &idxs));
3748: PetscCall(PetscBLASIntCast(subset_size, &B_N));
3749: /* this is experimental: we assume the dofs have been properly grouped to have
3750: the diagonal blocks Schur complements either positive or negative definite (true for Stokes) */
3751: if (!sub_schurs->is_posdef) {
3752: Mat T;
3754: for (j = 0; j < subset_size; j++) {
3755: if (PetscRealPart(*(Sarray + cumarray + j * (subset_size + 1))) < 0.0) {
3756: PetscCall(MatCreateSeqDense(PETSC_COMM_SELF, subset_size, subset_size, Sarray + cumarray, &T));
3757: PetscCall(MatScale(T, -1.0));
3758: PetscCall(MatDestroy(&T));
3759: PetscCall(MatCreateSeqDense(PETSC_COMM_SELF, subset_size, subset_size, Starray + cumarray, &T));
3760: PetscCall(MatScale(T, -1.0));
3761: PetscCall(MatDestroy(&T));
3762: if (sub_schurs->change_primal_sub) {
3763: PetscInt nz;
3764: const PetscInt *idxs;
3766: PetscCall(ISGetLocalSize(sub_schurs->change_primal_sub[i], &nz));
3767: PetscCall(ISGetIndices(sub_schurs->change_primal_sub[i], &idxs));
3768: for (PetscInt k = 0; k < nz; k++) {
3769: *(Sarray + cumarray + idxs[k] * (subset_size + 1)) *= -1.0;
3770: *(Starray + cumarray + idxs[k] * (subset_size + 1)) = 0.0;
3771: }
3772: PetscCall(ISRestoreIndices(sub_schurs->change_primal_sub[i], &idxs));
3773: }
3774: scal = PETSC_TRUE;
3775: break;
3776: }
3777: }
3778: }
3780: if (allocated_S_St) { /* S and S_t should be copied since we could need them later */
3781: if (sub_schurs->is_symmetric) {
3782: if (sub_schurs->n_subs == 1) { /* zeroing memory to use PetscArraycmp() later */
3783: PetscCall(PetscArrayzero(S, subset_size * subset_size));
3784: PetscCall(PetscArrayzero(St, subset_size * subset_size));
3785: }
3786: for (PetscInt j = 0; j < subset_size; j++) {
3787: for (PetscInt k = j; k < subset_size; k++) {
3788: S[j * subset_size + k] = Sarray[cumarray + j * subset_size + k];
3789: St[j * subset_size + k] = Starray[cumarray + j * subset_size + k];
3790: }
3791: }
3792: } else {
3793: PetscCall(PetscArraycpy(S, Sarray + cumarray, subset_size * subset_size));
3794: PetscCall(PetscArraycpy(St, Starray + cumarray, subset_size * subset_size));
3795: }
3796: } else {
3797: S = Sarray + cumarray;
3798: St = Starray + cumarray;
3799: }
3800: /* see if we can save some work */
3801: if (sub_schurs->n_subs == 1 && pcbddc->use_deluxe_scaling) PetscCall(PetscArraycmp(S, St, subset_size * subset_size, &same_data));
3803: if (same_data && !sub_schurs->change) { /* there's no need of constraints here */
3804: B_neigs = 0;
3805: } else {
3806: PetscBLASInt B_itype = 1, B_IL = 1, B_IU = 0;
3807: PetscReal eps = -1.0; /* dlamch? */
3808: PetscInt nmin_s;
3809: PetscBool compute_range;
3811: PetscCheck(sub_schurs->is_symmetric, PETSC_COMM_SELF, PETSC_ERR_SUP, "Not yet implemented");
3812: B_neigs = 0;
3813: compute_range = (PetscBool)!same_data;
3814: if (nmin >= subset_size) compute_range = PETSC_FALSE;
3816: if (pcbddc->dbg_flag) {
3817: PetscInt nc = 0, c = pcbddc->mat_graph->nodes[idxs[0]].count, w = pcbddc->mat_graph->nodes[idxs[0]].which_dof;
3819: if (sub_schurs->change_primal_sub) PetscCall(ISGetLocalSize(sub_schurs->change_primal_sub[i], &nc));
3820: PetscCall(
3821: PetscViewerASCIISynchronizedPrintf(pcbddc->dbg_viewer, "Computing for sub %" PetscInt_FMT "/%" PetscInt_FMT " size %" PetscInt_FMT " count %" PetscInt_FMT " fid %" PetscInt_FMT " (range %d) (change %" PetscInt_FMT ").\n", i, sub_schurs->n_subs, subset_size, c, w, compute_range, nc));
3822: }
3824: PetscCall(PetscFPTrapPush(PETSC_FP_TRAP_OFF));
3825: if (compute_range) {
3826: /* ask for eigenvalues larger than thresh */
3827: if (sub_schurs->is_posdef) {
3828: #if PetscDefined(USE_COMPLEX)
3829: PetscCallLAPACKInfo("LAPACKsygvx", LAPACKsygvx_(&B_itype, "V", "V", "L", &B_N, St, &B_N, S, &B_N, &lower, &upper, &B_IL, &B_IU, &eps, &B_neigs, eigs, eigv, &B_N, work, &B_lwork, rwork, B_iwork, B_ifail, &info));
3830: #else
3831: PetscCallLAPACKInfo("LAPACKsygvx", LAPACKsygvx_(&B_itype, "V", "V", "L", &B_N, St, &B_N, S, &B_N, &lower, &upper, &B_IL, &B_IU, &eps, &B_neigs, eigs, eigv, &B_N, work, &B_lwork, B_iwork, B_ifail, &info));
3832: #endif
3833: PetscCall(PetscLogFlops((4.0 * subset_size * subset_size * subset_size) / 3.0));
3834: } else { /* no theory so far, but it works nicely */
3835: PetscInt recipe = 0, recipe_m = 1;
3836: PetscReal bb[2];
3838: PetscCall(PetscOptionsGetInt(NULL, ((PetscObject)pc)->prefix, "-pc_bddc_adaptive_recipe", &recipe, NULL));
3839: switch (recipe) {
3840: case 0:
3841: if (scal) {
3842: bb[0] = PETSC_MIN_REAL;
3843: bb[1] = lthresh;
3844: } else {
3845: bb[0] = uthresh;
3846: bb[1] = PETSC_MAX_REAL;
3847: }
3848: #if PetscDefined(USE_COMPLEX)
3849: PetscCallLAPACKInfo("LAPACKsygvx", LAPACKsygvx_(&B_itype, "V", "V", "L", &B_N, St, &B_N, S, &B_N, &bb[0], &bb[1], &B_IL, &B_IU, &eps, &B_neigs, eigs, eigv, &B_N, work, &B_lwork, rwork, B_iwork, B_ifail, &info));
3850: #else
3851: PetscCallLAPACKInfo("LAPACKsygvx", LAPACKsygvx_(&B_itype, "V", "V", "L", &B_N, St, &B_N, S, &B_N, &bb[0], &bb[1], &B_IL, &B_IU, &eps, &B_neigs, eigs, eigv, &B_N, work, &B_lwork, B_iwork, B_ifail, &info));
3852: #endif
3853: PetscCall(PetscLogFlops((4.0 * subset_size * subset_size * subset_size) / 3.0));
3854: break;
3855: case 1:
3856: bb[0] = PETSC_MIN_REAL;
3857: bb[1] = lthresh * lthresh;
3858: #if PetscDefined(USE_COMPLEX)
3859: PetscCallLAPACKInfo("LAPACKsygvx", LAPACKsygvx_(&B_itype, "V", "V", "L", &B_N, St, &B_N, S, &B_N, &bb[0], &bb[1], &B_IL, &B_IU, &eps, &B_neigs, eigs, eigv, &B_N, work, &B_lwork, rwork, B_iwork, B_ifail, &info));
3860: #else
3861: PetscCallLAPACKInfo("LAPACKsygvx", LAPACKsygvx_(&B_itype, "V", "V", "L", &B_N, St, &B_N, S, &B_N, &bb[0], &bb[1], &B_IL, &B_IU, &eps, &B_neigs, eigs, eigv, &B_N, work, &B_lwork, B_iwork, B_ifail, &info));
3862: #endif
3863: PetscCall(PetscLogFlops((4.0 * subset_size * subset_size * subset_size) / 3.0));
3864: if (!scal) {
3865: PetscBLASInt B_neigs2 = 0;
3867: bb[0] = PetscMax(lthresh * lthresh, uthresh);
3868: bb[1] = PETSC_MAX_REAL;
3869: PetscCall(PetscArraycpy(S, Sarray + cumarray, subset_size * subset_size));
3870: PetscCall(PetscArraycpy(St, Starray + cumarray, subset_size * subset_size));
3871: #if PetscDefined(USE_COMPLEX)
3872: PetscCallLAPACKInfo("LAPACKsygvx", LAPACKsygvx_(&B_itype, "V", "V", "L", &B_N, St, &B_N, S, &B_N, &bb[0], &bb[1], &B_IL, &B_IU, &eps, &B_neigs2, eigs + B_neigs, eigv + B_neigs * B_N, &B_N, work, &B_lwork, rwork, B_iwork, B_ifail, &info));
3873: #else
3874: PetscCallLAPACKInfo("LAPACKsygvx", LAPACKsygvx_(&B_itype, "V", "V", "L", &B_N, St, &B_N, S, &B_N, &bb[0], &bb[1], &B_IL, &B_IU, &eps, &B_neigs2, eigs + B_neigs, eigv + B_neigs * B_N, &B_N, work, &B_lwork, B_iwork, B_ifail, &info));
3875: #endif
3876: PetscCall(PetscLogFlops((4.0 * subset_size * subset_size * subset_size) / 3.0));
3877: B_neigs += B_neigs2;
3878: }
3879: break;
3880: case 2:
3881: if (scal) {
3882: bb[0] = PETSC_MIN_REAL;
3883: bb[1] = 0;
3884: #if PetscDefined(USE_COMPLEX)
3885: PetscCallLAPACKInfo("LAPACKsygvx", LAPACKsygvx_(&B_itype, "V", "V", "L", &B_N, St, &B_N, S, &B_N, &bb[0], &bb[1], &B_IL, &B_IU, &eps, &B_neigs, eigs, eigv, &B_N, work, &B_lwork, rwork, B_iwork, B_ifail, &info));
3886: #else
3887: PetscCallLAPACKInfo("LAPACKsygvx", LAPACKsygvx_(&B_itype, "V", "V", "L", &B_N, St, &B_N, S, &B_N, &bb[0], &bb[1], &B_IL, &B_IU, &eps, &B_neigs, eigs, eigv, &B_N, work, &B_lwork, B_iwork, B_ifail, &info));
3888: #endif
3889: PetscCall(PetscLogFlops((4.0 * subset_size * subset_size * subset_size) / 3.0));
3890: } else {
3891: PetscBLASInt B_neigs2 = 0;
3892: PetscBool do_copy = PETSC_FALSE;
3894: lthresh = PetscMax(lthresh, 0.0);
3895: if (lthresh > 0.0) {
3896: bb[0] = PETSC_MIN_REAL;
3897: bb[1] = lthresh * lthresh;
3899: do_copy = PETSC_TRUE;
3900: #if PetscDefined(USE_COMPLEX)
3901: PetscCallLAPACKInfo("LAPACKsygvx", LAPACKsygvx_(&B_itype, "V", "V", "L", &B_N, St, &B_N, S, &B_N, &bb[0], &bb[1], &B_IL, &B_IU, &eps, &B_neigs, eigs, eigv, &B_N, work, &B_lwork, rwork, B_iwork, B_ifail, &info));
3902: #else
3903: PetscCallLAPACKInfo("LAPACKsygvx", LAPACKsygvx_(&B_itype, "V", "V", "L", &B_N, St, &B_N, S, &B_N, &bb[0], &bb[1], &B_IL, &B_IU, &eps, &B_neigs, eigs, eigv, &B_N, work, &B_lwork, B_iwork, B_ifail, &info));
3904: #endif
3905: PetscCall(PetscLogFlops((4.0 * subset_size * subset_size * subset_size) / 3.0));
3906: }
3907: bb[0] = PetscMax(lthresh * lthresh, uthresh);
3908: bb[1] = PETSC_MAX_REAL;
3909: if (do_copy) {
3910: PetscCall(PetscArraycpy(S, Sarray + cumarray, subset_size * subset_size));
3911: PetscCall(PetscArraycpy(St, Starray + cumarray, subset_size * subset_size));
3912: }
3913: #if PetscDefined(USE_COMPLEX)
3914: PetscCallLAPACKInfo("LAPACKsygvx", LAPACKsygvx_(&B_itype, "V", "V", "L", &B_N, St, &B_N, S, &B_N, &bb[0], &bb[1], &B_IL, &B_IU, &eps, &B_neigs2, eigs + B_neigs, eigv + B_neigs * B_N, &B_N, work, &B_lwork, rwork, B_iwork, B_ifail, &info));
3915: #else
3916: PetscCallLAPACKInfo("LAPACKsygvx", LAPACKsygvx_(&B_itype, "V", "V", "L", &B_N, St, &B_N, S, &B_N, &bb[0], &bb[1], &B_IL, &B_IU, &eps, &B_neigs2, eigs + B_neigs, eigv + B_neigs * B_N, &B_N, work, &B_lwork, B_iwork, B_ifail, &info));
3917: #endif
3918: PetscCall(PetscLogFlops((4.0 * subset_size * subset_size * subset_size) / 3.0));
3919: B_neigs += B_neigs2;
3920: }
3921: break;
3922: case 3:
3923: if (scal) {
3924: PetscCall(PetscOptionsGetInt(NULL, ((PetscObject)pc)->prefix, "-pc_bddc_adaptive_recipe3_min_scal", &recipe_m, NULL));
3925: } else {
3926: PetscCall(PetscOptionsGetInt(NULL, ((PetscObject)pc)->prefix, "-pc_bddc_adaptive_recipe3_min", &recipe_m, NULL));
3927: }
3928: if (!scal) {
3929: bb[0] = uthresh;
3930: bb[1] = PETSC_MAX_REAL;
3931: #if PetscDefined(USE_COMPLEX)
3932: PetscCallLAPACKInfo("LAPACKsygvx", LAPACKsygvx_(&B_itype, "V", "V", "L", &B_N, St, &B_N, S, &B_N, &bb[0], &bb[1], &B_IL, &B_IU, &eps, &B_neigs, eigs, eigv, &B_N, work, &B_lwork, rwork, B_iwork, B_ifail, &info));
3933: #else
3934: PetscCallLAPACKInfo("LAPACKsygvx", LAPACKsygvx_(&B_itype, "V", "V", "L", &B_N, St, &B_N, S, &B_N, &bb[0], &bb[1], &B_IL, &B_IU, &eps, &B_neigs, eigs, eigv, &B_N, work, &B_lwork, B_iwork, B_ifail, &info));
3935: #endif
3936: PetscCall(PetscLogFlops((4.0 * subset_size * subset_size * subset_size) / 3.0));
3937: }
3938: if (recipe_m > 0 && B_N - B_neigs > 0) {
3939: PetscBLASInt B_neigs2 = 0;
3941: PetscCall(PetscBLASIntCast(PetscMin(recipe_m, B_N - B_neigs), &B_IU));
3942: PetscCall(PetscArraycpy(S, Sarray + cumarray, subset_size * subset_size));
3943: PetscCall(PetscArraycpy(St, Starray + cumarray, subset_size * subset_size));
3944: #if PetscDefined(USE_COMPLEX)
3945: PetscCallLAPACKInfo("LAPACKsygvx", LAPACKsygvx_(&B_itype, "V", "I", "L", &B_N, St, &B_N, S, &B_N, &lower, &upper, &B_IL, &B_IU, &eps, &B_neigs2, eigs + B_neigs, eigv + B_neigs * B_N, &B_N, work, &B_lwork, rwork, B_iwork, B_ifail, &info));
3946: #else
3947: PetscCallLAPACKInfo("LAPACKsygvx", LAPACKsygvx_(&B_itype, "V", "I", "L", &B_N, St, &B_N, S, &B_N, &lower, &upper, &B_IL, &B_IU, &eps, &B_neigs2, eigs + B_neigs, eigv + B_neigs * B_N, &B_N, work, &B_lwork, B_iwork, B_ifail, &info));
3948: #endif
3949: PetscCall(PetscLogFlops((4.0 * subset_size * subset_size * subset_size) / 3.0));
3950: B_neigs += B_neigs2;
3951: }
3952: break;
3953: case 4:
3954: bb[0] = PETSC_MIN_REAL;
3955: bb[1] = lthresh;
3956: #if PetscDefined(USE_COMPLEX)
3957: PetscCallLAPACKInfo("LAPACKsygvx", LAPACKsygvx_(&B_itype, "V", "V", "L", &B_N, St, &B_N, S, &B_N, &bb[0], &bb[1], &B_IL, &B_IU, &eps, &B_neigs, eigs, eigv, &B_N, work, &B_lwork, rwork, B_iwork, B_ifail, &info));
3958: #else
3959: PetscCallLAPACKInfo("LAPACKsygvx", LAPACKsygvx_(&B_itype, "V", "V", "L", &B_N, St, &B_N, S, &B_N, &bb[0], &bb[1], &B_IL, &B_IU, &eps, &B_neigs, eigs, eigv, &B_N, work, &B_lwork, B_iwork, B_ifail, &info));
3960: #endif
3961: PetscCall(PetscLogFlops((4.0 * subset_size * subset_size * subset_size) / 3.0));
3962: {
3963: PetscBLASInt B_neigs2 = 0;
3965: bb[0] = PetscMax(lthresh + PETSC_SMALL, uthresh);
3966: bb[1] = PETSC_MAX_REAL;
3967: PetscCall(PetscArraycpy(S, Sarray + cumarray, subset_size * subset_size));
3968: PetscCall(PetscArraycpy(St, Starray + cumarray, subset_size * subset_size));
3969: #if PetscDefined(USE_COMPLEX)
3970: PetscCallLAPACKInfo("LAPACKsygvx", LAPACKsygvx_(&B_itype, "V", "V", "L", &B_N, St, &B_N, S, &B_N, &bb[0], &bb[1], &B_IL, &B_IU, &eps, &B_neigs2, eigs + B_neigs, eigv + B_neigs * B_N, &B_N, work, &B_lwork, rwork, B_iwork, B_ifail, &info));
3971: #else
3972: PetscCallLAPACKInfo("LAPACKsygvx", LAPACKsygvx_(&B_itype, "V", "V", "L", &B_N, St, &B_N, S, &B_N, &bb[0], &bb[1], &B_IL, &B_IU, &eps, &B_neigs2, eigs + B_neigs, eigv + B_neigs * B_N, &B_N, work, &B_lwork, B_iwork, B_ifail, &info));
3973: #endif
3974: PetscCall(PetscLogFlops((4.0 * subset_size * subset_size * subset_size) / 3.0));
3975: B_neigs += B_neigs2;
3976: }
3977: break;
3978: case 5: /* same as before: first compute all eigenvalues, then filter */
3979: #if PetscDefined(USE_COMPLEX)
3980: PetscCallLAPACKInfo("LAPACKsygvx", LAPACKsygvx_(&B_itype, "V", "A", "L", &B_N, St, &B_N, S, &B_N, &bb[0], &bb[1], &B_IL, &B_IU, &eps, &B_neigs, eigs, eigv, &B_N, work, &B_lwork, rwork, B_iwork, B_ifail, &info));
3981: #else
3982: PetscCallLAPACKInfo("LAPACKsygvx", LAPACKsygvx_(&B_itype, "V", "A", "L", &B_N, St, &B_N, S, &B_N, &bb[0], &bb[1], &B_IL, &B_IU, &eps, &B_neigs, eigs, eigv, &B_N, work, &B_lwork, B_iwork, B_ifail, &info));
3983: #endif
3984: PetscCall(PetscLogFlops((4.0 * subset_size * subset_size * subset_size) / 3.0));
3985: {
3986: PetscInt e, k, ne;
3987: for (e = 0, ne = 0; e < B_neigs; e++) {
3988: if (eigs[e] < lthresh || eigs[e] > uthresh) {
3989: for (k = 0; k < B_N; k++) S[ne * B_N + k] = eigv[e * B_N + k];
3990: eigs[ne] = eigs[e];
3991: ne++;
3992: }
3993: }
3994: PetscCall(PetscArraycpy(eigv, S, B_N * ne));
3995: PetscCall(PetscBLASIntCast(ne, &B_neigs));
3996: }
3997: break;
3998: default:
3999: SETERRQ(PetscObjectComm((PetscObject)pc), PETSC_ERR_SUP, "Unknown recipe %" PetscInt_FMT, recipe);
4000: }
4001: }
4002: } else if (!same_data) { /* this is just to see all the eigenvalues */
4003: PetscCall(PetscBLASIntCast(PetscMax(1, PetscMin(B_N, nmax)), &B_IU));
4004: #if PetscDefined(USE_COMPLEX)
4005: PetscCallLAPACKInfo("LAPACKsygvx", LAPACKsygvx_(&B_itype, "V", "I", "L", &B_N, St, &B_N, S, &B_N, &lower, &upper, &B_IL, &B_IU, &eps, &B_neigs, eigs, eigv, &B_N, work, &B_lwork, rwork, B_iwork, B_ifail, &info));
4006: #else
4007: PetscCallLAPACKInfo("LAPACKsygvx", LAPACKsygvx_(&B_itype, "V", "I", "L", &B_N, St, &B_N, S, &B_N, &lower, &upper, &B_IL, &B_IU, &eps, &B_neigs, eigs, eigv, &B_N, work, &B_lwork, B_iwork, B_ifail, &info));
4008: #endif
4009: PetscCall(PetscLogFlops((4.0 * subset_size * subset_size * subset_size) / 3.0));
4010: } else { /* same_data is true, so just get the adaptive functional requested by the user */
4011: PetscInt k;
4012: PetscCheck(sub_schurs->change_primal_sub, PETSC_COMM_SELF, PETSC_ERR_PLIB, "This should not happen");
4013: PetscCall(ISGetLocalSize(sub_schurs->change_primal_sub[i], &nmax));
4014: PetscCall(PetscBLASIntCast(nmax, &B_neigs));
4015: nmin = nmax;
4016: PetscCall(PetscArrayzero(eigv, subset_size * nmax));
4017: for (k = 0; k < nmax; k++) {
4018: eigs[k] = 1. / PETSC_SMALL;
4019: eigv[k * (subset_size + 1)] = 1.0;
4020: }
4021: }
4022: PetscCall(PetscFPTrapPop());
4024: if (B_neigs > nmax) {
4025: if (pcbddc->dbg_flag) PetscCall(PetscViewerASCIISynchronizedPrintf(pcbddc->dbg_viewer, " found %" PetscBLASInt_FMT " eigs, more than maximum required %" PetscInt_FMT ".\n", B_neigs, nmax));
4026: if (upart) eigs_start = scal ? 0 : B_neigs - nmax;
4027: PetscCall(PetscBLASIntCast(nmax, &B_neigs));
4028: }
4030: nmin_s = PetscMin(nmin, B_N);
4031: if (B_neigs < nmin_s) {
4032: PetscBLASInt B_neigs2 = 0;
4034: if (upart) {
4035: if (scal) {
4036: PetscCall(PetscBLASIntCast(nmin_s, &B_IU));
4037: B_IL = B_neigs + 1;
4038: } else {
4039: PetscCall(PetscBLASIntCast(B_N - nmin_s + 1, &B_IL));
4040: B_IU = B_N - B_neigs;
4041: }
4042: } else {
4043: B_IL = B_neigs + 1;
4044: PetscCall(PetscBLASIntCast(nmin_s, &B_IU));
4045: }
4046: if (pcbddc->dbg_flag) {
4047: PetscCall(PetscViewerASCIISynchronizedPrintf(pcbddc->dbg_viewer, " found %" PetscBLASInt_FMT " eigs, less than minimum required %" PetscInt_FMT ". Asking for %" PetscBLASInt_FMT " to %" PetscBLASInt_FMT " incl (fortran like)\n", B_neigs, nmin, B_IL, B_IU));
4048: }
4049: if (sub_schurs->is_symmetric) {
4050: for (PetscInt j = 0; j < subset_size; j++) {
4051: for (PetscInt k = j; k < subset_size; k++) {
4052: S[j * subset_size + k] = Sarray[cumarray + j * subset_size + k];
4053: St[j * subset_size + k] = Starray[cumarray + j * subset_size + k];
4054: }
4055: }
4056: } else {
4057: PetscCall(PetscArraycpy(S, Sarray + cumarray, subset_size * subset_size));
4058: PetscCall(PetscArraycpy(St, Starray + cumarray, subset_size * subset_size));
4059: }
4060: PetscCall(PetscFPTrapPush(PETSC_FP_TRAP_OFF));
4061: #if PetscDefined(USE_COMPLEX)
4062: PetscCallLAPACKInfo("LAPACKsygvx", LAPACKsygvx_(&B_itype, "V", "I", "L", &B_N, St, &B_N, S, &B_N, &lower, &upper, &B_IL, &B_IU, &eps, &B_neigs2, eigs + B_neigs, eigv + B_neigs * subset_size, &B_N, work, &B_lwork, rwork, B_iwork, B_ifail, &info));
4063: #else
4064: PetscCallLAPACKInfo("LAPACKsygvx", LAPACKsygvx_(&B_itype, "V", "I", "L", &B_N, St, &B_N, S, &B_N, &lower, &upper, &B_IL, &B_IU, &eps, &B_neigs2, eigs + B_neigs, eigv + B_neigs * subset_size, &B_N, work, &B_lwork, B_iwork, B_ifail, &info));
4065: #endif
4066: PetscCall(PetscLogFlops((4.0 * subset_size * subset_size * subset_size) / 3.0));
4067: PetscCall(PetscFPTrapPop());
4068: B_neigs += B_neigs2;
4069: }
4070: if (pcbddc->dbg_flag) {
4071: PetscCall(PetscViewerASCIISynchronizedPrintf(pcbddc->dbg_viewer, " -> Got %" PetscBLASInt_FMT " eigs\n", B_neigs));
4072: for (PetscInt j = 0; j < B_neigs; j++) {
4073: if (!sub_schurs->gdsw) {
4074: if (eigs[j] == 0.0) {
4075: PetscCall(PetscViewerASCIISynchronizedPrintf(pcbddc->dbg_viewer, " Inf\n"));
4076: } else {
4077: if (upart) {
4078: PetscCall(PetscViewerASCIISynchronizedPrintf(pcbddc->dbg_viewer, " %1.6e\n", (double)eigs[j + eigs_start]));
4079: } else {
4080: PetscCall(PetscViewerASCIISynchronizedPrintf(pcbddc->dbg_viewer, " %1.6e\n", (double)(1 / eigs[j + eigs_start])));
4081: }
4082: }
4083: } else {
4084: double pg = (double)eigs[j + eigs_start];
4085: if (pg < 2 * PETSC_SMALL) pg = 0.0;
4086: PetscCall(PetscViewerASCIISynchronizedPrintf(pcbddc->dbg_viewer, " %1.6e\n", pg));
4087: }
4088: }
4089: }
4090: }
4091: /* change the basis back to the original one */
4092: if (sub_schurs->change) {
4093: Mat change, phi, phit;
4095: if (pcbddc->dbg_flag > 2) {
4096: for (PetscInt ii = 0; ii < B_neigs; ii++) {
4097: PetscCall(PetscViewerASCIISynchronizedPrintf(pcbddc->dbg_viewer, " -> Eigenvector (old basis) %" PetscInt_FMT "/%" PetscBLASInt_FMT " (%" PetscBLASInt_FMT ")\n", ii, B_neigs, B_N));
4098: for (PetscInt j = 0; j < B_N; j++) {
4099: #if PetscDefined(USE_COMPLEX)
4100: PetscReal r = PetscRealPart(eigv[(ii + eigs_start) * subset_size + j]);
4101: PetscReal c = PetscImaginaryPart(eigv[(ii + eigs_start) * subset_size + j]);
4102: PetscCall(PetscViewerASCIISynchronizedPrintf(pcbddc->dbg_viewer, " %1.4e + %1.4e i\n", (double)r, (double)c));
4103: #else
4104: PetscCall(PetscViewerASCIISynchronizedPrintf(pcbddc->dbg_viewer, " %1.4e\n", (double)(eigv[(ii + eigs_start) * subset_size + j])));
4105: #endif
4106: }
4107: }
4108: }
4109: PetscCall(KSPGetOperators(sub_schurs->change[i], &change, NULL));
4110: PetscCall(MatCreateSeqDense(PETSC_COMM_SELF, subset_size, B_neigs, eigv + eigs_start * subset_size, &phit));
4111: PetscCall(MatMatMult(change, phit, MAT_INITIAL_MATRIX, PETSC_DETERMINE, &phi));
4112: PetscCall(MatCopy(phi, phit, SAME_NONZERO_PATTERN));
4113: PetscCall(MatDestroy(&phit));
4114: PetscCall(MatDestroy(&phi));
4115: }
4116: maxneigs = PetscMax(B_neigs, maxneigs);
4117: pcbddc->adaptive_constraints_n[i + nv] = B_neigs;
4118: if (B_neigs) {
4119: PetscCall(PetscArraycpy(pcbddc->adaptive_constraints_data + pcbddc->adaptive_constraints_data_ptr[cum], eigv + eigs_start * subset_size, B_neigs * subset_size));
4121: if (pcbddc->dbg_flag > 1) {
4122: for (PetscInt ii = 0; ii < B_neigs; ii++) {
4123: PetscCall(PetscViewerASCIISynchronizedPrintf(pcbddc->dbg_viewer, " -> Eigenvector %" PetscInt_FMT "/%" PetscBLASInt_FMT " (%" PetscBLASInt_FMT ")\n", ii, B_neigs, B_N));
4124: for (PetscInt j = 0; j < B_N; j++) {
4125: #if PetscDefined(USE_COMPLEX)
4126: PetscReal r = PetscRealPart(pcbddc->adaptive_constraints_data[ii * subset_size + j + pcbddc->adaptive_constraints_data_ptr[cum]]);
4127: PetscReal c = PetscImaginaryPart(pcbddc->adaptive_constraints_data[ii * subset_size + j + pcbddc->adaptive_constraints_data_ptr[cum]]);
4128: PetscCall(PetscViewerASCIISynchronizedPrintf(pcbddc->dbg_viewer, " %1.4e + %1.4e i\n", (double)r, (double)c));
4129: #else
4130: PetscCall(PetscViewerASCIISynchronizedPrintf(pcbddc->dbg_viewer, " %1.4e\n", (double)PetscRealPart(pcbddc->adaptive_constraints_data[ii * subset_size + j + pcbddc->adaptive_constraints_data_ptr[cum]])));
4131: #endif
4132: }
4133: }
4134: }
4135: PetscCall(PetscArraycpy(pcbddc->adaptive_constraints_idxs + pcbddc->adaptive_constraints_idxs_ptr[cum], idxs, subset_size));
4136: pcbddc->adaptive_constraints_idxs_ptr[cum + 1] = pcbddc->adaptive_constraints_idxs_ptr[cum] + subset_size;
4137: pcbddc->adaptive_constraints_data_ptr[cum + 1] = pcbddc->adaptive_constraints_data_ptr[cum] + subset_size * B_neigs;
4138: cum++;
4139: }
4140: PetscCall(ISRestoreIndices(sub_schurs->is_subs[i], &idxs));
4141: /* shift for next computation */
4142: cumarray += subset_size * subset_size;
4143: }
4144: if (pcbddc->dbg_flag) PetscCall(PetscViewerFlush(pcbddc->dbg_viewer));
4146: if (mss) {
4147: if (sub_schurs->gdsw) {
4148: PetscCall(MatSeqAIJGetArray(sub_schurs->sum_S_Ej_all, &Sarray));
4149: PetscCall(MatSeqAIJGetArray(sub_schurs->sum_S_Ej_tilda_all, &Starray));
4150: } else {
4151: PetscCall(MatSeqAIJRestoreArray(sub_schurs->sum_S_Ej_inv_all, &Sarray));
4152: PetscCall(MatSeqAIJRestoreArray(sub_schurs->sum_S_Ej_tilda_all, &Starray));
4153: /* destroy matrices (junk) */
4154: PetscCall(MatDestroy(&sub_schurs->sum_S_Ej_inv_all));
4155: PetscCall(MatDestroy(&sub_schurs->sum_S_Ej_tilda_all));
4156: }
4157: }
4158: if (allocated_S_St) PetscCall(PetscFree2(S, St));
4159: PetscCall(PetscFree5(eigv, eigs, work, B_iwork, B_ifail));
4160: #if PetscDefined(USE_COMPLEX)
4161: PetscCall(PetscFree(rwork));
4162: #endif
4163: if (pcbddc->dbg_flag) {
4164: PetscCallMPI(MPIU_Allreduce(MPI_IN_PLACE, &maxneigs, 1, MPIU_INT, MPI_MAX, PetscObjectComm((PetscObject)pc)));
4165: PetscCall(PetscViewerASCIIPrintf(pcbddc->dbg_viewer, "Maximum number of constraints per cc %" PetscInt_FMT "\n", maxneigs));
4166: }
4167: PetscCall(PetscLogEventEnd(PC_BDDC_AdaptiveSetUp[pcbddc->current_level], pc, 0, 0, 0));
4168: PetscFunctionReturn(PETSC_SUCCESS);
4169: }
4171: PetscErrorCode PCBDDCSetUpSolvers(PC pc)
4172: {
4173: Mat coarse_submat;
4175: PetscFunctionBegin;
4176: /* Setup local scatters R_to_B and (optionally) R_to_D */
4177: /* PCBDDCSetUpLocalWorkVectors should be called first! */
4178: PetscCall(PCBDDCSetUpLocalScatters(pc));
4180: /* Setup local neumann solver ksp_R */
4181: /* PCBDDCSetUpLocalScatters should be called first! */
4182: PetscCall(PCBDDCSetUpLocalSolvers(pc, PETSC_FALSE, PETSC_TRUE));
4184: /*
4185: Setup local correction and local part of coarse basis.
4186: Gives back the dense local part of the coarse matrix in column major ordering
4187: */
4188: PetscCall(PCBDDCSetUpCorrection(pc, &coarse_submat));
4190: /* Compute total number of coarse nodes and setup coarse solver */
4191: PetscCall(PCBDDCSetUpCoarseSolver(pc, coarse_submat));
4192: PetscCall(MatDestroy(&coarse_submat));
4193: PetscFunctionReturn(PETSC_SUCCESS);
4194: }
4196: PetscErrorCode PCBDDCResetCustomization(PC pc)
4197: {
4198: PC_BDDC *pcbddc = (PC_BDDC *)pc->data;
4200: PetscFunctionBegin;
4201: PetscCall(ISDestroy(&pcbddc->user_primal_vertices));
4202: PetscCall(ISDestroy(&pcbddc->user_primal_vertices_local));
4203: PetscCall(ISDestroy(&pcbddc->NeumannBoundaries));
4204: PetscCall(ISDestroy(&pcbddc->NeumannBoundariesLocal));
4205: PetscCall(ISDestroy(&pcbddc->DirichletBoundaries));
4206: PetscCall(MatNullSpaceDestroy(&pcbddc->onearnullspace));
4207: PetscCall(PetscFree(pcbddc->onearnullvecs_state));
4208: PetscCall(ISDestroy(&pcbddc->DirichletBoundariesLocal));
4209: PetscCall(PCBDDCSetDofsSplitting(pc, 0, NULL));
4210: PetscCall(PCBDDCSetDofsSplittingLocal(pc, 0, NULL));
4211: pcbddc->user_provided_isfordofs = PETSC_FALSE;
4212: PetscFunctionReturn(PETSC_SUCCESS);
4213: }
4215: PetscErrorCode PCBDDCResetTopography(PC pc)
4216: {
4217: PC_BDDC *pcbddc = (PC_BDDC *)pc->data;
4219: PetscFunctionBegin;
4220: PetscCall(MatDestroy(&pcbddc->nedcG));
4221: PetscCall(MatDestroy(&pcbddc->discretegradient));
4222: PetscCall(MatDestroy(&pcbddc->user_ChangeOfBasisMatrix));
4223: PetscCall(MatDestroy(&pcbddc->ChangeOfBasisMatrix));
4224: PetscCall(MatDestroy(&pcbddc->switch_static_change));
4225: PetscCall(VecDestroy(&pcbddc->work_change));
4226: PetscCall(MatDestroy(&pcbddc->ConstraintMatrix));
4227: PetscCall(MatDestroy(&pcbddc->divudotp));
4228: PetscCall(ISDestroy(&pcbddc->divudotp_vl2l));
4229: PetscCall(PCBDDCGraphResetCSR(pcbddc->mat_graph));
4230: PetscCall(PCBDDCGraphResetCoords(pcbddc->mat_graph));
4231: PetscCall(PCBDDCGraphReset(pcbddc->mat_graph));
4232: for (PetscInt i = 0; i < pcbddc->n_local_subs; i++) PetscCall(ISDestroy(&pcbddc->local_subs[i]));
4233: pcbddc->n_local_subs = 0;
4234: PetscCall(PetscFree(pcbddc->local_subs));
4235: PetscCall(PCBDDCSubSchursDestroy(&pcbddc->sub_schurs));
4236: pcbddc->graphanalyzed = PETSC_FALSE;
4237: pcbddc->recompute_topography = PETSC_TRUE;
4238: pcbddc->corner_selected = PETSC_FALSE;
4239: pcbddc->computed_rowadj = PETSC_FALSE;
4240: pcbddc->change_interior = PETSC_FALSE;
4241: PetscFunctionReturn(PETSC_SUCCESS);
4242: }
4244: PetscErrorCode PCBDDCResetSolvers(PC pc)
4245: {
4246: PC_BDDC *pcbddc = (PC_BDDC *)pc->data;
4248: PetscFunctionBegin;
4249: PetscCall(VecDestroy(&pcbddc->coarse_vec));
4250: PetscCall(MatDestroy(&pcbddc->coarse_phi_B));
4251: PetscCall(MatDestroy(&pcbddc->coarse_phi_D));
4252: PetscCall(MatDestroy(&pcbddc->coarse_psi_B));
4253: PetscCall(MatDestroy(&pcbddc->coarse_psi_D));
4254: PetscCall(VecDestroy(&pcbddc->vec1_P));
4255: PetscCall(VecDestroy(&pcbddc->vec1_C));
4256: PetscCall(MatDestroy(&pcbddc->local_auxmat2));
4257: PetscCall(MatDestroy(&pcbddc->local_auxmat1));
4258: PetscCall(VecDestroy(&pcbddc->vec1_R));
4259: PetscCall(VecDestroy(&pcbddc->vec2_R));
4260: PetscCall(ISDestroy(&pcbddc->is_R_local));
4261: PetscCall(VecScatterDestroy(&pcbddc->R_to_B));
4262: PetscCall(VecScatterDestroy(&pcbddc->R_to_D));
4263: PetscCall(VecScatterDestroy(&pcbddc->coarse_loc_to_glob));
4264: PetscCall(KSPReset(pcbddc->ksp_D));
4265: PetscCall(KSPReset(pcbddc->ksp_R));
4266: PetscCall(KSPReset(pcbddc->coarse_ksp));
4267: PetscCall(MatDestroy(&pcbddc->local_mat));
4268: PetscCall(PetscFree(pcbddc->primal_indices_local_idxs));
4269: PetscCall(PetscFree2(pcbddc->local_primal_ref_node, pcbddc->local_primal_ref_mult));
4270: PetscCall(PetscFree(pcbddc->global_primal_indices));
4271: PetscCall(ISDestroy(&pcbddc->coarse_subassembling));
4272: PetscCall(MatDestroy(&pcbddc->benign_change));
4273: PetscCall(VecDestroy(&pcbddc->benign_vec));
4274: PetscCall(PCBDDCBenignShellMat(pc, PETSC_TRUE));
4275: PetscCall(MatDestroy(&pcbddc->benign_B0));
4276: PetscCall(PetscSFDestroy(&pcbddc->benign_sf));
4277: if (pcbddc->benign_zerodiag_subs) {
4278: for (PetscInt i = 0; i < pcbddc->benign_n; i++) PetscCall(ISDestroy(&pcbddc->benign_zerodiag_subs[i]));
4279: PetscCall(PetscFree(pcbddc->benign_zerodiag_subs));
4280: }
4281: PetscCall(PetscFree3(pcbddc->benign_p0_lidx, pcbddc->benign_p0_gidx, pcbddc->benign_p0));
4282: pcbddc->local_primal_size = 0;
4283: pcbddc->local_primal_size_cc = 0;
4284: pcbddc->n_vertices = 0;
4285: pcbddc->coarse_size = -1;
4286: pcbddc->new_primal_space = PETSC_FALSE;
4287: pcbddc->new_primal_space_local = PETSC_FALSE;
4288: pcbddc->benign_n = 0;
4289: pcbddc->benign_have_null = PETSC_FALSE;
4290: pcbddc->benign_null = PETSC_FALSE;
4291: pcbddc->benign_apply_coarse_only = PETSC_FALSE;
4292: PetscFunctionReturn(PETSC_SUCCESS);
4293: }
4295: PetscErrorCode PCBDDCSetUpLocalWorkVectors(PC pc)
4296: {
4297: PC_BDDC *pcbddc = (PC_BDDC *)pc->data;
4298: PC_IS *pcis = (PC_IS *)pc->data;
4299: VecType impVecType;
4300: PetscInt n_constraints, n_R, old_size;
4302: PetscFunctionBegin;
4303: n_constraints = pcbddc->local_primal_size - pcbddc->benign_n - pcbddc->n_vertices;
4304: n_R = pcis->n - pcbddc->n_vertices;
4305: PetscCall(VecGetType(pcis->vec1_N, &impVecType));
4306: /* local work vectors (try to avoid unneeded work)*/
4307: /* R nodes */
4308: old_size = -1;
4309: if (pcbddc->vec1_R) PetscCall(VecGetSize(pcbddc->vec1_R, &old_size));
4310: if (n_R != old_size) {
4311: PetscCall(VecDestroy(&pcbddc->vec1_R));
4312: PetscCall(VecDestroy(&pcbddc->vec2_R));
4313: PetscCall(VecCreate(PetscObjectComm((PetscObject)pcis->vec1_N), &pcbddc->vec1_R));
4314: PetscCall(VecSetSizes(pcbddc->vec1_R, PETSC_DECIDE, n_R));
4315: PetscCall(VecSetType(pcbddc->vec1_R, impVecType));
4316: PetscCall(VecDuplicate(pcbddc->vec1_R, &pcbddc->vec2_R));
4317: }
4318: /* local primal dofs */
4319: old_size = -1;
4320: if (pcbddc->vec1_P) PetscCall(VecGetSize(pcbddc->vec1_P, &old_size));
4321: if (pcbddc->local_primal_size != old_size) {
4322: PetscCall(VecDestroy(&pcbddc->vec1_P));
4323: PetscCall(VecCreate(PetscObjectComm((PetscObject)pcis->vec1_N), &pcbddc->vec1_P));
4324: PetscCall(VecSetSizes(pcbddc->vec1_P, PETSC_DECIDE, pcbddc->local_primal_size));
4325: PetscCall(VecSetType(pcbddc->vec1_P, impVecType));
4326: }
4327: /* local explicit constraints */
4328: old_size = -1;
4329: if (pcbddc->vec1_C) PetscCall(VecGetSize(pcbddc->vec1_C, &old_size));
4330: if (n_constraints && n_constraints != old_size) {
4331: PetscCall(VecDestroy(&pcbddc->vec1_C));
4332: PetscCall(VecCreate(PetscObjectComm((PetscObject)pcis->vec1_N), &pcbddc->vec1_C));
4333: PetscCall(VecSetSizes(pcbddc->vec1_C, PETSC_DECIDE, n_constraints));
4334: PetscCall(VecSetType(pcbddc->vec1_C, impVecType));
4335: }
4336: PetscFunctionReturn(PETSC_SUCCESS);
4337: }
4339: static PetscErrorCode MatSetValuesSubMat(Mat A, Mat S, PetscInt nr, const PetscInt rows[], PetscInt nc, const PetscInt cols[], InsertMode imode)
4340: {
4341: PetscBool flg;
4342: const PetscScalar *a;
4344: PetscFunctionBegin;
4345: PetscCall(PetscObjectBaseTypeCompare((PetscObject)S, MATSEQDENSE, &flg));
4346: if (flg) {
4347: PetscCall(MatDenseGetArrayRead(S, &a));
4348: PetscCall(MatSetOption(A, MAT_ROW_ORIENTED, PETSC_FALSE));
4349: PetscCall(MatSetValues(A, nr, rows, nc, cols, a, imode));
4350: PetscCall(MatSetOption(A, MAT_ROW_ORIENTED, PETSC_TRUE));
4351: PetscCall(MatDenseRestoreArrayRead(S, &a));
4352: } else {
4353: const PetscInt *ii, *jj;
4354: PetscInt n;
4355: PetscInt buf[8192], *bufc = NULL;
4356: PetscBool freeb = PETSC_FALSE;
4357: Mat Sm = S;
4359: PetscCall(PetscObjectBaseTypeCompare((PetscObject)S, MATSEQAIJ, &flg));
4360: if (!flg) PetscCall(MatConvert(S, MATSEQAIJ, MAT_INITIAL_MATRIX, &Sm));
4361: else PetscCall(PetscObjectReference((PetscObject)S));
4362: PetscCall(MatSeqAIJGetArrayRead(Sm, &a));
4363: PetscCall(MatGetRowIJ(Sm, 0, PETSC_FALSE, PETSC_FALSE, &n, &ii, &jj, &flg));
4364: PetscCheck(flg, PETSC_COMM_SELF, PETSC_ERR_PLIB, "Cannot get IJ structure");
4365: if (nc <= (PetscInt)PETSC_STATIC_ARRAY_LENGTH(buf)) {
4366: bufc = buf;
4367: } else {
4368: PetscCall(PetscMalloc1(nc, &bufc));
4369: freeb = PETSC_TRUE;
4370: }
4372: for (PetscInt i = 0; i < n; i++) {
4373: const PetscInt nci = ii[i + 1] - ii[i];
4375: for (PetscInt j = 0; j < nci; j++) bufc[j] = cols[jj[ii[i] + j]];
4376: PetscCall(MatSetValues(A, 1, rows + i, nci, bufc, a + ii[i], imode));
4377: }
4378: PetscCall(MatRestoreRowIJ(Sm, 0, PETSC_FALSE, PETSC_FALSE, &n, &ii, &jj, &flg));
4379: PetscCall(MatSeqAIJRestoreArrayRead(Sm, &a));
4380: PetscCall(MatDestroy(&Sm));
4381: if (freeb) PetscCall(PetscFree(bufc));
4382: }
4383: PetscCall(MatAssemblyBegin(A, MAT_FLUSH_ASSEMBLY));
4384: PetscCall(MatAssemblyEnd(A, MAT_FLUSH_ASSEMBLY));
4385: PetscFunctionReturn(PETSC_SUCCESS);
4386: }
4388: static PetscErrorCode MatCreateSeqAIJFromDenseExpand(Mat D, PetscInt n, const PetscInt j[], Mat *mat)
4389: {
4390: Mat_SeqAIJ *aij;
4391: PetscInt *ii, *jj;
4392: PetscScalar *aa;
4393: PetscInt nnz = 0, m, nc;
4394: const PetscScalar *a;
4395: const PetscScalar zero = 0.0;
4397: PetscFunctionBegin;
4398: PetscCall(MatGetLocalSize(D, &m, &nc));
4399: PetscCall(MatDenseGetArrayRead(D, &a));
4400: PetscCall(PetscMalloc1(m + 1, &ii));
4401: PetscCall(PetscMalloc1(m * nc, &jj));
4402: PetscCall(PetscMalloc1(m * nc, &aa));
4403: ii[0] = 0;
4404: for (PetscInt k = 0; k < m; k++) {
4405: for (PetscInt s = 0; s < nc; s++) {
4406: const PetscInt c = s + k * nc;
4407: const PetscScalar v = a[k + s * m];
4409: if (PetscUnlikely(j[c] < 0 || v == zero)) continue;
4410: jj[nnz] = j[c];
4411: aa[nnz] = a[k + s * m];
4412: nnz++;
4413: }
4414: ii[k + 1] = nnz;
4415: }
4417: PetscCall(MatCreateSeqAIJWithArrays(PetscObjectComm((PetscObject)D), m, n, ii, jj, aa, mat));
4418: PetscCall(MatDenseRestoreArrayRead(D, &a));
4420: aij = (Mat_SeqAIJ *)(*mat)->data;
4421: aij->free_a = PETSC_TRUE;
4422: aij->free_ij = PETSC_TRUE;
4423: PetscFunctionReturn(PETSC_SUCCESS);
4424: }
4426: /* adapted from MatInvertVariableBlockDiagonal_SeqAIJ */
4427: static PetscErrorCode MatSeqAIJInvertVariableBlockDiagonalMat(Mat A, PetscInt nblocks, const PetscInt *bsizes, Mat *B)
4428: {
4429: PetscInt n = A->rmap->n, ncnt = 0, ncnt2 = 0, bsizemax = 0, *v_pivots = NULL;
4430: const PetscBool allowzeropivot = PETSC_FALSE;
4431: PetscBool zeropivotdetected = PETSC_FALSE;
4432: const PetscReal shift = 0.0;
4433: PetscInt ipvt[5], *ii, *jj, *indi, *indj;
4434: PetscScalar work[25], *v_work = NULL, *aa, *diag;
4435: PetscLogDouble flops = 0.0;
4437: PetscFunctionBegin;
4438: PetscCheck(A->rmap->n == A->cmap->n, PETSC_COMM_SELF, PETSC_ERR_ARG_SIZ, "Not for rectangular matrices");
4439: for (PetscInt i = 0; i < nblocks; i++) {
4440: ncnt += bsizes[i];
4441: ncnt2 += PetscSqr(bsizes[i]);
4442: }
4443: PetscCheck(ncnt == n, PETSC_COMM_SELF, PETSC_ERR_ARG_SIZ, "Total blocksizes %" PetscInt_FMT " doesn't match number matrix rows %" PetscInt_FMT, ncnt, n);
4444: for (PetscInt i = 0; i < nblocks; i++) bsizemax = PetscMax(bsizemax, bsizes[i]);
4445: if (bsizemax > 7) PetscCall(PetscMalloc2(bsizemax, &v_work, bsizemax, &v_pivots));
4447: PetscCall(PetscMalloc1(n + 1, &ii));
4448: PetscCall(PetscMalloc1(ncnt2, &jj));
4449: PetscCall(PetscCalloc1(ncnt2, &aa));
4451: ncnt = 0;
4452: ii[0] = 0;
4453: indi = ii;
4454: indj = jj;
4455: diag = aa;
4456: for (PetscInt i = 0; i < nblocks; i++) {
4457: const PetscInt bs = bsizes[i];
4459: for (PetscInt k = 0; k < bs; k++) {
4460: indi[k + 1] = indi[k] + bs;
4461: for (PetscInt j = 0; j < bs; j++) indj[k * bs + j] = ncnt + j;
4462: }
4463: PetscCall(MatGetValues(A, bs, indj, bs, indj, diag));
4464: switch (bs) {
4465: case 1:
4466: *diag = 1.0 / (*diag);
4467: break;
4468: case 2:
4469: PetscCall(PetscKernel_A_gets_inverse_A_2(diag, shift, allowzeropivot, &zeropivotdetected));
4470: break;
4471: case 3:
4472: PetscCall(PetscKernel_A_gets_inverse_A_3(diag, shift, allowzeropivot, &zeropivotdetected));
4473: break;
4474: case 4:
4475: PetscCall(PetscKernel_A_gets_inverse_A_4(diag, shift, allowzeropivot, &zeropivotdetected));
4476: break;
4477: case 5:
4478: PetscCall(PetscKernel_A_gets_inverse_A_5(diag, ipvt, work, shift, allowzeropivot, &zeropivotdetected));
4479: break;
4480: case 6:
4481: PetscCall(PetscKernel_A_gets_inverse_A_6(diag, shift, allowzeropivot, &zeropivotdetected));
4482: break;
4483: case 7:
4484: PetscCall(PetscKernel_A_gets_inverse_A_7(diag, shift, allowzeropivot, &zeropivotdetected));
4485: break;
4486: default:
4487: PetscCall(PetscKernel_A_gets_inverse_A(bs, diag, v_pivots, v_work, allowzeropivot, &zeropivotdetected));
4488: }
4489: ncnt += bs;
4490: flops += 2.0 * PetscPowInt(bs, 3) / 3.0;
4491: diag += bs * bs;
4492: indj += bs * bs;
4493: indi += bs;
4494: }
4495: PetscCall(PetscLogFlops(flops));
4496: PetscCall(PetscFree2(v_work, v_pivots));
4497: PetscCall(MatCreateSeqAIJWithArrays(PetscObjectComm((PetscObject)A), n, n, ii, jj, aa, B));
4498: {
4499: Mat_SeqAIJ *aij = (Mat_SeqAIJ *)(*B)->data;
4500: aij->free_a = PETSC_TRUE;
4501: aij->free_ij = PETSC_TRUE;
4502: }
4503: PetscFunctionReturn(PETSC_SUCCESS);
4504: }
4506: PetscErrorCode PCBDDCSetUpCorrection(PC pc, Mat *coarse_submat)
4507: {
4508: PC_IS *pcis = (PC_IS *)pc->data;
4509: PC_BDDC *pcbddc = (PC_BDDC *)pc->data;
4510: PCBDDCGraph graph = pcbddc->mat_graph;
4511: PCBDDCSubSchurs sub_schurs = pcbddc->sub_schurs;
4512: /* submatrices of local problem */
4513: Mat A_RV = NULL, A_VR, A_VV, local_auxmat2_R = NULL;
4514: /* submatrices of local coarse problem */
4515: Mat S_CV = NULL, S_VC = NULL, S_CC = NULL;
4516: /* working matrices */
4517: Mat C_CR;
4519: /* additional working stuff */
4520: PC pc_R;
4521: IS is_R, is_V, is_C;
4522: const PetscInt *idx_V, *idx_C;
4523: Mat F, Brhs = NULL;
4524: Vec dummy_vec;
4525: PetscBool isPreonly, isLU, isCHOL, need_benign_correction, sparserhs;
4526: PetscInt *idx_V_B;
4527: PetscInt lda_rhs, n_vertices, n_constraints, *p0_lidx_I;
4528: PetscInt n_eff_vertices, n_eff_constraints;
4529: PetscInt i, n_R, n_D, n_B;
4530: PetscScalar one = 1.0, m_one = -1.0;
4532: /* Multi-element support */
4533: PetscBool multi_element = graph->multi_element;
4534: PetscInt *V_to_eff_V = NULL, *C_to_eff_C = NULL;
4535: PetscInt *B_eff_V_J = NULL, *R_eff_V_J = NULL, *B_eff_C_J = NULL, *R_eff_C_J = NULL;
4536: IS is_C_perm = NULL;
4537: PetscInt n_C_bss = 0, *C_bss = NULL;
4538: Mat coarse_phi_multi;
4540: PetscFunctionBegin;
4541: PetscCheck(pcbddc->symmetric_primal || !pcbddc->benign_n, PETSC_COMM_SELF, PETSC_ERR_SUP, "Non-symmetric primal basis computation with benign trick not yet implemented");
4542: PetscCall(PetscLogEventBegin(PC_BDDC_CorrectionSetUp[pcbddc->current_level], pc, 0, 0, 0));
4544: /* Set Non-overlapping dimensions */
4545: n_vertices = pcbddc->n_vertices;
4546: n_constraints = pcbddc->local_primal_size - pcbddc->benign_n - n_vertices;
4547: n_B = pcis->n_B;
4548: n_D = pcis->n - n_B;
4549: n_R = pcis->n - n_vertices;
4551: /* vertices in boundary numbering */
4552: PetscCall(PetscMalloc1(n_vertices, &idx_V_B));
4553: PetscCall(ISGlobalToLocalMappingApply(pcis->BtoNmap, IS_GTOLM_DROP, n_vertices, pcbddc->local_primal_ref_node, &i, idx_V_B));
4554: PetscCheck(i == n_vertices, PETSC_COMM_SELF, PETSC_ERR_PLIB, "Error in boundary numbering for BDDC vertices! %" PetscInt_FMT " != %" PetscInt_FMT, n_vertices, i);
4556: /* these two cases still need to be optimized */
4557: if (pcbddc->benign_saddle_point || !pcbddc->symmetric_primal) multi_element = PETSC_FALSE;
4559: /* Subdomain contribution (Non-overlapping) to coarse matrix */
4560: if (multi_element) {
4561: PetscCheck(!pcbddc->benign_n, PETSC_COMM_SELF, PETSC_ERR_SUP, "Not yet implemented");
4563: PetscCall(MatCreate(PETSC_COMM_SELF, coarse_submat));
4564: PetscCall(MatSetSizes(*coarse_submat, pcbddc->local_primal_size, pcbddc->local_primal_size, pcbddc->local_primal_size, pcbddc->local_primal_size));
4565: PetscCall(MatSetType(*coarse_submat, MATSEQAIJ));
4566: PetscCall(MatSetOption(*coarse_submat, MAT_IGNORE_ZERO_ENTRIES, PETSC_TRUE));
4567: PetscCall(MatSetOption(*coarse_submat, MAT_NEW_NONZERO_LOCATION_ERR, PETSC_TRUE));
4569: /* group vertices and constraints by subdomain id */
4570: const PetscInt *vidxs = pcbddc->primal_indices_local_idxs;
4571: const PetscInt *cidxs = pcbddc->primal_indices_local_idxs + n_vertices;
4572: PetscInt *count_eff, *V_eff_to_V, *C_eff_to_C, *nnz;
4573: PetscInt n_el = PetscMax(graph->n_local_subs, 1);
4575: PetscCall(PetscCalloc1(2 * n_el, &count_eff));
4576: PetscCall(PetscMalloc1(n_vertices, &V_to_eff_V));
4577: PetscCall(PetscMalloc1(n_constraints, &C_to_eff_C));
4578: for (PetscInt i = 0; i < n_vertices; i++) {
4579: PetscInt s = 2 * graph->nodes[vidxs[i]].local_sub;
4581: V_to_eff_V[i] = count_eff[s];
4582: count_eff[s] += 1;
4583: }
4584: for (PetscInt i = 0; i < n_constraints; i++) {
4585: PetscInt s = 2 * graph->nodes[cidxs[i]].local_sub + 1;
4587: C_to_eff_C[i] = count_eff[s];
4588: count_eff[s] += 1;
4589: }
4591: /* preallocation */
4592: PetscCall(PetscMalloc1(n_vertices + n_constraints, &nnz));
4593: for (PetscInt i = 0; i < n_vertices; i++) {
4594: PetscInt s = 2 * graph->nodes[vidxs[i]].local_sub;
4596: nnz[i] = count_eff[s] + count_eff[s + 1];
4597: }
4598: for (PetscInt i = 0; i < n_constraints; i++) {
4599: PetscInt s = 2 * graph->nodes[cidxs[i]].local_sub;
4601: nnz[i + n_vertices] = count_eff[s] + count_eff[s + 1];
4602: }
4603: PetscCall(MatSeqAIJSetPreallocation(*coarse_submat, 0, nnz));
4604: PetscCall(PetscFree(nnz));
4606: n_eff_vertices = 0;
4607: n_eff_constraints = 0;
4608: for (PetscInt i = 0; i < n_el; i++) {
4609: n_eff_vertices = PetscMax(n_eff_vertices, count_eff[2 * i]);
4610: n_eff_constraints = PetscMax(n_eff_constraints, count_eff[2 * i + 1]);
4611: count_eff[2 * i] = 0;
4612: count_eff[2 * i + 1] = 0;
4613: }
4615: const PetscInt *idx;
4616: PetscCall(PetscMalloc2(n_el * n_eff_vertices, &V_eff_to_V, n_el * n_eff_constraints, &C_eff_to_C));
4618: for (PetscInt i = 0; i < n_vertices; i++) {
4619: const PetscInt e = graph->nodes[vidxs[i]].local_sub;
4620: const PetscInt s = 2 * e;
4622: V_eff_to_V[e * n_eff_vertices + count_eff[s]] = i;
4623: count_eff[s] += 1;
4624: }
4625: for (PetscInt i = 0; i < n_constraints; i++) {
4626: const PetscInt e = graph->nodes[cidxs[i]].local_sub;
4627: const PetscInt s = 2 * e + 1;
4629: C_eff_to_C[e * n_eff_constraints + count_eff[s]] = i;
4630: count_eff[s] += 1;
4631: }
4633: PetscCall(PetscMalloc1(n_R * n_eff_vertices, &R_eff_V_J));
4634: PetscCall(PetscMalloc1(n_R * n_eff_constraints, &R_eff_C_J));
4635: PetscCall(PetscMalloc1(n_B * n_eff_vertices, &B_eff_V_J));
4636: PetscCall(PetscMalloc1(n_B * n_eff_constraints, &B_eff_C_J));
4637: for (PetscInt i = 0; i < n_R * n_eff_vertices; i++) R_eff_V_J[i] = -1;
4638: for (PetscInt i = 0; i < n_R * n_eff_constraints; i++) R_eff_C_J[i] = -1;
4639: for (PetscInt i = 0; i < n_B * n_eff_vertices; i++) B_eff_V_J[i] = -1;
4640: for (PetscInt i = 0; i < n_B * n_eff_constraints; i++) B_eff_C_J[i] = -1;
4642: PetscCall(ISGetIndices(pcbddc->is_R_local, &idx));
4643: for (PetscInt i = 0; i < n_R; i++) {
4644: const PetscInt e = graph->nodes[idx[i]].local_sub;
4645: const PetscInt s = 2 * e;
4646: PetscInt j;
4648: for (j = 0; j < count_eff[s]; j++) R_eff_V_J[i * n_eff_vertices + j] = V_eff_to_V[e * n_eff_vertices + j];
4649: for (j = 0; j < count_eff[s + 1]; j++) R_eff_C_J[i * n_eff_constraints + j] = C_eff_to_C[e * n_eff_constraints + j];
4650: }
4651: PetscCall(ISRestoreIndices(pcbddc->is_R_local, &idx));
4652: PetscCall(ISGetIndices(pcis->is_B_local, &idx));
4653: for (PetscInt i = 0; i < n_B; i++) {
4654: const PetscInt e = graph->nodes[idx[i]].local_sub;
4655: const PetscInt s = 2 * e;
4657: for (PetscInt j = 0; j < count_eff[s]; j++) B_eff_V_J[i * n_eff_vertices + j] = V_eff_to_V[e * n_eff_vertices + j];
4658: for (PetscInt j = 0; j < count_eff[s + 1]; j++) B_eff_C_J[i * n_eff_constraints + j] = C_eff_to_C[e * n_eff_constraints + j];
4659: }
4660: PetscCall(ISRestoreIndices(pcis->is_B_local, &idx));
4662: /* permutation and blocksizes for block invert of S_CC */
4663: PetscInt *idxp;
4665: PetscCall(PetscMalloc1(n_constraints, &idxp));
4666: PetscCall(PetscMalloc1(n_el, &C_bss));
4667: n_C_bss = 0;
4668: for (PetscInt e = 0, cnt = 0; e < n_el; e++) {
4669: const PetscInt nc = count_eff[2 * e + 1];
4671: if (nc) C_bss[n_C_bss++] = nc;
4672: for (PetscInt c = 0; c < nc; c++) idxp[cnt + c] = C_eff_to_C[e * n_eff_constraints + c];
4673: cnt += nc;
4674: }
4676: PetscCall(ISCreateGeneral(PETSC_COMM_SELF, n_constraints, idxp, PETSC_OWN_POINTER, &is_C_perm));
4678: PetscCall(PetscFree2(V_eff_to_V, C_eff_to_C));
4679: PetscCall(PetscFree(count_eff));
4680: } else {
4681: PetscCall(MatCreateSeqDense(PETSC_COMM_SELF, pcbddc->local_primal_size, pcbddc->local_primal_size, NULL, coarse_submat));
4682: n_eff_constraints = n_constraints;
4683: n_eff_vertices = n_vertices;
4684: }
4686: /* determine if can use MatSolve routines instead of calling KSPSolve on ksp_R */
4687: PetscCall(KSPGetPC(pcbddc->ksp_R, &pc_R));
4688: PetscCall(PCSetUp(pc_R));
4689: PetscCall(PetscObjectTypeCompare((PetscObject)pcbddc->ksp_R, KSPPREONLY, &isPreonly));
4690: PetscCall(PetscObjectTypeCompare((PetscObject)pc_R, PCLU, &isLU));
4691: PetscCall(PetscObjectTypeCompare((PetscObject)pc_R, PCCHOLESKY, &isCHOL));
4692: lda_rhs = n_R;
4693: need_benign_correction = PETSC_FALSE;
4694: F = NULL;
4695: if (isPreonly && (isLU || isCHOL)) {
4696: PetscCall(PCFactorGetMatrix(pc_R, &F));
4697: } else if (sub_schurs && sub_schurs->reuse_solver) {
4698: PCBDDCReuseSolvers reuse_solver = sub_schurs->reuse_solver;
4699: MatFactorType type;
4701: F = reuse_solver->F;
4702: PetscCall(MatGetFactorType(F, &type));
4703: if (type == MAT_FACTOR_CHOLESKY) isCHOL = PETSC_TRUE;
4704: if (type == MAT_FACTOR_LU) isLU = PETSC_TRUE;
4705: PetscCall(MatGetSize(F, &lda_rhs, NULL));
4706: need_benign_correction = (PetscBool)(!!reuse_solver->benign_n);
4707: }
4709: /* determine if we can use a sparse right-hand side */
4710: sparserhs = PETSC_FALSE;
4711: if (F && !multi_element) {
4712: MatSolverType solver;
4714: PetscCall(MatFactorGetSolverType(F, &solver));
4715: PetscCall(PetscStrcmp(solver, MATSOLVERMUMPS, &sparserhs));
4716: }
4718: /* create dummy vector to modify rhs and sol of MatMatSolve (work array will never be used) */
4719: dummy_vec = NULL;
4720: if (need_benign_correction && lda_rhs != n_R && F) {
4721: PetscCall(VecCreate(PetscObjectComm((PetscObject)pcis->vec1_N), &dummy_vec));
4722: PetscCall(VecSetSizes(dummy_vec, lda_rhs, PETSC_DECIDE));
4723: PetscCall(VecSetType(dummy_vec, ((PetscObject)pcis->vec1_N)->type_name));
4724: }
4726: PetscCall(MatDestroy(&pcbddc->local_auxmat1));
4727: PetscCall(MatDestroy(&pcbddc->local_auxmat2));
4729: PetscCall(ISCreateStride(PETSC_COMM_SELF, n_R, 0, 1, &is_R));
4730: PetscCall(ISCreateStride(PETSC_COMM_SELF, n_vertices, 0, 1, &is_V));
4731: PetscCall(ISCreateStride(PETSC_COMM_SELF, n_constraints, n_vertices, 1, &is_C));
4732: PetscCall(ISGetIndices(is_V, &idx_V));
4733: PetscCall(ISGetIndices(is_C, &idx_C));
4735: /* Precompute stuffs needed for preprocessing and application of BDDC*/
4736: if (n_constraints) {
4737: Mat C_B;
4739: /* Extract constraints on R nodes: C_{CR} */
4740: PetscCall(MatCreateSubMatrix(pcbddc->ConstraintMatrix, is_C, pcbddc->is_R_local, MAT_INITIAL_MATRIX, &C_CR));
4741: PetscCall(MatCreateSubMatrix(pcbddc->ConstraintMatrix, is_C, pcis->is_B_local, MAT_INITIAL_MATRIX, &C_B));
4743: /* Assemble local_auxmat2_R = (- A_{RR}^{-1} C^T_{CR}) needed by BDDC setup */
4744: /* Assemble pcbddc->local_auxmat2 = R_to_B (- A_{RR}^{-1} C^T_{CR}) needed by BDDC application */
4745: if (!sparserhs) {
4746: PetscScalar *marr;
4748: PetscCall(MatCreateSeqDense(PETSC_COMM_SELF, lda_rhs, n_eff_constraints, NULL, &Brhs));
4749: PetscCall(MatDenseGetArrayWrite(Brhs, &marr));
4750: for (i = 0; i < n_constraints; i++) {
4751: const PetscScalar *row_cmat_values;
4752: const PetscInt *row_cmat_indices;
4753: PetscInt size_of_constraint, j, col = C_to_eff_C ? C_to_eff_C[i] : i;
4755: PetscCall(MatGetRow(C_CR, i, &size_of_constraint, &row_cmat_indices, &row_cmat_values));
4756: for (j = 0; j < size_of_constraint; j++) marr[row_cmat_indices[j] + col * lda_rhs] = -row_cmat_values[j];
4757: PetscCall(MatRestoreRow(C_CR, i, &size_of_constraint, &row_cmat_indices, &row_cmat_values));
4758: }
4759: PetscCall(MatDenseRestoreArrayWrite(Brhs, &marr));
4760: } else {
4761: Mat tC_CR;
4763: PetscCall(MatScale(C_CR, -1.0));
4764: if (lda_rhs != n_R) {
4765: PetscScalar *aa;
4766: PetscInt r, *ii, *jj;
4767: PetscBool done;
4769: PetscCall(MatGetRowIJ(C_CR, 0, PETSC_FALSE, PETSC_FALSE, &r, (const PetscInt **)&ii, (const PetscInt **)&jj, &done));
4770: PetscCheck(done, PETSC_COMM_SELF, PETSC_ERR_PLIB, "GetRowIJ failed");
4771: PetscCall(MatSeqAIJGetArray(C_CR, &aa));
4772: PetscCall(MatCreateSeqAIJWithArrays(PETSC_COMM_SELF, n_constraints, lda_rhs, ii, jj, aa, &tC_CR));
4773: PetscCall(MatRestoreRowIJ(C_CR, 0, PETSC_FALSE, PETSC_FALSE, &r, (const PetscInt **)&ii, (const PetscInt **)&jj, &done));
4774: PetscCheck(done, PETSC_COMM_SELF, PETSC_ERR_PLIB, "RestoreRowIJ failed");
4775: } else {
4776: PetscCall(PetscObjectReference((PetscObject)C_CR));
4777: tC_CR = C_CR;
4778: }
4779: PetscCall(MatCreateTranspose(tC_CR, &Brhs));
4780: PetscCall(MatDestroy(&tC_CR));
4781: }
4782: PetscCall(MatCreateSeqDense(PETSC_COMM_SELF, lda_rhs, n_eff_constraints, NULL, &local_auxmat2_R));
4783: if (F) {
4784: if (need_benign_correction) {
4785: PCBDDCReuseSolvers reuse_solver = sub_schurs->reuse_solver;
4787: /* rhs is already zero on interior dofs, no need to change the rhs */
4788: PetscCall(PetscArrayzero(reuse_solver->benign_save_vals, pcbddc->benign_n));
4789: }
4790: PetscCall(MatMatSolve(F, Brhs, local_auxmat2_R));
4791: if (need_benign_correction) {
4792: PetscScalar *marr;
4793: PCBDDCReuseSolvers reuse_solver = sub_schurs->reuse_solver;
4795: /* XXX multi_element? */
4796: PetscCall(MatDenseGetArray(local_auxmat2_R, &marr));
4797: if (lda_rhs != n_R) {
4798: for (i = 0; i < n_eff_constraints; i++) {
4799: PetscCall(VecPlaceArray(dummy_vec, marr + i * lda_rhs));
4800: PetscCall(PCBDDCReuseSolversBenignAdapt(reuse_solver, dummy_vec, NULL, PETSC_TRUE, PETSC_TRUE));
4801: PetscCall(VecResetArray(dummy_vec));
4802: }
4803: } else {
4804: for (i = 0; i < n_eff_constraints; i++) {
4805: PetscCall(VecPlaceArray(pcbddc->vec1_R, marr + i * lda_rhs));
4806: PetscCall(PCBDDCReuseSolversBenignAdapt(reuse_solver, pcbddc->vec1_R, NULL, PETSC_TRUE, PETSC_TRUE));
4807: PetscCall(VecResetArray(pcbddc->vec1_R));
4808: }
4809: }
4810: PetscCall(MatDenseRestoreArray(local_auxmat2_R, &marr));
4811: }
4812: } else {
4813: const PetscScalar *barr;
4814: PetscScalar *marr;
4816: PetscCall(MatDenseGetArrayRead(Brhs, &barr));
4817: PetscCall(MatDenseGetArray(local_auxmat2_R, &marr));
4818: for (i = 0; i < n_eff_constraints; i++) {
4819: PetscCall(VecPlaceArray(pcbddc->vec1_R, barr + i * lda_rhs));
4820: PetscCall(VecPlaceArray(pcbddc->vec2_R, marr + i * lda_rhs));
4821: PetscCall(KSPSolve(pcbddc->ksp_R, pcbddc->vec1_R, pcbddc->vec2_R));
4822: PetscCall(KSPCheckSolve(pcbddc->ksp_R, pc, pcbddc->vec2_R));
4823: PetscCall(VecResetArray(pcbddc->vec1_R));
4824: PetscCall(VecResetArray(pcbddc->vec2_R));
4825: }
4826: PetscCall(MatDenseRestoreArrayRead(Brhs, &barr));
4827: PetscCall(MatDenseRestoreArray(local_auxmat2_R, &marr));
4828: }
4829: if (sparserhs) PetscCall(MatScale(C_CR, -1.0));
4830: PetscCall(MatDestroy(&Brhs));
4831: /* Assemble explicitly S_CC = ( C_{CR} A_{RR}^{-1} C^T_{CR})^{-1} */
4832: if (!pcbddc->switch_static) {
4833: PetscCall(MatCreateSeqDense(PETSC_COMM_SELF, n_B, n_eff_constraints, NULL, &pcbddc->local_auxmat2));
4834: PetscCall(MatDenseScatter_Private(pcbddc->R_to_B, local_auxmat2_R, pcbddc->local_auxmat2, INSERT_VALUES, SCATTER_FORWARD));
4835: if (multi_element) {
4836: Mat T;
4838: PetscCall(MatCreateSeqAIJFromDenseExpand(local_auxmat2_R, n_constraints, R_eff_C_J, &T));
4839: PetscCall(MatDestroy(&local_auxmat2_R));
4840: local_auxmat2_R = T;
4841: PetscCall(MatCreateSeqAIJFromDenseExpand(pcbddc->local_auxmat2, n_constraints, B_eff_C_J, &T));
4842: PetscCall(MatDestroy(&pcbddc->local_auxmat2));
4843: pcbddc->local_auxmat2 = T;
4844: }
4845: PetscCall(MatMatMult(C_B, pcbddc->local_auxmat2, MAT_INITIAL_MATRIX, PETSC_DETERMINE, &S_CC));
4846: } else {
4847: if (multi_element) {
4848: Mat T;
4850: PetscCall(MatCreateSeqAIJFromDenseExpand(local_auxmat2_R, n_constraints, R_eff_C_J, &T));
4851: PetscCall(MatDestroy(&local_auxmat2_R));
4852: local_auxmat2_R = T;
4853: }
4854: if (lda_rhs != n_R) {
4855: PetscCall(MatCreateSubMatrix(local_auxmat2_R, is_R, NULL, MAT_INITIAL_MATRIX, &pcbddc->local_auxmat2));
4856: } else {
4857: PetscCall(PetscObjectReference((PetscObject)local_auxmat2_R));
4858: pcbddc->local_auxmat2 = local_auxmat2_R;
4859: }
4860: PetscCall(MatMatMult(C_CR, pcbddc->local_auxmat2, MAT_INITIAL_MATRIX, PETSC_DETERMINE, &S_CC));
4861: }
4862: PetscCall(MatScale(S_CC, m_one));
4863: if (multi_element) {
4864: Mat T, T2;
4865: IS isp, ispi;
4867: isp = is_C_perm;
4869: PetscCall(ISInvertPermutation(isp, PETSC_DECIDE, &ispi));
4870: PetscCall(MatPermute(S_CC, isp, isp, &T));
4871: PetscCall(MatSeqAIJInvertVariableBlockDiagonalMat(T, n_C_bss, C_bss, &T2));
4872: PetscCall(MatDestroy(&T));
4873: PetscCall(MatDestroy(&S_CC));
4874: PetscCall(MatPermute(T2, ispi, ispi, &S_CC));
4875: PetscCall(MatDestroy(&T2));
4876: PetscCall(ISDestroy(&ispi));
4877: } else {
4878: if (isCHOL) {
4879: PetscCall(MatCholeskyFactor(S_CC, NULL, NULL));
4880: } else {
4881: PetscCall(MatLUFactor(S_CC, NULL, NULL, NULL));
4882: }
4883: PetscCall(MatSeqDenseInvertFactors_Private(S_CC));
4884: }
4885: /* Assemble local_auxmat1 = S_CC*C_{CB} needed by BDDC application in KSP and in preproc */
4886: PetscCall(MatMatMult(S_CC, C_B, MAT_INITIAL_MATRIX, PETSC_DETERMINE, &pcbddc->local_auxmat1));
4887: PetscCall(MatDestroy(&C_B));
4888: PetscCall(MatSetValuesSubMat(*coarse_submat, S_CC, n_constraints, idx_C, n_constraints, idx_C, INSERT_VALUES));
4889: }
4891: /* Get submatrices from subdomain matrix */
4892: if (n_vertices) {
4893: #if PetscDefined(HAVE_VIENNACL) || PetscDefined(HAVE_CUDA)
4894: PetscBool oldpin;
4895: #endif
4896: IS is_aux;
4898: if (sub_schurs && sub_schurs->reuse_solver) { /* is_R_local is not sorted, ISComplement doesn't like it */
4899: IS tis;
4901: PetscCall(ISDuplicate(pcbddc->is_R_local, &tis));
4902: PetscCall(ISSort(tis));
4903: PetscCall(ISComplement(tis, 0, pcis->n, &is_aux));
4904: PetscCall(ISDestroy(&tis));
4905: } else {
4906: PetscCall(ISComplement(pcbddc->is_R_local, 0, pcis->n, &is_aux));
4907: }
4908: #if PetscDefined(HAVE_VIENNACL) || PetscDefined(HAVE_CUDA)
4909: oldpin = pcbddc->local_mat->boundtocpu;
4910: #endif
4911: PetscCall(MatBindToCPU(pcbddc->local_mat, PETSC_TRUE));
4912: PetscCall(MatCreateSubMatrix(pcbddc->local_mat, pcbddc->is_R_local, is_aux, MAT_INITIAL_MATRIX, &A_RV));
4913: PetscCall(MatCreateSubMatrix(pcbddc->local_mat, is_aux, pcbddc->is_R_local, MAT_INITIAL_MATRIX, &A_VR));
4914: /* TODO REMOVE: MatMatMult(A_VR,A_RRmA_RV) below may raise an error */
4915: PetscCall(MatConvert(A_VR, MATSEQAIJ, MAT_INPLACE_MATRIX, &A_VR));
4916: PetscCall(MatCreateSubMatrix(pcbddc->local_mat, is_aux, is_aux, MAT_INITIAL_MATRIX, &A_VV));
4917: #if PetscDefined(HAVE_VIENNACL) || PetscDefined(HAVE_CUDA)
4918: PetscCall(MatBindToCPU(pcbddc->local_mat, oldpin));
4919: #endif
4920: PetscCall(ISDestroy(&is_aux));
4921: }
4922: PetscCall(ISDestroy(&is_C_perm));
4923: PetscCall(PetscFree(C_bss));
4925: p0_lidx_I = NULL;
4926: if (pcbddc->benign_n && (pcbddc->switch_static || pcbddc->dbg_flag)) {
4927: const PetscInt *idxs;
4929: PetscCall(ISGetIndices(pcis->is_I_local, &idxs));
4930: PetscCall(PetscMalloc1(pcbddc->benign_n, &p0_lidx_I));
4931: for (i = 0; i < pcbddc->benign_n; i++) PetscCall(PetscFindInt(pcbddc->benign_p0_lidx[i], pcis->n - pcis->n_B, idxs, &p0_lidx_I[i]));
4932: PetscCall(ISRestoreIndices(pcis->is_I_local, &idxs));
4933: }
4935: /* We are now ready to evaluate coarse basis functions and subdomain contribution to coarse problem */
4937: /* Matrices of coarse basis functions (local) */
4938: PetscCall(MatDestroy(&pcbddc->coarse_phi_B));
4939: PetscCall(MatDestroy(&pcbddc->coarse_psi_B));
4940: PetscCall(MatDestroy(&pcbddc->coarse_phi_D));
4941: PetscCall(MatDestroy(&pcbddc->coarse_psi_D));
4942: if (!multi_element) {
4943: PetscCall(MatCreateSeqDense(PETSC_COMM_SELF, n_B, pcbddc->local_primal_size, NULL, &pcbddc->coarse_phi_B));
4944: if (pcbddc->switch_static || pcbddc->dbg_flag) PetscCall(MatCreateSeqDense(PETSC_COMM_SELF, n_D, pcbddc->local_primal_size, NULL, &pcbddc->coarse_phi_D));
4945: coarse_phi_multi = NULL;
4946: } else { /* Create temporary NEST matrix to hold coarse basis functions blocks */
4947: IS is_rows[2] = {pcbddc->is_R_local, NULL};
4948: IS is_cols[2] = {is_V, is_C};
4950: PetscCall(ISCreateGeneral(PETSC_COMM_SELF, n_vertices, pcbddc->local_primal_ref_node, PETSC_USE_POINTER, &is_rows[1]));
4951: PetscCall(MatCreateNest(PETSC_COMM_SELF, 2, is_rows, 2, is_cols, NULL, &coarse_phi_multi));
4952: PetscCall(ISDestroy(&is_rows[1]));
4953: }
4955: /* vertices */
4956: if (n_vertices) {
4957: PetscBool restoreavr = PETSC_FALSE;
4958: Mat A_RRmA_RV = NULL;
4960: PetscCall(MatSetValuesSubMat(*coarse_submat, A_VV, n_vertices, idx_V, n_vertices, idx_V, ADD_VALUES));
4961: PetscCall(MatDestroy(&A_VV));
4963: if (n_R) {
4964: Mat A_RV_bcorr = NULL, S_VV;
4966: PetscCall(MatScale(A_RV, m_one));
4967: if (need_benign_correction) {
4968: ISLocalToGlobalMapping RtoN;
4969: IS is_p0;
4970: PetscInt *idxs_p0, n;
4972: PetscCall(PetscMalloc1(pcbddc->benign_n, &idxs_p0));
4973: PetscCall(ISLocalToGlobalMappingCreateIS(pcbddc->is_R_local, &RtoN));
4974: PetscCall(ISGlobalToLocalMappingApply(RtoN, IS_GTOLM_DROP, pcbddc->benign_n, pcbddc->benign_p0_lidx, &n, idxs_p0));
4975: PetscCheck(n == pcbddc->benign_n, PETSC_COMM_SELF, PETSC_ERR_PLIB, "Error in R numbering for benign p0! %" PetscInt_FMT " != %" PetscInt_FMT, n, pcbddc->benign_n);
4976: PetscCall(ISLocalToGlobalMappingDestroy(&RtoN));
4977: PetscCall(ISCreateGeneral(PETSC_COMM_SELF, n, idxs_p0, PETSC_OWN_POINTER, &is_p0));
4978: PetscCall(MatCreateSubMatrix(A_RV, is_p0, NULL, MAT_INITIAL_MATRIX, &A_RV_bcorr));
4979: PetscCall(ISDestroy(&is_p0));
4980: }
4982: PetscCall(MatCreateSeqDense(PETSC_COMM_SELF, lda_rhs, n_eff_vertices, NULL, &A_RRmA_RV));
4983: if (!sparserhs || need_benign_correction) {
4984: if (lda_rhs == n_R && !multi_element) {
4985: PetscCall(MatConvert(A_RV, MATDENSE, MAT_INPLACE_MATRIX, &A_RV));
4986: } else {
4987: Mat T;
4988: PetscScalar *av, *array;
4989: const PetscInt *xadj, *adjncy;
4990: PetscInt n;
4991: PetscBool flg_row;
4993: PetscCall(MatCreateSeqDense(PETSC_COMM_SELF, lda_rhs, n_eff_vertices, NULL, &T));
4994: PetscCall(MatDenseGetArrayWrite(T, &array));
4995: PetscCall(MatConvert(A_RV, MATSEQAIJ, MAT_INPLACE_MATRIX, &A_RV));
4996: PetscCall(MatGetRowIJ(A_RV, 0, PETSC_FALSE, PETSC_FALSE, &n, &xadj, &adjncy, &flg_row));
4997: PetscCall(MatSeqAIJGetArray(A_RV, &av));
4998: for (i = 0; i < n; i++) {
4999: for (PetscInt j = xadj[i]; j < xadj[i + 1]; j++) array[lda_rhs * (V_to_eff_V ? V_to_eff_V[adjncy[j]] : adjncy[j]) + i] = av[j];
5000: }
5001: PetscCall(MatRestoreRowIJ(A_RV, 0, PETSC_FALSE, PETSC_FALSE, &n, &xadj, &adjncy, &flg_row));
5002: PetscCall(MatDenseRestoreArrayWrite(T, &array));
5003: PetscCall(MatDestroy(&A_RV));
5004: A_RV = T;
5005: }
5006: if (need_benign_correction) {
5007: PCBDDCReuseSolvers reuse_solver = sub_schurs->reuse_solver;
5008: PetscScalar *marr;
5010: /* XXX multi_element */
5011: PetscCall(MatDenseGetArray(A_RV, &marr));
5012: /* need \Phi^T A_RV = (I+L)A_RV, L given by
5014: | 0 0 0 | (V)
5015: L = | 0 0 -1 | (P-p0)
5016: | 0 0 -1 | (p0)
5018: */
5019: for (i = 0; i < reuse_solver->benign_n; i++) {
5020: const PetscScalar *vals;
5021: const PetscInt *idxs, *idxs_zero;
5022: PetscInt n, j, nz;
5024: PetscCall(ISGetLocalSize(reuse_solver->benign_zerodiag_subs[i], &nz));
5025: PetscCall(ISGetIndices(reuse_solver->benign_zerodiag_subs[i], &idxs_zero));
5026: PetscCall(MatGetRow(A_RV_bcorr, i, &n, &idxs, &vals));
5027: for (j = 0; j < n; j++) {
5028: PetscScalar val = vals[j];
5029: PetscInt k, col = idxs[j];
5030: for (k = 0; k < nz; k++) marr[idxs_zero[k] + lda_rhs * col] -= val;
5031: }
5032: PetscCall(MatRestoreRow(A_RV_bcorr, i, &n, &idxs, &vals));
5033: PetscCall(ISRestoreIndices(reuse_solver->benign_zerodiag_subs[i], &idxs_zero));
5034: }
5035: PetscCall(MatDenseRestoreArray(A_RV, &marr));
5036: }
5037: PetscCall(PetscObjectReference((PetscObject)A_RV));
5038: Brhs = A_RV;
5039: } else {
5040: Mat tA_RVT, A_RVT;
5042: if (!pcbddc->symmetric_primal) {
5043: /* A_RV already scaled by -1 */
5044: PetscCall(MatTranspose(A_RV, MAT_INITIAL_MATRIX, &A_RVT));
5045: } else {
5046: restoreavr = PETSC_TRUE;
5047: PetscCall(MatScale(A_VR, -1.0));
5048: PetscCall(PetscObjectReference((PetscObject)A_VR));
5049: A_RVT = A_VR;
5050: }
5051: if (lda_rhs != n_R) {
5052: PetscScalar *aa;
5053: PetscInt r, *ii, *jj;
5054: PetscBool done;
5056: PetscCall(MatGetRowIJ(A_RVT, 0, PETSC_FALSE, PETSC_FALSE, &r, (const PetscInt **)&ii, (const PetscInt **)&jj, &done));
5057: PetscCheck(done, PETSC_COMM_SELF, PETSC_ERR_PLIB, "GetRowIJ failed");
5058: PetscCall(MatSeqAIJGetArray(A_RVT, &aa));
5059: PetscCall(MatCreateSeqAIJWithArrays(PETSC_COMM_SELF, n_vertices, lda_rhs, ii, jj, aa, &tA_RVT));
5060: PetscCall(MatRestoreRowIJ(A_RVT, 0, PETSC_FALSE, PETSC_FALSE, &r, (const PetscInt **)&ii, (const PetscInt **)&jj, &done));
5061: PetscCheck(done, PETSC_COMM_SELF, PETSC_ERR_PLIB, "RestoreRowIJ failed");
5062: } else {
5063: PetscCall(PetscObjectReference((PetscObject)A_RVT));
5064: tA_RVT = A_RVT;
5065: }
5066: PetscCall(MatCreateTranspose(tA_RVT, &Brhs));
5067: PetscCall(MatDestroy(&tA_RVT));
5068: PetscCall(MatDestroy(&A_RVT));
5069: }
5070: if (F) {
5071: /* need to correct the rhs */
5072: if (need_benign_correction) {
5073: PCBDDCReuseSolvers reuse_solver = sub_schurs->reuse_solver;
5074: PetscScalar *marr;
5076: PetscCall(MatDenseGetArray(Brhs, &marr));
5077: if (lda_rhs != n_R) {
5078: for (i = 0; i < n_eff_vertices; i++) {
5079: PetscCall(VecPlaceArray(dummy_vec, marr + i * lda_rhs));
5080: PetscCall(PCBDDCReuseSolversBenignAdapt(reuse_solver, dummy_vec, NULL, PETSC_FALSE, PETSC_TRUE));
5081: PetscCall(VecResetArray(dummy_vec));
5082: }
5083: } else {
5084: for (i = 0; i < n_eff_vertices; i++) {
5085: PetscCall(VecPlaceArray(pcbddc->vec1_R, marr + i * lda_rhs));
5086: PetscCall(PCBDDCReuseSolversBenignAdapt(reuse_solver, pcbddc->vec1_R, NULL, PETSC_FALSE, PETSC_TRUE));
5087: PetscCall(VecResetArray(pcbddc->vec1_R));
5088: }
5089: }
5090: PetscCall(MatDenseRestoreArray(Brhs, &marr));
5091: }
5092: PetscCall(MatMatSolve(F, Brhs, A_RRmA_RV));
5093: if (restoreavr) PetscCall(MatScale(A_VR, -1.0));
5094: /* need to correct the solution */
5095: if (need_benign_correction) {
5096: PCBDDCReuseSolvers reuse_solver = sub_schurs->reuse_solver;
5097: PetscScalar *marr;
5099: PetscCall(MatDenseGetArray(A_RRmA_RV, &marr));
5100: if (lda_rhs != n_R) {
5101: for (i = 0; i < n_eff_vertices; i++) {
5102: PetscCall(VecPlaceArray(dummy_vec, marr + i * lda_rhs));
5103: PetscCall(PCBDDCReuseSolversBenignAdapt(reuse_solver, dummy_vec, NULL, PETSC_TRUE, PETSC_TRUE));
5104: PetscCall(VecResetArray(dummy_vec));
5105: }
5106: } else {
5107: for (i = 0; i < n_eff_vertices; i++) {
5108: PetscCall(VecPlaceArray(pcbddc->vec1_R, marr + i * lda_rhs));
5109: PetscCall(PCBDDCReuseSolversBenignAdapt(reuse_solver, pcbddc->vec1_R, NULL, PETSC_TRUE, PETSC_TRUE));
5110: PetscCall(VecResetArray(pcbddc->vec1_R));
5111: }
5112: }
5113: PetscCall(MatDenseRestoreArray(A_RRmA_RV, &marr));
5114: }
5115: } else {
5116: const PetscScalar *barr;
5117: PetscScalar *marr;
5119: PetscCall(MatDenseGetArrayRead(Brhs, &barr));
5120: PetscCall(MatDenseGetArray(A_RRmA_RV, &marr));
5121: for (i = 0; i < n_eff_vertices; i++) {
5122: PetscCall(VecPlaceArray(pcbddc->vec1_R, barr + i * lda_rhs));
5123: PetscCall(VecPlaceArray(pcbddc->vec2_R, marr + i * lda_rhs));
5124: PetscCall(KSPSolve(pcbddc->ksp_R, pcbddc->vec1_R, pcbddc->vec2_R));
5125: PetscCall(KSPCheckSolve(pcbddc->ksp_R, pc, pcbddc->vec2_R));
5126: PetscCall(VecResetArray(pcbddc->vec1_R));
5127: PetscCall(VecResetArray(pcbddc->vec2_R));
5128: }
5129: PetscCall(MatDenseRestoreArrayRead(Brhs, &barr));
5130: PetscCall(MatDenseRestoreArray(A_RRmA_RV, &marr));
5131: }
5132: PetscCall(MatDestroy(&A_RV));
5133: PetscCall(MatDestroy(&Brhs));
5134: /* S_VV and S_CV */
5135: if (n_constraints) {
5136: Mat B;
5138: PetscCall(MatCreateSeqDense(PETSC_COMM_SELF, n_B, n_eff_vertices, NULL, &B));
5139: PetscCall(MatDenseScatter_Private(pcbddc->R_to_B, A_RRmA_RV, B, INSERT_VALUES, SCATTER_FORWARD));
5141: /* S_CV = pcbddc->local_auxmat1 * B */
5142: if (multi_element) {
5143: Mat T;
5145: PetscCall(MatCreateSeqAIJFromDenseExpand(B, n_vertices, B_eff_V_J, &T));
5146: PetscCall(MatDestroy(&B));
5147: B = T;
5148: }
5149: PetscCall(MatProductCreate(pcbddc->local_auxmat1, B, NULL, &S_CV));
5150: PetscCall(MatProductSetType(S_CV, MATPRODUCT_AB));
5151: PetscCall(MatProductSetFromOptions(S_CV));
5152: PetscCall(MatProductSymbolic(S_CV));
5153: PetscCall(MatProductNumeric(S_CV));
5154: PetscCall(MatProductClear(S_CV));
5155: PetscCall(MatDestroy(&B));
5157: /* B = local_auxmat2_R * S_CV */
5158: PetscCall(MatProductCreate(local_auxmat2_R, S_CV, NULL, &B));
5159: PetscCall(MatProductSetType(B, MATPRODUCT_AB));
5160: PetscCall(MatProductSetFromOptions(B));
5161: PetscCall(MatProductSymbolic(B));
5162: PetscCall(MatProductNumeric(B));
5164: PetscCall(MatScale(S_CV, m_one));
5165: PetscCall(MatSetValuesSubMat(*coarse_submat, S_CV, n_constraints, idx_C, n_vertices, idx_V, INSERT_VALUES));
5167: if (multi_element) {
5168: Mat T;
5170: PetscCall(MatCreateSeqAIJFromDenseExpand(A_RRmA_RV, n_vertices, R_eff_V_J, &T));
5171: PetscCall(MatDestroy(&A_RRmA_RV));
5172: A_RRmA_RV = T;
5173: }
5174: PetscCall(MatAXPY(A_RRmA_RV, 1.0, B, UNKNOWN_NONZERO_PATTERN)); /* XXX ? */
5175: PetscCall(MatDestroy(&B));
5176: } else if (multi_element) {
5177: Mat T;
5179: PetscCall(MatCreateSeqAIJFromDenseExpand(A_RRmA_RV, n_vertices, R_eff_V_J, &T));
5180: PetscCall(MatDestroy(&A_RRmA_RV));
5181: A_RRmA_RV = T;
5182: }
5184: if (lda_rhs != n_R) {
5185: Mat T;
5187: PetscCall(MatCreateSubMatrix(A_RRmA_RV, is_R, NULL, MAT_INITIAL_MATRIX, &T));
5188: PetscCall(MatDestroy(&A_RRmA_RV));
5189: A_RRmA_RV = T;
5190: }
5192: /* need A_VR * \Phi * A_RRmA_RV = A_VR * (I+L)^T * A_RRmA_RV, L given as before */
5193: if (need_benign_correction) { /* XXX SPARSE */
5194: PCBDDCReuseSolvers reuse_solver = sub_schurs->reuse_solver;
5195: PetscScalar *sums;
5196: const PetscScalar *marr;
5198: PetscCall(MatDenseGetArrayRead(A_RRmA_RV, &marr));
5199: PetscCall(PetscMalloc1(n_vertices, &sums));
5200: for (i = 0; i < reuse_solver->benign_n; i++) {
5201: const PetscScalar *vals;
5202: const PetscInt *idxs, *idxs_zero;
5203: PetscInt n, j, nz;
5205: PetscCall(ISGetLocalSize(reuse_solver->benign_zerodiag_subs[i], &nz));
5206: PetscCall(ISGetIndices(reuse_solver->benign_zerodiag_subs[i], &idxs_zero));
5207: for (j = 0; j < n_vertices; j++) {
5208: sums[j] = 0.;
5209: for (PetscInt k = 0; k < nz; k++) sums[j] += marr[idxs_zero[k] + j * n_R];
5210: }
5211: PetscCall(MatGetRow(A_RV_bcorr, i, &n, &idxs, &vals));
5212: for (j = 0; j < n; j++) {
5213: PetscScalar val = vals[j];
5214: for (PetscInt k = 0; k < n_vertices; k++) PetscCall(MatSetValue(*coarse_submat, idx_V[idxs[j]], idx_V[k], val * sums[k], ADD_VALUES));
5215: }
5216: PetscCall(MatRestoreRow(A_RV_bcorr, i, &n, &idxs, &vals));
5217: PetscCall(ISRestoreIndices(reuse_solver->benign_zerodiag_subs[i], &idxs_zero));
5218: }
5219: PetscCall(PetscFree(sums));
5220: PetscCall(MatDestroy(&A_RV_bcorr));
5221: PetscCall(MatDenseRestoreArrayRead(A_RRmA_RV, &marr));
5222: }
5224: PetscCall(MatMatMult(A_VR, A_RRmA_RV, MAT_INITIAL_MATRIX, PETSC_DETERMINE, &S_VV));
5225: PetscCall(MatSetValuesSubMat(*coarse_submat, S_VV, n_vertices, idx_V, n_vertices, idx_V, ADD_VALUES));
5226: PetscCall(MatDestroy(&S_VV));
5227: }
5229: /* coarse basis functions */
5230: if (coarse_phi_multi) {
5231: Mat Vid;
5233: PetscCall(MatCreateSeqAIJ(PETSC_COMM_SELF, n_vertices, n_vertices, 1, NULL, &Vid));
5234: PetscCall(MatShift_Basic(Vid, 1.0));
5235: PetscCall(MatNestSetSubMat(coarse_phi_multi, 0, 0, A_RRmA_RV));
5236: PetscCall(MatNestSetSubMat(coarse_phi_multi, 1, 0, Vid));
5237: PetscCall(MatDestroy(&Vid));
5238: } else {
5239: if (A_RRmA_RV) {
5240: Mat B;
5242: PetscCall(MatDenseGetSubMatrix(pcbddc->coarse_phi_B, PETSC_DECIDE, PETSC_DECIDE, 0, n_vertices, &B));
5243: PetscCall(MatDenseScatter_Private(pcbddc->R_to_B, A_RRmA_RV, B, INSERT_VALUES, SCATTER_FORWARD));
5244: PetscCall(MatDenseRestoreSubMatrix(pcbddc->coarse_phi_B, &B));
5245: if (pcbddc->switch_static || pcbddc->dbg_flag) {
5246: PetscCall(MatDenseGetSubMatrix(pcbddc->coarse_phi_D, PETSC_DECIDE, PETSC_DECIDE, 0, n_vertices, &B));
5247: PetscCall(MatDenseScatter_Private(pcbddc->R_to_D, A_RRmA_RV, B, INSERT_VALUES, SCATTER_FORWARD));
5248: PetscCall(MatDenseRestoreSubMatrix(pcbddc->coarse_phi_D, &B));
5249: if (pcbddc->benign_n) {
5250: for (i = 0; i < n_vertices; i++) PetscCall(MatSetValues(pcbddc->coarse_phi_D, pcbddc->benign_n, p0_lidx_I, 1, &i, NULL, INSERT_VALUES));
5251: PetscCall(MatAssemblyBegin(pcbddc->coarse_phi_D, MAT_FINAL_ASSEMBLY));
5252: PetscCall(MatAssemblyEnd(pcbddc->coarse_phi_D, MAT_FINAL_ASSEMBLY));
5253: }
5254: }
5255: }
5256: for (i = 0; i < n_vertices; i++) PetscCall(MatSetValues(pcbddc->coarse_phi_B, 1, &idx_V_B[i], 1, &i, &one, INSERT_VALUES));
5257: PetscCall(MatAssemblyBegin(pcbddc->coarse_phi_B, MAT_FINAL_ASSEMBLY));
5258: PetscCall(MatAssemblyEnd(pcbddc->coarse_phi_B, MAT_FINAL_ASSEMBLY));
5259: }
5260: PetscCall(MatDestroy(&A_RRmA_RV));
5261: }
5262: PetscCall(MatDestroy(&A_RV));
5263: PetscCall(VecDestroy(&dummy_vec));
5265: if (n_constraints) {
5266: Mat B, B2;
5268: PetscCall(MatScale(S_CC, m_one));
5269: PetscCall(MatProductCreate(local_auxmat2_R, S_CC, NULL, &B));
5270: PetscCall(MatProductSetType(B, MATPRODUCT_AB));
5271: PetscCall(MatProductSetFromOptions(B));
5272: PetscCall(MatProductSymbolic(B));
5273: PetscCall(MatProductNumeric(B));
5275: if (n_vertices) {
5276: if (isCHOL || need_benign_correction) { /* if we can solve the interior problem with cholesky, we should also be fine with transposing here */
5277: PetscCall(MatTranspose(S_CV, MAT_INITIAL_MATRIX, &S_VC));
5278: } else {
5279: if (lda_rhs != n_R) {
5280: Mat tB;
5282: PetscCall(MatCreateSubMatrix(B, is_R, NULL, MAT_INITIAL_MATRIX, &tB));
5283: PetscCall(MatDestroy(&B));
5284: B = tB;
5285: }
5286: PetscCall(MatMatMult(A_VR, B, MAT_INITIAL_MATRIX, PETSC_DETERMINE, &S_VC));
5287: }
5288: PetscCall(MatSetValuesSubMat(*coarse_submat, S_VC, n_vertices, idx_V, n_constraints, idx_C, INSERT_VALUES));
5289: }
5291: /* coarse basis functions */
5292: if (coarse_phi_multi) {
5293: PetscCall(MatNestSetSubMat(coarse_phi_multi, 0, 1, B));
5294: } else {
5295: PetscCall(MatDenseGetSubMatrix(pcbddc->coarse_phi_B, PETSC_DECIDE, PETSC_DECIDE, n_vertices, n_vertices + n_constraints, &B2));
5296: PetscCall(MatDenseScatter_Private(pcbddc->R_to_B, B, B2, INSERT_VALUES, SCATTER_FORWARD));
5297: PetscCall(MatDenseRestoreSubMatrix(pcbddc->coarse_phi_B, &B2));
5298: if (pcbddc->switch_static || pcbddc->dbg_flag) {
5299: PetscCall(MatDenseGetSubMatrix(pcbddc->coarse_phi_D, PETSC_DECIDE, PETSC_DECIDE, n_vertices, n_vertices + n_constraints, &B2));
5300: PetscCall(MatDenseScatter_Private(pcbddc->R_to_D, B, B2, INSERT_VALUES, SCATTER_FORWARD));
5301: if (pcbddc->benign_n) {
5302: for (i = 0; i < n_constraints; i++) PetscCall(MatSetValues(B2, pcbddc->benign_n, p0_lidx_I, 1, &i, NULL, INSERT_VALUES));
5303: }
5304: PetscCall(MatDenseRestoreSubMatrix(pcbddc->coarse_phi_D, &B2));
5305: }
5306: }
5307: PetscCall(MatDestroy(&B));
5308: }
5310: /* assemble sparse coarse basis functions */
5311: if (coarse_phi_multi) {
5312: Mat T;
5314: PetscCall(MatConvert(coarse_phi_multi, MATSEQAIJ, MAT_INITIAL_MATRIX, &T));
5315: PetscCall(MatDestroy(&coarse_phi_multi));
5316: PetscCall(MatCreateSubMatrix(T, pcis->is_B_local, NULL, MAT_INITIAL_MATRIX, &pcbddc->coarse_phi_B));
5317: if (pcbddc->switch_static || pcbddc->dbg_flag) PetscCall(MatCreateSubMatrix(T, pcis->is_I_local, NULL, MAT_INITIAL_MATRIX, &pcbddc->coarse_phi_D));
5318: PetscCall(MatDestroy(&T));
5319: }
5320: PetscCall(MatDestroy(&local_auxmat2_R));
5321: PetscCall(PetscFree(p0_lidx_I));
5323: /* coarse matrix entries relative to B_0 */
5324: if (pcbddc->benign_n) {
5325: Mat B0_B, B0_BPHI;
5326: IS is_dummy;
5327: const PetscScalar *data;
5329: PetscCall(ISCreateStride(PETSC_COMM_SELF, pcbddc->benign_n, 0, 1, &is_dummy));
5330: PetscCall(MatCreateSubMatrix(pcbddc->benign_B0, is_dummy, pcis->is_B_local, MAT_INITIAL_MATRIX, &B0_B));
5331: PetscCall(ISDestroy(&is_dummy));
5332: PetscCall(MatMatMult(B0_B, pcbddc->coarse_phi_B, MAT_INITIAL_MATRIX, 1.0, &B0_BPHI));
5333: PetscCall(MatConvert(B0_BPHI, MATSEQDENSE, MAT_INPLACE_MATRIX, &B0_BPHI));
5334: PetscCall(MatDenseGetArrayRead(B0_BPHI, &data));
5335: for (PetscInt j = 0; j < pcbddc->benign_n; j++) {
5336: PetscInt primal_idx = pcbddc->local_primal_size - pcbddc->benign_n + j;
5337: for (i = 0; i < pcbddc->local_primal_size; i++) {
5338: PetscCall(MatSetValue(*coarse_submat, primal_idx, i, data[i * pcbddc->benign_n + j], INSERT_VALUES));
5339: PetscCall(MatSetValue(*coarse_submat, i, primal_idx, data[i * pcbddc->benign_n + j], INSERT_VALUES));
5340: }
5341: }
5342: PetscCall(MatDenseRestoreArrayRead(B0_BPHI, &data));
5343: PetscCall(MatDestroy(&B0_B));
5344: PetscCall(MatDestroy(&B0_BPHI));
5345: }
5347: /* compute other basis functions for non-symmetric problems */
5348: if (!pcbddc->symmetric_primal) {
5349: Mat B_V = NULL, B_C = NULL;
5350: PetscScalar *marray, *work;
5352: /* TODO multi_element MatDenseScatter */
5353: if (n_constraints) {
5354: Mat S_CCT, C_CRT;
5356: PetscCall(MatScale(S_CC, m_one));
5357: PetscCall(MatTranspose(C_CR, MAT_INITIAL_MATRIX, &C_CRT));
5358: PetscCall(MatTranspose(S_CC, MAT_INITIAL_MATRIX, &S_CCT));
5359: PetscCall(MatMatMult(C_CRT, S_CCT, MAT_INITIAL_MATRIX, PETSC_DETERMINE, &B_C));
5360: PetscCall(MatConvert(B_C, MATDENSE, MAT_INPLACE_MATRIX, &B_C));
5361: PetscCall(MatDestroy(&S_CCT));
5362: if (n_vertices) {
5363: Mat S_VCT;
5365: PetscCall(MatTranspose(S_VC, MAT_INITIAL_MATRIX, &S_VCT));
5366: PetscCall(MatMatMult(C_CRT, S_VCT, MAT_INITIAL_MATRIX, PETSC_DETERMINE, &B_V));
5367: PetscCall(MatDestroy(&S_VCT));
5368: PetscCall(MatConvert(B_V, MATDENSE, MAT_INPLACE_MATRIX, &B_V));
5369: }
5370: PetscCall(MatDestroy(&C_CRT));
5371: } else {
5372: PetscCall(MatCreateSeqDense(PETSC_COMM_SELF, n_R, n_vertices, NULL, &B_V));
5373: }
5374: if (n_vertices && n_R) {
5375: PetscScalar *av, *marray;
5376: const PetscInt *xadj, *adjncy;
5377: PetscInt n;
5378: PetscBool flg_row;
5380: /* B_V = B_V - A_VR^T */
5381: PetscCall(MatConvert(A_VR, MATSEQAIJ, MAT_INPLACE_MATRIX, &A_VR));
5382: PetscCall(MatGetRowIJ(A_VR, 0, PETSC_FALSE, PETSC_FALSE, &n, &xadj, &adjncy, &flg_row));
5383: PetscCall(MatSeqAIJGetArray(A_VR, &av));
5384: PetscCall(MatDenseGetArray(B_V, &marray));
5385: for (i = 0; i < n; i++) {
5386: for (PetscInt j = xadj[i]; j < xadj[i + 1]; j++) marray[i * n_R + adjncy[j]] -= av[j];
5387: }
5388: PetscCall(MatDenseRestoreArray(B_V, &marray));
5389: PetscCall(MatRestoreRowIJ(A_VR, 0, PETSC_FALSE, PETSC_FALSE, &n, &xadj, &adjncy, &flg_row));
5390: PetscCall(MatDestroy(&A_VR));
5391: }
5393: /* currently there's no support for MatTransposeMatSolve(F,B,X) */
5394: PetscCall(PetscMalloc1(n_R * pcbddc->local_primal_size, &work));
5395: if (n_vertices) {
5396: PetscCall(MatDenseGetArray(B_V, &marray));
5397: for (i = 0; i < n_vertices; i++) {
5398: PetscCall(VecPlaceArray(pcbddc->vec1_R, marray + i * n_R));
5399: PetscCall(VecPlaceArray(pcbddc->vec2_R, work + i * n_R));
5400: PetscCall(KSPSolveTranspose(pcbddc->ksp_R, pcbddc->vec1_R, pcbddc->vec2_R));
5401: PetscCall(KSPCheckSolve(pcbddc->ksp_R, pc, pcbddc->vec2_R));
5402: PetscCall(VecResetArray(pcbddc->vec1_R));
5403: PetscCall(VecResetArray(pcbddc->vec2_R));
5404: }
5405: PetscCall(MatDenseRestoreArray(B_V, &marray));
5406: }
5407: if (B_C) {
5408: PetscCall(MatDenseGetArray(B_C, &marray));
5409: for (i = n_vertices; i < n_constraints + n_vertices; i++) {
5410: PetscCall(VecPlaceArray(pcbddc->vec1_R, marray + (i - n_vertices) * n_R));
5411: PetscCall(VecPlaceArray(pcbddc->vec2_R, work + i * n_R));
5412: PetscCall(KSPSolveTranspose(pcbddc->ksp_R, pcbddc->vec1_R, pcbddc->vec2_R));
5413: PetscCall(KSPCheckSolve(pcbddc->ksp_R, pc, pcbddc->vec2_R));
5414: PetscCall(VecResetArray(pcbddc->vec1_R));
5415: PetscCall(VecResetArray(pcbddc->vec2_R));
5416: }
5417: PetscCall(MatDenseRestoreArray(B_C, &marray));
5418: }
5419: /* coarse basis functions */
5420: PetscCall(MatCreateSeqDense(PETSC_COMM_SELF, n_B, pcbddc->local_primal_size, NULL, &pcbddc->coarse_psi_B));
5421: if (pcbddc->switch_static || pcbddc->dbg_flag) PetscCall(MatCreateSeqDense(PETSC_COMM_SELF, n_D, pcbddc->local_primal_size, NULL, &pcbddc->coarse_psi_D));
5422: for (i = 0; i < pcbddc->local_primal_size; i++) {
5423: Vec v;
5425: PetscCall(VecPlaceArray(pcbddc->vec1_R, work + i * n_R));
5426: PetscCall(MatDenseGetColumnVec(pcbddc->coarse_psi_B, i, &v));
5427: PetscCall(VecScatterBegin(pcbddc->R_to_B, pcbddc->vec1_R, v, INSERT_VALUES, SCATTER_FORWARD));
5428: PetscCall(VecScatterEnd(pcbddc->R_to_B, pcbddc->vec1_R, v, INSERT_VALUES, SCATTER_FORWARD));
5429: if (i < n_vertices) {
5430: PetscScalar one = 1.0;
5431: PetscCall(VecSetValues(v, 1, &idx_V_B[i], &one, INSERT_VALUES));
5432: PetscCall(VecAssemblyBegin(v));
5433: PetscCall(VecAssemblyEnd(v));
5434: }
5435: PetscCall(MatDenseRestoreColumnVec(pcbddc->coarse_psi_B, i, &v));
5437: if (pcbddc->switch_static || pcbddc->dbg_flag) {
5438: PetscCall(MatDenseGetColumnVec(pcbddc->coarse_psi_D, i, &v));
5439: PetscCall(VecScatterBegin(pcbddc->R_to_D, pcbddc->vec1_R, v, INSERT_VALUES, SCATTER_FORWARD));
5440: PetscCall(VecScatterEnd(pcbddc->R_to_D, pcbddc->vec1_R, v, INSERT_VALUES, SCATTER_FORWARD));
5441: PetscCall(MatDenseRestoreColumnVec(pcbddc->coarse_psi_D, i, &v));
5442: }
5443: PetscCall(VecResetArray(pcbddc->vec1_R));
5444: }
5445: PetscCall(MatDestroy(&B_V));
5446: PetscCall(MatDestroy(&B_C));
5447: PetscCall(PetscFree(work));
5448: } else {
5449: PetscCall(PetscObjectReference((PetscObject)pcbddc->coarse_phi_B));
5450: pcbddc->coarse_psi_B = pcbddc->coarse_phi_B;
5451: PetscCall(PetscObjectReference((PetscObject)pcbddc->coarse_phi_D));
5452: pcbddc->coarse_psi_D = pcbddc->coarse_phi_D;
5453: }
5454: PetscCall(MatAssemblyBegin(*coarse_submat, MAT_FINAL_ASSEMBLY));
5455: PetscCall(MatAssemblyEnd(*coarse_submat, MAT_FINAL_ASSEMBLY));
5457: /* free memory */
5458: PetscCall(PetscFree(V_to_eff_V));
5459: PetscCall(PetscFree(C_to_eff_C));
5460: PetscCall(PetscFree(R_eff_V_J));
5461: PetscCall(PetscFree(R_eff_C_J));
5462: PetscCall(PetscFree(B_eff_V_J));
5463: PetscCall(PetscFree(B_eff_C_J));
5464: PetscCall(ISDestroy(&is_R));
5465: PetscCall(ISRestoreIndices(is_V, &idx_V));
5466: PetscCall(ISRestoreIndices(is_C, &idx_C));
5467: PetscCall(ISDestroy(&is_V));
5468: PetscCall(ISDestroy(&is_C));
5469: PetscCall(PetscFree(idx_V_B));
5470: PetscCall(MatDestroy(&S_CV));
5471: PetscCall(MatDestroy(&S_VC));
5472: PetscCall(MatDestroy(&S_CC));
5473: if (n_vertices) PetscCall(MatDestroy(&A_VR));
5474: if (n_constraints) PetscCall(MatDestroy(&C_CR));
5475: PetscCall(PetscLogEventEnd(PC_BDDC_CorrectionSetUp[pcbddc->current_level], pc, 0, 0, 0));
5477: /* Checking coarse_sub_mat and coarse basis functions */
5478: /* Symmetric case : It should be \Phi^{(j)^T} A^{(j)} \Phi^{(j)}=coarse_sub_mat */
5479: /* Non-symmetric case : It should be \Psi^{(j)^T} A^{(j)} \Phi^{(j)}=coarse_sub_mat */
5480: if (pcbddc->dbg_flag) {
5481: Mat AUXMAT, TM1, TM2, TM3, TM4;
5482: Mat coarse_phi_D, coarse_phi_B;
5483: Mat coarse_psi_D, coarse_psi_B;
5484: Mat A_II, A_BB, A_IB, A_BI;
5485: Mat C_B, CPHI;
5486: IS is_dummy;
5487: Vec mones;
5488: MatType checkmattype = MATSEQAIJ;
5489: PetscReal real_value;
5491: if (pcbddc->benign_n && !pcbddc->benign_change_explicit) {
5492: Mat A;
5493: PetscCall(PCBDDCBenignProject(pc, NULL, NULL, &A));
5494: PetscCall(MatCreateSubMatrix(A, pcis->is_I_local, pcis->is_I_local, MAT_INITIAL_MATRIX, &A_II));
5495: PetscCall(MatCreateSubMatrix(A, pcis->is_I_local, pcis->is_B_local, MAT_INITIAL_MATRIX, &A_IB));
5496: PetscCall(MatCreateSubMatrix(A, pcis->is_B_local, pcis->is_I_local, MAT_INITIAL_MATRIX, &A_BI));
5497: PetscCall(MatCreateSubMatrix(A, pcis->is_B_local, pcis->is_B_local, MAT_INITIAL_MATRIX, &A_BB));
5498: PetscCall(MatDestroy(&A));
5499: } else {
5500: PetscCall(MatConvert(pcis->A_II, checkmattype, MAT_INITIAL_MATRIX, &A_II));
5501: PetscCall(MatConvert(pcis->A_IB, checkmattype, MAT_INITIAL_MATRIX, &A_IB));
5502: PetscCall(MatConvert(pcis->A_BI, checkmattype, MAT_INITIAL_MATRIX, &A_BI));
5503: PetscCall(MatConvert(pcis->A_BB, checkmattype, MAT_INITIAL_MATRIX, &A_BB));
5504: }
5505: PetscCall(MatConvert(pcbddc->coarse_phi_D, checkmattype, MAT_INITIAL_MATRIX, &coarse_phi_D));
5506: PetscCall(MatConvert(pcbddc->coarse_phi_B, checkmattype, MAT_INITIAL_MATRIX, &coarse_phi_B));
5507: if (!pcbddc->symmetric_primal) {
5508: PetscCall(MatConvert(pcbddc->coarse_psi_D, checkmattype, MAT_INITIAL_MATRIX, &coarse_psi_D));
5509: PetscCall(MatConvert(pcbddc->coarse_psi_B, checkmattype, MAT_INITIAL_MATRIX, &coarse_psi_B));
5510: }
5511: PetscCall(PetscViewerASCIIPrintf(pcbddc->dbg_viewer, "--------------------------------------------------\n"));
5512: PetscCall(PetscViewerASCIIPrintf(pcbddc->dbg_viewer, "Check coarse sub mat computation (symmetric %d)\n", pcbddc->symmetric_primal));
5513: PetscCall(PetscViewerFlush(pcbddc->dbg_viewer));
5514: if (!pcbddc->symmetric_primal) {
5515: PetscCall(MatMatMult(A_II, coarse_phi_D, MAT_INITIAL_MATRIX, 1.0, &AUXMAT));
5516: PetscCall(MatTransposeMatMult(coarse_psi_D, AUXMAT, MAT_INITIAL_MATRIX, 1.0, &TM1));
5517: PetscCall(MatDestroy(&AUXMAT));
5518: PetscCall(MatMatMult(A_BB, coarse_phi_B, MAT_INITIAL_MATRIX, 1.0, &AUXMAT));
5519: PetscCall(MatTransposeMatMult(coarse_psi_B, AUXMAT, MAT_INITIAL_MATRIX, 1.0, &TM2));
5520: PetscCall(MatDestroy(&AUXMAT));
5521: PetscCall(MatMatMult(A_IB, coarse_phi_B, MAT_INITIAL_MATRIX, 1.0, &AUXMAT));
5522: PetscCall(MatTransposeMatMult(coarse_psi_D, AUXMAT, MAT_INITIAL_MATRIX, 1.0, &TM3));
5523: PetscCall(MatDestroy(&AUXMAT));
5524: PetscCall(MatMatMult(A_BI, coarse_phi_D, MAT_INITIAL_MATRIX, 1.0, &AUXMAT));
5525: PetscCall(MatTransposeMatMult(coarse_psi_B, AUXMAT, MAT_INITIAL_MATRIX, 1.0, &TM4));
5526: PetscCall(MatDestroy(&AUXMAT));
5527: } else {
5528: PetscCall(MatPtAP(A_II, coarse_phi_D, MAT_INITIAL_MATRIX, 1.0, &TM1));
5529: PetscCall(MatPtAP(A_BB, coarse_phi_B, MAT_INITIAL_MATRIX, 1.0, &TM2));
5530: PetscCall(MatMatMult(A_IB, coarse_phi_B, MAT_INITIAL_MATRIX, 1.0, &AUXMAT));
5531: PetscCall(MatTransposeMatMult(coarse_phi_D, AUXMAT, MAT_INITIAL_MATRIX, 1.0, &TM3));
5532: PetscCall(MatDestroy(&AUXMAT));
5533: PetscCall(MatMatMult(A_BI, coarse_phi_D, MAT_INITIAL_MATRIX, 1.0, &AUXMAT));
5534: PetscCall(MatTransposeMatMult(coarse_phi_B, AUXMAT, MAT_INITIAL_MATRIX, 1.0, &TM4));
5535: PetscCall(MatDestroy(&AUXMAT));
5536: }
5537: PetscCall(MatAXPY(TM1, one, TM2, DIFFERENT_NONZERO_PATTERN));
5538: PetscCall(MatAXPY(TM1, one, TM3, DIFFERENT_NONZERO_PATTERN));
5539: PetscCall(MatAXPY(TM1, one, TM4, DIFFERENT_NONZERO_PATTERN));
5540: PetscCall(MatConvert(TM1, MATSEQDENSE, MAT_INPLACE_MATRIX, &TM1));
5541: if (pcbddc->benign_n) {
5542: Mat B0_B, B0_BPHI;
5543: const PetscScalar *data2;
5544: PetscScalar *data;
5546: PetscCall(ISCreateStride(PETSC_COMM_SELF, pcbddc->benign_n, 0, 1, &is_dummy));
5547: PetscCall(MatCreateSubMatrix(pcbddc->benign_B0, is_dummy, pcis->is_B_local, MAT_INITIAL_MATRIX, &B0_B));
5548: PetscCall(MatMatMult(B0_B, coarse_phi_B, MAT_INITIAL_MATRIX, 1.0, &B0_BPHI));
5549: PetscCall(MatConvert(B0_BPHI, MATSEQDENSE, MAT_INPLACE_MATRIX, &B0_BPHI));
5550: PetscCall(MatDenseGetArray(TM1, &data));
5551: PetscCall(MatDenseGetArrayRead(B0_BPHI, &data2));
5552: for (PetscInt j = 0; j < pcbddc->benign_n; j++) {
5553: PetscInt primal_idx = pcbddc->local_primal_size - pcbddc->benign_n + j;
5554: for (i = 0; i < pcbddc->local_primal_size; i++) {
5555: data[primal_idx * pcbddc->local_primal_size + i] += data2[i * pcbddc->benign_n + j];
5556: data[i * pcbddc->local_primal_size + primal_idx] += data2[i * pcbddc->benign_n + j];
5557: }
5558: }
5559: PetscCall(MatDenseRestoreArray(TM1, &data));
5560: PetscCall(MatDenseRestoreArrayRead(B0_BPHI, &data2));
5561: PetscCall(MatDestroy(&B0_B));
5562: PetscCall(ISDestroy(&is_dummy));
5563: PetscCall(MatDestroy(&B0_BPHI));
5564: }
5565: PetscCall(MatAXPY(TM1, m_one, *coarse_submat, DIFFERENT_NONZERO_PATTERN));
5566: PetscCall(MatNorm(TM1, NORM_FROBENIUS, &real_value));
5567: PetscCall(PetscViewerASCIIPushSynchronized(pcbddc->dbg_viewer));
5568: PetscCall(PetscViewerASCIISynchronizedPrintf(pcbddc->dbg_viewer, "Subdomain %04d matrix error % 1.14e\n", PetscGlobalRank, (double)real_value));
5570: /* check constraints */
5571: PetscCall(ISCreateStride(PETSC_COMM_SELF, pcbddc->local_primal_size - pcbddc->benign_n, 0, 1, &is_dummy));
5572: PetscCall(MatCreateSubMatrix(pcbddc->ConstraintMatrix, is_dummy, pcis->is_B_local, MAT_INITIAL_MATRIX, &C_B));
5573: if (!pcbddc->benign_n) { /* TODO: add benign case */
5574: PetscCall(MatMatMult(C_B, coarse_phi_B, MAT_INITIAL_MATRIX, 1.0, &CPHI));
5575: } else {
5576: PetscScalar *data;
5577: Mat tmat;
5578: PetscCall(MatDenseGetArray(pcbddc->coarse_phi_B, &data));
5579: PetscCall(MatCreateSeqDense(PETSC_COMM_SELF, pcis->n_B, pcbddc->local_primal_size - pcbddc->benign_n, data, &tmat));
5580: PetscCall(MatDenseRestoreArray(pcbddc->coarse_phi_B, &data));
5581: PetscCall(MatMatMult(C_B, tmat, MAT_INITIAL_MATRIX, 1.0, &CPHI));
5582: PetscCall(MatDestroy(&tmat));
5583: }
5584: PetscCall(MatCreateVecs(CPHI, &mones, NULL));
5585: PetscCall(VecSet(mones, -1.0));
5586: PetscCall(MatDiagonalSet(CPHI, mones, ADD_VALUES));
5587: PetscCall(MatNorm(CPHI, NORM_FROBENIUS, &real_value));
5588: PetscCall(PetscViewerASCIISynchronizedPrintf(pcbddc->dbg_viewer, "Subdomain %04d phi constraints error % 1.14e\n", PetscGlobalRank, (double)real_value));
5589: if (!pcbddc->symmetric_primal) {
5590: PetscCall(MatMatMult(C_B, coarse_psi_B, MAT_REUSE_MATRIX, 1.0, &CPHI));
5591: PetscCall(VecSet(mones, -1.0));
5592: PetscCall(MatDiagonalSet(CPHI, mones, ADD_VALUES));
5593: PetscCall(MatNorm(CPHI, NORM_FROBENIUS, &real_value));
5594: PetscCall(PetscViewerASCIISynchronizedPrintf(pcbddc->dbg_viewer, "Subdomain %04d psi constraints error % 1.14e\n", PetscGlobalRank, (double)real_value));
5595: }
5596: PetscCall(MatDestroy(&C_B));
5597: PetscCall(MatDestroy(&CPHI));
5598: PetscCall(ISDestroy(&is_dummy));
5599: PetscCall(VecDestroy(&mones));
5600: PetscCall(PetscViewerFlush(pcbddc->dbg_viewer));
5601: PetscCall(MatDestroy(&A_II));
5602: PetscCall(MatDestroy(&A_BB));
5603: PetscCall(MatDestroy(&A_IB));
5604: PetscCall(MatDestroy(&A_BI));
5605: PetscCall(MatDestroy(&TM1));
5606: PetscCall(MatDestroy(&TM2));
5607: PetscCall(MatDestroy(&TM3));
5608: PetscCall(MatDestroy(&TM4));
5609: PetscCall(MatDestroy(&coarse_phi_D));
5610: PetscCall(MatDestroy(&coarse_phi_B));
5611: if (!pcbddc->symmetric_primal) {
5612: PetscCall(MatDestroy(&coarse_psi_D));
5613: PetscCall(MatDestroy(&coarse_psi_B));
5614: }
5615: }
5617: #if 0
5618: {
5619: PetscViewer viewer;
5620: char filename[256];
5622: PetscCall(PetscSNPrintf(filename, PETSC_STATIC_ARRAY_LENGTH(filename), "details_local_coarse_mat%d_level%d.m",PetscGlobalRank,pcbddc->current_level));
5623: PetscCall(PetscViewerASCIIOpen(PETSC_COMM_SELF,filename,&viewer));
5624: PetscCall(PetscViewerPushFormat(viewer,PETSC_VIEWER_ASCII_MATLAB));
5625: PetscCall(PetscObjectSetName((PetscObject)*coarse_submat,"coarse submat"));
5626: PetscCall(MatView(*coarse_submat,viewer));
5627: if (pcbddc->coarse_phi_B) {
5628: PetscCall(PetscObjectSetName((PetscObject)pcbddc->coarse_phi_B,"phi_B"));
5629: PetscCall(MatView(pcbddc->coarse_phi_B,viewer));
5630: }
5631: if (pcbddc->coarse_phi_D) {
5632: PetscCall(PetscObjectSetName((PetscObject)pcbddc->coarse_phi_D,"phi_D"));
5633: PetscCall(MatView(pcbddc->coarse_phi_D,viewer));
5634: }
5635: if (pcbddc->coarse_psi_B) {
5636: PetscCall(PetscObjectSetName((PetscObject)pcbddc->coarse_psi_B,"psi_B"));
5637: PetscCall(MatView(pcbddc->coarse_psi_B,viewer));
5638: }
5639: if (pcbddc->coarse_psi_D) {
5640: PetscCall(PetscObjectSetName((PetscObject)pcbddc->coarse_psi_D,"psi_D"));
5641: PetscCall(MatView(pcbddc->coarse_psi_D,viewer));
5642: }
5643: PetscCall(PetscObjectSetName((PetscObject)pcbddc->local_mat,"A"));
5644: PetscCall(MatView(pcbddc->local_mat,viewer));
5645: PetscCall(PetscObjectSetName((PetscObject)pcbddc->ConstraintMatrix,"C"));
5646: PetscCall(MatView(pcbddc->ConstraintMatrix,viewer));
5647: PetscCall(PetscObjectSetName((PetscObject)pcis->is_I_local,"I"));
5648: PetscCall(ISView(pcis->is_I_local,viewer));
5649: PetscCall(PetscObjectSetName((PetscObject)pcis->is_B_local,"B"));
5650: PetscCall(ISView(pcis->is_B_local,viewer));
5651: PetscCall(PetscObjectSetName((PetscObject)pcbddc->is_R_local,"R"));
5652: PetscCall(ISView(pcbddc->is_R_local,viewer));
5653: PetscCall(PetscViewerDestroy(&viewer));
5654: }
5655: #endif
5657: /* device support */
5658: {
5659: PetscBool iscuda, iship, iskokkos;
5660: MatType mtype = NULL;
5662: PetscCall(PetscObjectTypeCompareAny((PetscObject)pcis->vec1_N, &iscuda, VECCUDA, VECMPICUDA, VECSEQCUDA, ""));
5663: PetscCall(PetscObjectTypeCompareAny((PetscObject)pcis->vec1_N, &iship, VECHIP, VECMPIHIP, VECSEQHIP, ""));
5664: PetscCall(PetscObjectTypeCompareAny((PetscObject)pcis->vec1_N, &iskokkos, VECKOKKOS, VECMPIKOKKOS, VECSEQKOKKOS, ""));
5665: if (iskokkos) {
5666: if (PetscDefined(HAVE_MACRO_KOKKOS_ENABLE_CUDA)) iscuda = PETSC_TRUE;
5667: else if (PetscDefined(HAVE_MACRO_KOKKOS_ENABLE_HIP)) iship = PETSC_TRUE;
5668: }
5669: if (iskokkos) mtype = multi_element ? MATSEQAIJKOKKOS : (iscuda ? MATSEQDENSECUDA : MATSEQDENSEHIP);
5670: else if (iship) mtype = multi_element ? MATSEQAIJHIPSPARSE : MATSEQDENSEHIP;
5671: else if (iscuda) mtype = multi_element ? MATSEQAIJCUSPARSE : MATSEQDENSECUDA;
5672: if (mtype) {
5673: if (pcbddc->local_auxmat1) PetscCall(MatConvert(pcbddc->local_auxmat1, mtype, MAT_INPLACE_MATRIX, &pcbddc->local_auxmat1));
5674: if (pcbddc->local_auxmat2) PetscCall(MatConvert(pcbddc->local_auxmat2, mtype, MAT_INPLACE_MATRIX, &pcbddc->local_auxmat2));
5675: if (pcbddc->coarse_phi_B) PetscCall(MatConvert(pcbddc->coarse_phi_B, mtype, MAT_INPLACE_MATRIX, &pcbddc->coarse_phi_B));
5676: if (pcbddc->coarse_phi_D) PetscCall(MatConvert(pcbddc->coarse_phi_D, mtype, MAT_INPLACE_MATRIX, &pcbddc->coarse_phi_D));
5677: if (pcbddc->coarse_psi_B) PetscCall(MatConvert(pcbddc->coarse_psi_B, mtype, MAT_INPLACE_MATRIX, &pcbddc->coarse_psi_B));
5678: if (pcbddc->coarse_psi_D) PetscCall(MatConvert(pcbddc->coarse_psi_D, mtype, MAT_INPLACE_MATRIX, &pcbddc->coarse_psi_D));
5679: }
5680: }
5681: PetscFunctionReturn(PETSC_SUCCESS);
5682: }
5684: PetscErrorCode MatCreateSubMatrixUnsorted(Mat A, IS isrow, IS iscol, Mat *B)
5685: {
5686: Mat *work_mat;
5687: IS isrow_s, iscol_s;
5688: PetscBool rsorted, csorted;
5689: PetscInt rsize, *idxs_perm_r = NULL, csize, *idxs_perm_c = NULL;
5691: PetscFunctionBegin;
5692: PetscCall(ISSorted(isrow, &rsorted));
5693: PetscCall(ISSorted(iscol, &csorted));
5694: PetscCall(ISGetLocalSize(isrow, &rsize));
5695: PetscCall(ISGetLocalSize(iscol, &csize));
5697: if (!rsorted) {
5698: const PetscInt *idxs;
5699: PetscInt *idxs_sorted, i;
5701: PetscCall(PetscMalloc1(rsize, &idxs_perm_r));
5702: PetscCall(PetscMalloc1(rsize, &idxs_sorted));
5703: for (i = 0; i < rsize; i++) idxs_perm_r[i] = i;
5704: PetscCall(ISGetIndices(isrow, &idxs));
5705: PetscCall(PetscSortIntWithPermutation(rsize, idxs, idxs_perm_r));
5706: for (i = 0; i < rsize; i++) idxs_sorted[i] = idxs[idxs_perm_r[i]];
5707: PetscCall(ISRestoreIndices(isrow, &idxs));
5708: PetscCall(ISCreateGeneral(PETSC_COMM_SELF, rsize, idxs_sorted, PETSC_OWN_POINTER, &isrow_s));
5709: } else {
5710: PetscCall(PetscObjectReference((PetscObject)isrow));
5711: isrow_s = isrow;
5712: }
5714: if (!csorted) {
5715: if (isrow == iscol) {
5716: PetscCall(PetscObjectReference((PetscObject)isrow_s));
5717: iscol_s = isrow_s;
5718: } else {
5719: const PetscInt *idxs;
5720: PetscInt *idxs_sorted, i;
5722: PetscCall(PetscMalloc1(csize, &idxs_perm_c));
5723: PetscCall(PetscMalloc1(csize, &idxs_sorted));
5724: for (i = 0; i < csize; i++) idxs_perm_c[i] = i;
5725: PetscCall(ISGetIndices(iscol, &idxs));
5726: PetscCall(PetscSortIntWithPermutation(csize, idxs, idxs_perm_c));
5727: for (i = 0; i < csize; i++) idxs_sorted[i] = idxs[idxs_perm_c[i]];
5728: PetscCall(ISRestoreIndices(iscol, &idxs));
5729: PetscCall(ISCreateGeneral(PETSC_COMM_SELF, csize, idxs_sorted, PETSC_OWN_POINTER, &iscol_s));
5730: }
5731: } else {
5732: PetscCall(PetscObjectReference((PetscObject)iscol));
5733: iscol_s = iscol;
5734: }
5736: PetscCall(MatCreateSubMatrices(A, 1, &isrow_s, &iscol_s, MAT_INITIAL_MATRIX, &work_mat));
5738: if (!rsorted || !csorted) {
5739: Mat new_mat;
5740: IS is_perm_r, is_perm_c;
5742: if (!rsorted) {
5743: PetscInt *idxs_r, i;
5744: PetscCall(PetscMalloc1(rsize, &idxs_r));
5745: for (i = 0; i < rsize; i++) idxs_r[idxs_perm_r[i]] = i;
5746: PetscCall(PetscFree(idxs_perm_r));
5747: PetscCall(ISCreateGeneral(PETSC_COMM_SELF, rsize, idxs_r, PETSC_OWN_POINTER, &is_perm_r));
5748: } else {
5749: PetscCall(ISCreateStride(PETSC_COMM_SELF, rsize, 0, 1, &is_perm_r));
5750: }
5751: PetscCall(ISSetPermutation(is_perm_r));
5753: if (!csorted) {
5754: if (isrow_s == iscol_s) {
5755: PetscCall(PetscObjectReference((PetscObject)is_perm_r));
5756: is_perm_c = is_perm_r;
5757: } else {
5758: PetscInt *idxs_c, i;
5759: PetscCheck(idxs_perm_c, PETSC_COMM_SELF, PETSC_ERR_PLIB, "Permutation array not present");
5760: PetscCall(PetscMalloc1(csize, &idxs_c));
5761: for (i = 0; i < csize; i++) idxs_c[idxs_perm_c[i]] = i;
5762: PetscCall(PetscFree(idxs_perm_c));
5763: PetscCall(ISCreateGeneral(PETSC_COMM_SELF, csize, idxs_c, PETSC_OWN_POINTER, &is_perm_c));
5764: }
5765: } else {
5766: PetscCall(ISCreateStride(PETSC_COMM_SELF, csize, 0, 1, &is_perm_c));
5767: }
5768: PetscCall(ISSetPermutation(is_perm_c));
5770: PetscCall(MatPermute(work_mat[0], is_perm_r, is_perm_c, &new_mat));
5771: PetscCall(MatDestroy(&work_mat[0]));
5772: work_mat[0] = new_mat;
5773: PetscCall(ISDestroy(&is_perm_r));
5774: PetscCall(ISDestroy(&is_perm_c));
5775: }
5777: PetscCall(PetscObjectReference((PetscObject)work_mat[0]));
5778: *B = work_mat[0];
5779: PetscCall(MatDestroyMatrices(1, &work_mat));
5780: PetscCall(ISDestroy(&isrow_s));
5781: PetscCall(ISDestroy(&iscol_s));
5782: PetscFunctionReturn(PETSC_SUCCESS);
5783: }
5785: static PetscErrorCode MatPtAPWithPrefix_Private(Mat A, Mat P, PetscReal fill, const char *prefix, Mat *C)
5786: {
5787: PetscFunctionBegin;
5788: PetscCall(MatProductCreate(A, P, NULL, C));
5789: PetscCall(MatProductSetType(*C, MATPRODUCT_PtAP));
5790: PetscCall(MatProductSetAlgorithm(*C, "default"));
5791: PetscCall(MatProductSetFill(*C, fill));
5792: PetscCall(MatSetOptionsPrefix(*C, prefix));
5793: PetscCall(MatProductSetFromOptions(*C));
5794: PetscCall(MatProductSymbolic(*C));
5795: PetscCall(MatProductNumeric(*C));
5796: (*C)->symmetric = A->symmetric;
5797: (*C)->spd = A->spd;
5798: PetscFunctionReturn(PETSC_SUCCESS);
5799: }
5801: PetscErrorCode PCBDDCComputeLocalMatrix(PC pc, Mat ChangeOfBasisMatrix)
5802: {
5803: Mat_IS *matis = (Mat_IS *)pc->pmat->data;
5804: PC_BDDC *pcbddc = (PC_BDDC *)pc->data;
5805: Mat new_mat, lA;
5806: IS is_local, is_global;
5807: PetscInt local_size;
5808: PetscBool isseqaij, issym, isset;
5809: char ptapprefix[256];
5811: PetscFunctionBegin;
5812: PetscCall(MatDestroy(&pcbddc->local_mat));
5813: PetscCall(MatGetSize(matis->A, &local_size, NULL));
5814: if (pcbddc->mat_graph->multi_element) {
5815: Mat *mats, *bdiags;
5816: IS *gsubs;
5817: PetscInt nsubs = pcbddc->n_local_subs;
5819: PetscCall(PetscCalloc1(nsubs * nsubs, &mats));
5820: #if 1
5821: PetscCall(PetscMalloc1(nsubs, &gsubs));
5822: for (PetscInt i = 0; i < nsubs; i++) PetscCall(ISLocalToGlobalMappingApplyIS(matis->rmapping, pcbddc->local_subs[i], &gsubs[i]));
5823: PetscCall(MatCreateSubMatrices(ChangeOfBasisMatrix, nsubs, gsubs, gsubs, MAT_INITIAL_MATRIX, &bdiags));
5824: for (PetscInt i = 0; i < nsubs; i++) PetscCall(ISDestroy(&gsubs[i]));
5825: PetscCall(PetscFree(gsubs));
5826: #else /* this does not work since MatCreateSubMatrices does not support repeated indices */
5827: Mat *tmats;
5828: PetscCall(ISCreateStride(PetscObjectComm((PetscObject)matis->A), local_size, 0, 1, &is_local));
5829: PetscCall(ISLocalToGlobalMappingApplyIS(matis->rmapping, is_local, &is_global));
5830: PetscCall(ISDestroy(&is_local));
5831: PetscCall(MatSetOption(ChangeOfBasisMatrix, MAT_SUBMAT_SINGLEIS, PETSC_TRUE));
5832: PetscCall(MatCreateSubMatrices(ChangeOfBasisMatrix, 1, &is_global, &is_global, MAT_INITIAL_MATRIX, &tmats));
5833: PetscCall(ISDestroy(&is_global));
5834: PetscCall(MatCreateSubMatrices(tmats[0], nsubs, pcbddc->local_subs, pcbddc->local_subs, MAT_INITIAL_MATRIX, &bdiags));
5835: PetscCall(MatDestroySubMatrices(1, &tmats));
5836: #endif
5837: for (PetscInt i = 0; i < nsubs; i++) mats[i * (1 + nsubs)] = bdiags[i];
5838: PetscCall(MatCreateNest(PETSC_COMM_SELF, nsubs, pcbddc->local_subs, nsubs, pcbddc->local_subs, mats, &new_mat));
5839: PetscCall(MatConvert(new_mat, MATSEQAIJ, MAT_INPLACE_MATRIX, &new_mat));
5840: PetscCall(MatDestroySubMatrices(nsubs, &bdiags));
5841: PetscCall(PetscFree(mats));
5842: } else {
5843: PetscCall(ISCreateStride(PetscObjectComm((PetscObject)matis->A), local_size, 0, 1, &is_local));
5844: PetscCall(ISLocalToGlobalMappingApplyIS(matis->rmapping, is_local, &is_global));
5845: PetscCall(ISDestroy(&is_local));
5846: PetscCall(MatCreateSubMatrixUnsorted(ChangeOfBasisMatrix, is_global, is_global, &new_mat));
5847: PetscCall(ISDestroy(&is_global));
5848: }
5849: if (pcbddc->dbg_flag) {
5850: Vec x, x_change;
5851: PetscReal error = 0.;
5853: PetscCall(MatCreateVecs(ChangeOfBasisMatrix, &x, &x_change));
5854: PetscCall(VecSetRandom(x, NULL));
5855: PetscCall(MatMult(ChangeOfBasisMatrix, x, x_change));
5856: PetscCall(VecScatterBegin(matis->cctx, x, matis->x, INSERT_VALUES, SCATTER_FORWARD));
5857: PetscCall(VecScatterEnd(matis->cctx, x, matis->x, INSERT_VALUES, SCATTER_FORWARD));
5858: PetscCall(MatMult(new_mat, matis->x, matis->y));
5859: if (!pcbddc->change_interior) {
5860: const PetscScalar *x, *y, *v;
5861: PetscInt i;
5863: PetscCall(VecGetArrayRead(matis->x, &x));
5864: PetscCall(VecGetArrayRead(matis->y, &y));
5865: PetscCall(VecGetArrayRead(matis->counter, &v));
5866: for (i = 0; i < local_size; i++)
5867: if (PetscRealPart(v[i]) < 1.5 && PetscAbsScalar(x[i] - y[i]) > error) error = PetscAbsScalar(x[i] - y[i]);
5868: PetscCall(VecRestoreArrayRead(matis->x, &x));
5869: PetscCall(VecRestoreArrayRead(matis->y, &y));
5870: PetscCall(VecRestoreArrayRead(matis->counter, &v));
5871: PetscCallMPI(MPIU_Allreduce(MPI_IN_PLACE, &error, 1, MPIU_REAL, MPIU_MAX, PetscObjectComm((PetscObject)pc)));
5872: if (error > PETSC_SMALL) {
5873: if (!pcbddc->user_ChangeOfBasisMatrix || pcbddc->current_level) {
5874: SETERRQ(PetscObjectComm((PetscObject)pc), PETSC_ERR_PLIB, "Error global vs local change on I: %1.6e", (double)error);
5875: } else {
5876: SETERRQ(PetscObjectComm((PetscObject)pc), PETSC_ERR_USER, "Error global vs local change on I: %1.6e", (double)error);
5877: }
5878: }
5879: }
5880: PetscCall(VecScatterBegin(matis->rctx, matis->y, x, INSERT_VALUES, SCATTER_REVERSE));
5881: PetscCall(VecScatterEnd(matis->rctx, matis->y, x, INSERT_VALUES, SCATTER_REVERSE));
5882: PetscCall(VecAXPY(x, -1.0, x_change));
5883: PetscCall(VecNorm(x, NORM_INFINITY, &error));
5884: if (error > PETSC_SMALL) {
5885: if (!pcbddc->user_ChangeOfBasisMatrix || pcbddc->current_level) {
5886: SETERRQ(PetscObjectComm((PetscObject)pc), PETSC_ERR_PLIB, "Error global vs local change on N: %1.6e", (double)error);
5887: } else {
5888: SETERRQ(PetscObjectComm((PetscObject)pc), PETSC_ERR_USER, "Error global vs local change on N: %1.6e", (double)error);
5889: }
5890: }
5891: PetscCall(VecDestroy(&x));
5892: PetscCall(VecDestroy(&x_change));
5893: }
5895: /* lA is present if we are setting up an inner BDDC for a saddle point FETI-DP */
5896: PetscCall(PetscObjectQuery((PetscObject)pc, "__KSPFETIDP_lA", (PetscObject *)&lA));
5898: /* TODO: HOW TO WORK WITH BAIJ and SBAIJ and SEQDENSE? */
5899: if (((PetscObject)pc)->prefix) PetscCall(PetscSNPrintf(ptapprefix, sizeof(ptapprefix), "%spc_bddc_change_", ((PetscObject)pc)->prefix));
5900: else PetscCall(PetscSNPrintf(ptapprefix, sizeof(ptapprefix), "pc_bddc_change_"));
5901: PetscCall(PetscObjectBaseTypeCompare((PetscObject)matis->A, MATSEQAIJ, &isseqaij));
5902: if (isseqaij) {
5903: PetscCall(MatDestroy(&pcbddc->local_mat));
5904: PetscCall(MatPtAPWithPrefix_Private(matis->A, new_mat, PETSC_DEFAULT, ptapprefix, &pcbddc->local_mat));
5905: if (lA) {
5906: Mat work;
5907: PetscCall(MatPtAPWithPrefix_Private(lA, new_mat, PETSC_DEFAULT, ptapprefix, &work));
5908: PetscCall(PetscObjectCompose((PetscObject)pc, "__KSPFETIDP_lA", (PetscObject)work));
5909: PetscCall(MatDestroy(&work));
5910: }
5911: } else {
5912: Mat work_mat;
5914: PetscCall(MatDestroy(&pcbddc->local_mat));
5915: PetscCall(MatConvert(matis->A, MATSEQAIJ, MAT_INITIAL_MATRIX, &work_mat));
5916: PetscCall(MatPtAPWithPrefix_Private(work_mat, new_mat, PETSC_DEFAULT, ptapprefix, &pcbddc->local_mat));
5917: PetscCall(MatDestroy(&work_mat));
5918: if (lA) {
5919: Mat work;
5920: PetscCall(MatConvert(lA, MATSEQAIJ, MAT_INITIAL_MATRIX, &work_mat));
5921: PetscCall(MatPtAPWithPrefix_Private(work_mat, new_mat, PETSC_DEFAULT, ptapprefix, &work));
5922: PetscCall(PetscObjectCompose((PetscObject)pc, "__KSPFETIDP_lA", (PetscObject)work));
5923: PetscCall(MatDestroy(&work));
5924: }
5925: }
5926: PetscCall(MatIsSymmetricKnown(matis->A, &isset, &issym));
5927: if (isset) PetscCall(MatSetOption(pcbddc->local_mat, MAT_SYMMETRIC, issym));
5928: PetscCall(MatDestroy(&new_mat));
5929: PetscFunctionReturn(PETSC_SUCCESS);
5930: }
5932: PetscErrorCode PCBDDCSetUpLocalScatters(PC pc)
5933: {
5934: PC_IS *pcis = (PC_IS *)pc->data;
5935: PC_BDDC *pcbddc = (PC_BDDC *)pc->data;
5936: PCBDDCSubSchurs sub_schurs = pcbddc->sub_schurs;
5937: PetscInt *idx_R_local = NULL;
5938: PetscInt n_vertices, i, j, n_R, n_D, n_B;
5939: PetscInt vbs, bs;
5940: PetscBT bitmask = NULL;
5942: PetscFunctionBegin;
5943: /*
5944: No need to setup local scatters if
5945: - primal space is unchanged
5946: AND
5947: - we actually have locally some primal dofs (could not be true in multilevel or for isolated subdomains)
5948: AND
5949: - we are not in debugging mode (this is needed since there are Synchronized prints at the end of the subroutine
5950: */
5951: if (!pcbddc->new_primal_space_local && pcbddc->local_primal_size && !pcbddc->dbg_flag) PetscFunctionReturn(PETSC_SUCCESS);
5952: /* destroy old objects */
5953: PetscCall(ISDestroy(&pcbddc->is_R_local));
5954: PetscCall(VecScatterDestroy(&pcbddc->R_to_B));
5955: PetscCall(VecScatterDestroy(&pcbddc->R_to_D));
5956: /* Set Non-overlapping dimensions */
5957: n_B = pcis->n_B;
5958: n_D = pcis->n - n_B;
5959: n_vertices = pcbddc->n_vertices;
5961: /* Dohrmann's notation: dofs split in R (Remaining: all dofs but the vertices) and V (Vertices) */
5963: /* create auxiliary bitmask and allocate workspace */
5964: if (!sub_schurs || !sub_schurs->reuse_solver) {
5965: PetscCall(PetscMalloc1(pcis->n - n_vertices, &idx_R_local));
5966: PetscCall(PetscBTCreate(pcis->n, &bitmask));
5967: for (i = 0; i < n_vertices; i++) PetscCall(PetscBTSet(bitmask, pcbddc->local_primal_ref_node[i]));
5969: for (i = 0, n_R = 0; i < pcis->n; i++) {
5970: if (!PetscBTLookup(bitmask, i)) idx_R_local[n_R++] = i;
5971: }
5972: } else { /* A different ordering (already computed) is present if we are reusing the Schur solver */
5973: PCBDDCReuseSolvers reuse_solver = sub_schurs->reuse_solver;
5975: PetscCall(ISGetIndices(reuse_solver->is_R, (const PetscInt **)&idx_R_local));
5976: PetscCall(ISGetLocalSize(reuse_solver->is_R, &n_R));
5977: }
5979: /* Block code */
5980: vbs = 1;
5981: PetscCall(MatGetBlockSize(pcbddc->local_mat, &bs));
5982: if (bs > 1 && !(n_vertices % bs)) {
5983: PetscBool is_blocked = PETSC_TRUE;
5984: PetscInt *vary;
5985: if (!sub_schurs || !sub_schurs->reuse_solver) {
5986: PetscCall(PetscMalloc1(pcis->n / bs, &vary));
5987: PetscCall(PetscArrayzero(vary, pcis->n / bs));
5988: /* Verify that the vertex indices correspond to each element in a block (code taken from sbaij2.c) */
5989: /* it is ok to check this way since local_primal_ref_node are always sorted by local numbering and idx_R_local is obtained as a complement */
5990: for (i = 0; i < n_vertices; i++) vary[pcbddc->local_primal_ref_node[i] / bs]++;
5991: for (i = 0; i < pcis->n / bs; i++) {
5992: if (vary[i] != 0 && vary[i] != bs) {
5993: is_blocked = PETSC_FALSE;
5994: break;
5995: }
5996: }
5997: PetscCall(PetscFree(vary));
5998: } else {
5999: /* Verify directly the R set */
6000: for (i = 0; i < n_R / bs; i++) {
6001: PetscInt j, node = idx_R_local[bs * i];
6002: for (j = 1; j < bs; j++) {
6003: if (node != idx_R_local[bs * i + j] - j) {
6004: is_blocked = PETSC_FALSE;
6005: break;
6006: }
6007: }
6008: }
6009: }
6010: if (is_blocked) { /* build compressed IS for R nodes (complement of vertices) */
6011: vbs = bs;
6012: for (i = 0; i < n_R / vbs; i++) idx_R_local[i] = idx_R_local[vbs * i] / vbs;
6013: }
6014: }
6015: PetscCall(ISCreateBlock(PETSC_COMM_SELF, vbs, n_R / vbs, idx_R_local, PETSC_COPY_VALUES, &pcbddc->is_R_local));
6016: if (sub_schurs && sub_schurs->reuse_solver) {
6017: PCBDDCReuseSolvers reuse_solver = sub_schurs->reuse_solver;
6019: PetscCall(ISRestoreIndices(reuse_solver->is_R, (const PetscInt **)&idx_R_local));
6020: PetscCall(ISDestroy(&reuse_solver->is_R));
6021: PetscCall(PetscObjectReference((PetscObject)pcbddc->is_R_local));
6022: reuse_solver->is_R = pcbddc->is_R_local;
6023: } else {
6024: PetscCall(PetscFree(idx_R_local));
6025: }
6027: /* print some info if requested */
6028: if (pcbddc->dbg_flag) {
6029: PetscCall(PetscViewerASCIIPrintf(pcbddc->dbg_viewer, "--------------------------------------------------\n"));
6030: PetscCall(PetscViewerFlush(pcbddc->dbg_viewer));
6031: PetscCall(PetscViewerASCIIPushSynchronized(pcbddc->dbg_viewer));
6032: PetscCall(PetscViewerASCIISynchronizedPrintf(pcbddc->dbg_viewer, "Subdomain %04d local dimensions\n", PetscGlobalRank));
6033: PetscCall(PetscViewerASCIISynchronizedPrintf(pcbddc->dbg_viewer, "local_size = %" PetscInt_FMT ", dirichlet_size = %" PetscInt_FMT ", boundary_size = %" PetscInt_FMT "\n", pcis->n, n_D, n_B));
6034: PetscCall(PetscViewerASCIISynchronizedPrintf(pcbddc->dbg_viewer, "r_size = %" PetscInt_FMT ", v_size = %" PetscInt_FMT ", constraints = %" PetscInt_FMT ", local_primal_size = %" PetscInt_FMT "\n", n_R, n_vertices,
6035: pcbddc->local_primal_size - n_vertices - pcbddc->benign_n, pcbddc->local_primal_size));
6036: PetscCall(PetscViewerFlush(pcbddc->dbg_viewer));
6037: }
6039: /* VecScatters pcbddc->R_to_B and (optionally) pcbddc->R_to_D */
6040: if (!sub_schurs || !sub_schurs->reuse_solver) {
6041: IS is_aux1, is_aux2;
6042: PetscInt *aux_array1, *aux_array2, *is_indices, *idx_R_local;
6044: PetscCall(ISGetIndices(pcbddc->is_R_local, (const PetscInt **)&idx_R_local));
6045: PetscCall(PetscMalloc1(pcis->n_B - n_vertices, &aux_array1));
6046: PetscCall(PetscMalloc1(pcis->n_B - n_vertices, &aux_array2));
6047: PetscCall(ISGetIndices(pcis->is_I_local, (const PetscInt **)&is_indices));
6048: for (i = 0; i < n_D; i++) PetscCall(PetscBTSet(bitmask, is_indices[i]));
6049: PetscCall(ISRestoreIndices(pcis->is_I_local, (const PetscInt **)&is_indices));
6050: for (i = 0, j = 0; i < n_R; i++) {
6051: if (!PetscBTLookup(bitmask, idx_R_local[i])) aux_array1[j++] = i;
6052: }
6053: PetscCall(ISCreateGeneral(PETSC_COMM_SELF, j, aux_array1, PETSC_OWN_POINTER, &is_aux1));
6054: PetscCall(ISGetIndices(pcis->is_B_local, (const PetscInt **)&is_indices));
6055: for (i = 0, j = 0; i < n_B; i++) {
6056: if (!PetscBTLookup(bitmask, is_indices[i])) aux_array2[j++] = i;
6057: }
6058: PetscCall(ISRestoreIndices(pcis->is_B_local, (const PetscInt **)&is_indices));
6059: PetscCall(ISCreateGeneral(PETSC_COMM_SELF, j, aux_array2, PETSC_OWN_POINTER, &is_aux2));
6060: PetscCall(VecScatterCreate(pcbddc->vec1_R, is_aux1, pcis->vec1_B, is_aux2, &pcbddc->R_to_B));
6061: PetscCall(ISDestroy(&is_aux1));
6062: PetscCall(ISDestroy(&is_aux2));
6064: if (pcbddc->switch_static || pcbddc->dbg_flag) {
6065: PetscCall(PetscMalloc1(n_D, &aux_array1));
6066: for (i = 0, j = 0; i < n_R; i++) {
6067: if (PetscBTLookup(bitmask, idx_R_local[i])) aux_array1[j++] = i;
6068: }
6069: PetscCall(ISCreateGeneral(PETSC_COMM_SELF, j, aux_array1, PETSC_OWN_POINTER, &is_aux1));
6070: PetscCall(VecScatterCreate(pcbddc->vec1_R, is_aux1, pcis->vec1_D, (IS)0, &pcbddc->R_to_D));
6071: PetscCall(ISDestroy(&is_aux1));
6072: }
6073: PetscCall(PetscBTDestroy(&bitmask));
6074: PetscCall(ISRestoreIndices(pcbddc->is_R_local, (const PetscInt **)&idx_R_local));
6075: } else {
6076: PCBDDCReuseSolvers reuse_solver = sub_schurs->reuse_solver;
6077: IS tis;
6078: PetscInt schur_size;
6080: PetscCall(ISGetLocalSize(reuse_solver->is_B, &schur_size));
6081: PetscCall(ISCreateStride(PETSC_COMM_SELF, schur_size, n_D, 1, &tis));
6082: PetscCall(VecScatterCreate(pcbddc->vec1_R, tis, pcis->vec1_B, reuse_solver->is_B, &pcbddc->R_to_B));
6083: PetscCall(ISDestroy(&tis));
6084: if (pcbddc->switch_static || pcbddc->dbg_flag) {
6085: PetscCall(ISCreateStride(PETSC_COMM_SELF, n_D, 0, 1, &tis));
6086: PetscCall(VecScatterCreate(pcbddc->vec1_R, tis, pcis->vec1_D, (IS)0, &pcbddc->R_to_D));
6087: PetscCall(ISDestroy(&tis));
6088: }
6089: }
6090: PetscFunctionReturn(PETSC_SUCCESS);
6091: }
6093: PetscErrorCode MatNullSpacePropagateAny_Private(Mat A, IS is, Mat B)
6094: {
6095: MatNullSpace NullSpace;
6096: Mat dmat;
6097: const Vec *nullvecs;
6098: Vec v, v2, *nullvecs2;
6099: VecScatter sct = NULL;
6100: PetscScalar *ddata;
6101: PetscInt k, nnsp_size, bsiz, bsiz2, n, N, bs;
6102: PetscBool nnsp_has_cnst;
6104: PetscFunctionBegin;
6105: if (!is && !B) { /* MATIS */
6106: Mat_IS *matis = (Mat_IS *)A->data;
6108: if (!B) PetscCall(MatISGetLocalMat(A, &B));
6109: sct = matis->cctx;
6110: PetscCall(PetscObjectReference((PetscObject)sct));
6111: } else {
6112: PetscCall(MatGetNullSpace(B, &NullSpace));
6113: if (!NullSpace) PetscCall(MatGetNearNullSpace(B, &NullSpace));
6114: if (NullSpace) PetscFunctionReturn(PETSC_SUCCESS);
6115: }
6116: PetscCall(MatGetNullSpace(A, &NullSpace));
6117: if (!NullSpace) PetscCall(MatGetNearNullSpace(A, &NullSpace));
6118: if (!NullSpace) PetscFunctionReturn(PETSC_SUCCESS);
6120: PetscCall(MatCreateVecs(A, &v, NULL));
6121: PetscCall(MatCreateVecs(B, &v2, NULL));
6122: if (!sct) PetscCall(VecScatterCreate(v, is, v2, NULL, &sct));
6123: PetscCall(MatNullSpaceGetVecs(NullSpace, &nnsp_has_cnst, &nnsp_size, &nullvecs));
6124: bsiz = bsiz2 = nnsp_size + !!nnsp_has_cnst;
6125: PetscCall(PetscMalloc1(bsiz, &nullvecs2));
6126: PetscCall(VecGetBlockSize(v2, &bs));
6127: PetscCall(VecGetSize(v2, &N));
6128: PetscCall(VecGetLocalSize(v2, &n));
6129: PetscCall(PetscMalloc1(n * bsiz, &ddata));
6130: for (k = 0; k < nnsp_size; k++) {
6131: PetscCall(VecCreateMPIWithArray(PetscObjectComm((PetscObject)B), bs, n, N, ddata + n * k, &nullvecs2[k]));
6132: PetscCall(VecScatterBegin(sct, nullvecs[k], nullvecs2[k], INSERT_VALUES, SCATTER_FORWARD));
6133: PetscCall(VecScatterEnd(sct, nullvecs[k], nullvecs2[k], INSERT_VALUES, SCATTER_FORWARD));
6134: }
6135: if (nnsp_has_cnst) {
6136: PetscCall(VecCreateMPIWithArray(PetscObjectComm((PetscObject)B), bs, n, N, ddata + n * nnsp_size, &nullvecs2[nnsp_size]));
6137: PetscCall(VecSet(nullvecs2[nnsp_size], 1.0));
6138: }
6139: PetscCall(PCBDDCOrthonormalizeVecs(&bsiz2, nullvecs2));
6140: PetscCall(MatNullSpaceCreate(PetscObjectComm((PetscObject)B), PETSC_FALSE, bsiz2, nullvecs2, &NullSpace));
6142: PetscCall(MatCreateDense(PetscObjectComm((PetscObject)B), n, PETSC_DECIDE, N, bsiz2, ddata, &dmat));
6143: PetscCall(PetscObjectContainerCompose((PetscObject)dmat, "_PBDDC_Null_dmat_arr", ddata, PetscCtxDestroyDefault));
6144: PetscCall(PetscObjectCompose((PetscObject)NullSpace, "_PBDDC_Null_dmat", (PetscObject)dmat));
6145: PetscCall(MatDestroy(&dmat));
6147: for (k = 0; k < bsiz; k++) PetscCall(VecDestroy(&nullvecs2[k]));
6148: PetscCall(PetscFree(nullvecs2));
6149: PetscCall(MatSetNearNullSpace(B, NullSpace));
6150: PetscCall(MatNullSpaceDestroy(&NullSpace));
6151: PetscCall(VecDestroy(&v));
6152: PetscCall(VecDestroy(&v2));
6153: PetscCall(VecScatterDestroy(&sct));
6154: PetscFunctionReturn(PETSC_SUCCESS);
6155: }
6157: PetscErrorCode PCBDDCSetUpLocalSolvers(PC pc, PetscBool dirichlet, PetscBool neumann)
6158: {
6159: PC_BDDC *pcbddc = (PC_BDDC *)pc->data;
6160: PC_IS *pcis = (PC_IS *)pc->data;
6161: PC pc_temp;
6162: Mat A_RR;
6163: MatNullSpace nnsp;
6164: MatReuse reuse;
6165: PetscScalar m_one = -1.0;
6166: PetscReal value;
6167: PetscInt n_D, n_R;
6168: PetscBool issbaij, opts, isset, issym;
6169: PetscBool f = PETSC_FALSE;
6170: char dir_prefix[256], neu_prefix[256], str_level[16];
6171: size_t len;
6173: PetscFunctionBegin;
6174: PetscCall(PetscLogEventBegin(PC_BDDC_LocalSolvers[pcbddc->current_level], pc, 0, 0, 0));
6175: /* approximate solver, propagate NearNullSpace if needed */
6176: if (!pc->setupcalled && (pcbddc->NullSpace_corr[0] || pcbddc->NullSpace_corr[2])) {
6177: MatNullSpace gnnsp1, gnnsp2;
6178: PetscBool ghas;
6180: PetscCall(MatGetNearNullSpace(pcbddc->local_mat, &nnsp));
6181: PetscCall(MatGetNearNullSpace(pc->pmat, &gnnsp1));
6182: PetscCall(MatGetNullSpace(pc->pmat, &gnnsp2));
6183: ghas = nnsp ? PETSC_TRUE : PETSC_FALSE;
6184: PetscCallMPI(MPIU_Allreduce(MPI_IN_PLACE, &ghas, 1, MPI_C_BOOL, MPI_LOR, PetscObjectComm((PetscObject)pc)));
6185: if (!ghas && (gnnsp1 || gnnsp2)) PetscCall(MatNullSpacePropagateAny_Private(pc->pmat, NULL, NULL));
6186: }
6188: /* compute prefixes */
6189: PetscCall(PetscStrncpy(dir_prefix, "", sizeof(dir_prefix)));
6190: PetscCall(PetscStrncpy(neu_prefix, "", sizeof(neu_prefix)));
6191: if (!pcbddc->current_level) {
6192: PetscCall(PetscStrncpy(dir_prefix, ((PetscObject)pc)->prefix, sizeof(dir_prefix)));
6193: PetscCall(PetscStrncpy(neu_prefix, ((PetscObject)pc)->prefix, sizeof(neu_prefix)));
6194: PetscCall(PetscStrlcat(dir_prefix, "pc_bddc_dirichlet_", sizeof(dir_prefix)));
6195: PetscCall(PetscStrlcat(neu_prefix, "pc_bddc_neumann_", sizeof(neu_prefix)));
6196: } else {
6197: PetscCall(PetscSNPrintf(str_level, sizeof(str_level), "l%" PetscInt_FMT "_", pcbddc->current_level));
6198: PetscCall(PetscStrlen(((PetscObject)pc)->prefix, &len));
6199: len -= 15; /* remove "pc_bddc_coarse_" */
6200: if (pcbddc->current_level > 1) len -= 3; /* remove "lX_" with X level number */
6201: if (pcbddc->current_level > 10) len -= 1; /* remove another char from level number */
6202: /* Nonstandard use of PetscStrncpy() to only copy a portion of the input string */
6203: PetscCall(PetscStrncpy(dir_prefix, ((PetscObject)pc)->prefix, len + 1));
6204: PetscCall(PetscStrncpy(neu_prefix, ((PetscObject)pc)->prefix, len + 1));
6205: PetscCall(PetscStrlcat(dir_prefix, "pc_bddc_dirichlet_", sizeof(dir_prefix)));
6206: PetscCall(PetscStrlcat(neu_prefix, "pc_bddc_neumann_", sizeof(neu_prefix)));
6207: PetscCall(PetscStrlcat(dir_prefix, str_level, sizeof(dir_prefix)));
6208: PetscCall(PetscStrlcat(neu_prefix, str_level, sizeof(neu_prefix)));
6209: }
6211: /* DIRICHLET PROBLEM */
6212: if (dirichlet) {
6213: PCBDDCSubSchurs sub_schurs = pcbddc->sub_schurs;
6214: if (pcbddc->benign_n && !pcbddc->benign_change_explicit) {
6215: PetscCheck(sub_schurs && sub_schurs->reuse_solver, PETSC_COMM_SELF, PETSC_ERR_SUP, "Not yet implemented");
6216: if (pcbddc->dbg_flag) {
6217: Mat A_IIn;
6219: PetscCall(PCBDDCBenignProject(pc, pcis->is_I_local, pcis->is_I_local, &A_IIn));
6220: PetscCall(MatDestroy(&pcis->A_II));
6221: pcis->A_II = A_IIn;
6222: }
6223: }
6224: PetscCall(MatIsSymmetricKnown(pcbddc->local_mat, &isset, &issym));
6225: if (isset) PetscCall(MatSetOption(pcis->A_II, MAT_SYMMETRIC, issym));
6227: /* Matrix for Dirichlet problem is pcis->A_II */
6228: n_D = pcis->n - pcis->n_B;
6229: opts = PETSC_FALSE;
6230: if (!pcbddc->ksp_D) { /* create object if not yet build */
6231: opts = PETSC_TRUE;
6232: PetscCall(KSPCreate(PETSC_COMM_SELF, &pcbddc->ksp_D));
6233: PetscCall(KSPSetNestLevel(pcbddc->ksp_D, pc->kspnestlevel));
6234: PetscCall(PetscObjectIncrementTabLevel((PetscObject)pcbddc->ksp_D, (PetscObject)pc, 1));
6235: /* default */
6236: PetscCall(KSPSetType(pcbddc->ksp_D, KSPPREONLY));
6237: PetscCall(KSPSetOptionsPrefix(pcbddc->ksp_D, dir_prefix));
6238: PetscCall(PetscObjectTypeCompare((PetscObject)pcis->pA_II, MATSEQSBAIJ, &issbaij));
6239: PetscCall(KSPGetPC(pcbddc->ksp_D, &pc_temp));
6240: if (issbaij) PetscCall(PCSetType(pc_temp, PCCHOLESKY));
6241: else PetscCall(PCSetType(pc_temp, PCLU));
6242: PetscCall(KSPSetErrorIfNotConverged(pcbddc->ksp_D, pc->erroriffailure));
6243: }
6244: PetscCall(MatSetOptionsPrefix(pcis->pA_II, ((PetscObject)pcbddc->ksp_D)->prefix));
6245: PetscCall(MatViewFromOptions(pcis->pA_II, NULL, "-mat_view"));
6246: PetscCall(KSPSetOperators(pcbddc->ksp_D, pcis->A_II, pcis->pA_II));
6247: /* Allow user's customization */
6248: if (opts) PetscCall(KSPSetFromOptions(pcbddc->ksp_D));
6249: PetscCall(MatGetNearNullSpace(pcis->pA_II, &nnsp));
6250: if (pcbddc->NullSpace_corr[0] && !nnsp) { /* approximate solver, propagate NearNullSpace */
6251: PetscCall(MatNullSpacePropagateAny_Private(pcbddc->local_mat, pcis->is_I_local, pcis->pA_II));
6252: }
6253: PetscCall(MatGetNearNullSpace(pcis->pA_II, &nnsp));
6254: PetscCall(KSPGetPC(pcbddc->ksp_D, &pc_temp));
6255: PetscCall(PetscObjectHasFunction((PetscObject)pc_temp, "PCSetCoordinates_C", &f));
6256: if (f && pcbddc->mat_graph->cloc && !nnsp) {
6257: PetscReal *coords = pcbddc->mat_graph->coords, *scoords;
6258: const PetscInt *idxs;
6259: PetscInt cdim = pcbddc->mat_graph->cdim, nl, i, d;
6261: PetscCall(ISGetLocalSize(pcis->is_I_local, &nl));
6262: PetscCall(ISGetIndices(pcis->is_I_local, &idxs));
6263: PetscCall(PetscMalloc1(nl * cdim, &scoords));
6264: for (i = 0; i < nl; i++) {
6265: for (d = 0; d < cdim; d++) scoords[i * cdim + d] = coords[idxs[i] * cdim + d];
6266: }
6267: PetscCall(ISRestoreIndices(pcis->is_I_local, &idxs));
6268: PetscCall(PCSetCoordinates(pc_temp, cdim, nl, scoords));
6269: PetscCall(PetscFree(scoords));
6270: }
6271: if (sub_schurs && sub_schurs->reuse_solver) {
6272: PCBDDCReuseSolvers reuse_solver = sub_schurs->reuse_solver;
6274: PetscCall(KSPSetPC(pcbddc->ksp_D, reuse_solver->interior_solver));
6275: }
6277: /* umfpack interface has a bug when matrix dimension is zero. TODO solve from umfpack interface */
6278: if (!n_D) {
6279: PetscCall(KSPGetPC(pcbddc->ksp_D, &pc_temp));
6280: PetscCall(PCSetType(pc_temp, PCNONE));
6281: }
6282: PetscCall(KSPSetUp(pcbddc->ksp_D));
6283: /* set ksp_D into pcis data */
6284: PetscCall(PetscObjectReference((PetscObject)pcbddc->ksp_D));
6285: PetscCall(KSPDestroy(&pcis->ksp_D));
6286: pcis->ksp_D = pcbddc->ksp_D;
6287: }
6289: /* NEUMANN PROBLEM */
6290: A_RR = NULL;
6291: if (neumann) {
6292: PCBDDCSubSchurs sub_schurs = pcbddc->sub_schurs;
6293: PetscInt ibs, mbs;
6294: PetscBool issbaij, reuse_neumann_solver, isset, issym;
6295: Mat_IS *matis = (Mat_IS *)pc->pmat->data;
6297: reuse_neumann_solver = PETSC_FALSE;
6298: if (sub_schurs && sub_schurs->reuse_solver) {
6299: IS iP;
6301: reuse_neumann_solver = PETSC_TRUE;
6302: PetscCall(PetscObjectQuery((PetscObject)sub_schurs->A, "__KSPFETIDP_iP", (PetscObject *)&iP));
6303: if (iP) reuse_neumann_solver = PETSC_FALSE;
6304: }
6305: /* Matrix for Neumann problem is A_RR -> we need to create/reuse it at this point */
6306: PetscCall(ISGetSize(pcbddc->is_R_local, &n_R));
6307: if (pcbddc->ksp_R) { /* already created ksp */
6308: PetscInt nn_R;
6309: PetscCall(KSPGetOperators(pcbddc->ksp_R, NULL, &A_RR));
6310: PetscCall(PetscObjectReference((PetscObject)A_RR));
6311: PetscCall(MatGetSize(A_RR, &nn_R, NULL));
6312: if (nn_R != n_R) { /* old ksp is not reusable, so reset it */
6313: PetscCall(KSPReset(pcbddc->ksp_R));
6314: PetscCall(MatDestroy(&A_RR));
6315: reuse = MAT_INITIAL_MATRIX;
6316: } else { /* same sizes, but nonzero pattern depend on primal vertices so it can be changed */
6317: if (pcbddc->new_primal_space_local) { /* we are not sure the matrix will have the same nonzero pattern */
6318: PetscCall(MatDestroy(&A_RR));
6319: reuse = MAT_INITIAL_MATRIX;
6320: } else { /* safe to reuse the matrix */
6321: reuse = MAT_REUSE_MATRIX;
6322: }
6323: }
6324: /* last check */
6325: if (pc->flag == DIFFERENT_NONZERO_PATTERN) {
6326: PetscCall(MatDestroy(&A_RR));
6327: reuse = MAT_INITIAL_MATRIX;
6328: }
6329: } else { /* first time, so we need to create the matrix */
6330: reuse = MAT_INITIAL_MATRIX;
6331: }
6332: /* convert pcbddc->local_mat if needed later in PCBDDCSetUpCorrection
6333: TODO: Get Rid of these conversions */
6334: PetscCall(MatGetBlockSize(pcbddc->local_mat, &mbs));
6335: PetscCall(ISGetBlockSize(pcbddc->is_R_local, &ibs));
6336: PetscCall(PetscObjectTypeCompare((PetscObject)pcbddc->local_mat, MATSEQSBAIJ, &issbaij));
6337: if (ibs != mbs) { /* need to convert to SEQAIJ to extract any submatrix with is_R_local */
6338: if (matis->A == pcbddc->local_mat) {
6339: PetscCall(MatDestroy(&pcbddc->local_mat));
6340: PetscCall(MatConvert(matis->A, MATSEQAIJ, MAT_INITIAL_MATRIX, &pcbddc->local_mat));
6341: } else {
6342: PetscCall(MatConvert(pcbddc->local_mat, MATSEQAIJ, MAT_INPLACE_MATRIX, &pcbddc->local_mat));
6343: }
6344: } else if (issbaij) { /* need to convert to BAIJ to get off-diagonal blocks */
6345: if (matis->A == pcbddc->local_mat) {
6346: PetscCall(MatDestroy(&pcbddc->local_mat));
6347: PetscCall(MatConvert(matis->A, mbs > 1 ? MATSEQBAIJ : MATSEQAIJ, MAT_INITIAL_MATRIX, &pcbddc->local_mat));
6348: } else {
6349: PetscCall(MatConvert(pcbddc->local_mat, mbs > 1 ? MATSEQBAIJ : MATSEQAIJ, MAT_INPLACE_MATRIX, &pcbddc->local_mat));
6350: }
6351: }
6352: /* extract A_RR */
6353: if (reuse_neumann_solver) {
6354: PCBDDCReuseSolvers reuse_solver = sub_schurs->reuse_solver;
6356: if (pcbddc->dbg_flag) { /* we need A_RR to test the solver later */
6357: PetscCall(MatDestroy(&A_RR));
6358: if (reuse_solver->benign_n) { /* we are not using the explicit change of basis on the pressures */
6359: PetscCall(PCBDDCBenignProject(pc, pcbddc->is_R_local, pcbddc->is_R_local, &A_RR));
6360: } else {
6361: PetscCall(MatCreateSubMatrix(pcbddc->local_mat, pcbddc->is_R_local, pcbddc->is_R_local, MAT_INITIAL_MATRIX, &A_RR));
6362: }
6363: } else {
6364: PetscCall(MatDestroy(&A_RR));
6365: PetscCall(PCGetOperators(reuse_solver->correction_solver, &A_RR, NULL));
6366: PetscCall(PetscObjectReference((PetscObject)A_RR));
6367: }
6368: } else { /* we have to build the neumann solver, so we need to extract the relevant matrix */
6369: PetscCall(MatCreateSubMatrix(pcbddc->local_mat, pcbddc->is_R_local, pcbddc->is_R_local, reuse, &A_RR));
6370: }
6371: PetscCall(MatIsSymmetricKnown(pcbddc->local_mat, &isset, &issym));
6372: if (isset) PetscCall(MatSetOption(A_RR, MAT_SYMMETRIC, issym));
6373: opts = PETSC_FALSE;
6374: if (!pcbddc->ksp_R) { /* create object if not present */
6375: opts = PETSC_TRUE;
6376: PetscCall(KSPCreate(PETSC_COMM_SELF, &pcbddc->ksp_R));
6377: PetscCall(KSPSetNestLevel(pcbddc->ksp_R, pc->kspnestlevel));
6378: PetscCall(PetscObjectIncrementTabLevel((PetscObject)pcbddc->ksp_R, (PetscObject)pc, 1));
6379: /* default */
6380: PetscCall(KSPSetType(pcbddc->ksp_R, KSPPREONLY));
6381: PetscCall(KSPSetOptionsPrefix(pcbddc->ksp_R, neu_prefix));
6382: PetscCall(KSPGetPC(pcbddc->ksp_R, &pc_temp));
6383: PetscCall(PetscObjectTypeCompare((PetscObject)A_RR, MATSEQSBAIJ, &issbaij));
6384: if (issbaij) PetscCall(PCSetType(pc_temp, PCCHOLESKY));
6385: else PetscCall(PCSetType(pc_temp, PCLU));
6386: PetscCall(KSPSetErrorIfNotConverged(pcbddc->ksp_R, pc->erroriffailure));
6387: }
6388: PetscCall(MatSetOptionsPrefix(A_RR, ((PetscObject)pcbddc->ksp_R)->prefix));
6389: PetscCall(MatViewFromOptions(A_RR, NULL, "-mat_view"));
6390: PetscCall(KSPSetOperators(pcbddc->ksp_R, A_RR, A_RR));
6391: if (opts) { /* Allow user's customization once */
6392: PetscCall(KSPSetFromOptions(pcbddc->ksp_R));
6393: }
6394: PetscCall(MatGetNearNullSpace(A_RR, &nnsp));
6395: if (pcbddc->NullSpace_corr[2] && !nnsp) { /* approximate solver, propagate NearNullSpace */
6396: PetscCall(MatNullSpacePropagateAny_Private(pcbddc->local_mat, pcbddc->is_R_local, A_RR));
6397: }
6398: PetscCall(MatGetNearNullSpace(A_RR, &nnsp));
6399: PetscCall(KSPGetPC(pcbddc->ksp_R, &pc_temp));
6400: PetscCall(PetscObjectHasFunction((PetscObject)pc_temp, "PCSetCoordinates_C", &f));
6401: if (f && pcbddc->mat_graph->cloc && !nnsp) {
6402: PetscReal *coords = pcbddc->mat_graph->coords, *scoords;
6403: const PetscInt *idxs;
6404: PetscInt cdim = pcbddc->mat_graph->cdim, nl, i, d;
6406: PetscCall(ISGetLocalSize(pcbddc->is_R_local, &nl));
6407: PetscCall(ISGetIndices(pcbddc->is_R_local, &idxs));
6408: PetscCall(PetscMalloc1(nl * cdim, &scoords));
6409: for (i = 0; i < nl; i++) {
6410: for (d = 0; d < cdim; d++) scoords[i * cdim + d] = coords[idxs[i] * cdim + d];
6411: }
6412: PetscCall(ISRestoreIndices(pcbddc->is_R_local, &idxs));
6413: PetscCall(PCSetCoordinates(pc_temp, cdim, nl, scoords));
6414: PetscCall(PetscFree(scoords));
6415: }
6417: /* umfpack interface has a bug when matrix dimension is zero. TODO solve from umfpack interface */
6418: if (!n_R) {
6419: PetscCall(KSPGetPC(pcbddc->ksp_R, &pc_temp));
6420: PetscCall(PCSetType(pc_temp, PCNONE));
6421: }
6422: /* Reuse solver if it is present */
6423: if (reuse_neumann_solver) {
6424: PCBDDCReuseSolvers reuse_solver = sub_schurs->reuse_solver;
6426: PetscCall(KSPSetPC(pcbddc->ksp_R, reuse_solver->correction_solver));
6427: }
6428: PetscCall(KSPSetUp(pcbddc->ksp_R));
6429: }
6431: if (pcbddc->dbg_flag) {
6432: PetscCall(PetscViewerFlush(pcbddc->dbg_viewer));
6433: PetscCall(PetscViewerASCIIPushSynchronized(pcbddc->dbg_viewer));
6434: PetscCall(PetscViewerASCIIPrintf(pcbddc->dbg_viewer, "--------------------------------------------------\n"));
6435: }
6436: PetscCall(PetscLogEventEnd(PC_BDDC_LocalSolvers[pcbddc->current_level], pc, 0, 0, 0));
6438: /* adapt Dirichlet and Neumann solvers if a nullspace correction has been requested */
6439: if (pcbddc->NullSpace_corr[0]) PetscCall(PCBDDCSetUseExactDirichlet(pc, PETSC_FALSE));
6440: if (dirichlet && pcbddc->NullSpace_corr[0] && !pcbddc->switch_static) PetscCall(PCBDDCNullSpaceAssembleCorrection(pc, PETSC_TRUE, pcbddc->NullSpace_corr[1]));
6441: if (neumann && pcbddc->NullSpace_corr[2]) PetscCall(PCBDDCNullSpaceAssembleCorrection(pc, PETSC_FALSE, pcbddc->NullSpace_corr[3]));
6442: /* check Dirichlet and Neumann solvers */
6443: if (pcbddc->dbg_flag) {
6444: if (dirichlet) { /* Dirichlet */
6445: PetscCall(VecSetRandom(pcis->vec1_D, NULL));
6446: PetscCall(MatMult(pcis->A_II, pcis->vec1_D, pcis->vec2_D));
6447: PetscCall(KSPSolve(pcbddc->ksp_D, pcis->vec2_D, pcis->vec2_D));
6448: PetscCall(KSPCheckSolve(pcbddc->ksp_D, pc, pcis->vec2_D));
6449: PetscCall(VecAXPY(pcis->vec1_D, m_one, pcis->vec2_D));
6450: PetscCall(VecNorm(pcis->vec1_D, NORM_INFINITY, &value));
6451: PetscCall(PetscViewerASCIISynchronizedPrintf(pcbddc->dbg_viewer, "Subdomain %04d infinity error for Dirichlet solve (%s) = % 1.14e \n", PetscGlobalRank, ((PetscObject)pcbddc->ksp_D)->prefix, (double)value));
6452: PetscCall(PetscViewerFlush(pcbddc->dbg_viewer));
6453: }
6454: if (neumann) { /* Neumann */
6455: PetscCall(VecSetRandom(pcbddc->vec1_R, NULL));
6456: PetscCall(MatMult(A_RR, pcbddc->vec1_R, pcbddc->vec2_R));
6457: PetscCall(KSPSolve(pcbddc->ksp_R, pcbddc->vec2_R, pcbddc->vec2_R));
6458: PetscCall(KSPCheckSolve(pcbddc->ksp_R, pc, pcbddc->vec2_R));
6459: PetscCall(VecAXPY(pcbddc->vec1_R, m_one, pcbddc->vec2_R));
6460: PetscCall(VecNorm(pcbddc->vec1_R, NORM_INFINITY, &value));
6461: PetscCall(PetscViewerASCIISynchronizedPrintf(pcbddc->dbg_viewer, "Subdomain %04d infinity error for Neumann solve (%s) = % 1.14e\n", PetscGlobalRank, ((PetscObject)pcbddc->ksp_R)->prefix, (double)value));
6462: PetscCall(PetscViewerFlush(pcbddc->dbg_viewer));
6463: }
6464: }
6465: /* free Neumann problem's matrix */
6466: PetscCall(MatDestroy(&A_RR));
6467: PetscFunctionReturn(PETSC_SUCCESS);
6468: }
6470: static PetscErrorCode PCBDDCSolveSubstructureCorrection(PC pc, Vec inout_B, Vec inout_D, PetscBool applytranspose)
6471: {
6472: PC_BDDC *pcbddc = (PC_BDDC *)pc->data;
6473: PCBDDCSubSchurs sub_schurs = pcbddc->sub_schurs;
6474: PetscBool reuse_solver = sub_schurs ? (sub_schurs->reuse_solver ? PETSC_TRUE : PETSC_FALSE) : PETSC_FALSE;
6476: PetscFunctionBegin;
6477: if (!reuse_solver) PetscCall(VecSet(pcbddc->vec1_R, 0.));
6478: if (!pcbddc->switch_static) {
6479: if (applytranspose && pcbddc->local_auxmat1) {
6480: PetscCall(MatMultTranspose(pcbddc->local_auxmat2, inout_B, pcbddc->vec1_C));
6481: PetscCall(MatMultTransposeAdd(pcbddc->local_auxmat1, pcbddc->vec1_C, inout_B, inout_B));
6482: }
6483: if (!reuse_solver) {
6484: PetscCall(VecScatterBegin(pcbddc->R_to_B, inout_B, pcbddc->vec1_R, INSERT_VALUES, SCATTER_REVERSE));
6485: PetscCall(VecScatterEnd(pcbddc->R_to_B, inout_B, pcbddc->vec1_R, INSERT_VALUES, SCATTER_REVERSE));
6486: } else {
6487: PCBDDCReuseSolvers reuse_solver = sub_schurs->reuse_solver;
6489: PetscCall(VecScatterBegin(reuse_solver->correction_scatter_B, inout_B, reuse_solver->rhs_B, INSERT_VALUES, SCATTER_FORWARD));
6490: PetscCall(VecScatterEnd(reuse_solver->correction_scatter_B, inout_B, reuse_solver->rhs_B, INSERT_VALUES, SCATTER_FORWARD));
6491: }
6492: } else {
6493: PetscCall(VecScatterBegin(pcbddc->R_to_B, inout_B, pcbddc->vec1_R, INSERT_VALUES, SCATTER_REVERSE));
6494: PetscCall(VecScatterEnd(pcbddc->R_to_B, inout_B, pcbddc->vec1_R, INSERT_VALUES, SCATTER_REVERSE));
6495: PetscCall(VecScatterBegin(pcbddc->R_to_D, inout_D, pcbddc->vec1_R, INSERT_VALUES, SCATTER_REVERSE));
6496: PetscCall(VecScatterEnd(pcbddc->R_to_D, inout_D, pcbddc->vec1_R, INSERT_VALUES, SCATTER_REVERSE));
6497: if (applytranspose && pcbddc->local_auxmat1) {
6498: PetscCall(MatMultTranspose(pcbddc->local_auxmat2, pcbddc->vec1_R, pcbddc->vec1_C));
6499: PetscCall(MatMultTransposeAdd(pcbddc->local_auxmat1, pcbddc->vec1_C, inout_B, inout_B));
6500: PetscCall(VecScatterBegin(pcbddc->R_to_B, inout_B, pcbddc->vec1_R, INSERT_VALUES, SCATTER_REVERSE));
6501: PetscCall(VecScatterEnd(pcbddc->R_to_B, inout_B, pcbddc->vec1_R, INSERT_VALUES, SCATTER_REVERSE));
6502: }
6503: }
6504: PetscCall(PetscLogEventBegin(PC_BDDC_Solves[pcbddc->current_level][1], pc, 0, 0, 0));
6505: if (!reuse_solver || pcbddc->switch_static) {
6506: if (applytranspose) {
6507: PetscCall(KSPSolveTranspose(pcbddc->ksp_R, pcbddc->vec1_R, pcbddc->vec1_R));
6508: } else {
6509: PetscCall(KSPSolve(pcbddc->ksp_R, pcbddc->vec1_R, pcbddc->vec1_R));
6510: }
6511: PetscCall(KSPCheckSolve(pcbddc->ksp_R, pc, pcbddc->vec1_R));
6512: } else {
6513: PCBDDCReuseSolvers reuse_solver = sub_schurs->reuse_solver;
6515: if (applytranspose) {
6516: PetscCall(MatFactorSolveSchurComplementTranspose(reuse_solver->F, reuse_solver->rhs_B, reuse_solver->sol_B));
6517: } else {
6518: PetscCall(MatFactorSolveSchurComplement(reuse_solver->F, reuse_solver->rhs_B, reuse_solver->sol_B));
6519: }
6520: }
6521: PetscCall(PetscLogEventEnd(PC_BDDC_Solves[pcbddc->current_level][1], pc, 0, 0, 0));
6522: PetscCall(VecSet(inout_B, 0.));
6523: if (!pcbddc->switch_static) {
6524: if (!reuse_solver) {
6525: PetscCall(VecScatterBegin(pcbddc->R_to_B, pcbddc->vec1_R, inout_B, INSERT_VALUES, SCATTER_FORWARD));
6526: PetscCall(VecScatterEnd(pcbddc->R_to_B, pcbddc->vec1_R, inout_B, INSERT_VALUES, SCATTER_FORWARD));
6527: } else {
6528: PCBDDCReuseSolvers reuse_solver = sub_schurs->reuse_solver;
6530: PetscCall(VecScatterBegin(reuse_solver->correction_scatter_B, reuse_solver->sol_B, inout_B, INSERT_VALUES, SCATTER_REVERSE));
6531: PetscCall(VecScatterEnd(reuse_solver->correction_scatter_B, reuse_solver->sol_B, inout_B, INSERT_VALUES, SCATTER_REVERSE));
6532: }
6533: if (!applytranspose && pcbddc->local_auxmat1) {
6534: PetscCall(MatMult(pcbddc->local_auxmat1, inout_B, pcbddc->vec1_C));
6535: PetscCall(MatMultAdd(pcbddc->local_auxmat2, pcbddc->vec1_C, inout_B, inout_B));
6536: }
6537: } else {
6538: PetscCall(VecScatterBegin(pcbddc->R_to_B, pcbddc->vec1_R, inout_B, INSERT_VALUES, SCATTER_FORWARD));
6539: PetscCall(VecScatterEnd(pcbddc->R_to_B, pcbddc->vec1_R, inout_B, INSERT_VALUES, SCATTER_FORWARD));
6540: PetscCall(VecScatterBegin(pcbddc->R_to_D, pcbddc->vec1_R, inout_D, INSERT_VALUES, SCATTER_FORWARD));
6541: PetscCall(VecScatterEnd(pcbddc->R_to_D, pcbddc->vec1_R, inout_D, INSERT_VALUES, SCATTER_FORWARD));
6542: if (!applytranspose && pcbddc->local_auxmat1) {
6543: PetscCall(MatMult(pcbddc->local_auxmat1, inout_B, pcbddc->vec1_C));
6544: PetscCall(MatMultAdd(pcbddc->local_auxmat2, pcbddc->vec1_C, pcbddc->vec1_R, pcbddc->vec1_R));
6545: }
6546: PetscCall(VecScatterBegin(pcbddc->R_to_B, pcbddc->vec1_R, inout_B, INSERT_VALUES, SCATTER_FORWARD));
6547: PetscCall(VecScatterEnd(pcbddc->R_to_B, pcbddc->vec1_R, inout_B, INSERT_VALUES, SCATTER_FORWARD));
6548: PetscCall(VecScatterBegin(pcbddc->R_to_D, pcbddc->vec1_R, inout_D, INSERT_VALUES, SCATTER_FORWARD));
6549: PetscCall(VecScatterEnd(pcbddc->R_to_D, pcbddc->vec1_R, inout_D, INSERT_VALUES, SCATTER_FORWARD));
6550: }
6551: PetscFunctionReturn(PETSC_SUCCESS);
6552: }
6554: /* parameter apply transpose determines if the interface preconditioner should be applied transposed or not */
6555: PetscErrorCode PCBDDCApplyInterfacePreconditioner(PC pc, PetscBool applytranspose)
6556: {
6557: PC_BDDC *pcbddc = (PC_BDDC *)pc->data;
6558: PC_IS *pcis = (PC_IS *)pc->data;
6559: const PetscScalar zero = 0.0;
6561: PetscFunctionBegin;
6562: /* Application of PSI^T or PHI^T (depending on applytranspose, see comment above) */
6563: if (!pcbddc->benign_apply_coarse_only) {
6564: if (applytranspose) {
6565: PetscCall(MatMultTranspose(pcbddc->coarse_phi_B, pcis->vec1_B, pcbddc->vec1_P));
6566: if (pcbddc->switch_static) PetscCall(MatMultTransposeAdd(pcbddc->coarse_phi_D, pcis->vec1_D, pcbddc->vec1_P, pcbddc->vec1_P));
6567: } else {
6568: PetscCall(MatMultTranspose(pcbddc->coarse_psi_B, pcis->vec1_B, pcbddc->vec1_P));
6569: if (pcbddc->switch_static) PetscCall(MatMultTransposeAdd(pcbddc->coarse_psi_D, pcis->vec1_D, pcbddc->vec1_P, pcbddc->vec1_P));
6570: }
6571: } else {
6572: PetscCall(VecSet(pcbddc->vec1_P, zero));
6573: }
6575: /* add p0 to the last value of vec1_P holding the coarse dof relative to p0 */
6576: if (pcbddc->benign_n) {
6577: PetscScalar *array;
6579: PetscCall(VecGetArray(pcbddc->vec1_P, &array));
6580: for (PetscInt j = 0; j < pcbddc->benign_n; j++) array[pcbddc->local_primal_size - pcbddc->benign_n + j] += pcbddc->benign_p0[j];
6581: PetscCall(VecRestoreArray(pcbddc->vec1_P, &array));
6582: }
6584: /* start communications from local primal nodes to rhs of coarse solver */
6585: PetscCall(VecSet(pcbddc->coarse_vec, zero));
6586: PetscCall(PCBDDCScatterCoarseDataBegin(pc, ADD_VALUES, SCATTER_FORWARD));
6587: PetscCall(PCBDDCScatterCoarseDataEnd(pc, ADD_VALUES, SCATTER_FORWARD));
6589: /* Coarse solution -> rhs and sol updated inside PCBDDCScattarCoarseDataBegin/End */
6590: PetscCall(PetscLogEventBegin(PC_BDDC_Solves[pcbddc->current_level][2], pc, 0, 0, 0));
6591: if (pcbddc->coarse_ksp) {
6592: Mat coarse_mat;
6593: Vec rhs, sol;
6594: MatNullSpace nullsp;
6595: PetscBool isbddc = PETSC_FALSE;
6597: if (pcbddc->benign_have_null) {
6598: PC coarse_pc;
6600: PetscCall(KSPGetPC(pcbddc->coarse_ksp, &coarse_pc));
6601: PetscCall(PetscObjectTypeCompare((PetscObject)coarse_pc, PCBDDC, &isbddc));
6602: /* we need to propagate to coarser levels the need for a possible benign correction */
6603: if (isbddc && pcbddc->benign_apply_coarse_only && !pcbddc->benign_skip_correction) {
6604: PC_BDDC *coarsepcbddc = (PC_BDDC *)coarse_pc->data;
6605: coarsepcbddc->benign_skip_correction = PETSC_FALSE;
6606: coarsepcbddc->benign_apply_coarse_only = PETSC_TRUE;
6607: }
6608: }
6609: PetscCall(KSPGetRhs(pcbddc->coarse_ksp, &rhs));
6610: PetscCall(KSPGetSolution(pcbddc->coarse_ksp, &sol));
6611: PetscCall(KSPGetOperators(pcbddc->coarse_ksp, &coarse_mat, NULL));
6612: if (applytranspose) {
6613: PetscCheck(!pcbddc->benign_apply_coarse_only, PetscObjectComm((PetscObject)pcbddc->coarse_ksp), PETSC_ERR_SUP, "Not yet implemented");
6614: PetscCall(KSPSolveTranspose(pcbddc->coarse_ksp, rhs, sol));
6615: PetscCall(KSPCheckSolve(pcbddc->coarse_ksp, pc, sol));
6616: PetscCall(MatGetTransposeNullSpace(coarse_mat, &nullsp));
6617: if (nullsp) PetscCall(MatNullSpaceRemove(nullsp, sol));
6618: } else {
6619: PetscCall(MatGetNullSpace(coarse_mat, &nullsp));
6620: if (pcbddc->benign_apply_coarse_only && isbddc) { /* need just to apply the coarse preconditioner during presolve */
6621: PC coarse_pc;
6623: if (nullsp) PetscCall(MatNullSpaceRemove(nullsp, rhs));
6624: PetscCall(KSPGetPC(pcbddc->coarse_ksp, &coarse_pc));
6625: PetscCall(PCPreSolve(coarse_pc, pcbddc->coarse_ksp));
6626: PetscCall(PCBDDCBenignRemoveInterior(coarse_pc, rhs, sol));
6627: PetscCall(PCPostSolve(coarse_pc, pcbddc->coarse_ksp));
6628: } else {
6629: PetscCall(KSPSolve(pcbddc->coarse_ksp, rhs, sol));
6630: PetscCall(KSPCheckSolve(pcbddc->coarse_ksp, pc, sol));
6631: if (nullsp) PetscCall(MatNullSpaceRemove(nullsp, sol));
6632: }
6633: }
6634: /* we don't need the benign correction at coarser levels anymore */
6635: if (pcbddc->benign_have_null && isbddc) {
6636: PC coarse_pc;
6637: PC_BDDC *coarsepcbddc;
6639: PetscCall(KSPGetPC(pcbddc->coarse_ksp, &coarse_pc));
6640: coarsepcbddc = (PC_BDDC *)coarse_pc->data;
6641: coarsepcbddc->benign_skip_correction = PETSC_TRUE;
6642: coarsepcbddc->benign_apply_coarse_only = PETSC_FALSE;
6643: }
6644: }
6645: PetscCall(PetscLogEventEnd(PC_BDDC_Solves[pcbddc->current_level][2], pc, 0, 0, 0));
6647: /* Local solution on R nodes */
6648: if (!pcbddc->benign_apply_coarse_only) PetscCall(PCBDDCSolveSubstructureCorrection(pc, pcis->vec1_B, pcis->vec1_D, applytranspose));
6649: /* communications from coarse sol to local primal nodes */
6650: PetscCall(PCBDDCScatterCoarseDataBegin(pc, INSERT_VALUES, SCATTER_REVERSE));
6651: PetscCall(PCBDDCScatterCoarseDataEnd(pc, INSERT_VALUES, SCATTER_REVERSE));
6653: /* Sum contributions from the two levels */
6654: if (!pcbddc->benign_apply_coarse_only) {
6655: if (applytranspose) {
6656: PetscCall(MatMultAdd(pcbddc->coarse_psi_B, pcbddc->vec1_P, pcis->vec1_B, pcis->vec1_B));
6657: if (pcbddc->switch_static) PetscCall(MatMultAdd(pcbddc->coarse_psi_D, pcbddc->vec1_P, pcis->vec1_D, pcis->vec1_D));
6658: } else {
6659: PetscCall(MatMultAdd(pcbddc->coarse_phi_B, pcbddc->vec1_P, pcis->vec1_B, pcis->vec1_B));
6660: if (pcbddc->switch_static) PetscCall(MatMultAdd(pcbddc->coarse_phi_D, pcbddc->vec1_P, pcis->vec1_D, pcis->vec1_D));
6661: }
6662: /* store p0 */
6663: if (pcbddc->benign_n) {
6664: PetscScalar *array;
6666: PetscCall(VecGetArray(pcbddc->vec1_P, &array));
6667: for (PetscInt j = 0; j < pcbddc->benign_n; j++) pcbddc->benign_p0[j] = array[pcbddc->local_primal_size - pcbddc->benign_n + j];
6668: PetscCall(VecRestoreArray(pcbddc->vec1_P, &array));
6669: }
6670: } else { /* expand the coarse solution */
6671: if (applytranspose) {
6672: PetscCall(MatMult(pcbddc->coarse_psi_B, pcbddc->vec1_P, pcis->vec1_B));
6673: } else {
6674: PetscCall(MatMult(pcbddc->coarse_phi_B, pcbddc->vec1_P, pcis->vec1_B));
6675: }
6676: }
6677: PetscFunctionReturn(PETSC_SUCCESS);
6678: }
6680: PetscErrorCode PCBDDCScatterCoarseDataBegin(PC pc, InsertMode imode, ScatterMode smode)
6681: {
6682: PC_BDDC *pcbddc = (PC_BDDC *)pc->data;
6683: Vec from, to;
6684: const PetscScalar *array;
6686: PetscFunctionBegin;
6687: if (smode == SCATTER_REVERSE) { /* from global to local -> get data from coarse solution */
6688: from = pcbddc->coarse_vec;
6689: to = pcbddc->vec1_P;
6690: if (pcbddc->coarse_ksp) { /* get array from coarse processes */
6691: Vec tvec;
6693: PetscCall(KSPGetRhs(pcbddc->coarse_ksp, &tvec));
6694: PetscCall(VecResetArray(tvec));
6695: PetscCall(KSPGetSolution(pcbddc->coarse_ksp, &tvec));
6696: PetscCall(VecGetArrayRead(tvec, &array));
6697: PetscCall(VecPlaceArray(from, array));
6698: PetscCall(VecRestoreArrayRead(tvec, &array));
6699: }
6700: } else { /* from local to global -> put data in coarse right-hand side */
6701: from = pcbddc->vec1_P;
6702: to = pcbddc->coarse_vec;
6703: }
6704: PetscCall(VecScatterBegin(pcbddc->coarse_loc_to_glob, from, to, imode, smode));
6705: PetscFunctionReturn(PETSC_SUCCESS);
6706: }
6708: PetscErrorCode PCBDDCScatterCoarseDataEnd(PC pc, InsertMode imode, ScatterMode smode)
6709: {
6710: PC_BDDC *pcbddc = (PC_BDDC *)pc->data;
6711: Vec from, to;
6712: const PetscScalar *array;
6714: PetscFunctionBegin;
6715: if (smode == SCATTER_REVERSE) { /* from global to local -> get data from coarse solution */
6716: from = pcbddc->coarse_vec;
6717: to = pcbddc->vec1_P;
6718: } else { /* from local to global -> put data in coarse right-hand side */
6719: from = pcbddc->vec1_P;
6720: to = pcbddc->coarse_vec;
6721: }
6722: PetscCall(VecScatterEnd(pcbddc->coarse_loc_to_glob, from, to, imode, smode));
6723: if (smode == SCATTER_FORWARD) {
6724: if (pcbddc->coarse_ksp) { /* get array from coarse processes */
6725: Vec tvec;
6727: PetscCall(KSPGetRhs(pcbddc->coarse_ksp, &tvec));
6728: PetscCall(VecGetArrayRead(to, &array));
6729: PetscCall(VecPlaceArray(tvec, array));
6730: PetscCall(VecRestoreArrayRead(to, &array));
6731: }
6732: } else {
6733: if (pcbddc->coarse_ksp) { /* restore array of pcbddc->coarse_vec */
6734: PetscCall(VecResetArray(from));
6735: }
6736: }
6737: PetscFunctionReturn(PETSC_SUCCESS);
6738: }
6740: PetscErrorCode PCBDDCConstraintsSetUp(PC pc)
6741: {
6742: PC_IS *pcis = (PC_IS *)pc->data;
6743: PC_BDDC *pcbddc = (PC_BDDC *)pc->data;
6744: Mat_IS *matis = (Mat_IS *)pc->pmat->data;
6745: /* one and zero */
6746: PetscScalar one = 1.0, zero = 0.0;
6747: /* space to store constraints and their local indices */
6748: PetscScalar *constraints_data;
6749: PetscInt *constraints_idxs, *constraints_idxs_B;
6750: PetscInt *constraints_idxs_ptr, *constraints_data_ptr;
6751: PetscInt *constraints_n;
6752: /* iterators */
6753: PetscInt i, j, k, total_counts, total_counts_cc, cum;
6754: /* BLAS integers */
6755: PetscBLASInt lwork;
6756: PetscBLASInt Blas_N, Blas_M, Blas_K, Blas_one = 1;
6757: PetscBLASInt Blas_LDA, Blas_LDB, Blas_LDC;
6758: /* reuse */
6759: PetscInt olocal_primal_size, olocal_primal_size_cc;
6760: PetscInt *olocal_primal_ref_node, *olocal_primal_ref_mult;
6761: /* change of basis */
6762: PetscBool qr_needed;
6763: PetscBT change_basis, qr_needed_idx;
6764: /* auxiliary stuff */
6765: PetscInt *nnz, *is_indices;
6766: PetscInt ncc;
6767: /* some quantities */
6768: PetscInt n_vertices, total_primal_vertices, valid_constraints;
6769: PetscInt size_of_constraint, max_size_of_constraint = 0, max_constraints, temp_constraints;
6770: PetscReal tol = PetscSqrtReal(PETSC_SMALL); /* tolerance for retaining eigenmodes */
6771: PetscReal null_tol = PETSC_SMALL; /* tolerance for retaining imported nearnullspace vectors */
6773: PetscFunctionBegin;
6774: PetscOptionsBegin(PetscObjectComm((PetscObject)pc), ((PetscObject)pc)->prefix, "BDDC constraints options", "PC");
6775: PetscCall(PetscOptionsReal("-pc_bddc_constraint_near_null_space_tol", "Retain nearnullspace data if larger than tolerance", NULL, null_tol, &null_tol, NULL));
6776: PetscCall(PetscOptionsReal("-pc_bddc_constraint_singular_tol", "Retain singular vectors up to tolerance", NULL, tol, &tol, NULL));
6777: PetscOptionsEnd();
6779: /* Destroy Mat objects computed previously */
6780: PetscCall(MatDestroy(&pcbddc->ChangeOfBasisMatrix));
6781: PetscCall(MatDestroy(&pcbddc->ConstraintMatrix));
6782: PetscCall(MatDestroy(&pcbddc->switch_static_change));
6783: /* save info on constraints from previous setup (if any) */
6784: olocal_primal_size = pcbddc->local_primal_size;
6785: olocal_primal_size_cc = pcbddc->local_primal_size_cc;
6786: PetscCall(PetscMalloc2(olocal_primal_size_cc, &olocal_primal_ref_node, olocal_primal_size_cc, &olocal_primal_ref_mult));
6787: PetscCall(PetscArraycpy(olocal_primal_ref_node, pcbddc->local_primal_ref_node, olocal_primal_size_cc));
6788: PetscCall(PetscArraycpy(olocal_primal_ref_mult, pcbddc->local_primal_ref_mult, olocal_primal_size_cc));
6789: PetscCall(PetscFree2(pcbddc->local_primal_ref_node, pcbddc->local_primal_ref_mult));
6790: PetscCall(PetscFree(pcbddc->primal_indices_local_idxs));
6792: if (!pcbddc->adaptive_selection) {
6793: IS ISForVertices, *ISForFaces, *ISForEdges;
6794: MatNullSpace nearnullsp;
6795: const Vec *nearnullvecs;
6796: Vec *localnearnullsp;
6797: PetscScalar *array;
6798: PetscInt n_ISForFaces, n_ISForEdges, nnsp_size, o_nf, o_ne;
6799: PetscBool nnsp_has_cnst;
6800: /* LAPACK working arrays for SVD or POD */
6801: PetscBool skip_lapack, boolforchange;
6802: PetscScalar *work;
6803: PetscReal *singular_vals;
6804: #if PetscDefined(USE_COMPLEX)
6805: PetscReal *rwork;
6806: #endif
6807: PetscScalar *temp_basis = NULL, *correlation_mat = NULL;
6808: PetscBLASInt dummy_int = 1;
6809: PetscScalar dummy_scalar = 1.;
6810: PetscBool use_pod = PetscDefined(MISSING_LAPACK_GESVD) || PetscDefined(HAVE_MKL_LIBS) ? PETSC_TRUE : PETSC_FALSE; /* MKL SVD with same input gives different results on different processes! */
6812: /* Get index sets for faces, edges and vertices from graph */
6813: PetscCall(PCBDDCGraphGetCandidatesIS(pcbddc->mat_graph, &n_ISForFaces, &ISForFaces, &n_ISForEdges, &ISForEdges, &ISForVertices));
6814: o_nf = n_ISForFaces;
6815: o_ne = n_ISForEdges;
6816: n_vertices = 0;
6817: if (ISForVertices) PetscCall(ISGetSize(ISForVertices, &n_vertices));
6818: /* print some info */
6819: if (pcbddc->dbg_flag && (!pcbddc->sub_schurs || pcbddc->sub_schurs_rebuild)) {
6820: if (!pcbddc->dbg_viewer) pcbddc->dbg_viewer = PETSC_VIEWER_STDOUT_(PetscObjectComm((PetscObject)pc));
6821: PetscCall(PCBDDCGraphASCIIView(pcbddc->mat_graph, pcbddc->dbg_flag, pcbddc->dbg_viewer));
6822: PetscCall(PetscViewerASCIIPushSynchronized(pcbddc->dbg_viewer));
6823: PetscCall(PetscViewerASCIISynchronizedPrintf(pcbddc->dbg_viewer, "--------------------------------------------------------------\n"));
6824: PetscCall(PetscViewerASCIISynchronizedPrintf(pcbddc->dbg_viewer, "Subdomain %04d got %02" PetscInt_FMT " local candidate vertices (%d)\n", PetscGlobalRank, n_vertices, pcbddc->use_vertices));
6825: PetscCall(PetscViewerASCIISynchronizedPrintf(pcbddc->dbg_viewer, "Subdomain %04d got %02" PetscInt_FMT " local candidate edges (%d)\n", PetscGlobalRank, n_ISForEdges, pcbddc->use_edges));
6826: PetscCall(PetscViewerASCIISynchronizedPrintf(pcbddc->dbg_viewer, "Subdomain %04d got %02" PetscInt_FMT " local candidate faces (%d)\n", PetscGlobalRank, n_ISForFaces, pcbddc->use_faces));
6827: PetscCall(PetscViewerFlush(pcbddc->dbg_viewer));
6828: PetscCall(PetscViewerASCIIPopSynchronized(pcbddc->dbg_viewer));
6829: }
6831: if (!pcbddc->use_vertices) n_vertices = 0;
6832: if (!pcbddc->use_edges) n_ISForEdges = 0;
6833: if (!pcbddc->use_faces) n_ISForFaces = 0;
6835: /* check if near null space is attached to global mat */
6836: if (pcbddc->use_nnsp) PetscCall(MatGetNearNullSpace(pc->pmat, &nearnullsp));
6837: else nearnullsp = NULL;
6839: if (nearnullsp) {
6840: PetscCall(MatNullSpaceGetVecs(nearnullsp, &nnsp_has_cnst, &nnsp_size, &nearnullvecs));
6841: /* remove any stored info */
6842: PetscCall(MatNullSpaceDestroy(&pcbddc->onearnullspace));
6843: PetscCall(PetscFree(pcbddc->onearnullvecs_state));
6844: /* store information for BDDC solver reuse */
6845: PetscCall(PetscObjectReference((PetscObject)nearnullsp));
6846: pcbddc->onearnullspace = nearnullsp;
6847: PetscCall(PetscMalloc1(nnsp_size, &pcbddc->onearnullvecs_state));
6848: for (i = 0; i < nnsp_size; i++) PetscCall(PetscObjectStateGet((PetscObject)nearnullvecs[i], &pcbddc->onearnullvecs_state[i]));
6849: } else { /* if near null space is not provided BDDC uses constants by default */
6850: nnsp_size = 0;
6851: nnsp_has_cnst = PETSC_TRUE;
6852: }
6853: /* get max number of constraints on a single cc */
6854: max_constraints = nnsp_size;
6855: if (nnsp_has_cnst) max_constraints++;
6857: /*
6858: Evaluate maximum storage size needed by the procedure
6859: - Indices for connected component i stored at "constraints_idxs + constraints_idxs_ptr[i]"
6860: - Values for constraints on connected component i stored at "constraints_data + constraints_data_ptr[i]"
6861: There can be multiple constraints per connected component
6862: */
6863: ncc = n_vertices + n_ISForFaces + n_ISForEdges;
6864: PetscCall(PetscMalloc3(ncc + 1, &constraints_idxs_ptr, ncc + 1, &constraints_data_ptr, ncc, &constraints_n));
6866: total_counts = n_ISForFaces + n_ISForEdges;
6867: total_counts *= max_constraints;
6868: total_counts += n_vertices;
6869: PetscCall(PetscBTCreate(total_counts, &change_basis));
6871: total_counts = 0;
6872: max_size_of_constraint = 0;
6873: for (i = 0; i < n_ISForEdges + n_ISForFaces; i++) {
6874: IS used_is;
6875: if (i < n_ISForEdges) {
6876: used_is = ISForEdges[i];
6877: } else {
6878: used_is = ISForFaces[i - n_ISForEdges];
6879: }
6880: PetscCall(ISGetSize(used_is, &j));
6881: total_counts += j;
6882: max_size_of_constraint = PetscMax(j, max_size_of_constraint);
6883: }
6884: PetscCall(PetscMalloc3(total_counts * max_constraints + n_vertices, &constraints_data, total_counts + n_vertices, &constraints_idxs, total_counts + n_vertices, &constraints_idxs_B));
6886: /* get local part of global near null space vectors */
6887: PetscCall(PetscMalloc1(nnsp_size, &localnearnullsp));
6888: for (k = 0; k < nnsp_size; k++) {
6889: PetscCall(VecDuplicate(pcis->vec1_N, &localnearnullsp[k]));
6890: PetscCall(VecScatterBegin(matis->rctx, nearnullvecs[k], localnearnullsp[k], INSERT_VALUES, SCATTER_FORWARD));
6891: PetscCall(VecScatterEnd(matis->rctx, nearnullvecs[k], localnearnullsp[k], INSERT_VALUES, SCATTER_FORWARD));
6892: }
6894: /* whether or not to skip lapack calls */
6895: skip_lapack = PETSC_TRUE;
6896: if (n_ISForFaces + n_ISForEdges && max_constraints > 1 && !pcbddc->use_nnsp_true) skip_lapack = PETSC_FALSE;
6898: /* First we issue queries to allocate optimal workspace for LAPACKgesvd (or LAPACKsyev if SVD is missing) */
6899: if (!skip_lapack) {
6900: PetscScalar temp_work;
6902: if (use_pod) {
6903: /* Proper Orthogonal Decomposition (POD) using the snapshot method */
6904: PetscCall(PetscMalloc1(max_constraints * max_constraints, &correlation_mat));
6905: PetscCall(PetscMalloc1(max_constraints, &singular_vals));
6906: PetscCall(PetscMalloc1(max_size_of_constraint * max_constraints, &temp_basis));
6907: #if PetscDefined(USE_COMPLEX)
6908: PetscCall(PetscMalloc1(3 * max_constraints, &rwork));
6909: #endif
6910: /* now we evaluate the optimal workspace using query with lwork=-1 */
6911: PetscCall(PetscBLASIntCast(max_constraints, &Blas_N));
6912: PetscCall(PetscBLASIntCast(max_constraints, &Blas_LDA));
6913: lwork = -1;
6914: PetscCall(PetscFPTrapPush(PETSC_FP_TRAP_OFF));
6915: #if !PetscDefined(USE_COMPLEX)
6916: PetscCallLAPACKInfo("LAPACKsyev", LAPACKsyev_("V", "U", &Blas_N, correlation_mat, &Blas_LDA, singular_vals, &temp_work, &lwork, &info));
6917: #else
6918: PetscCallLAPACKInfo("LAPACKsyev", LAPACKsyev_("V", "U", &Blas_N, correlation_mat, &Blas_LDA, singular_vals, &temp_work, &lwork, rwork, &info));
6919: #endif
6920: PetscCall(PetscFPTrapPop());
6921: } else {
6922: #if !PetscDefined(MISSING_LAPACK_GESVD)
6923: /* SVD */
6924: PetscInt max_n, min_n;
6925: max_n = max_size_of_constraint;
6926: min_n = max_constraints;
6927: if (max_size_of_constraint < max_constraints) {
6928: min_n = max_size_of_constraint;
6929: max_n = max_constraints;
6930: }
6931: PetscCall(PetscMalloc1(min_n, &singular_vals));
6932: #if PetscDefined(USE_COMPLEX)
6933: PetscCall(PetscMalloc1(5 * min_n, &rwork));
6934: #endif
6935: /* now we evaluate the optimal workspace using query with lwork=-1 */
6936: lwork = -1;
6937: PetscCall(PetscBLASIntCast(max_n, &Blas_M));
6938: PetscCall(PetscBLASIntCast(min_n, &Blas_N));
6939: PetscCall(PetscBLASIntCast(max_n, &Blas_LDA));
6940: PetscCall(PetscFPTrapPush(PETSC_FP_TRAP_OFF));
6941: #if !PetscDefined(USE_COMPLEX)
6942: PetscCallLAPACKInfo("LAPACKgesvd", LAPACKgesvd_("O", "N", &Blas_M, &Blas_N, &constraints_data[0], &Blas_LDA, singular_vals, &dummy_scalar, &dummy_int, &dummy_scalar, &dummy_int, &temp_work, &lwork, &info));
6943: #else
6944: PetscCallLAPACKInfo("LAPACKgesvd", LAPACKgesvd_("O", "N", &Blas_M, &Blas_N, &constraints_data[0], &Blas_LDA, singular_vals, &dummy_scalar, &dummy_int, &dummy_scalar, &dummy_int, &temp_work, &lwork, rwork, &info));
6945: #endif
6946: PetscCall(PetscFPTrapPop());
6947: #else
6948: SETERRQ(PETSC_COMM_SELF, PETSC_ERR_LIB, "This should not happen");
6949: #endif /* on missing GESVD */
6950: }
6951: /* Allocate optimal workspace */
6952: PetscCall(PetscBLASIntCast((PetscInt)PetscRealPart(temp_work), &lwork));
6953: PetscCall(PetscMalloc1(lwork, &work));
6954: }
6955: /* Now we can loop on constraining sets */
6956: total_counts = 0;
6957: constraints_idxs_ptr[0] = 0;
6958: constraints_data_ptr[0] = 0;
6959: /* vertices */
6960: if (n_vertices) {
6961: PetscCall(ISGetIndices(ISForVertices, (const PetscInt **)&is_indices));
6962: PetscCall(PetscArraycpy(constraints_idxs, is_indices, n_vertices));
6963: for (i = 0; i < n_vertices; i++) {
6964: constraints_n[total_counts] = 1;
6965: constraints_data[total_counts] = 1.0;
6966: constraints_idxs_ptr[total_counts + 1] = constraints_idxs_ptr[total_counts] + 1;
6967: constraints_data_ptr[total_counts + 1] = constraints_data_ptr[total_counts] + 1;
6968: total_counts++;
6969: }
6970: PetscCall(ISRestoreIndices(ISForVertices, (const PetscInt **)&is_indices));
6971: }
6973: /* edges and faces */
6974: total_counts_cc = total_counts;
6975: for (ncc = 0; ncc < n_ISForEdges + n_ISForFaces; ncc++) {
6976: IS used_is;
6977: PetscBool idxs_copied = PETSC_FALSE;
6979: if (ncc < n_ISForEdges) {
6980: used_is = ISForEdges[ncc];
6981: boolforchange = pcbddc->use_change_of_basis; /* change or not the basis on the edge */
6982: } else {
6983: used_is = ISForFaces[ncc - n_ISForEdges];
6984: boolforchange = (PetscBool)(pcbddc->use_change_of_basis && pcbddc->use_change_on_faces); /* change or not the basis on the face */
6985: }
6986: temp_constraints = 0; /* zero the number of constraints I have on this conn comp */
6988: PetscCall(ISGetSize(used_is, &size_of_constraint));
6989: if (!size_of_constraint) continue;
6990: PetscCall(ISGetIndices(used_is, (const PetscInt **)&is_indices));
6991: if (nnsp_has_cnst) {
6992: PetscScalar quad_value;
6994: PetscCall(PetscArraycpy(constraints_idxs + constraints_idxs_ptr[total_counts_cc], is_indices, size_of_constraint));
6995: idxs_copied = PETSC_TRUE;
6997: if (!pcbddc->use_nnsp_true) {
6998: quad_value = (PetscScalar)(1.0 / PetscSqrtReal((PetscReal)size_of_constraint));
6999: } else {
7000: quad_value = 1.0;
7001: }
7002: for (j = 0; j < size_of_constraint; j++) constraints_data[constraints_data_ptr[total_counts_cc] + j] = quad_value;
7003: temp_constraints++;
7004: total_counts++;
7005: }
7006: for (k = 0; k < nnsp_size; k++) {
7007: PetscReal real_value;
7008: PetscScalar *ptr_to_data;
7010: PetscCall(VecGetArrayRead(localnearnullsp[k], (const PetscScalar **)&array));
7011: ptr_to_data = &constraints_data[constraints_data_ptr[total_counts_cc] + temp_constraints * size_of_constraint];
7012: for (j = 0; j < size_of_constraint; j++) ptr_to_data[j] = array[is_indices[j]];
7013: PetscCall(VecRestoreArrayRead(localnearnullsp[k], (const PetscScalar **)&array));
7014: /* check if array is null on the connected component */
7015: PetscCall(PetscBLASIntCast(size_of_constraint, &Blas_N));
7016: PetscCallBLAS("BLASnrm2", real_value = BLASnrm2_(&Blas_N, ptr_to_data, &Blas_one));
7017: if (real_value > null_tol) { /* keep indices and values */
7018: temp_constraints++;
7019: total_counts++;
7020: if (!idxs_copied) {
7021: PetscCall(PetscArraycpy(constraints_idxs + constraints_idxs_ptr[total_counts_cc], is_indices, size_of_constraint));
7022: idxs_copied = PETSC_TRUE;
7023: }
7024: }
7025: }
7026: PetscCall(ISRestoreIndices(used_is, (const PetscInt **)&is_indices));
7027: valid_constraints = temp_constraints;
7028: if (!pcbddc->use_nnsp_true && temp_constraints) {
7029: if (temp_constraints == 1) { /* just normalize the constraint */
7030: PetscScalar norm, *ptr_to_data;
7032: ptr_to_data = &constraints_data[constraints_data_ptr[total_counts_cc]];
7033: PetscCall(PetscBLASIntCast(size_of_constraint, &Blas_N));
7034: PetscCallBLAS("BLASdot", norm = BLASdot_(&Blas_N, ptr_to_data, &Blas_one, ptr_to_data, &Blas_one));
7035: norm = 1.0 / PetscSqrtReal(PetscRealPart(norm));
7036: PetscCallBLAS("BLASscal", BLASscal_(&Blas_N, &norm, ptr_to_data, &Blas_one));
7037: } else { /* perform SVD */
7038: PetscScalar *ptr_to_data = &constraints_data[constraints_data_ptr[total_counts_cc]];
7040: if (use_pod) {
7041: /* SVD: Y = U*S*V^H -> U (eigenvectors of Y*Y^H) = Y*V*(S)^\dag
7042: POD: Y^H*Y = V*D*V^H, D = S^H*S -> U = Y*V*D^(-1/2)
7043: -> When PETSC_USE_COMPLEX and PETSC_MISSING_LAPACK_GESVD are defined
7044: the constraints basis will differ (by a complex factor with absolute value equal to 1)
7045: from that computed using LAPACKgesvd
7046: -> This is due to a different computation of eigenvectors in LAPACKheev
7047: -> The quality of the POD-computed basis will be the same */
7048: PetscCall(PetscArrayzero(correlation_mat, temp_constraints * temp_constraints));
7049: /* Store upper triangular part of correlation matrix */
7050: PetscCall(PetscBLASIntCast(size_of_constraint, &Blas_N));
7051: PetscCall(PetscFPTrapPush(PETSC_FP_TRAP_OFF));
7052: for (j = 0; j < temp_constraints; j++) {
7053: for (k = 0; k < j + 1; k++) PetscCallBLAS("BLASdot", correlation_mat[j * temp_constraints + k] = BLASdot_(&Blas_N, ptr_to_data + k * size_of_constraint, &Blas_one, ptr_to_data + j * size_of_constraint, &Blas_one));
7054: }
7055: /* compute eigenvalues and eigenvectors of correlation matrix */
7056: PetscCall(PetscBLASIntCast(temp_constraints, &Blas_N));
7057: PetscCall(PetscBLASIntCast(temp_constraints, &Blas_LDA));
7058: #if !PetscDefined(USE_COMPLEX)
7059: PetscCallLAPACKInfo("LAPACKsyev", LAPACKsyev_("V", "U", &Blas_N, correlation_mat, &Blas_LDA, singular_vals, work, &lwork, &info));
7060: #else
7061: PetscCallLAPACKInfo("LAPACKsyev", LAPACKsyev_("V", "U", &Blas_N, correlation_mat, &Blas_LDA, singular_vals, work, &lwork, rwork, &info));
7062: #endif
7063: PetscCall(PetscFPTrapPop());
7064: /* retain eigenvalues greater than tol: note that LAPACKsyev gives eigs in ascending order */
7065: j = 0;
7066: while (j < temp_constraints && singular_vals[j] / singular_vals[temp_constraints - 1] < tol) j++;
7067: total_counts = total_counts - j;
7068: valid_constraints = temp_constraints - j;
7069: /* scale and copy POD basis into used quadrature memory */
7070: PetscCall(PetscBLASIntCast(size_of_constraint, &Blas_M));
7071: PetscCall(PetscBLASIntCast(temp_constraints, &Blas_N));
7072: PetscCall(PetscBLASIntCast(temp_constraints, &Blas_K));
7073: PetscCall(PetscBLASIntCast(size_of_constraint, &Blas_LDA));
7074: PetscCall(PetscBLASIntCast(temp_constraints, &Blas_LDB));
7075: PetscCall(PetscBLASIntCast(size_of_constraint, &Blas_LDC));
7076: if (j < temp_constraints) {
7077: for (k = j; k < temp_constraints; k++) singular_vals[k] = 1.0 / PetscSqrtReal(singular_vals[k]);
7078: PetscCall(PetscFPTrapPush(PETSC_FP_TRAP_OFF));
7079: PetscCallBLAS("BLASgemm", BLASgemm_("N", "N", &Blas_M, &Blas_N, &Blas_K, &one, ptr_to_data, &Blas_LDA, correlation_mat, &Blas_LDB, &zero, temp_basis, &Blas_LDC));
7080: PetscCall(PetscFPTrapPop());
7081: for (k = 0; k < temp_constraints - j; k++) {
7082: for (PetscInt ii = 0; ii < size_of_constraint; ii++) ptr_to_data[k * size_of_constraint + ii] = singular_vals[temp_constraints - 1 - k] * temp_basis[(temp_constraints - 1 - k) * size_of_constraint + ii];
7083: }
7084: }
7085: } else {
7086: #if !PetscDefined(MISSING_LAPACK_GESVD)
7087: PetscCall(PetscBLASIntCast(size_of_constraint, &Blas_M));
7088: PetscCall(PetscBLASIntCast(temp_constraints, &Blas_N));
7089: PetscCall(PetscBLASIntCast(size_of_constraint, &Blas_LDA));
7090: PetscCall(PetscFPTrapPush(PETSC_FP_TRAP_OFF));
7091: #if !PetscDefined(USE_COMPLEX)
7092: PetscCallLAPACKInfo("LAPACKgesvd", LAPACKgesvd_("O", "N", &Blas_M, &Blas_N, ptr_to_data, &Blas_LDA, singular_vals, &dummy_scalar, &dummy_int, &dummy_scalar, &dummy_int, work, &lwork, &info));
7093: #else
7094: PetscCallLAPACKInfo("LAPACKgesvd", LAPACKgesvd_("O", "N", &Blas_M, &Blas_N, ptr_to_data, &Blas_LDA, singular_vals, &dummy_scalar, &dummy_int, &dummy_scalar, &dummy_int, work, &lwork, rwork, &info));
7095: #endif
7096: PetscCall(PetscFPTrapPop());
7097: /* retain eigenvalues greater than tol: note that LAPACKgesvd gives eigs in descending order */
7098: k = temp_constraints;
7099: if (k > size_of_constraint) k = size_of_constraint;
7100: j = 0;
7101: while (j < k && singular_vals[k - j - 1] / singular_vals[0] < tol) j++;
7102: valid_constraints = k - j;
7103: total_counts = total_counts - temp_constraints + valid_constraints;
7104: #else
7105: SETERRQ(PETSC_COMM_SELF, PETSC_ERR_LIB, "This should not happen");
7106: #endif /* on missing GESVD */
7107: }
7108: }
7109: }
7110: /* update pointers information */
7111: if (valid_constraints) {
7112: constraints_n[total_counts_cc] = valid_constraints;
7113: constraints_idxs_ptr[total_counts_cc + 1] = constraints_idxs_ptr[total_counts_cc] + size_of_constraint;
7114: constraints_data_ptr[total_counts_cc + 1] = constraints_data_ptr[total_counts_cc] + size_of_constraint * valid_constraints;
7115: /* set change_of_basis flag */
7116: if (boolforchange) PetscCall(PetscBTSet(change_basis, total_counts_cc));
7117: total_counts_cc++;
7118: }
7119: }
7120: /* free workspace */
7121: if (!skip_lapack) {
7122: PetscCall(PetscFree(work));
7123: #if PetscDefined(USE_COMPLEX)
7124: PetscCall(PetscFree(rwork));
7125: #endif
7126: PetscCall(PetscFree(singular_vals));
7127: PetscCall(PetscFree(correlation_mat));
7128: PetscCall(PetscFree(temp_basis));
7129: }
7130: for (k = 0; k < nnsp_size; k++) PetscCall(VecDestroy(&localnearnullsp[k]));
7131: PetscCall(PetscFree(localnearnullsp));
7132: /* free index sets of faces, edges and vertices */
7133: PetscCall(PCBDDCGraphRestoreCandidatesIS(pcbddc->mat_graph, &o_nf, &ISForFaces, &o_ne, &ISForEdges, &ISForVertices));
7134: } else {
7135: PCBDDCSubSchurs sub_schurs = pcbddc->sub_schurs;
7137: total_counts = 0;
7138: n_vertices = 0;
7139: if (sub_schurs->is_vertices && pcbddc->use_vertices) PetscCall(ISGetLocalSize(sub_schurs->is_vertices, &n_vertices));
7140: max_constraints = 0;
7141: total_counts_cc = 0;
7142: for (i = 0; i < sub_schurs->n_subs + n_vertices; i++) {
7143: total_counts += pcbddc->adaptive_constraints_n[i];
7144: if (pcbddc->adaptive_constraints_n[i]) total_counts_cc++;
7145: max_constraints = PetscMax(max_constraints, pcbddc->adaptive_constraints_n[i]);
7146: }
7147: constraints_idxs_ptr = pcbddc->adaptive_constraints_idxs_ptr;
7148: constraints_data_ptr = pcbddc->adaptive_constraints_data_ptr;
7149: constraints_idxs = pcbddc->adaptive_constraints_idxs;
7150: constraints_data = pcbddc->adaptive_constraints_data;
7151: /* constraints_n differs from pcbddc->adaptive_constraints_n */
7152: PetscCall(PetscMalloc1(total_counts_cc, &constraints_n));
7153: total_counts_cc = 0;
7154: for (i = 0; i < sub_schurs->n_subs + n_vertices; i++) {
7155: if (pcbddc->adaptive_constraints_n[i]) constraints_n[total_counts_cc++] = pcbddc->adaptive_constraints_n[i];
7156: }
7158: max_size_of_constraint = 0;
7159: for (i = 0; i < total_counts_cc; i++) max_size_of_constraint = PetscMax(max_size_of_constraint, constraints_idxs_ptr[i + 1] - constraints_idxs_ptr[i]);
7160: PetscCall(PetscMalloc1(constraints_idxs_ptr[total_counts_cc], &constraints_idxs_B));
7161: /* Change of basis */
7162: PetscCall(PetscBTCreate(total_counts_cc, &change_basis));
7163: if (pcbddc->use_change_of_basis) {
7164: for (i = 0; i < sub_schurs->n_subs; i++) {
7165: if (PetscBTLookup(sub_schurs->is_edge, i) || pcbddc->use_change_on_faces) PetscCall(PetscBTSet(change_basis, i + n_vertices));
7166: }
7167: }
7168: }
7169: pcbddc->local_primal_size = total_counts;
7170: PetscCall(PetscMalloc1(pcbddc->local_primal_size + pcbddc->benign_n, &pcbddc->primal_indices_local_idxs));
7172: /* map constraints_idxs in boundary numbering */
7173: if (pcbddc->use_change_of_basis) {
7174: PetscCall(ISGlobalToLocalMappingApply(pcis->BtoNmap, IS_GTOLM_DROP, constraints_idxs_ptr[total_counts_cc], constraints_idxs, &i, constraints_idxs_B));
7175: PetscCheck(i == constraints_idxs_ptr[total_counts_cc], PETSC_COMM_SELF, PETSC_ERR_PLIB, "Error in boundary numbering for constraints indices %" PetscInt_FMT " != %" PetscInt_FMT, constraints_idxs_ptr[total_counts_cc], i);
7176: }
7178: /* Create constraint matrix */
7179: PetscCall(MatCreate(PETSC_COMM_SELF, &pcbddc->ConstraintMatrix));
7180: PetscCall(MatSetType(pcbddc->ConstraintMatrix, MATAIJ));
7181: PetscCall(MatSetSizes(pcbddc->ConstraintMatrix, pcbddc->local_primal_size, pcis->n, pcbddc->local_primal_size, pcis->n));
7183: /* find primal_dofs: subdomain corners plus dofs selected as primal after change of basis */
7184: /* determine if a QR strategy is needed for change of basis */
7185: qr_needed = pcbddc->use_qr_single;
7186: PetscCall(PetscBTCreate(total_counts_cc, &qr_needed_idx));
7187: total_primal_vertices = 0;
7188: pcbddc->local_primal_size_cc = 0;
7189: for (i = 0; i < total_counts_cc; i++) {
7190: size_of_constraint = constraints_idxs_ptr[i + 1] - constraints_idxs_ptr[i];
7191: if (size_of_constraint == 1 && pcbddc->mat_graph->custom_minimal_size) {
7192: pcbddc->primal_indices_local_idxs[total_primal_vertices++] = constraints_idxs[constraints_idxs_ptr[i]];
7193: pcbddc->local_primal_size_cc += 1;
7194: } else if (PetscBTLookup(change_basis, i)) {
7195: for (k = 0; k < constraints_n[i]; k++) pcbddc->primal_indices_local_idxs[total_primal_vertices++] = constraints_idxs[constraints_idxs_ptr[i] + k];
7196: pcbddc->local_primal_size_cc += constraints_n[i];
7197: if (constraints_n[i] > 1 || pcbddc->use_qr_single) {
7198: PetscCall(PetscBTSet(qr_needed_idx, i));
7199: qr_needed = PETSC_TRUE;
7200: }
7201: } else {
7202: pcbddc->local_primal_size_cc += 1;
7203: }
7204: }
7205: /* note that the local variable n_vertices used below stores the number of pointwise constraints */
7206: pcbddc->n_vertices = total_primal_vertices;
7207: /* permute indices in order to have a sorted set of vertices */
7208: PetscCall(PetscSortInt(total_primal_vertices, pcbddc->primal_indices_local_idxs));
7209: PetscCall(PetscMalloc2(pcbddc->local_primal_size_cc + pcbddc->benign_n, &pcbddc->local_primal_ref_node, pcbddc->local_primal_size_cc + pcbddc->benign_n, &pcbddc->local_primal_ref_mult));
7210: PetscCall(PetscArraycpy(pcbddc->local_primal_ref_node, pcbddc->primal_indices_local_idxs, total_primal_vertices));
7211: for (i = 0; i < total_primal_vertices; i++) pcbddc->local_primal_ref_mult[i] = 1;
7213: /* nonzero structure of constraint matrix */
7214: /* and get reference dof for local constraints */
7215: PetscCall(PetscMalloc1(pcbddc->local_primal_size, &nnz));
7216: for (i = 0; i < total_primal_vertices; i++) nnz[i] = 1;
7218: j = total_primal_vertices;
7219: total_counts = total_primal_vertices;
7220: cum = total_primal_vertices;
7221: for (i = n_vertices; i < total_counts_cc; i++) {
7222: if (!PetscBTLookup(change_basis, i)) {
7223: pcbddc->local_primal_ref_node[cum] = constraints_idxs[constraints_idxs_ptr[i]];
7224: pcbddc->local_primal_ref_mult[cum] = constraints_n[i];
7225: cum++;
7226: size_of_constraint = constraints_idxs_ptr[i + 1] - constraints_idxs_ptr[i];
7227: for (k = 0; k < constraints_n[i]; k++) {
7228: pcbddc->primal_indices_local_idxs[total_counts++] = constraints_idxs[constraints_idxs_ptr[i] + k];
7229: nnz[j + k] = size_of_constraint;
7230: }
7231: j += constraints_n[i];
7232: }
7233: }
7234: PetscCall(MatSeqAIJSetPreallocation(pcbddc->ConstraintMatrix, 0, nnz));
7235: PetscCall(MatSetOption(pcbddc->ConstraintMatrix, MAT_NEW_NONZERO_ALLOCATION_ERR, PETSC_TRUE));
7236: PetscCall(MatSetOption(pcbddc->ConstraintMatrix, MAT_IGNORE_ZERO_ENTRIES, PETSC_TRUE));
7237: PetscCall(PetscFree(nnz));
7239: /* set values in constraint matrix */
7240: for (i = 0; i < total_primal_vertices; i++) PetscCall(MatSetValue(pcbddc->ConstraintMatrix, i, pcbddc->local_primal_ref_node[i], 1.0, INSERT_VALUES));
7241: total_counts = total_primal_vertices;
7242: for (i = n_vertices; i < total_counts_cc; i++) {
7243: if (!PetscBTLookup(change_basis, i)) {
7244: PetscInt *cols;
7246: size_of_constraint = constraints_idxs_ptr[i + 1] - constraints_idxs_ptr[i];
7247: cols = constraints_idxs + constraints_idxs_ptr[i];
7248: for (k = 0; k < constraints_n[i]; k++) {
7249: PetscInt row = total_counts + k;
7250: PetscScalar *vals;
7252: vals = constraints_data + constraints_data_ptr[i] + k * size_of_constraint;
7253: PetscCall(MatSetValues(pcbddc->ConstraintMatrix, 1, &row, size_of_constraint, cols, vals, INSERT_VALUES));
7254: }
7255: total_counts += constraints_n[i];
7256: }
7257: }
7258: /* assembling */
7259: PetscCall(MatAssemblyBegin(pcbddc->ConstraintMatrix, MAT_FINAL_ASSEMBLY));
7260: PetscCall(MatAssemblyEnd(pcbddc->ConstraintMatrix, MAT_FINAL_ASSEMBLY));
7261: PetscCall(MatViewFromOptions(pcbddc->ConstraintMatrix, (PetscObject)pc, "-pc_bddc_constraint_mat_view"));
7263: /* Create matrix for change of basis. We don't need it in case pcbddc->use_change_of_basis is FALSE */
7264: if (pcbddc->use_change_of_basis) {
7265: /* dual and primal dofs on a single cc */
7266: PetscInt dual_dofs, primal_dofs;
7267: /* working stuff for GEQRF */
7268: PetscScalar *qr_basis = NULL, *qr_tau = NULL, *qr_work = NULL, lqr_work_t;
7269: PetscBLASInt lqr_work;
7270: /* working stuff for UNGQR */
7271: PetscScalar *gqr_work = NULL, lgqr_work_t = 0.0;
7272: PetscBLASInt lgqr_work;
7273: /* working stuff for TRTRS */
7274: PetscScalar *trs_rhs = NULL;
7275: PetscBLASInt Blas_NRHS;
7276: /* pointers for values insertion into change of basis matrix */
7277: PetscInt *start_rows, *start_cols;
7278: PetscScalar *start_vals;
7279: /* working stuff for values insertion */
7280: PetscBT is_primal;
7281: PetscInt *aux_primal_numbering_B;
7282: /* matrix sizes */
7283: PetscInt global_size, local_size;
7284: /* temporary change of basis */
7285: Mat localChangeOfBasisMatrix;
7286: /* extra space for debugging */
7287: PetscScalar *dbg_work = NULL;
7289: PetscCall(MatCreate(PETSC_COMM_SELF, &localChangeOfBasisMatrix));
7290: PetscCall(MatSetType(localChangeOfBasisMatrix, MATAIJ));
7291: PetscCall(MatSetSizes(localChangeOfBasisMatrix, pcis->n, pcis->n, pcis->n, pcis->n));
7292: /* nonzeros for local mat */
7293: PetscCall(PetscMalloc1(pcis->n, &nnz));
7294: if (!pcbddc->benign_change || pcbddc->fake_change) {
7295: for (i = 0; i < pcis->n; i++) nnz[i] = 1;
7296: } else {
7297: const PetscInt *ii;
7298: PetscInt n;
7299: PetscBool flg_row;
7300: PetscCall(MatGetRowIJ(pcbddc->benign_change, 0, PETSC_FALSE, PETSC_FALSE, &n, &ii, NULL, &flg_row));
7301: for (i = 0; i < n; i++) nnz[i] = ii[i + 1] - ii[i];
7302: PetscCall(MatRestoreRowIJ(pcbddc->benign_change, 0, PETSC_FALSE, PETSC_FALSE, &n, &ii, NULL, &flg_row));
7303: }
7304: for (i = n_vertices; i < total_counts_cc; i++) {
7305: if (PetscBTLookup(change_basis, i)) {
7306: size_of_constraint = constraints_idxs_ptr[i + 1] - constraints_idxs_ptr[i];
7307: if (PetscBTLookup(qr_needed_idx, i)) {
7308: for (j = 0; j < size_of_constraint; j++) nnz[constraints_idxs[constraints_idxs_ptr[i] + j]] = size_of_constraint;
7309: } else {
7310: nnz[constraints_idxs[constraints_idxs_ptr[i]]] = size_of_constraint;
7311: for (j = 1; j < size_of_constraint; j++) nnz[constraints_idxs[constraints_idxs_ptr[i] + j]] = 2;
7312: }
7313: }
7314: }
7315: PetscCall(MatSeqAIJSetPreallocation(localChangeOfBasisMatrix, 0, nnz));
7316: PetscCall(MatSetOption(localChangeOfBasisMatrix, MAT_NEW_NONZERO_ALLOCATION_ERR, PETSC_TRUE));
7317: PetscCall(PetscFree(nnz));
7318: /* Set interior change in the matrix */
7319: if (!pcbddc->benign_change || pcbddc->fake_change) {
7320: for (i = 0; i < pcis->n; i++) PetscCall(MatSetValue(localChangeOfBasisMatrix, i, i, 1.0, INSERT_VALUES));
7321: } else {
7322: const PetscInt *ii, *jj;
7323: PetscScalar *aa;
7324: PetscInt n;
7325: PetscBool flg_row;
7326: PetscCall(MatGetRowIJ(pcbddc->benign_change, 0, PETSC_FALSE, PETSC_FALSE, &n, &ii, &jj, &flg_row));
7327: PetscCall(MatSeqAIJGetArray(pcbddc->benign_change, &aa));
7328: for (i = 0; i < n; i++) PetscCall(MatSetValues(localChangeOfBasisMatrix, 1, &i, ii[i + 1] - ii[i], jj + ii[i], aa + ii[i], INSERT_VALUES));
7329: PetscCall(MatSeqAIJRestoreArray(pcbddc->benign_change, &aa));
7330: PetscCall(MatRestoreRowIJ(pcbddc->benign_change, 0, PETSC_FALSE, PETSC_FALSE, &n, &ii, &jj, &flg_row));
7331: }
7333: if (pcbddc->dbg_flag) {
7334: PetscCall(PetscViewerASCIISynchronizedPrintf(pcbddc->dbg_viewer, "--------------------------------------------------------------\n"));
7335: PetscCall(PetscViewerASCIISynchronizedPrintf(pcbddc->dbg_viewer, "Checking change of basis computation for subdomain %04d\n", PetscGlobalRank));
7336: }
7338: /* Now we loop on the constraints which need a change of basis */
7339: /*
7340: Change of basis matrix is evaluated similarly to the FIRST APPROACH in
7341: Klawonn and Widlund, Dual-primal FETI-DP methods for linear elasticity, (see Sect 6.2.1)
7343: Basic blocks of change of basis matrix T computed:
7345: - By using the following block transformation if there is only a primal dof on the cc (and -pc_bddc_use_qr_single is not specified)
7347: | 1 0 ... 0 s_1/S |
7348: | 0 1 ... 0 s_2/S |
7349: | ... |
7350: | 0 ... 1 s_{n-1}/S |
7351: | -s_1/s_n ... -s_{n-1}/s_n s_n/S |
7353: with S = \sum_{i=1}^n s_i^2
7354: NOTE: in the above example, the primal dof is the last one of the edge in LOCAL ordering
7355: in the current implementation, the primal dof is the first one of the edge in GLOBAL ordering
7357: - QR decomposition of constraints otherwise
7358: */
7359: if (qr_needed && max_size_of_constraint) {
7360: /* space to store Q */
7361: PetscCall(PetscMalloc1(max_size_of_constraint * max_size_of_constraint, &qr_basis));
7362: /* array to store scaling factors for reflectors */
7363: PetscCall(PetscMalloc1(max_constraints, &qr_tau));
7364: /* first we issue queries for optimal work */
7365: PetscCall(PetscBLASIntCast(max_size_of_constraint, &Blas_M));
7366: PetscCall(PetscBLASIntCast(max_constraints, &Blas_N));
7367: PetscCall(PetscBLASIntCast(max_size_of_constraint, &Blas_LDA));
7368: lqr_work = -1;
7369: PetscCallLAPACKInfo("LAPACKgeqrf", LAPACKgeqrf_(&Blas_M, &Blas_N, qr_basis, &Blas_LDA, qr_tau, &lqr_work_t, &lqr_work, &info));
7370: PetscCall(PetscBLASIntCast((PetscInt)PetscRealPart(lqr_work_t), &lqr_work));
7371: PetscCall(PetscMalloc1(lqr_work, &qr_work));
7372: lgqr_work = -1;
7373: PetscCall(PetscBLASIntCast(max_size_of_constraint, &Blas_M));
7374: PetscCall(PetscBLASIntCast(max_size_of_constraint, &Blas_N));
7375: PetscCall(PetscBLASIntCast(max_constraints, &Blas_K));
7376: PetscCall(PetscBLASIntCast(max_size_of_constraint, &Blas_LDA));
7377: if (Blas_K > Blas_M) Blas_K = Blas_M; /* adjust just for computing optimal work */
7378: PetscCallLAPACKInfo("LAPACKorgqr", LAPACKorgqr_(&Blas_M, &Blas_N, &Blas_K, qr_basis, &Blas_LDA, qr_tau, &lgqr_work_t, &lgqr_work, &info));
7379: PetscCall(PetscBLASIntCast((PetscInt)PetscRealPart(lgqr_work_t), &lgqr_work));
7380: PetscCall(PetscMalloc1(lgqr_work, &gqr_work));
7381: /* array to store rhs and solution of triangular solver */
7382: PetscCall(PetscMalloc1(max_constraints * max_constraints, &trs_rhs));
7383: /* allocating workspace for check */
7384: if (pcbddc->dbg_flag) PetscCall(PetscMalloc1(max_size_of_constraint * (max_constraints + max_size_of_constraint), &dbg_work));
7385: }
7386: /* array to store whether a node is primal or not */
7387: PetscCall(PetscBTCreate(pcis->n_B, &is_primal));
7388: PetscCall(PetscMalloc1(total_primal_vertices, &aux_primal_numbering_B));
7389: PetscCall(ISGlobalToLocalMappingApply(pcis->BtoNmap, IS_GTOLM_DROP, total_primal_vertices, pcbddc->local_primal_ref_node, &i, aux_primal_numbering_B));
7390: PetscCheck(i == total_primal_vertices, PETSC_COMM_SELF, PETSC_ERR_PLIB, "Error in boundary numbering for BDDC vertices! %" PetscInt_FMT " != %" PetscInt_FMT, total_primal_vertices, i);
7391: for (i = 0; i < total_primal_vertices; i++) PetscCall(PetscBTSet(is_primal, aux_primal_numbering_B[i]));
7392: PetscCall(PetscFree(aux_primal_numbering_B));
7394: /* loop on constraints and see whether or not they need a change of basis and compute it */
7395: for (total_counts = n_vertices; total_counts < total_counts_cc; total_counts++) {
7396: size_of_constraint = constraints_idxs_ptr[total_counts + 1] - constraints_idxs_ptr[total_counts];
7397: if (PetscBTLookup(change_basis, total_counts)) {
7398: /* get constraint info */
7399: primal_dofs = constraints_n[total_counts];
7400: dual_dofs = size_of_constraint - primal_dofs;
7402: if (pcbddc->dbg_flag) PetscCall(PetscViewerASCIISynchronizedPrintf(pcbddc->dbg_viewer, "Constraints %" PetscInt_FMT ": %" PetscInt_FMT " need a change of basis (size %" PetscInt_FMT ")\n", total_counts, primal_dofs, size_of_constraint));
7404: if (PetscBTLookup(qr_needed_idx, total_counts)) { /* QR */
7406: /* copy quadrature constraints for change of basis check */
7407: if (pcbddc->dbg_flag) PetscCall(PetscArraycpy(dbg_work, &constraints_data[constraints_data_ptr[total_counts]], size_of_constraint * primal_dofs));
7408: /* copy temporary constraints into larger work vector (in order to store all columns of Q) */
7409: PetscCall(PetscArraycpy(qr_basis, &constraints_data[constraints_data_ptr[total_counts]], size_of_constraint * primal_dofs));
7411: /* compute QR decomposition of constraints */
7412: PetscCall(PetscBLASIntCast(size_of_constraint, &Blas_M));
7413: PetscCall(PetscBLASIntCast(primal_dofs, &Blas_N));
7414: PetscCall(PetscBLASIntCast(size_of_constraint, &Blas_LDA));
7415: PetscCall(PetscFPTrapPush(PETSC_FP_TRAP_OFF));
7416: PetscCallLAPACKInfo("LAPACKgeqrf", LAPACKgeqrf_(&Blas_M, &Blas_N, qr_basis, &Blas_LDA, qr_tau, qr_work, &lqr_work, &info));
7417: PetscCall(PetscFPTrapPop());
7419: /* explicitly compute R^-T */
7420: PetscCall(PetscArrayzero(trs_rhs, primal_dofs * primal_dofs));
7421: for (j = 0; j < primal_dofs; j++) trs_rhs[j * (primal_dofs + 1)] = 1.0;
7422: PetscCall(PetscBLASIntCast(primal_dofs, &Blas_N));
7423: PetscCall(PetscBLASIntCast(primal_dofs, &Blas_NRHS));
7424: PetscCall(PetscBLASIntCast(size_of_constraint, &Blas_LDA));
7425: PetscCall(PetscBLASIntCast(primal_dofs, &Blas_LDB));
7426: PetscCall(PetscFPTrapPush(PETSC_FP_TRAP_OFF));
7427: PetscCallLAPACKInfo("LAPACKtrtrs", LAPACKtrtrs_("U", "T", "N", &Blas_N, &Blas_NRHS, qr_basis, &Blas_LDA, trs_rhs, &Blas_LDB, &info));
7428: PetscCall(PetscFPTrapPop());
7430: /* explicitly compute all columns of Q (Q = [Q1 | Q2]) overwriting QR factorization in qr_basis */
7431: PetscCall(PetscBLASIntCast(size_of_constraint, &Blas_M));
7432: PetscCall(PetscBLASIntCast(size_of_constraint, &Blas_N));
7433: PetscCall(PetscBLASIntCast(primal_dofs, &Blas_K));
7434: PetscCall(PetscBLASIntCast(size_of_constraint, &Blas_LDA));
7435: PetscCall(PetscFPTrapPush(PETSC_FP_TRAP_OFF));
7436: PetscCallLAPACKInfo("LAPACKorgqr", LAPACKorgqr_(&Blas_M, &Blas_N, &Blas_K, qr_basis, &Blas_LDA, qr_tau, gqr_work, &lgqr_work, &info));
7437: PetscCall(PetscFPTrapPop());
7439: /* first primal_dofs columns of Q need to be re-scaled in order to be unitary w.r.t constraints
7440: i.e. C_{pxn}*Q_{nxn} should be equal to [I_pxp | 0_pxd] (see check below)
7441: where n=size_of_constraint, p=primal_dofs, d=dual_dofs (n=p+d), I and 0 identity and null matrix resp. */
7442: PetscCall(PetscBLASIntCast(size_of_constraint, &Blas_M));
7443: PetscCall(PetscBLASIntCast(primal_dofs, &Blas_N));
7444: PetscCall(PetscBLASIntCast(primal_dofs, &Blas_K));
7445: PetscCall(PetscBLASIntCast(size_of_constraint, &Blas_LDA));
7446: PetscCall(PetscBLASIntCast(primal_dofs, &Blas_LDB));
7447: PetscCall(PetscBLASIntCast(size_of_constraint, &Blas_LDC));
7448: PetscCall(PetscFPTrapPush(PETSC_FP_TRAP_OFF));
7449: PetscCallBLAS("BLASgemm", BLASgemm_("N", "N", &Blas_M, &Blas_N, &Blas_K, &one, qr_basis, &Blas_LDA, trs_rhs, &Blas_LDB, &zero, constraints_data + constraints_data_ptr[total_counts], &Blas_LDC));
7450: PetscCall(PetscFPTrapPop());
7451: PetscCall(PetscArraycpy(qr_basis, &constraints_data[constraints_data_ptr[total_counts]], size_of_constraint * primal_dofs));
7453: /* insert values in change of basis matrix respecting global ordering of new primal dofs */
7454: start_rows = &constraints_idxs[constraints_idxs_ptr[total_counts]];
7455: /* insert cols for primal dofs */
7456: for (j = 0; j < primal_dofs; j++) {
7457: start_vals = &qr_basis[j * size_of_constraint];
7458: start_cols = &constraints_idxs[constraints_idxs_ptr[total_counts] + j];
7459: PetscCall(MatSetValues(localChangeOfBasisMatrix, size_of_constraint, start_rows, 1, start_cols, start_vals, INSERT_VALUES));
7460: }
7461: /* insert cols for dual dofs */
7462: for (j = 0, k = 0; j < dual_dofs; k++) {
7463: if (!PetscBTLookup(is_primal, constraints_idxs_B[constraints_idxs_ptr[total_counts] + k])) {
7464: start_vals = &qr_basis[(primal_dofs + j) * size_of_constraint];
7465: start_cols = &constraints_idxs[constraints_idxs_ptr[total_counts] + k];
7466: PetscCall(MatSetValues(localChangeOfBasisMatrix, size_of_constraint, start_rows, 1, start_cols, start_vals, INSERT_VALUES));
7467: j++;
7468: }
7469: }
7471: /* check change of basis */
7472: if (pcbddc->dbg_flag) {
7473: PetscBool valid_qr = PETSC_TRUE;
7474: PetscCall(PetscBLASIntCast(primal_dofs, &Blas_M));
7475: PetscCall(PetscBLASIntCast(size_of_constraint, &Blas_N));
7476: PetscCall(PetscBLASIntCast(size_of_constraint, &Blas_K));
7477: PetscCall(PetscBLASIntCast(size_of_constraint, &Blas_LDA));
7478: PetscCall(PetscBLASIntCast(size_of_constraint, &Blas_LDB));
7479: PetscCall(PetscBLASIntCast(primal_dofs, &Blas_LDC));
7480: PetscCall(PetscFPTrapPush(PETSC_FP_TRAP_OFF));
7481: PetscCallBLAS("BLASgemm", BLASgemm_("T", "N", &Blas_M, &Blas_N, &Blas_K, &one, dbg_work, &Blas_LDA, qr_basis, &Blas_LDB, &zero, &dbg_work[size_of_constraint * primal_dofs], &Blas_LDC));
7482: PetscCall(PetscFPTrapPop());
7483: for (PetscInt jj = 0; jj < size_of_constraint; jj++) {
7484: for (PetscInt ii = 0; ii < primal_dofs; ii++) {
7485: if (ii != jj && PetscAbsScalar(dbg_work[size_of_constraint * primal_dofs + jj * primal_dofs + ii]) > 1.e-12) valid_qr = PETSC_FALSE;
7486: if (ii == jj && PetscAbsScalar(dbg_work[size_of_constraint * primal_dofs + jj * primal_dofs + ii] - (PetscReal)1) > 1.e-12) valid_qr = PETSC_FALSE;
7487: }
7488: }
7489: if (!valid_qr) {
7490: PetscCall(PetscViewerASCIISynchronizedPrintf(pcbddc->dbg_viewer, "\t-> wrong change of basis!\n"));
7491: for (PetscInt jj = 0; jj < size_of_constraint; jj++) {
7492: for (PetscInt ii = 0; ii < primal_dofs; ii++) {
7493: if (ii != jj && PetscAbsScalar(dbg_work[size_of_constraint * primal_dofs + jj * primal_dofs + ii]) > 1.e-12) {
7494: PetscCall(PetscViewerASCIISynchronizedPrintf(pcbddc->dbg_viewer, "\tQr basis function %" PetscInt_FMT " is not orthogonal to constraint %" PetscInt_FMT " (%1.14e)!\n", jj, ii, (double)PetscAbsScalar(dbg_work[size_of_constraint * primal_dofs + jj * primal_dofs + ii])));
7495: }
7496: if (ii == jj && PetscAbsScalar(dbg_work[size_of_constraint * primal_dofs + jj * primal_dofs + ii] - (PetscReal)1) > 1.e-12) {
7497: PetscCall(PetscViewerASCIISynchronizedPrintf(pcbddc->dbg_viewer, "\tQr basis function %" PetscInt_FMT " is not unitary w.r.t constraint %" PetscInt_FMT " (%1.14e)!\n", jj, ii, (double)PetscAbsScalar(dbg_work[size_of_constraint * primal_dofs + jj * primal_dofs + ii])));
7498: }
7499: }
7500: }
7501: } else {
7502: PetscCall(PetscViewerASCIISynchronizedPrintf(pcbddc->dbg_viewer, "\t-> right change of basis!\n"));
7503: }
7504: }
7505: } else { /* simple transformation block */
7506: PetscInt row, col;
7507: PetscScalar val, norm;
7509: PetscCall(PetscBLASIntCast(size_of_constraint, &Blas_N));
7510: PetscCallBLAS("BLASdot", norm = BLASdot_(&Blas_N, constraints_data + constraints_data_ptr[total_counts], &Blas_one, constraints_data + constraints_data_ptr[total_counts], &Blas_one));
7511: for (j = 0; j < size_of_constraint; j++) {
7512: PetscInt row_B = constraints_idxs_B[constraints_idxs_ptr[total_counts] + j];
7513: row = constraints_idxs[constraints_idxs_ptr[total_counts] + j];
7514: if (!PetscBTLookup(is_primal, row_B)) {
7515: col = constraints_idxs[constraints_idxs_ptr[total_counts]];
7516: PetscCall(MatSetValue(localChangeOfBasisMatrix, row, row, 1.0, INSERT_VALUES));
7517: PetscCall(MatSetValue(localChangeOfBasisMatrix, row, col, constraints_data[constraints_data_ptr[total_counts] + j] / norm, INSERT_VALUES));
7518: } else {
7519: for (k = 0; k < size_of_constraint; k++) {
7520: col = constraints_idxs[constraints_idxs_ptr[total_counts] + k];
7521: if (row != col) {
7522: val = -constraints_data[constraints_data_ptr[total_counts] + k] / constraints_data[constraints_data_ptr[total_counts]];
7523: } else {
7524: val = constraints_data[constraints_data_ptr[total_counts]] / norm;
7525: }
7526: PetscCall(MatSetValue(localChangeOfBasisMatrix, row, col, val, INSERT_VALUES));
7527: }
7528: }
7529: }
7530: if (pcbddc->dbg_flag) PetscCall(PetscViewerASCIISynchronizedPrintf(pcbddc->dbg_viewer, "\t-> using standard change of basis\n"));
7531: }
7532: } else {
7533: if (pcbddc->dbg_flag) PetscCall(PetscViewerASCIISynchronizedPrintf(pcbddc->dbg_viewer, "Constraint %" PetscInt_FMT " does not need a change of basis (size %" PetscInt_FMT ")\n", total_counts, size_of_constraint));
7534: }
7535: }
7537: /* free workspace */
7538: if (qr_needed) {
7539: if (pcbddc->dbg_flag) PetscCall(PetscFree(dbg_work));
7540: PetscCall(PetscFree(trs_rhs));
7541: PetscCall(PetscFree(qr_tau));
7542: PetscCall(PetscFree(qr_work));
7543: PetscCall(PetscFree(gqr_work));
7544: PetscCall(PetscFree(qr_basis));
7545: }
7546: PetscCall(PetscBTDestroy(&is_primal));
7547: PetscCall(MatAssemblyBegin(localChangeOfBasisMatrix, MAT_FINAL_ASSEMBLY));
7548: PetscCall(MatAssemblyEnd(localChangeOfBasisMatrix, MAT_FINAL_ASSEMBLY));
7550: /* assembling of global change of variable */
7551: if (!pcbddc->fake_change) {
7552: Mat tmat;
7554: PetscCall(VecGetSize(pcis->vec1_global, &global_size));
7555: PetscCall(VecGetLocalSize(pcis->vec1_global, &local_size));
7556: PetscCall(MatDuplicate(pc->pmat, MAT_DO_NOT_COPY_VALUES, &tmat));
7557: PetscCall(MatISSetLocalMat(tmat, localChangeOfBasisMatrix));
7558: PetscCall(MatAssemblyBegin(tmat, MAT_FINAL_ASSEMBLY));
7559: PetscCall(MatAssemblyEnd(tmat, MAT_FINAL_ASSEMBLY));
7560: PetscCall(MatConvert(tmat, MATAIJ, MAT_INITIAL_MATRIX, &pcbddc->ChangeOfBasisMatrix));
7561: PetscCall(MatDestroy(&tmat));
7562: PetscCall(VecSet(pcis->vec1_global, 0.0));
7563: PetscCall(VecSet(pcis->vec1_N, 1.0));
7564: PetscCall(VecScatterBegin(matis->rctx, pcis->vec1_N, pcis->vec1_global, ADD_VALUES, SCATTER_REVERSE));
7565: PetscCall(VecScatterEnd(matis->rctx, pcis->vec1_N, pcis->vec1_global, ADD_VALUES, SCATTER_REVERSE));
7566: PetscCall(VecReciprocal(pcis->vec1_global));
7567: PetscCall(MatDiagonalScale(pcbddc->ChangeOfBasisMatrix, pcis->vec1_global, NULL));
7569: /* check */
7570: if (pcbddc->dbg_flag) {
7571: PetscReal error;
7572: Vec x, x_change;
7574: PetscCall(VecDuplicate(pcis->vec1_global, &x));
7575: PetscCall(VecDuplicate(pcis->vec1_global, &x_change));
7576: PetscCall(VecSetRandom(x, NULL));
7577: PetscCall(VecCopy(x, pcis->vec1_global));
7578: PetscCall(VecScatterBegin(matis->rctx, x, pcis->vec1_N, INSERT_VALUES, SCATTER_FORWARD));
7579: PetscCall(VecScatterEnd(matis->rctx, x, pcis->vec1_N, INSERT_VALUES, SCATTER_FORWARD));
7580: PetscCall(MatMult(localChangeOfBasisMatrix, pcis->vec1_N, pcis->vec2_N));
7581: PetscCall(VecScatterBegin(matis->rctx, pcis->vec2_N, x, INSERT_VALUES, SCATTER_REVERSE));
7582: PetscCall(VecScatterEnd(matis->rctx, pcis->vec2_N, x, INSERT_VALUES, SCATTER_REVERSE));
7583: PetscCall(MatMult(pcbddc->ChangeOfBasisMatrix, pcis->vec1_global, x_change));
7584: PetscCall(VecAXPY(x, -1.0, x_change));
7585: PetscCall(VecNorm(x, NORM_INFINITY, &error));
7586: PetscCheck(error <= PETSC_SMALL, PetscObjectComm((PetscObject)pc), PETSC_ERR_PLIB, "Error global vs local change on N: %1.6e", (double)error);
7587: PetscCall(VecDestroy(&x));
7588: PetscCall(VecDestroy(&x_change));
7589: }
7590: /* adapt sub_schurs computed (if any) */
7591: if (pcbddc->use_deluxe_scaling) {
7592: PCBDDCSubSchurs sub_schurs = pcbddc->sub_schurs;
7594: PetscCheck(!pcbddc->use_change_of_basis || !pcbddc->adaptive_userdefined, PetscObjectComm((PetscObject)pc), PETSC_ERR_SUP, "Cannot mix automatic change of basis, adaptive selection and user-defined constraints");
7595: if (sub_schurs && sub_schurs->S_Ej_all) {
7596: Mat S_new, tmat;
7597: IS is_all_N, is_V_Sall = NULL;
7599: PetscCall(ISLocalToGlobalMappingApplyIS(pcis->BtoNmap, sub_schurs->is_Ej_all, &is_all_N));
7600: PetscCall(MatCreateSubMatrix(localChangeOfBasisMatrix, is_all_N, is_all_N, MAT_INITIAL_MATRIX, &tmat));
7601: if (pcbddc->deluxe_zerorows) {
7602: ISLocalToGlobalMapping NtoSall;
7603: IS is_V;
7604: PetscCall(ISCreateGeneral(PETSC_COMM_SELF, pcbddc->n_vertices, pcbddc->local_primal_ref_node, PETSC_COPY_VALUES, &is_V));
7605: PetscCall(ISLocalToGlobalMappingCreateIS(is_all_N, &NtoSall));
7606: PetscCall(ISGlobalToLocalMappingApplyIS(NtoSall, IS_GTOLM_DROP, is_V, &is_V_Sall));
7607: PetscCall(ISLocalToGlobalMappingDestroy(&NtoSall));
7608: PetscCall(ISDestroy(&is_V));
7609: }
7610: PetscCall(ISDestroy(&is_all_N));
7611: PetscCall(MatPtAP(sub_schurs->S_Ej_all, tmat, MAT_INITIAL_MATRIX, 1.0, &S_new));
7612: PetscCall(MatDestroy(&sub_schurs->S_Ej_all));
7613: PetscCall(PetscObjectReference((PetscObject)S_new));
7614: if (pcbddc->deluxe_zerorows) {
7615: const PetscScalar *array;
7616: const PetscInt *idxs_V, *idxs_all;
7617: PetscInt n_V;
7619: PetscCall(MatZeroRowsColumnsIS(S_new, is_V_Sall, 1., NULL, NULL));
7620: PetscCall(ISGetLocalSize(is_V_Sall, &n_V));
7621: PetscCall(ISGetIndices(is_V_Sall, &idxs_V));
7622: PetscCall(ISGetIndices(sub_schurs->is_Ej_all, &idxs_all));
7623: PetscCall(VecGetArrayRead(pcis->D, &array));
7624: for (PetscInt i = 0; i < n_V; i++) {
7625: PetscScalar val;
7626: PetscInt idx;
7628: idx = idxs_V[i];
7629: val = array[idxs_all[idxs_V[i]]];
7630: PetscCall(MatSetValue(S_new, idx, idx, val, INSERT_VALUES));
7631: }
7632: PetscCall(MatAssemblyBegin(S_new, MAT_FINAL_ASSEMBLY));
7633: PetscCall(MatAssemblyEnd(S_new, MAT_FINAL_ASSEMBLY));
7634: PetscCall(VecRestoreArrayRead(pcis->D, &array));
7635: PetscCall(ISRestoreIndices(sub_schurs->is_Ej_all, &idxs_all));
7636: PetscCall(ISRestoreIndices(is_V_Sall, &idxs_V));
7637: }
7638: sub_schurs->S_Ej_all = S_new;
7639: PetscCall(MatDestroy(&S_new));
7640: if (sub_schurs->sum_S_Ej_all) {
7641: PetscCall(MatPtAP(sub_schurs->sum_S_Ej_all, tmat, MAT_INITIAL_MATRIX, 1.0, &S_new));
7642: PetscCall(MatDestroy(&sub_schurs->sum_S_Ej_all));
7643: PetscCall(PetscObjectReference((PetscObject)S_new));
7644: if (pcbddc->deluxe_zerorows) PetscCall(MatZeroRowsColumnsIS(S_new, is_V_Sall, 1., NULL, NULL));
7645: sub_schurs->sum_S_Ej_all = S_new;
7646: PetscCall(MatDestroy(&S_new));
7647: }
7648: PetscCall(ISDestroy(&is_V_Sall));
7649: PetscCall(MatDestroy(&tmat));
7650: }
7651: /* destroy any change of basis context in sub_schurs */
7652: if (sub_schurs && sub_schurs->change) {
7653: for (PetscInt i = 0; i < sub_schurs->n_subs; i++) PetscCall(KSPDestroy(&sub_schurs->change[i]));
7654: PetscCall(PetscFree(sub_schurs->change));
7655: }
7656: }
7657: if (pcbddc->switch_static) { /* need to save the local change */
7658: pcbddc->switch_static_change = localChangeOfBasisMatrix;
7659: } else {
7660: PetscCall(MatDestroy(&localChangeOfBasisMatrix));
7661: }
7662: /* determine if any process has changed the pressures locally */
7663: pcbddc->change_interior = pcbddc->benign_have_null;
7664: } else { /* fake change (get back change of basis into ConstraintMatrix and info on qr) */
7665: PetscCall(MatDestroy(&pcbddc->ConstraintMatrix));
7666: pcbddc->ConstraintMatrix = localChangeOfBasisMatrix;
7667: pcbddc->use_qr_single = qr_needed;
7668: }
7669: } else if (pcbddc->user_ChangeOfBasisMatrix || pcbddc->benign_saddle_point) {
7670: if (!pcbddc->benign_have_null && pcbddc->user_ChangeOfBasisMatrix) {
7671: PetscCall(PetscObjectReference((PetscObject)pcbddc->user_ChangeOfBasisMatrix));
7672: pcbddc->ChangeOfBasisMatrix = pcbddc->user_ChangeOfBasisMatrix;
7673: } else {
7674: Mat benign_global = NULL;
7675: if (pcbddc->benign_have_null) {
7676: Mat M;
7678: pcbddc->change_interior = PETSC_TRUE;
7679: PetscCall(VecCopy(matis->counter, pcis->vec1_N));
7680: PetscCall(VecReciprocal(pcis->vec1_N));
7681: PetscCall(MatDuplicate(pc->pmat, MAT_DO_NOT_COPY_VALUES, &benign_global));
7682: if (pcbddc->benign_change) {
7683: PetscCall(MatDuplicate(pcbddc->benign_change, MAT_COPY_VALUES, &M));
7684: PetscCall(MatDiagonalScale(M, pcis->vec1_N, NULL));
7685: } else {
7686: PetscCall(MatCreateSeqAIJ(PETSC_COMM_SELF, pcis->n, pcis->n, 1, NULL, &M));
7687: PetscCall(MatDiagonalSet(M, pcis->vec1_N, INSERT_VALUES));
7688: }
7689: PetscCall(MatISSetLocalMat(benign_global, M));
7690: PetscCall(MatDestroy(&M));
7691: PetscCall(MatAssemblyBegin(benign_global, MAT_FINAL_ASSEMBLY));
7692: PetscCall(MatAssemblyEnd(benign_global, MAT_FINAL_ASSEMBLY));
7693: }
7694: if (pcbddc->user_ChangeOfBasisMatrix) {
7695: PetscCall(MatMatMult(pcbddc->user_ChangeOfBasisMatrix, benign_global, MAT_INITIAL_MATRIX, PETSC_DETERMINE, &pcbddc->ChangeOfBasisMatrix));
7696: PetscCall(MatDestroy(&benign_global));
7697: } else if (pcbddc->benign_have_null) {
7698: pcbddc->ChangeOfBasisMatrix = benign_global;
7699: }
7700: }
7701: if (pcbddc->switch_static && pcbddc->ChangeOfBasisMatrix) { /* need to save the local change */
7702: IS is_global;
7703: const PetscInt *gidxs;
7705: PetscCall(ISLocalToGlobalMappingGetIndices(matis->rmapping, &gidxs));
7706: PetscCall(ISCreateGeneral(PetscObjectComm((PetscObject)pc), pcis->n, gidxs, PETSC_COPY_VALUES, &is_global));
7707: PetscCall(ISLocalToGlobalMappingRestoreIndices(matis->rmapping, &gidxs));
7708: PetscCall(MatCreateSubMatrixUnsorted(pcbddc->ChangeOfBasisMatrix, is_global, is_global, &pcbddc->switch_static_change));
7709: PetscCall(ISDestroy(&is_global));
7710: }
7711: }
7712: if (!pcbddc->fake_change && pcbddc->ChangeOfBasisMatrix && !pcbddc->work_change) PetscCall(VecDuplicate(pcis->vec1_global, &pcbddc->work_change));
7714: if (!pcbddc->fake_change) {
7715: /* add pressure dofs to set of primal nodes for numbering purposes */
7716: for (i = 0; i < pcbddc->benign_n; i++) {
7717: pcbddc->local_primal_ref_node[pcbddc->local_primal_size_cc] = pcbddc->benign_p0_lidx[i];
7718: pcbddc->primal_indices_local_idxs[pcbddc->local_primal_size] = pcbddc->benign_p0_lidx[i];
7719: pcbddc->local_primal_ref_mult[pcbddc->local_primal_size_cc] = 1;
7720: pcbddc->local_primal_size_cc++;
7721: pcbddc->local_primal_size++;
7722: }
7724: /* check if a new primal space has been introduced (also take into account benign trick) */
7725: pcbddc->new_primal_space_local = PETSC_TRUE;
7726: if (olocal_primal_size == pcbddc->local_primal_size) {
7727: PetscCall(PetscArraycmp(pcbddc->local_primal_ref_node, olocal_primal_ref_node, olocal_primal_size_cc, &pcbddc->new_primal_space_local));
7728: pcbddc->new_primal_space_local = (PetscBool)(!pcbddc->new_primal_space_local);
7729: if (!pcbddc->new_primal_space_local) {
7730: PetscCall(PetscArraycmp(pcbddc->local_primal_ref_mult, olocal_primal_ref_mult, olocal_primal_size_cc, &pcbddc->new_primal_space_local));
7731: pcbddc->new_primal_space_local = (PetscBool)(!pcbddc->new_primal_space_local);
7732: }
7733: }
7734: /* new_primal_space will be used for numbering of coarse dofs, so it should be the same across all subdomains */
7735: PetscCallMPI(MPIU_Allreduce(&pcbddc->new_primal_space_local, &pcbddc->new_primal_space, 1, MPI_C_BOOL, MPI_LOR, PetscObjectComm((PetscObject)pc)));
7736: }
7737: PetscCall(PetscFree2(olocal_primal_ref_node, olocal_primal_ref_mult));
7739: /* flush dbg viewer */
7740: if (pcbddc->dbg_flag) PetscCall(PetscViewerFlush(pcbddc->dbg_viewer));
7742: /* free workspace */
7743: PetscCall(PetscBTDestroy(&qr_needed_idx));
7744: PetscCall(PetscBTDestroy(&change_basis));
7745: if (!pcbddc->adaptive_selection) {
7746: PetscCall(PetscFree3(constraints_idxs_ptr, constraints_data_ptr, constraints_n));
7747: PetscCall(PetscFree3(constraints_data, constraints_idxs, constraints_idxs_B));
7748: } else {
7749: PetscCall(PetscFree5(pcbddc->adaptive_constraints_n, pcbddc->adaptive_constraints_idxs_ptr, pcbddc->adaptive_constraints_data_ptr, pcbddc->adaptive_constraints_idxs, pcbddc->adaptive_constraints_data));
7750: PetscCall(PetscFree(constraints_n));
7751: PetscCall(PetscFree(constraints_idxs_B));
7752: }
7753: PetscFunctionReturn(PETSC_SUCCESS);
7754: }
7756: PetscErrorCode PCBDDCAnalyzeInterface(PC pc)
7757: {
7758: ISLocalToGlobalMapping map;
7759: PC_BDDC *pcbddc = (PC_BDDC *)pc->data;
7760: Mat_IS *matis = (Mat_IS *)pc->pmat->data;
7761: PetscInt i, N;
7762: PetscBool rcsr = PETSC_FALSE;
7764: PetscFunctionBegin;
7765: if (pcbddc->recompute_topography) {
7766: pcbddc->graphanalyzed = PETSC_FALSE;
7767: /* Reset previously computed graph */
7768: PetscCall(PCBDDCGraphReset(pcbddc->mat_graph));
7769: /* Init local Graph struct */
7770: PetscCall(MatGetSize(pc->pmat, &N, NULL));
7771: PetscCall(MatISGetLocalToGlobalMapping(pc->pmat, &map, NULL));
7772: PetscCall(PCBDDCGraphInit(pcbddc->mat_graph, map, N, pcbddc->graphmaxcount));
7774: if (pcbddc->user_primal_vertices_local && !pcbddc->user_primal_vertices) PetscCall(PCBDDCConsistencyCheckIS(pc, MPI_LOR, &pcbddc->user_primal_vertices_local));
7775: /* Check validity of the csr graph passed in by the user */
7776: PetscCheck(!pcbddc->mat_graph->nvtxs_csr || pcbddc->mat_graph->nvtxs_csr == pcbddc->mat_graph->nvtxs, PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "Invalid size of local CSR graph! Found %" PetscInt_FMT ", expected %" PetscInt_FMT, pcbddc->mat_graph->nvtxs_csr,
7777: pcbddc->mat_graph->nvtxs);
7779: /* Set default CSR adjacency of local dofs if not provided by the user with PCBDDCSetLocalAdjacencyGraph */
7780: if (!pcbddc->mat_graph->xadj && pcbddc->use_local_adj) {
7781: PetscInt *xadj, *adjncy;
7782: PetscInt nvtxs;
7783: PetscBool flg_row;
7784: Mat A;
7786: PetscCall(PetscObjectReference((PetscObject)matis->A));
7787: A = matis->A;
7788: for (PetscInt i = 0; i < pcbddc->local_adj_square; i++) {
7789: Mat AtA;
7791: PetscCall(MatProductCreate(A, A, NULL, &AtA));
7792: PetscCall(MatSetOption(AtA, MAT_STRUCTURE_ONLY, PETSC_TRUE));
7793: PetscCall(MatSetOptionsPrefix(AtA, "pc_bddc_graph_"));
7794: PetscCall(MatProductSetType(AtA, MATPRODUCT_AtB));
7795: PetscCall(MatProductSetFromOptions(AtA));
7796: PetscCall(MatProductSymbolic(AtA));
7797: PetscCall(MatProductClear(AtA));
7798: PetscCall(MatDestroy(&A));
7799: A = AtA;
7800: }
7801: PetscCall(MatGetRowIJ(A, 0, PETSC_TRUE, PETSC_FALSE, &nvtxs, (const PetscInt **)&xadj, (const PetscInt **)&adjncy, &flg_row));
7802: if (flg_row) {
7803: PetscCall(PCBDDCSetLocalAdjacencyGraph(pc, nvtxs, xadj, adjncy, PETSC_COPY_VALUES));
7804: pcbddc->computed_rowadj = PETSC_TRUE;
7805: PetscCall(MatRestoreRowIJ(A, 0, PETSC_TRUE, PETSC_FALSE, &nvtxs, (const PetscInt **)&xadj, (const PetscInt **)&adjncy, &flg_row));
7806: rcsr = PETSC_TRUE;
7807: }
7808: PetscCall(MatDestroy(&A));
7809: }
7810: if (pcbddc->dbg_flag) PetscCall(PetscViewerFlush(pcbddc->dbg_viewer));
7812: if (pcbddc->mat_graph->cdim && !pcbddc->mat_graph->cloc) {
7813: PetscReal *lcoords;
7814: PetscInt n;
7815: MPI_Datatype dimrealtype;
7816: PetscMPIInt cdimi;
7818: /* TODO: support for blocked */
7819: PetscCheck(pcbddc->mat_graph->cnloc == pc->pmat->rmap->n, PETSC_COMM_SELF, PETSC_ERR_USER, "Invalid number of local coordinates! Got %" PetscInt_FMT ", expected %" PetscInt_FMT, pcbddc->mat_graph->cnloc, pc->pmat->rmap->n);
7820: PetscCall(MatGetLocalSize(matis->A, &n, NULL));
7821: PetscCall(PetscMalloc1(pcbddc->mat_graph->cdim * n, &lcoords));
7822: PetscCall(PetscMPIIntCast(pcbddc->mat_graph->cdim, &cdimi));
7823: PetscCallMPI(MPI_Type_contiguous(cdimi, MPIU_REAL, &dimrealtype));
7824: PetscCallMPI(MPI_Type_commit(&dimrealtype));
7825: PetscCall(PetscSFBcastBegin(matis->sf, dimrealtype, pcbddc->mat_graph->coords, lcoords, MPI_REPLACE));
7826: PetscCall(PetscSFBcastEnd(matis->sf, dimrealtype, pcbddc->mat_graph->coords, lcoords, MPI_REPLACE));
7827: PetscCallMPI(MPI_Type_free(&dimrealtype));
7828: PetscCall(PetscFree(pcbddc->mat_graph->coords));
7830: pcbddc->mat_graph->coords = lcoords;
7831: pcbddc->mat_graph->cloc = PETSC_TRUE;
7832: pcbddc->mat_graph->cnloc = n;
7833: }
7834: PetscCheck(!pcbddc->mat_graph->cnloc || pcbddc->mat_graph->cnloc == pcbddc->mat_graph->nvtxs, PETSC_COMM_SELF, PETSC_ERR_USER, "Invalid number of local subdomain coordinates! Got %" PetscInt_FMT ", expected %" PetscInt_FMT, pcbddc->mat_graph->cnloc,
7835: pcbddc->mat_graph->nvtxs);
7836: pcbddc->mat_graph->active_coords = (PetscBool)(pcbddc->corner_selection && pcbddc->mat_graph->cdim && !pcbddc->corner_selected);
7838: /* attach info on disconnected subdomains if present */
7839: if (pcbddc->n_local_subs) {
7840: PetscInt *local_subs, n, totn;
7842: PetscCall(MatGetLocalSize(matis->A, &n, NULL));
7843: PetscCall(PetscMalloc1(n, &local_subs));
7844: for (i = 0; i < n; i++) local_subs[i] = pcbddc->n_local_subs;
7845: for (i = 0; i < pcbddc->n_local_subs; i++) {
7846: const PetscInt *idxs;
7847: PetscInt nl;
7849: PetscCall(ISGetLocalSize(pcbddc->local_subs[i], &nl));
7850: PetscCall(ISGetIndices(pcbddc->local_subs[i], &idxs));
7851: for (PetscInt j = 0; j < nl; j++) local_subs[idxs[j]] = i;
7852: PetscCall(ISRestoreIndices(pcbddc->local_subs[i], &idxs));
7853: }
7854: for (i = 0, totn = 0; i < n; i++) totn = PetscMax(totn, local_subs[i]);
7855: pcbddc->mat_graph->n_local_subs = totn + 1;
7856: pcbddc->mat_graph->local_subs = local_subs;
7857: }
7859: /* Setup of Graph */
7860: PetscCall(PCBDDCGraphSetUp(pcbddc->mat_graph, pcbddc->vertex_size, pcbddc->NeumannBoundariesLocal, pcbddc->DirichletBoundariesLocal, pcbddc->n_ISForDofsLocal, pcbddc->ISForDofsLocal, pcbddc->user_primal_vertices_local));
7861: }
7863: if (!pcbddc->graphanalyzed) {
7864: /* Graph's connected components analysis */
7865: PetscCall(PCBDDCGraphComputeConnectedComponents(pcbddc->mat_graph));
7866: pcbddc->graphanalyzed = PETSC_TRUE;
7867: pcbddc->corner_selected = pcbddc->corner_selection;
7868: }
7869: if (rcsr) pcbddc->mat_graph->nvtxs_csr = 0;
7870: PetscFunctionReturn(PETSC_SUCCESS);
7871: }
7873: PetscErrorCode PCBDDCOrthonormalizeVecs(PetscInt *nio, Vec vecs[])
7874: {
7875: PetscInt i, j, n;
7876: PetscScalar *alphas;
7877: PetscReal norm, *onorms;
7879: PetscFunctionBegin;
7880: n = *nio;
7881: if (!n) PetscFunctionReturn(PETSC_SUCCESS);
7882: PetscCall(PetscMalloc2(n, &alphas, n, &onorms));
7883: PetscCall(VecNormalize(vecs[0], &norm));
7884: if (norm < PETSC_SMALL) {
7885: onorms[0] = 0.0;
7886: PetscCall(VecSet(vecs[0], 0.0));
7887: } else {
7888: onorms[0] = norm;
7889: }
7891: for (i = 1; i < n; i++) {
7892: PetscCall(VecMDot(vecs[i], i, vecs, alphas));
7893: for (j = 0; j < i; j++) alphas[j] = PetscConj(-alphas[j]);
7894: PetscCall(VecMAXPY(vecs[i], i, alphas, vecs));
7895: PetscCall(VecNormalize(vecs[i], &norm));
7896: if (norm < PETSC_SMALL) {
7897: onorms[i] = 0.0;
7898: PetscCall(VecSet(vecs[i], 0.0));
7899: } else {
7900: onorms[i] = norm;
7901: }
7902: }
7903: /* push nonzero vectors at the beginning */
7904: for (i = 0; i < n; i++) {
7905: if (onorms[i] == 0.0) {
7906: for (j = i + 1; j < n; j++) {
7907: if (onorms[j] != 0.0) {
7908: PetscCall(VecCopy(vecs[j], vecs[i]));
7909: onorms[i] = onorms[j];
7910: onorms[j] = 0.0;
7911: break;
7912: }
7913: }
7914: }
7915: }
7916: for (i = 0, *nio = 0; i < n; i++) *nio += onorms[i] != 0.0 ? 1 : 0;
7917: PetscCall(PetscFree2(alphas, onorms));
7918: PetscFunctionReturn(PETSC_SUCCESS);
7919: }
7921: static PetscErrorCode PCBDDCMatISGetSubassemblingPattern(Mat mat, const char *prefix, PetscInt *n_subdomains, PetscInt redprocs, IS *is_sends, PetscBool *have_void)
7922: {
7923: ISLocalToGlobalMapping mapping;
7924: Mat A;
7925: PetscInt n_neighs, *neighs, *n_shared, **shared;
7926: PetscMPIInt size, rank, color;
7927: PetscInt *xadj, *adjncy;
7928: PetscInt *adjncy_wgt, *v_wgt, *ranks_send_to_idx;
7929: PetscInt im_active, active_procs, N, n, i, j, threshold = 2;
7930: PetscInt void_procs, *procs_candidates = NULL;
7931: PetscInt xadj_count, *count;
7932: PetscBool ismatis, use_vwgt = PETSC_FALSE;
7933: PetscSubcomm psubcomm;
7934: MPI_Comm subcomm;
7936: PetscFunctionBegin;
7938: PetscAssertPointer(n_subdomains, 3);
7939: PetscCall(PetscObjectTypeCompare((PetscObject)mat, MATIS, &ismatis));
7940: PetscCheck(ismatis, PetscObjectComm((PetscObject)mat), PETSC_ERR_SUP, "Cannot use %s on a matrix object which is not of type MATIS", PETSC_FUNCTION_NAME);
7943: PetscCheck(*n_subdomains > 0, PetscObjectComm((PetscObject)mat), PETSC_ERR_ARG_WRONG, "Invalid number of subdomains requested %" PetscInt_FMT, *n_subdomains);
7945: if (have_void) *have_void = PETSC_FALSE;
7946: PetscCallMPI(MPI_Comm_size(PetscObjectComm((PetscObject)mat), &size));
7947: PetscCallMPI(MPI_Comm_rank(PetscObjectComm((PetscObject)mat), &rank));
7948: PetscCall(MatISGetLocalMat(mat, &A));
7949: PetscCall(MatGetLocalSize(A, &n, NULL));
7950: im_active = !!n;
7951: PetscCallMPI(MPIU_Allreduce(&im_active, &active_procs, 1, MPIU_INT, MPI_SUM, PetscObjectComm((PetscObject)mat)));
7952: void_procs = size - active_procs;
7953: /* get ranks of non-active processes in mat communicator */
7954: if (void_procs) {
7955: PetscInt ncand;
7957: if (have_void) *have_void = PETSC_TRUE;
7958: PetscCall(PetscMalloc1(size, &procs_candidates));
7959: PetscCallMPI(MPI_Allgather(&im_active, 1, MPIU_INT, procs_candidates, 1, MPIU_INT, PetscObjectComm((PetscObject)mat)));
7960: for (i = 0, ncand = 0; i < size; i++) {
7961: if (!procs_candidates[i]) procs_candidates[ncand++] = i;
7962: }
7963: /* force n_subdomains to be not greater that the number of non-active processes */
7964: *n_subdomains = PetscMin(void_procs, *n_subdomains);
7965: }
7967: /* number of subdomains requested greater than active processes or matrix size -> just shift the matrix
7968: number of subdomains requested 1 -> send to rank-0 or first candidate in voids */
7969: PetscCall(MatGetSize(mat, &N, NULL));
7970: if (active_procs < *n_subdomains || *n_subdomains == 1 || N <= *n_subdomains) {
7971: PetscInt issize, isidx, dest;
7972: PetscBool default_sub;
7974: if (*n_subdomains == 1) dest = 0;
7975: else dest = rank;
7976: if (im_active) {
7977: issize = 1;
7978: if (procs_candidates) { /* shift the pattern on non-active candidates (if any) */
7979: isidx = procs_candidates[dest];
7980: } else {
7981: isidx = dest;
7982: }
7983: } else {
7984: issize = 0;
7985: isidx = rank;
7986: }
7987: if (*n_subdomains != 1) *n_subdomains = active_procs;
7988: PetscCall(ISCreateGeneral(PetscObjectComm((PetscObject)mat), issize, &isidx, PETSC_COPY_VALUES, is_sends));
7989: default_sub = (PetscBool)(isidx == rank);
7990: PetscCallMPI(MPIU_Allreduce(MPI_IN_PLACE, &default_sub, 1, MPI_C_BOOL, MPI_LAND, PetscObjectComm((PetscObject)mat)));
7991: if (default_sub) PetscCall(PetscObjectSetName((PetscObject)*is_sends, "default subassembling"));
7992: PetscCall(PetscFree(procs_candidates));
7993: PetscFunctionReturn(PETSC_SUCCESS);
7994: }
7995: PetscCall(PetscOptionsGetBool(NULL, prefix, "-mat_is_partitioning_use_vwgt", &use_vwgt, NULL));
7996: PetscCall(PetscOptionsGetInt(NULL, prefix, "-mat_is_partitioning_threshold", &threshold, NULL));
7997: threshold = PetscMax(threshold, 2);
7999: /* Get info on mapping */
8000: PetscCall(MatISGetLocalToGlobalMapping(mat, &mapping, NULL));
8001: PetscCall(ISLocalToGlobalMappingGetInfo(mapping, &n_neighs, &neighs, &n_shared, &shared));
8003: /* build local CSR graph of subdomains' connectivity */
8004: PetscCall(PetscMalloc1(2, &xadj));
8005: xadj[0] = 0;
8006: xadj[1] = PetscMax(n_neighs - 1, 0);
8007: PetscCall(PetscMalloc1(xadj[1], &adjncy));
8008: PetscCall(PetscMalloc1(xadj[1], &adjncy_wgt));
8009: PetscCall(PetscCalloc1(n, &count));
8010: for (i = 1; i < n_neighs; i++)
8011: for (j = 0; j < n_shared[i]; j++) count[shared[i][j]] += 1;
8013: xadj_count = 0;
8014: for (i = 1; i < n_neighs; i++) {
8015: for (j = 0; j < n_shared[i]; j++) {
8016: if (count[shared[i][j]] < threshold) {
8017: adjncy[xadj_count] = neighs[i];
8018: adjncy_wgt[xadj_count] = n_shared[i];
8019: xadj_count++;
8020: break;
8021: }
8022: }
8023: }
8024: xadj[1] = xadj_count;
8025: PetscCall(PetscFree(count));
8026: PetscCall(ISLocalToGlobalMappingRestoreInfo(mapping, &n_neighs, &neighs, &n_shared, &shared));
8027: PetscCall(PetscSortIntWithArray(xadj[1], adjncy, adjncy_wgt));
8029: PetscCall(PetscMalloc1(1, &ranks_send_to_idx));
8031: /* Restrict work on active processes only */
8032: PetscCall(PetscMPIIntCast(im_active, &color));
8033: if (void_procs) {
8034: PetscCall(PetscSubcommCreate(PetscObjectComm((PetscObject)mat), &psubcomm));
8035: PetscCall(PetscSubcommSetNumber(psubcomm, 2)); /* 2 groups, active process and not active processes */
8036: PetscCall(PetscSubcommSetTypeGeneral(psubcomm, color, rank));
8037: subcomm = PetscSubcommChild(psubcomm);
8038: } else {
8039: psubcomm = NULL;
8040: subcomm = PetscObjectComm((PetscObject)mat);
8041: }
8043: v_wgt = NULL;
8044: if (!color) {
8045: PetscCall(PetscFree(xadj));
8046: PetscCall(PetscFree(adjncy));
8047: PetscCall(PetscFree(adjncy_wgt));
8048: } else {
8049: Mat subdomain_adj;
8050: IS new_ranks, new_ranks_contig;
8051: MatPartitioning partitioner;
8052: PetscInt rstart, rend;
8053: PetscMPIInt irstart = 0, irend = 0;
8054: PetscInt *is_indices, *oldranks;
8055: PetscMPIInt size;
8056: PetscBool aggregate;
8058: PetscCallMPI(MPI_Comm_size(subcomm, &size));
8059: if (void_procs) {
8060: PetscInt prank = rank;
8061: PetscCall(PetscMalloc1(size, &oldranks));
8062: PetscCallMPI(MPI_Allgather(&prank, 1, MPIU_INT, oldranks, 1, MPIU_INT, subcomm));
8063: for (i = 0; i < xadj[1]; i++) PetscCall(PetscFindInt(adjncy[i], size, oldranks, &adjncy[i]));
8064: PetscCall(PetscSortIntWithArray(xadj[1], adjncy, adjncy_wgt));
8065: } else {
8066: oldranks = NULL;
8067: }
8068: aggregate = ((redprocs > 0 && redprocs < size) ? PETSC_TRUE : PETSC_FALSE);
8069: if (aggregate) { /* TODO: all this part could be made more efficient */
8070: PetscInt lrows, row, ncols, *cols;
8071: PetscMPIInt nrank;
8072: PetscScalar *vals;
8074: PetscCallMPI(MPI_Comm_rank(subcomm, &nrank));
8075: lrows = 0;
8076: if (nrank < redprocs) {
8077: lrows = size / redprocs;
8078: if (nrank < size % redprocs) lrows++;
8079: }
8080: PetscCall(MatCreateAIJ(subcomm, lrows, lrows, size, size, 50, NULL, 50, NULL, &subdomain_adj));
8081: PetscCall(MatGetOwnershipRange(subdomain_adj, &rstart, &rend));
8082: PetscCall(PetscMPIIntCast(rstart, &irstart));
8083: PetscCall(PetscMPIIntCast(rend, &irend));
8084: PetscCall(MatSetOption(subdomain_adj, MAT_NEW_NONZERO_LOCATION_ERR, PETSC_FALSE));
8085: PetscCall(MatSetOption(subdomain_adj, MAT_NEW_NONZERO_ALLOCATION_ERR, PETSC_FALSE));
8086: row = nrank;
8087: ncols = xadj[1] - xadj[0];
8088: cols = adjncy;
8089: PetscCall(PetscMalloc1(ncols, &vals));
8090: for (i = 0; i < ncols; i++) vals[i] = adjncy_wgt[i];
8091: PetscCall(MatSetValues(subdomain_adj, 1, &row, ncols, cols, vals, INSERT_VALUES));
8092: PetscCall(MatAssemblyBegin(subdomain_adj, MAT_FINAL_ASSEMBLY));
8093: PetscCall(MatAssemblyEnd(subdomain_adj, MAT_FINAL_ASSEMBLY));
8094: PetscCall(PetscFree(xadj));
8095: PetscCall(PetscFree(adjncy));
8096: PetscCall(PetscFree(adjncy_wgt));
8097: PetscCall(PetscFree(vals));
8098: if (use_vwgt) {
8099: Vec v;
8100: const PetscScalar *array;
8101: PetscInt nl;
8103: PetscCall(MatCreateVecs(subdomain_adj, &v, NULL));
8104: PetscCall(VecSetValue(v, row, (PetscScalar)n, INSERT_VALUES));
8105: PetscCall(VecAssemblyBegin(v));
8106: PetscCall(VecAssemblyEnd(v));
8107: PetscCall(VecGetLocalSize(v, &nl));
8108: PetscCall(VecGetArrayRead(v, &array));
8109: PetscCall(PetscMalloc1(nl, &v_wgt));
8110: for (i = 0; i < nl; i++) v_wgt[i] = (PetscInt)PetscRealPart(array[i]);
8111: PetscCall(VecRestoreArrayRead(v, &array));
8112: PetscCall(VecDestroy(&v));
8113: }
8114: } else {
8115: PetscCall(MatCreateMPIAdj(subcomm, 1, size, xadj, adjncy, adjncy_wgt, &subdomain_adj));
8116: if (use_vwgt) {
8117: PetscCall(PetscMalloc1(1, &v_wgt));
8118: v_wgt[0] = n;
8119: }
8120: }
8121: /* PetscCall(MatView(subdomain_adj,0)); */
8123: /* Partition */
8124: PetscCall(MatPartitioningCreate(subcomm, &partitioner));
8125: #if PetscDefined(HAVE_PTSCOTCH)
8126: PetscCall(MatPartitioningSetType(partitioner, MATPARTITIONINGPTSCOTCH));
8127: #elif PetscDefined(HAVE_PARMETIS)
8128: PetscCall(MatPartitioningSetType(partitioner, MATPARTITIONINGPARMETIS));
8129: #else
8130: PetscCall(MatPartitioningSetType(partitioner, MATPARTITIONINGAVERAGE));
8131: #endif
8132: PetscCall(MatPartitioningSetAdjacency(partitioner, subdomain_adj));
8133: if (v_wgt) PetscCall(MatPartitioningSetVertexWeights(partitioner, v_wgt));
8134: *n_subdomains = PetscMin(size, *n_subdomains);
8135: PetscCall(MatPartitioningSetNParts(partitioner, *n_subdomains));
8136: PetscCall(PetscObjectSetOptionsPrefix((PetscObject)partitioner, prefix));
8137: PetscCall(MatPartitioningSetFromOptions(partitioner));
8138: PetscCall(MatPartitioningApply(partitioner, &new_ranks));
8140: /* renumber new_ranks to avoid "holes" in new set of processors */
8141: PetscCall(ISRenumber(new_ranks, NULL, NULL, &new_ranks_contig));
8142: PetscCall(ISDestroy(&new_ranks));
8143: PetscCall(ISGetIndices(new_ranks_contig, (const PetscInt **)&is_indices));
8144: if (!aggregate) {
8145: if (procs_candidates) { /* shift the pattern on non-active candidates (if any) */
8146: PetscAssert(oldranks, PETSC_COMM_SELF, PETSC_ERR_PLIB, "This should not happen");
8147: ranks_send_to_idx[0] = procs_candidates[oldranks[is_indices[0]]];
8148: } else if (oldranks) {
8149: ranks_send_to_idx[0] = oldranks[is_indices[0]];
8150: } else {
8151: ranks_send_to_idx[0] = is_indices[0];
8152: }
8153: } else {
8154: PetscInt idx = 0;
8155: PetscMPIInt tag;
8156: MPI_Request *reqs;
8158: PetscCall(PetscObjectGetNewTag((PetscObject)subdomain_adj, &tag));
8159: PetscCall(PetscMalloc1(rend - rstart, &reqs));
8160: for (PetscMPIInt i = irstart; i < irend; i++) PetscCallMPI(MPIU_Isend(is_indices + i - rstart, 1, MPIU_INT, i, tag, subcomm, &reqs[i - rstart]));
8161: PetscCallMPI(MPIU_Recv(&idx, 1, MPIU_INT, MPI_ANY_SOURCE, tag, subcomm, MPI_STATUS_IGNORE));
8162: PetscCallMPI(MPI_Waitall(irend - irstart, reqs, MPI_STATUSES_IGNORE));
8163: PetscCall(PetscFree(reqs));
8164: if (procs_candidates) { /* shift the pattern on non-active candidates (if any) */
8165: PetscAssert(oldranks, PETSC_COMM_SELF, PETSC_ERR_PLIB, "This should not happen");
8166: ranks_send_to_idx[0] = procs_candidates[oldranks[idx]];
8167: } else if (oldranks) {
8168: ranks_send_to_idx[0] = oldranks[idx];
8169: } else {
8170: ranks_send_to_idx[0] = idx;
8171: }
8172: }
8173: PetscCall(ISRestoreIndices(new_ranks_contig, (const PetscInt **)&is_indices));
8174: /* clean up */
8175: PetscCall(PetscFree(oldranks));
8176: PetscCall(ISDestroy(&new_ranks_contig));
8177: PetscCall(MatDestroy(&subdomain_adj));
8178: PetscCall(MatPartitioningDestroy(&partitioner));
8179: }
8180: PetscCall(PetscSubcommDestroy(&psubcomm));
8181: PetscCall(PetscFree(procs_candidates));
8183: /* assemble parallel IS for sends */
8184: i = 1;
8185: if (!color) i = 0;
8186: PetscCall(ISCreateGeneral(PetscObjectComm((PetscObject)mat), i, ranks_send_to_idx, PETSC_OWN_POINTER, is_sends));
8187: PetscFunctionReturn(PETSC_SUCCESS);
8188: }
8190: typedef enum {
8191: MATDENSE_PRIVATE = 0,
8192: MATAIJ_PRIVATE,
8193: MATBAIJ_PRIVATE,
8194: MATSBAIJ_PRIVATE
8195: } MatTypePrivate;
8197: static PetscErrorCode PCBDDCMatISSubassemble(Mat mat, IS is_sends, PetscInt n_subdomains, PetscBool restrict_comm, PetscBool restrict_full, PetscBool reuse, Mat *mat_n, PetscInt nis, IS isarray[], PetscInt nvecs, Vec nnsp_vec[])
8198: {
8199: Mat local_mat;
8200: PetscInt rows, cols, new_local_rows;
8201: PetscInt i, bs, buf_size_idxs, buf_size_idxs_is, buf_size_vals, buf_size_vecs;
8202: PetscBool ismatis, isdense, newisdense, destroy_mat;
8203: ISLocalToGlobalMapping l2gmap;
8204: PetscInt *l2gmap_indices;
8205: const PetscInt *is_indices;
8206: MatType new_local_type;
8207: /* buffers */
8208: PetscInt *ptr_idxs, *send_buffer_idxs, *recv_buffer_idxs;
8209: PetscInt *ptr_idxs_is, *send_buffer_idxs_is, *recv_buffer_idxs_is;
8210: PetscInt *recv_buffer_idxs_local;
8211: PetscScalar *ptr_vals, *recv_buffer_vals;
8212: const PetscScalar *send_buffer_vals;
8213: PetscScalar *ptr_vecs, *send_buffer_vecs, *recv_buffer_vecs;
8214: /* MPI */
8215: MPI_Comm comm, comm_n;
8216: PetscSubcomm subcomm;
8217: PetscMPIInt n_sends, n_recvs, size;
8218: PetscMPIInt *iflags, *ilengths_idxs, *ilengths_vals, *ilengths_idxs_is;
8219: PetscMPIInt *onodes, *onodes_is, *olengths_idxs, *olengths_idxs_is, *olengths_vals;
8220: PetscMPIInt len, tag_idxs, tag_idxs_is, tag_vals, tag_vecs, source_dest;
8221: MPI_Request *send_req_idxs, *send_req_idxs_is, *send_req_vals, *send_req_vecs;
8222: MPI_Request *recv_req_idxs, *recv_req_idxs_is, *recv_req_vals, *recv_req_vecs;
8224: PetscFunctionBegin;
8226: PetscCall(PetscObjectTypeCompare((PetscObject)mat, MATIS, &ismatis));
8227: PetscCheck(ismatis, PetscObjectComm((PetscObject)mat), PETSC_ERR_SUP, "Cannot use %s on a matrix object which is not of type MATIS", PETSC_FUNCTION_NAME);
8235: if (nvecs) {
8236: PetscCheck(nvecs <= 1, PetscObjectComm((PetscObject)mat), PETSC_ERR_SUP, "Just 1 vector supported");
8238: }
8239: /* further checks */
8240: PetscCall(MatISGetLocalMat(mat, &local_mat));
8241: PetscCall(PetscObjectTypeCompare((PetscObject)local_mat, MATSEQDENSE, &isdense));
8242: PetscCheck(isdense, PetscObjectComm((PetscObject)mat), PETSC_ERR_SUP, "Currently cannot subassemble MATIS when local matrix type is not of type SEQDENSE");
8244: PetscCall(MatGetSize(local_mat, &rows, &cols));
8245: PetscCheck(rows == cols, PetscObjectComm((PetscObject)mat), PETSC_ERR_SUP, "Local MATIS matrices should be square");
8246: if (reuse && *mat_n) {
8247: PetscInt mrows, mcols, mnrows, mncols;
8249: PetscCall(PetscObjectTypeCompare((PetscObject)*mat_n, MATIS, &ismatis));
8250: PetscCheck(ismatis, PetscObjectComm((PetscObject)*mat_n), PETSC_ERR_SUP, "Cannot reuse a matrix which is not of type MATIS");
8251: PetscCall(MatGetSize(mat, &mrows, &mcols));
8252: PetscCall(MatGetSize(*mat_n, &mnrows, &mncols));
8253: PetscCheck(mrows == mnrows, PetscObjectComm((PetscObject)mat), PETSC_ERR_SUP, "Cannot reuse matrix! Wrong number of rows %" PetscInt_FMT " != %" PetscInt_FMT, mrows, mnrows);
8254: PetscCheck(mcols == mncols, PetscObjectComm((PetscObject)mat), PETSC_ERR_SUP, "Cannot reuse matrix! Wrong number of cols %" PetscInt_FMT " != %" PetscInt_FMT, mcols, mncols);
8255: }
8256: PetscCall(MatGetBlockSize(local_mat, &bs));
8259: /* get comm */
8260: PetscCall(PetscObjectGetComm((PetscObject)mat, &comm));
8262: /* compute number of sends */
8263: PetscCall(ISGetLocalSize(is_sends, &i));
8264: PetscCall(PetscMPIIntCast(i, &n_sends));
8266: /* compute number of receives */
8267: PetscCallMPI(MPI_Comm_size(comm, &size));
8268: PetscCall(PetscMalloc1(size, &iflags));
8269: PetscCall(PetscArrayzero(iflags, size));
8270: PetscCall(ISGetIndices(is_sends, &is_indices));
8271: for (i = 0; i < n_sends; i++) iflags[is_indices[i]] = 1;
8272: PetscCall(PetscGatherNumberOfMessages(comm, iflags, NULL, &n_recvs));
8273: PetscCall(PetscFree(iflags));
8275: /* restrict comm if requested */
8276: subcomm = NULL;
8277: destroy_mat = PETSC_FALSE;
8278: if (restrict_comm) {
8279: PetscMPIInt color, subcommsize;
8281: color = 0;
8282: if (restrict_full) {
8283: if (!n_recvs) color = 1; /* processes not receiving anything will not participate in new comm (full restriction) */
8284: } else {
8285: if (!n_recvs && n_sends) color = 1; /* just those processes that are sending but not receiving anything will not participate in new comm */
8286: }
8287: PetscCallMPI(MPIU_Allreduce(&color, &subcommsize, 1, MPI_INT, MPI_SUM, comm));
8288: subcommsize = size - subcommsize;
8289: /* check if reuse has been requested */
8290: if (reuse) {
8291: if (*mat_n) {
8292: PetscMPIInt subcommsize2;
8293: PetscCallMPI(MPI_Comm_size(PetscObjectComm((PetscObject)*mat_n), &subcommsize2));
8294: PetscCheck(subcommsize == subcommsize2, PetscObjectComm((PetscObject)*mat_n), PETSC_ERR_PLIB, "Cannot reuse matrix! wrong subcomm size %d != %d", subcommsize, subcommsize2);
8295: comm_n = PetscObjectComm((PetscObject)*mat_n);
8296: } else {
8297: comm_n = PETSC_COMM_SELF;
8298: }
8299: } else { /* MAT_INITIAL_MATRIX */
8300: PetscMPIInt rank;
8302: PetscCallMPI(MPI_Comm_rank(comm, &rank));
8303: PetscCall(PetscSubcommCreate(comm, &subcomm));
8304: PetscCall(PetscSubcommSetNumber(subcomm, 2));
8305: PetscCall(PetscSubcommSetTypeGeneral(subcomm, color, rank));
8306: comm_n = PetscSubcommChild(subcomm);
8307: }
8308: /* flag to destroy *mat_n if not significative */
8309: if (color) destroy_mat = PETSC_TRUE;
8310: } else {
8311: comm_n = comm;
8312: }
8314: /* prepare send/receive buffers */
8315: PetscCall(PetscMalloc1(size, &ilengths_idxs));
8316: PetscCall(PetscArrayzero(ilengths_idxs, size));
8317: PetscCall(PetscMalloc1(size, &ilengths_vals));
8318: PetscCall(PetscArrayzero(ilengths_vals, size));
8319: if (nis) PetscCall(PetscCalloc1(size, &ilengths_idxs_is));
8321: /* Get data from local matrices */
8322: PetscCheck(isdense, PetscObjectComm((PetscObject)mat), PETSC_ERR_SUP, "Subassembling of AIJ local matrices not yet implemented");
8323: /* TODO: See below some guidelines on how to prepare the local buffers */
8324: /*
8325: send_buffer_vals should contain the raw values of the local matrix
8326: send_buffer_idxs should contain:
8327: - MatType_PRIVATE type
8328: - PetscInt size_of_l2gmap
8329: - PetscInt global_row_indices[size_of_l2gmap]
8330: - PetscInt all_other_info_which_is_needed_to_compute_preallocation_and_set_values
8331: */
8332: {
8333: ISLocalToGlobalMapping mapping;
8335: PetscCall(MatISGetLocalToGlobalMapping(mat, &mapping, NULL));
8336: PetscCall(MatDenseGetArrayRead(local_mat, &send_buffer_vals));
8337: PetscCall(ISLocalToGlobalMappingGetSize(mapping, &i));
8338: PetscCall(PetscMalloc1(i + 2, &send_buffer_idxs));
8339: send_buffer_idxs[0] = (PetscInt)MATDENSE_PRIVATE;
8340: send_buffer_idxs[1] = i;
8341: PetscCall(ISLocalToGlobalMappingGetIndices(mapping, (const PetscInt **)&ptr_idxs));
8342: PetscCall(PetscArraycpy(&send_buffer_idxs[2], ptr_idxs, i));
8343: PetscCall(ISLocalToGlobalMappingRestoreIndices(mapping, (const PetscInt **)&ptr_idxs));
8344: PetscCall(PetscMPIIntCast(i, &len));
8345: for (i = 0; i < n_sends; i++) {
8346: ilengths_vals[is_indices[i]] = len * len;
8347: ilengths_idxs[is_indices[i]] = len + 2;
8348: }
8349: }
8350: PetscCall(PetscGatherMessageLengths2(comm, n_sends, n_recvs, ilengths_idxs, ilengths_vals, &onodes, &olengths_idxs, &olengths_vals));
8351: /* additional is (if any) */
8352: if (nis) {
8353: PetscMPIInt psum;
8354: PetscInt j;
8355: for (j = 0, psum = 0; j < nis; j++) {
8356: PetscInt plen;
8357: PetscCall(ISGetLocalSize(isarray[j], &plen));
8358: PetscCall(PetscMPIIntCast(plen, &len));
8359: psum += len + 1; /* indices + length */
8360: }
8361: PetscCall(PetscMalloc1(psum, &send_buffer_idxs_is));
8362: for (j = 0, psum = 0; j < nis; j++) {
8363: PetscInt plen;
8364: const PetscInt *is_array_idxs;
8365: PetscCall(ISGetLocalSize(isarray[j], &plen));
8366: send_buffer_idxs_is[psum] = plen;
8367: PetscCall(ISGetIndices(isarray[j], &is_array_idxs));
8368: PetscCall(PetscArraycpy(&send_buffer_idxs_is[psum + 1], is_array_idxs, plen));
8369: PetscCall(ISRestoreIndices(isarray[j], &is_array_idxs));
8370: psum += plen + 1; /* indices + length */
8371: }
8372: for (i = 0; i < n_sends; i++) ilengths_idxs_is[is_indices[i]] = psum;
8373: PetscCall(PetscGatherMessageLengths(comm, n_sends, n_recvs, ilengths_idxs_is, &onodes_is, &olengths_idxs_is));
8374: }
8375: PetscCall(MatISRestoreLocalMat(mat, &local_mat));
8377: buf_size_idxs = 0;
8378: buf_size_vals = 0;
8379: buf_size_idxs_is = 0;
8380: buf_size_vecs = 0;
8381: for (i = 0; i < n_recvs; i++) {
8382: buf_size_idxs += olengths_idxs[i];
8383: buf_size_vals += olengths_vals[i];
8384: if (nis) buf_size_idxs_is += olengths_idxs_is[i];
8385: if (nvecs) buf_size_vecs += olengths_idxs[i];
8386: }
8387: PetscCall(PetscMalloc1(buf_size_idxs, &recv_buffer_idxs));
8388: PetscCall(PetscMalloc1(buf_size_vals, &recv_buffer_vals));
8389: PetscCall(PetscMalloc1(buf_size_idxs_is, &recv_buffer_idxs_is));
8390: PetscCall(PetscMalloc1(buf_size_vecs, &recv_buffer_vecs));
8392: /* get new tags for clean communications */
8393: PetscCall(PetscObjectGetNewTag((PetscObject)mat, &tag_idxs));
8394: PetscCall(PetscObjectGetNewTag((PetscObject)mat, &tag_vals));
8395: PetscCall(PetscObjectGetNewTag((PetscObject)mat, &tag_idxs_is));
8396: PetscCall(PetscObjectGetNewTag((PetscObject)mat, &tag_vecs));
8398: /* allocate for requests */
8399: PetscCall(PetscMalloc1(n_sends, &send_req_idxs));
8400: PetscCall(PetscMalloc1(n_sends, &send_req_vals));
8401: PetscCall(PetscMalloc1(n_sends, &send_req_idxs_is));
8402: PetscCall(PetscMalloc1(n_sends, &send_req_vecs));
8403: PetscCall(PetscMalloc1(n_recvs, &recv_req_idxs));
8404: PetscCall(PetscMalloc1(n_recvs, &recv_req_vals));
8405: PetscCall(PetscMalloc1(n_recvs, &recv_req_idxs_is));
8406: PetscCall(PetscMalloc1(n_recvs, &recv_req_vecs));
8408: /* communications */
8409: ptr_idxs = recv_buffer_idxs;
8410: ptr_vals = recv_buffer_vals;
8411: ptr_idxs_is = recv_buffer_idxs_is;
8412: ptr_vecs = recv_buffer_vecs;
8413: for (i = 0; i < n_recvs; i++) {
8414: PetscCallMPI(MPIU_Irecv(ptr_idxs, olengths_idxs[i], MPIU_INT, onodes[i], tag_idxs, comm, &recv_req_idxs[i]));
8415: PetscCallMPI(MPIU_Irecv(ptr_vals, olengths_vals[i], MPIU_SCALAR, onodes[i], tag_vals, comm, &recv_req_vals[i]));
8416: ptr_idxs += olengths_idxs[i];
8417: ptr_vals += olengths_vals[i];
8418: if (nis) {
8419: PetscCallMPI(MPIU_Irecv(ptr_idxs_is, olengths_idxs_is[i], MPIU_INT, onodes_is[i], tag_idxs_is, comm, &recv_req_idxs_is[i]));
8420: ptr_idxs_is += olengths_idxs_is[i];
8421: }
8422: if (nvecs) {
8423: PetscCallMPI(MPIU_Irecv(ptr_vecs, olengths_idxs[i] - 2, MPIU_SCALAR, onodes[i], tag_vecs, comm, &recv_req_vecs[i]));
8424: ptr_vecs += olengths_idxs[i] - 2;
8425: }
8426: }
8427: for (i = 0; i < n_sends; i++) {
8428: PetscCall(PetscMPIIntCast(is_indices[i], &source_dest));
8429: PetscCallMPI(MPIU_Isend(send_buffer_idxs, ilengths_idxs[source_dest], MPIU_INT, source_dest, tag_idxs, comm, &send_req_idxs[i]));
8430: PetscCallMPI(MPIU_Isend(send_buffer_vals, ilengths_vals[source_dest], MPIU_SCALAR, source_dest, tag_vals, comm, &send_req_vals[i]));
8431: if (nis) PetscCallMPI(MPIU_Isend(send_buffer_idxs_is, ilengths_idxs_is[source_dest], MPIU_INT, source_dest, tag_idxs_is, comm, &send_req_idxs_is[i]));
8432: if (nvecs) {
8433: PetscCall(VecGetArray(nnsp_vec[0], &send_buffer_vecs));
8434: PetscCallMPI(MPIU_Isend(send_buffer_vecs, ilengths_idxs[source_dest] - 2, MPIU_SCALAR, source_dest, tag_vecs, comm, &send_req_vecs[i]));
8435: }
8436: }
8437: PetscCall(ISRestoreIndices(is_sends, &is_indices));
8439: /* assemble new l2g map */
8440: PetscCallMPI(MPI_Waitall(n_recvs, recv_req_idxs, MPI_STATUSES_IGNORE));
8441: ptr_idxs = recv_buffer_idxs;
8442: new_local_rows = 0;
8443: for (i = 0; i < n_recvs; i++) {
8444: new_local_rows += *(ptr_idxs + 1); /* second element is the local size of the l2gmap */
8445: ptr_idxs += olengths_idxs[i];
8446: }
8447: PetscCall(PetscMalloc1(new_local_rows, &l2gmap_indices));
8448: ptr_idxs = recv_buffer_idxs;
8449: new_local_rows = 0;
8450: for (i = 0; i < n_recvs; i++) {
8451: PetscCall(PetscArraycpy(&l2gmap_indices[new_local_rows], ptr_idxs + 2, *(ptr_idxs + 1)));
8452: new_local_rows += *(ptr_idxs + 1); /* second element is the local size of the l2gmap */
8453: ptr_idxs += olengths_idxs[i];
8454: }
8455: PetscCall(PetscSortRemoveDupsInt(&new_local_rows, l2gmap_indices));
8456: PetscCall(ISLocalToGlobalMappingCreate(comm_n, 1, new_local_rows, l2gmap_indices, PETSC_COPY_VALUES, &l2gmap));
8457: PetscCall(PetscFree(l2gmap_indices));
8459: /* infer new local matrix type from received local matrices type */
8460: /* currently if all local matrices are of type X, then the resulting matrix will be of type X, except for the dense case */
8461: /* it also assumes that if the block size is set, than it is the same among all local matrices (see checks at the beginning of the function) */
8462: if (n_recvs) {
8463: MatTypePrivate new_local_type_private = (MatTypePrivate)send_buffer_idxs[0];
8464: ptr_idxs = recv_buffer_idxs;
8465: for (i = 0; i < n_recvs; i++) {
8466: if ((PetscInt)new_local_type_private != *ptr_idxs) {
8467: new_local_type_private = MATAIJ_PRIVATE;
8468: break;
8469: }
8470: ptr_idxs += olengths_idxs[i];
8471: }
8472: switch (new_local_type_private) {
8473: case MATDENSE_PRIVATE:
8474: new_local_type = MATSEQAIJ;
8475: bs = 1;
8476: break;
8477: case MATAIJ_PRIVATE:
8478: new_local_type = MATSEQAIJ;
8479: bs = 1;
8480: break;
8481: case MATBAIJ_PRIVATE:
8482: new_local_type = MATSEQBAIJ;
8483: break;
8484: case MATSBAIJ_PRIVATE:
8485: new_local_type = MATSEQSBAIJ;
8486: break;
8487: default:
8488: SETERRQ(comm, PETSC_ERR_SUP, "Unsupported private type %d in %s", new_local_type_private, PETSC_FUNCTION_NAME);
8489: }
8490: } else { /* by default, new_local_type is seqaij */
8491: new_local_type = MATSEQAIJ;
8492: bs = 1;
8493: }
8495: /* create MATIS object if needed */
8496: if (!reuse) {
8497: PetscCall(MatGetSize(mat, &rows, &cols));
8498: PetscCall(MatCreateIS(comm_n, bs, PETSC_DECIDE, PETSC_DECIDE, rows, cols, l2gmap, l2gmap, mat_n));
8499: } else {
8500: /* it also destroys the local matrices */
8501: if (*mat_n) PetscCall(MatSetLocalToGlobalMapping(*mat_n, l2gmap, l2gmap));
8502: else PetscCall(MatCreateIS(comm_n, bs, PETSC_DECIDE, PETSC_DECIDE, rows, cols, l2gmap, l2gmap, mat_n)); /* this is a fake object */
8503: }
8504: PetscCall(MatISGetLocalMat(*mat_n, &local_mat));
8505: PetscCall(MatSetType(local_mat, new_local_type));
8507: PetscCallMPI(MPI_Waitall(n_recvs, recv_req_vals, MPI_STATUSES_IGNORE));
8509: /* Global to local map of received indices */
8510: PetscCall(PetscMalloc1(buf_size_idxs, &recv_buffer_idxs_local)); /* needed for values insertion */
8511: PetscCall(ISGlobalToLocalMappingApply(l2gmap, IS_GTOLM_MASK, buf_size_idxs, recv_buffer_idxs, &i, recv_buffer_idxs_local));
8512: PetscCall(ISLocalToGlobalMappingDestroy(&l2gmap));
8514: /* restore attributes -> type of incoming data and its size */
8515: buf_size_idxs = 0;
8516: for (i = 0; i < n_recvs; i++) {
8517: recv_buffer_idxs_local[buf_size_idxs] = recv_buffer_idxs[buf_size_idxs];
8518: recv_buffer_idxs_local[buf_size_idxs + 1] = recv_buffer_idxs[buf_size_idxs + 1];
8519: buf_size_idxs += olengths_idxs[i];
8520: }
8521: PetscCall(PetscFree(recv_buffer_idxs));
8523: /* set preallocation */
8524: PetscCall(PetscObjectTypeCompare((PetscObject)local_mat, MATSEQDENSE, &newisdense));
8525: if (!newisdense) {
8526: PetscInt *new_local_nnz = NULL;
8528: ptr_idxs = recv_buffer_idxs_local;
8529: if (n_recvs) PetscCall(PetscCalloc1(new_local_rows, &new_local_nnz));
8530: for (i = 0; i < n_recvs; i++) {
8531: if (*ptr_idxs == (PetscInt)MATDENSE_PRIVATE) { /* preallocation provided for dense case only */
8532: for (PetscInt j = 0; j < *(ptr_idxs + 1); j++) new_local_nnz[*(ptr_idxs + 2 + j)] += *(ptr_idxs + 1);
8533: } else {
8534: /* TODO */
8535: }
8536: ptr_idxs += olengths_idxs[i];
8537: }
8538: if (new_local_nnz) {
8539: for (i = 0; i < new_local_rows; i++) new_local_nnz[i] = PetscMin(new_local_nnz[i], new_local_rows);
8540: PetscCall(MatSeqAIJSetPreallocation(local_mat, 0, new_local_nnz));
8541: for (i = 0; i < new_local_rows; i++) new_local_nnz[i] /= bs;
8542: PetscCall(MatSeqBAIJSetPreallocation(local_mat, bs, 0, new_local_nnz));
8543: for (i = 0; i < new_local_rows; i++) new_local_nnz[i] = PetscMax(new_local_nnz[i] - i, 0);
8544: PetscCall(MatSeqSBAIJSetPreallocation(local_mat, bs, 0, new_local_nnz));
8545: } else {
8546: PetscCall(MatSetUp(local_mat));
8547: }
8548: PetscCall(PetscFree(new_local_nnz));
8549: } else {
8550: PetscCall(MatSetUp(local_mat));
8551: }
8553: /* set values */
8554: ptr_vals = recv_buffer_vals;
8555: ptr_idxs = recv_buffer_idxs_local;
8556: for (i = 0; i < n_recvs; i++) {
8557: if (*ptr_idxs == (PetscInt)MATDENSE_PRIVATE) { /* values insertion provided for dense case only */
8558: PetscCall(MatSetOption(local_mat, MAT_ROW_ORIENTED, PETSC_FALSE));
8559: PetscCall(MatSetValues(local_mat, *(ptr_idxs + 1), ptr_idxs + 2, *(ptr_idxs + 1), ptr_idxs + 2, ptr_vals, ADD_VALUES));
8560: PetscCall(MatAssemblyBegin(local_mat, MAT_FLUSH_ASSEMBLY));
8561: PetscCall(MatAssemblyEnd(local_mat, MAT_FLUSH_ASSEMBLY));
8562: PetscCall(MatSetOption(local_mat, MAT_ROW_ORIENTED, PETSC_TRUE));
8563: } else {
8564: /* TODO */
8565: }
8566: ptr_idxs += olengths_idxs[i];
8567: ptr_vals += olengths_vals[i];
8568: }
8569: PetscCall(MatAssemblyBegin(local_mat, MAT_FINAL_ASSEMBLY));
8570: PetscCall(MatAssemblyEnd(local_mat, MAT_FINAL_ASSEMBLY));
8571: PetscCall(MatISRestoreLocalMat(*mat_n, &local_mat));
8572: PetscCall(MatAssemblyBegin(*mat_n, MAT_FINAL_ASSEMBLY));
8573: PetscCall(MatAssemblyEnd(*mat_n, MAT_FINAL_ASSEMBLY));
8574: PetscCall(PetscFree(recv_buffer_vals));
8576: #if 0
8577: if (!restrict_comm) { /* check */
8578: Vec lvec,rvec;
8579: PetscReal infty_error;
8581: PetscCall(MatCreateVecs(mat,&rvec,&lvec));
8582: PetscCall(VecSetRandom(rvec,NULL));
8583: PetscCall(MatMult(mat,rvec,lvec));
8584: PetscCall(VecScale(lvec,-1.0));
8585: PetscCall(MatMultAdd(*mat_n,rvec,lvec,lvec));
8586: PetscCall(VecNorm(lvec,NORM_INFINITY,&infty_error));
8587: PetscCall(PetscPrintf(PetscObjectComm((PetscObject)mat),"Infinity error subassembling %1.6e\n",infty_error));
8588: PetscCall(VecDestroy(&rvec));
8589: PetscCall(VecDestroy(&lvec));
8590: }
8591: #endif
8593: /* assemble new additional is (if any) */
8594: if (nis) {
8595: PetscInt **temp_idxs, *count_is, j, psum;
8597: PetscCallMPI(MPI_Waitall(n_recvs, recv_req_idxs_is, MPI_STATUSES_IGNORE));
8598: PetscCall(PetscCalloc1(nis, &count_is));
8599: ptr_idxs = recv_buffer_idxs_is;
8600: psum = 0;
8601: for (i = 0; i < n_recvs; i++) {
8602: for (j = 0; j < nis; j++) {
8603: PetscInt plen = *ptr_idxs; /* first element is the local size of IS's indices */
8604: count_is[j] += plen; /* increment counting of buffer for j-th IS */
8605: psum += plen;
8606: ptr_idxs += plen + 1; /* shift pointer to received data */
8607: }
8608: }
8609: PetscCall(PetscMalloc1(nis, &temp_idxs));
8610: PetscCall(PetscMalloc1(psum, &temp_idxs[0]));
8611: for (i = 1; i < nis; i++) temp_idxs[i] = PetscSafePointerPlusOffset(temp_idxs[i - 1], count_is[i - 1]);
8612: PetscCall(PetscArrayzero(count_is, nis));
8613: ptr_idxs = recv_buffer_idxs_is;
8614: for (i = 0; i < n_recvs; i++) {
8615: for (j = 0; j < nis; j++) {
8616: PetscInt plen = *ptr_idxs; /* first element is the local size of IS's indices */
8617: PetscCall(PetscArraycpy(&temp_idxs[j][count_is[j]], ptr_idxs + 1, plen));
8618: count_is[j] += plen; /* increment starting point of buffer for j-th IS */
8619: ptr_idxs += plen + 1; /* shift pointer to received data */
8620: }
8621: }
8622: for (i = 0; i < nis; i++) {
8623: PetscCall(ISDestroy(&isarray[i]));
8624: PetscCall(PetscSortRemoveDupsInt(&count_is[i], temp_idxs[i]));
8625: PetscCall(ISCreateGeneral(comm_n, count_is[i], temp_idxs[i], PETSC_COPY_VALUES, &isarray[i]));
8626: }
8627: PetscCall(PetscFree(count_is));
8628: PetscCall(PetscFree(temp_idxs[0]));
8629: PetscCall(PetscFree(temp_idxs));
8630: }
8631: /* free workspace */
8632: PetscCall(PetscFree(recv_buffer_idxs_is));
8633: PetscCallMPI(MPI_Waitall(n_sends, send_req_idxs, MPI_STATUSES_IGNORE));
8634: PetscCall(PetscFree(send_buffer_idxs));
8635: PetscCallMPI(MPI_Waitall(n_sends, send_req_vals, MPI_STATUSES_IGNORE));
8636: if (isdense) {
8637: PetscCall(MatISGetLocalMat(mat, &local_mat));
8638: PetscCall(MatDenseRestoreArrayRead(local_mat, &send_buffer_vals));
8639: PetscCall(MatISRestoreLocalMat(mat, &local_mat));
8640: } else {
8641: /* PetscCall(PetscFree(send_buffer_vals)); */
8642: }
8643: if (nis) {
8644: PetscCallMPI(MPI_Waitall(n_sends, send_req_idxs_is, MPI_STATUSES_IGNORE));
8645: PetscCall(PetscFree(send_buffer_idxs_is));
8646: }
8648: if (nvecs) {
8649: PetscCallMPI(MPI_Waitall(n_recvs, recv_req_vecs, MPI_STATUSES_IGNORE));
8650: PetscCallMPI(MPI_Waitall(n_sends, send_req_vecs, MPI_STATUSES_IGNORE));
8651: PetscCall(VecRestoreArray(nnsp_vec[0], &send_buffer_vecs));
8652: PetscCall(VecDestroy(&nnsp_vec[0]));
8653: PetscCall(VecCreate(comm_n, &nnsp_vec[0]));
8654: PetscCall(VecSetSizes(nnsp_vec[0], new_local_rows, PETSC_DECIDE));
8655: PetscCall(VecSetType(nnsp_vec[0], VECSTANDARD));
8656: /* set values */
8657: ptr_vals = recv_buffer_vecs;
8658: ptr_idxs = recv_buffer_idxs_local;
8659: PetscCall(VecGetArray(nnsp_vec[0], &send_buffer_vecs));
8660: for (i = 0; i < n_recvs; i++) {
8661: for (PetscInt j = 0; j < *(ptr_idxs + 1); j++) send_buffer_vecs[*(ptr_idxs + 2 + j)] += *(ptr_vals + j);
8662: ptr_idxs += olengths_idxs[i];
8663: ptr_vals += olengths_idxs[i] - 2;
8664: }
8665: PetscCall(VecRestoreArray(nnsp_vec[0], &send_buffer_vecs));
8666: PetscCall(VecAssemblyBegin(nnsp_vec[0]));
8667: PetscCall(VecAssemblyEnd(nnsp_vec[0]));
8668: }
8670: PetscCall(PetscFree(recv_buffer_vecs));
8671: PetscCall(PetscFree(recv_buffer_idxs_local));
8672: PetscCall(PetscFree(recv_req_idxs));
8673: PetscCall(PetscFree(recv_req_vals));
8674: PetscCall(PetscFree(recv_req_vecs));
8675: PetscCall(PetscFree(recv_req_idxs_is));
8676: PetscCall(PetscFree(send_req_idxs));
8677: PetscCall(PetscFree(send_req_vals));
8678: PetscCall(PetscFree(send_req_vecs));
8679: PetscCall(PetscFree(send_req_idxs_is));
8680: PetscCall(PetscFree(ilengths_vals));
8681: PetscCall(PetscFree(ilengths_idxs));
8682: PetscCall(PetscFree(olengths_vals));
8683: PetscCall(PetscFree(olengths_idxs));
8684: PetscCall(PetscFree(onodes));
8685: if (nis) {
8686: PetscCall(PetscFree(ilengths_idxs_is));
8687: PetscCall(PetscFree(olengths_idxs_is));
8688: PetscCall(PetscFree(onodes_is));
8689: }
8690: PetscCall(PetscSubcommDestroy(&subcomm));
8691: if (destroy_mat) { /* destroy mat is true only if restrict comm is true and process will not participate */
8692: PetscCall(MatDestroy(mat_n));
8693: for (i = 0; i < nis; i++) PetscCall(ISDestroy(&isarray[i]));
8694: if (nvecs) { /* need to match VecDestroy nnsp_vec called in the other code path */
8695: PetscCall(VecDestroy(&nnsp_vec[0]));
8696: }
8697: *mat_n = NULL;
8698: }
8699: PetscFunctionReturn(PETSC_SUCCESS);
8700: }
8702: static PetscErrorCode PCBDDCAggregateLocalCoarseVec(Mat mat, Vec *vec)
8703: {
8704: ISLocalToGlobalMapping l2gmap;
8705: IS fine_to_aggregate;
8706: Vec vec_new;
8707: const PetscInt *idxs;
8708: const PetscScalar *array;
8709: PetscScalar *array_new;
8710: PetscInt n, n_new, n_vec;
8712: PetscFunctionBegin;
8713: if (!vec || !*vec) PetscFunctionReturn(PETSC_SUCCESS);
8714: PetscCall(PetscObjectQuery((PetscObject)mat, "_PCBDDC_fine_to_aggregate", (PetscObject *)&fine_to_aggregate));
8715: PetscCheck(fine_to_aggregate, PETSC_COMM_SELF, PETSC_ERR_PLIB, "Missing fine-to-aggregate map");
8716: PetscCall(ISGetLocalSize(fine_to_aggregate, &n));
8717: PetscCall(VecGetLocalSize(*vec, &n_vec));
8718: PetscCheck(n_vec == n, PETSC_COMM_SELF, PETSC_ERR_PLIB, "Invalid local vector size %" PetscInt_FMT " != %" PetscInt_FMT, n_vec, n);
8719: PetscCall(MatISGetLocalToGlobalMapping(mat, &l2gmap, NULL));
8720: PetscCall(ISLocalToGlobalMappingGetSize(l2gmap, &n_new));
8721: PetscCall(VecCreate(PetscObjectComm((PetscObject)*vec), &vec_new));
8722: PetscCall(VecSetSizes(vec_new, n_new, PETSC_DECIDE));
8723: PetscCall(VecSetType(vec_new, VECSTANDARD));
8724: PetscCall(VecSet(vec_new, 0.0));
8725: PetscCall(ISGetIndices(fine_to_aggregate, &idxs));
8726: PetscCall(VecGetArrayRead(*vec, &array));
8727: PetscCall(VecGetArray(vec_new, &array_new));
8728: for (PetscInt i = 0; i < n; i++) array_new[idxs[i]] += array[i];
8729: PetscCall(VecRestoreArray(vec_new, &array_new));
8730: PetscCall(VecRestoreArrayRead(*vec, &array));
8731: PetscCall(ISRestoreIndices(fine_to_aggregate, &idxs));
8732: PetscCall(VecDestroy(vec));
8733: *vec = vec_new;
8734: PetscFunctionReturn(PETSC_SUCCESS);
8735: }
8737: PetscErrorCode PCBDDCAggregateLocalCoarseMat(PC pc, Mat mat_is, IS partition, PetscInt nparts, MatReuse reuse, Vec *vec, Mat *mat_new)
8738: {
8739: PC_BDDC *pcbddc = (PC_BDDC *)pc->data;
8740: PCBDDCGraph graph = pcbddc->mat_graph;
8741: Mat_IS *matis;
8742: Mat local_mat, local_mat_aij = NULL, new_local_mat;
8743: ISLocalToGlobalMapping l2gmap;
8744: IS is_fine_to_aggregate = NULL;
8745: const PetscInt *parts, *gidxs, *ii, *jj;
8746: const PetscScalar *array;
8747: PetscInt *counts, *offsets, *cursor, *order, *sorted_gidxs;
8748: PetscInt *fine_to_aggregate, *aggregate_gidxs, *block_sizes;
8749: PetscInt *coo_i, *coo_j;
8750: PetscInt n, n_subs, nrows, naggregate, nblocks = 0, M, N, m, nc;
8751: PetscCount ncoo;
8752: PetscBool isseqaij, ismatis, done;
8754: PetscFunctionBegin;
8758: PetscAssertPointer(mat_new, 7);
8760: PetscCheck(reuse == MAT_INITIAL_MATRIX || reuse == MAT_REUSE_MATRIX, PetscObjectComm((PetscObject)mat_is), PETSC_ERR_SUP, "Unsupported reuse mode %d", (int)reuse);
8762: PetscCall(PetscObjectBaseTypeCompare((PetscObject)mat_is, MATIS, &ismatis));
8763: PetscCheck(ismatis, PetscObjectComm((PetscObject)mat_is), PETSC_ERR_ARG_WRONG, "Cannot aggregate coarse matrix of type %s", ((PetscObject)mat_is)->type_name);
8764: matis = (Mat_IS *)mat_is->data;
8765: PetscCall(PetscObjectBaseTypeCompare((PetscObject)matis->A, MATSEQAIJ, &isseqaij));
8766: local_mat = matis->A;
8767: if (!isseqaij) {
8768: PetscCall(MatConvert(local_mat, MATSEQAIJ, MAT_INITIAL_MATRIX, &local_mat_aij));
8769: local_mat = local_mat_aij;
8770: }
8771: PetscCall(ISLocalToGlobalMappingGetSize(matis->rmapping, &n));
8772: PetscCheck(n == pcbddc->local_primal_size, PETSC_COMM_SELF, PETSC_ERR_PLIB, "Invalid local coarse mapping size %" PetscInt_FMT " != %" PetscInt_FMT, n, pcbddc->local_primal_size);
8773: if (reuse == MAT_REUSE_MATRIX) {
8774: PetscCall(PetscObjectBaseTypeCompare((PetscObject)*mat_new, MATIS, &ismatis));
8775: PetscCheck(ismatis, PetscObjectComm((PetscObject)*mat_new), PETSC_ERR_ARG_WRONG, "Cannot reuse aggregated coarse matrix of type %s", ((PetscObject)*mat_new)->type_name);
8776: PetscCall(PetscObjectQuery((PetscObject)*mat_new, "_PCBDDC_fine_to_aggregate", (PetscObject *)&is_fine_to_aggregate));
8777: PetscCheck(is_fine_to_aggregate, PETSC_COMM_SELF, PETSC_ERR_PLIB, "Missing fine-to-aggregate map");
8778: PetscCall(ISGetLocalSize(is_fine_to_aggregate, &nrows));
8779: PetscCheck(nrows == n, PETSC_COMM_SELF, PETSC_ERR_PLIB, "Invalid fine-to-aggregate map size %" PetscInt_FMT " != %" PetscInt_FMT, nrows, n);
8780: } else {
8781: PetscCall(ISGetLocalSize(partition, &n_subs));
8782: PetscCheck(n_subs == graph->n_local_subs, PETSC_COMM_SELF, PETSC_ERR_PLIB, "Invalid local partition size %" PetscInt_FMT " != %" PetscInt_FMT, n_subs, graph->n_local_subs);
8783: PetscCall(ISGetIndices(partition, &parts));
8784: PetscCall(ISLocalToGlobalMappingGetIndices(matis->rmapping, &gidxs));
8786: PetscCall(PetscCalloc3(nparts, &counts, nparts + 1, &offsets, nparts, &cursor));
8787: for (PetscInt i = 0; i < n; i++) {
8788: const PetscInt node = pcbddc->primal_indices_local_idxs[i];
8789: const PetscInt sub = graph->nodes[node].local_sub;
8790: PetscInt part;
8792: PetscCheck(sub >= 0 && sub < n_subs, PETSC_COMM_SELF, PETSC_ERR_PLIB, "Invalid local subdomain index %" PetscInt_FMT, sub);
8793: part = parts[sub];
8794: PetscCheck(part >= 0 && part < nparts, PETSC_COMM_SELF, PETSC_ERR_PLIB, "Invalid local partition index %" PetscInt_FMT, part);
8795: counts[part]++;
8796: }
8797: for (PetscInt i = 0; i < nparts; i++) offsets[i + 1] = offsets[i] + counts[i];
8798: PetscCall(PetscMalloc3(n, &order, n, &sorted_gidxs, n, &fine_to_aggregate));
8799: for (PetscInt i = 0; i < n; i++) {
8800: const PetscInt node = pcbddc->primal_indices_local_idxs[i];
8801: const PetscInt sub = graph->nodes[node].local_sub;
8802: PetscInt part, slot;
8804: PetscCheck(sub >= 0 && sub < n_subs, PETSC_COMM_SELF, PETSC_ERR_PLIB, "Invalid local subdomain index %" PetscInt_FMT, sub);
8805: part = parts[sub];
8806: slot = offsets[part] + cursor[part]++;
8807: order[slot] = i;
8808: sorted_gidxs[slot] = gidxs[i];
8809: }
8811: PetscCall(PetscMalloc1(n, &aggregate_gidxs));
8812: PetscCall(PetscMalloc1(nparts, &block_sizes));
8813: naggregate = 0;
8814: for (PetscInt part = 0; part < nparts; part++) {
8815: PetscInt last = PETSC_INT_MIN;
8817: PetscCall(PetscSortIntWithArray(counts[part], sorted_gidxs + offsets[part], order + offsets[part]));
8818: block_sizes[part] = 0;
8819: for (PetscInt j = offsets[part]; j < offsets[part + 1]; j++) {
8820: if (!block_sizes[part] || sorted_gidxs[j] != last) {
8821: last = sorted_gidxs[j];
8822: aggregate_gidxs[naggregate] = last;
8823: block_sizes[part]++;
8824: naggregate++;
8825: }
8826: fine_to_aggregate[order[j]] = naggregate - 1;
8827: }
8828: /* Empty parts do not define variable blocks in the aggregated matrix */
8829: if (block_sizes[part]) block_sizes[nblocks++] = block_sizes[part];
8830: }
8831: PetscCall(PetscFree3(counts, offsets, cursor));
8832: PetscCall(ISLocalToGlobalMappingRestoreIndices(matis->rmapping, &gidxs));
8833: PetscCall(ISRestoreIndices(partition, &parts));
8835: PetscCall(ISLocalToGlobalMappingCreate(PetscObjectComm((PetscObject)mat_is), 1, naggregate, aggregate_gidxs, PETSC_COPY_VALUES, &l2gmap));
8836: PetscCall(MatGetSize(mat_is, &M, &N));
8837: PetscCall(MatGetLocalSize(mat_is, &m, &nc));
8838: PetscCall(MatCreate(PetscObjectComm((PetscObject)mat_is), mat_new));
8839: PetscCall(MatSetType(*mat_new, MATIS));
8840: PetscCall(MatSetSizes(*mat_new, m, nc, M, N));
8841: PetscCall(MatISSetAllowRepeated(*mat_new, PETSC_TRUE));
8842: PetscCall(MatSetLocalToGlobalMapping(*mat_new, l2gmap, l2gmap));
8843: PetscCall(ISLocalToGlobalMappingDestroy(&l2gmap));
8844: PetscCall(PetscFree(aggregate_gidxs));
8845: PetscCall(ISCreateGeneral(PETSC_COMM_SELF, n, fine_to_aggregate, PETSC_COPY_VALUES, &is_fine_to_aggregate));
8846: PetscCall(PetscObjectCompose((PetscObject)*mat_new, "_PCBDDC_fine_to_aggregate", (PetscObject)is_fine_to_aggregate));
8847: PetscCall(ISDestroy(&is_fine_to_aggregate));
8849: PetscCall(MatGetRowIJ(local_mat, 0, PETSC_FALSE, PETSC_FALSE, &nrows, &ii, &jj, &done));
8850: PetscCheck(done, PETSC_COMM_SELF, PETSC_ERR_PLIB, "Error in MatGetRowIJ()");
8851: PetscCheck(nrows == n, PETSC_COMM_SELF, PETSC_ERR_PLIB, "Invalid local coarse matrix size %" PetscInt_FMT " != %" PetscInt_FMT, nrows, n);
8852: ncoo = ii[nrows];
8853: PetscCall(PetscMalloc2(ncoo, &coo_i, ncoo, &coo_j));
8854: for (PetscInt i = 0; i < nrows; i++) {
8855: for (PetscInt j = ii[i]; j < ii[i + 1]; j++) {
8856: coo_i[j] = fine_to_aggregate[i];
8857: coo_j[j] = fine_to_aggregate[jj[j]];
8858: }
8859: }
8860: PetscCall(MatRestoreRowIJ(local_mat, 0, PETSC_FALSE, PETSC_FALSE, &nrows, &ii, &jj, &done));
8861: PetscCheck(done, PETSC_COMM_SELF, PETSC_ERR_PLIB, "Error in MatRestoreRowIJ()");
8862: PetscCall(MatSetPreallocationCOOLocal(*mat_new, ncoo, coo_i, coo_j));
8863: PetscCall(PetscFree2(coo_i, coo_j));
8864: PetscCall(PetscFree3(order, sorted_gidxs, fine_to_aggregate));
8865: }
8866: /* Reuse requires the same local sparsity pattern and entry ordering. */
8867: PetscCall(MatSeqAIJGetArrayRead(local_mat, &array));
8868: PetscCall(MatSetValuesCOO(*mat_new, array, INSERT_VALUES));
8869: PetscCall(MatSeqAIJRestoreArrayRead(local_mat, &array));
8870: if (reuse == MAT_INITIAL_MATRIX) {
8871: PetscCall(MatISGetLocalMat(*mat_new, &new_local_mat));
8872: PetscCall(MatSetVariableBlockSizes(new_local_mat, nblocks, block_sizes));
8873: PetscCall(MatISRestoreLocalMat(*mat_new, &new_local_mat));
8874: PetscCall(PetscFree(block_sizes));
8875: }
8876: PetscCall(MatDestroy(&local_mat_aij));
8877: PetscCall(PCBDDCAggregateLocalCoarseVec(*mat_new, vec));
8878: PetscFunctionReturn(PETSC_SUCCESS);
8879: }
8881: /* temporary hack into ksp private data structure */
8882: #include <petsc/private/kspimpl.h>
8884: PetscErrorCode PCBDDCSetUpCoarseSolver(PC pc, Mat coarse_submat)
8885: {
8886: PC_BDDC *pcbddc = (PC_BDDC *)pc->data;
8887: PC_IS *pcis = (PC_IS *)pc->data;
8888: PCBDDCGraph graph = pcbddc->mat_graph;
8889: Mat coarse_mat, coarse_mat_is;
8890: Mat coarsedivudotp = NULL;
8891: Mat coarseG, t_coarse_mat_is;
8892: MatNullSpace CoarseNullSpace = NULL;
8893: ISLocalToGlobalMapping coarse_islg;
8894: IS coarse_is, *isarray, corners;
8895: PetscInt i, active_procs = -1;
8896: PetscInt nis, nisdofs, nisneu, nisvert;
8897: PetscInt coarse_eqs_per_proc, coarsening_ratio;
8898: PC pc_temp;
8899: PCType coarse_pc_type;
8900: KSPType coarse_ksp_type;
8901: PetscBool multilevel_requested, multilevel_allowed;
8902: PetscBool coarse_reuse, multi_element = graph->multi_element;
8903: PetscInt ncoarse;
8904: PetscBool compute_vecs = PETSC_FALSE;
8905: PetscScalar *array;
8906: MatReuse coarse_mat_reuse;
8907: PetscBool restr, full_restr, have_void, dump_subassembling = PETSC_FALSE;
8908: PetscMPIInt size;
8909: char *part_prefix = NULL;
8911: PetscFunctionBegin;
8912: PetscCall(PetscLogEventBegin(PC_BDDC_CoarseSetUp[pcbddc->current_level], pc, 0, 0, 0));
8913: /* Assign global numbering to coarse dofs */
8914: if (pcbddc->new_primal_space || pcbddc->coarse_size == -1) { /* a new primal space is present or it is the first initialization, so recompute global numbering */
8915: PetscInt ocoarse_size;
8916: compute_vecs = PETSC_TRUE;
8918: pcbddc->new_primal_space = PETSC_TRUE;
8919: ocoarse_size = pcbddc->coarse_size;
8920: PetscCall(PetscFree(pcbddc->global_primal_indices));
8921: PetscCall(PCBDDCComputePrimalNumbering(pc, &pcbddc->coarse_size, &pcbddc->global_primal_indices));
8922: /* see if we can avoid some work */
8923: if (pcbddc->coarse_ksp) { /* coarse ksp has already been created */
8924: /* better not to reuse the coarse matrix in these cases */
8925: if (ocoarse_size != pcbddc->coarse_size || pcbddc->adaptive_selection || pcbddc->recompute_topography) {
8926: PetscCall(KSPReset(pcbddc->coarse_ksp));
8927: coarse_reuse = PETSC_FALSE;
8928: } else { /* we can safely reuse already computed coarse matrix */
8929: coarse_reuse = PETSC_TRUE;
8930: }
8931: } else { /* there's no coarse ksp, so we need to create the coarse matrix too */
8932: coarse_reuse = PETSC_FALSE;
8933: }
8934: /* reset any subassembling information */
8935: if (!coarse_reuse) PetscCall(ISDestroy(&pcbddc->coarse_subassembling));
8936: } else { /* primal space is unchanged, so we can reuse coarse matrix */
8937: coarse_reuse = PETSC_TRUE;
8938: }
8939: /* allow override of coarse reuse: diagnostic option */
8940: PetscCall(PetscOptionsGetBool(((PetscObject)pc)->options, ((PetscObject)pc)->prefix, "-pc_bddc_coarse_reuse", &coarse_reuse, NULL));
8942: if (coarse_reuse && pcbddc->coarse_ksp) {
8943: PetscCall(KSPGetOperators(pcbddc->coarse_ksp, &coarse_mat, NULL));
8944: PetscCall(PetscObjectReference((PetscObject)coarse_mat));
8945: coarse_mat_reuse = MAT_REUSE_MATRIX;
8946: } else {
8947: coarse_mat = NULL;
8948: coarse_mat_reuse = MAT_INITIAL_MATRIX;
8949: }
8951: /* creates temporary l2gmap and IS for coarse indexes */
8952: PetscCall(ISCreateGeneral(PetscObjectComm((PetscObject)pc), pcbddc->local_primal_size, pcbddc->global_primal_indices, PETSC_COPY_VALUES, &coarse_is));
8953: PetscCall(ISLocalToGlobalMappingCreateIS(coarse_is, &coarse_islg));
8955: /* creates temporary MATIS object for coarse matrix */
8956: PetscCall(MatCreate(PetscObjectComm((PetscObject)pc), &t_coarse_mat_is));
8957: PetscCall(MatSetType(t_coarse_mat_is, MATIS));
8958: PetscCall(MatSetSizes(t_coarse_mat_is, PETSC_DECIDE, PETSC_DECIDE, pcbddc->coarse_size, pcbddc->coarse_size));
8959: PetscCall(MatISSetAllowRepeated(t_coarse_mat_is, multi_element));
8960: PetscCall(MatSetLocalToGlobalMapping(t_coarse_mat_is, coarse_islg, coarse_islg));
8961: PetscCall(MatISSetLocalMat(t_coarse_mat_is, coarse_submat));
8962: PetscCall(MatAssemblyBegin(t_coarse_mat_is, MAT_FINAL_ASSEMBLY));
8963: PetscCall(MatAssemblyEnd(t_coarse_mat_is, MAT_FINAL_ASSEMBLY));
8964: PetscCall(MatViewFromOptions(t_coarse_mat_is, (PetscObject)pc, "-pc_bddc_coarse_mat_is_view"));
8966: /* count "active" (i.e. with positive local size) and "void" processes */
8967: active_procs = !!pcis->n;
8968: PetscCallMPI(MPIU_Allreduce(MPI_IN_PLACE, &active_procs, 1, MPIU_INT, MPI_SUM, PetscObjectComm((PetscObject)pc)));
8970: /* determine number of processes partecipating to coarse solver and compute subassembling pattern */
8971: /* restr : whether we want to exclude senders (which are not receivers) from the subassembling pattern */
8972: /* full_restr : just use the receivers from the subassembling pattern */
8973: PetscCallMPI(MPI_Comm_size(PetscObjectComm((PetscObject)pc), &size));
8974: coarse_mat_is = NULL;
8975: multilevel_allowed = PETSC_FALSE;
8976: multilevel_requested = PETSC_FALSE;
8977: coarse_eqs_per_proc = PetscMin(PetscMax(pcbddc->coarse_size, 1), pcbddc->coarse_eqs_per_proc);
8978: if (coarse_eqs_per_proc < 0 || size == 1) coarse_eqs_per_proc = PetscMax(pcbddc->coarse_size, 1);
8979: if (pcbddc->current_level < pcbddc->max_levels) multilevel_requested = PETSC_TRUE;
8980: if (pcbddc->coarse_size <= pcbddc->coarse_eqs_limit) multilevel_requested = PETSC_FALSE;
8981: coarsening_ratio = pcbddc->coarsening_ratio;
8983: /* aggregation prefix */
8984: {
8985: const char *pc_prefix = ((PetscObject)pc)->prefix ? ((PetscObject)pc)->prefix : "";
8986: char aggregator_suffix[64];
8987: size_t user_len, pc_len, len, aggregator_len;
8988: PetscInt level = pcbddc->current_level;
8990: /* prefix for aggregation and coarse redistribution */
8991: PetscCall(PetscStrlen(pc_prefix, &pc_len));
8992: user_len = pc_len;
8993: if (level) {
8994: char coarse_suffix[64];
8995: size_t coarse_len;
8996: PetscBool valid;
8998: if (level > 1) PetscCall(PetscSNPrintf(coarse_suffix, sizeof(coarse_suffix), "pc_bddc_coarse_l%" PetscInt_FMT "_", level - 1));
8999: else PetscCall(PetscStrncpy(coarse_suffix, "pc_bddc_coarse_", sizeof(coarse_suffix)));
9000: PetscCall(PetscStrendswith(pc_prefix, coarse_suffix, &valid));
9001: PetscCheck(valid, PetscObjectComm((PetscObject)pc), PETSC_ERR_PLIB, "Unexpected BDDC prefix \"%s\" at level %" PetscInt_FMT ", expected suffix \"%s\"", pc_prefix, level, coarse_suffix);
9002: PetscCall(PetscStrlen(coarse_suffix, &coarse_len));
9003: user_len = pc_len - coarse_len;
9004: }
9006: PetscCall(PetscSNPrintf(aggregator_suffix, sizeof(aggregator_suffix), "pc_bddc_aggregator_%" PetscInt_FMT "_", level));
9007: PetscCall(PetscStrlen(aggregator_suffix, &aggregator_len));
9008: len = user_len + aggregator_len + 1;
9009: PetscCall(PetscMalloc1(len, &part_prefix));
9010: PetscCall(PetscStrncpy(part_prefix, pc_prefix, user_len + 1));
9011: PetscCall(PetscStrlcat(part_prefix, aggregator_suffix, len));
9012: }
9013: if (multilevel_requested) {
9014: if (multi_element) ncoarse = active_procs;
9015: else ncoarse = active_procs / coarsening_ratio;
9016: restr = PETSC_FALSE;
9017: full_restr = PETSC_FALSE;
9018: } else {
9019: ncoarse = pcbddc->coarse_size / coarse_eqs_per_proc + !!(pcbddc->coarse_size % coarse_eqs_per_proc);
9020: restr = PETSC_TRUE;
9021: full_restr = PETSC_TRUE;
9022: }
9023: if (!pcbddc->coarse_size || (size == 1 && !multi_element)) multilevel_allowed = multilevel_requested = restr = full_restr = PETSC_FALSE;
9024: ncoarse = PetscMax(1, ncoarse);
9026: if (!pcbddc->coarse_subassembling) {
9027: if (!multi_element && coarsening_ratio > 1) {
9028: dump_subassembling = PETSC_TRUE;
9029: if (multilevel_requested) PetscCall(PCBDDCMatISGetSubassemblingPattern(pc->pmat, part_prefix, &ncoarse, pcbddc->coarse_adj_red, &pcbddc->coarse_subassembling, &have_void));
9030: else PetscCall(PCBDDCMatISGetSubassemblingPattern(t_coarse_mat_is, part_prefix, &ncoarse, pcbddc->coarse_adj_red, &pcbddc->coarse_subassembling, &have_void));
9031: } else {
9032: PetscMPIInt rank;
9034: PetscCallMPI(MPI_Comm_rank(PetscObjectComm((PetscObject)pc), &rank));
9035: have_void = (active_procs == size) ? PETSC_FALSE : PETSC_TRUE;
9036: PetscCall(ISCreateStride(PetscObjectComm((PetscObject)pc), 1, rank, 1, &pcbddc->coarse_subassembling));
9037: PetscCall(PetscObjectSetName((PetscObject)pcbddc->coarse_subassembling, "default subassembling"));
9038: }
9039: } else { /* if a subassembling pattern exists, then we can reuse the coarse ksp and compute the number of process involved */
9040: if (pcbddc->coarse_ksp) ncoarse = 1;
9041: else ncoarse = 0;
9042: PetscCallMPI(MPIU_Allreduce(MPI_IN_PLACE, &ncoarse, 1, MPIU_INT, MPI_SUM, PetscObjectComm((PetscObject)pc)));
9043: have_void = ncoarse < size ? PETSC_TRUE : PETSC_FALSE;
9044: }
9045: /* determine if we can do multilevel */
9046: if (multilevel_requested) {
9047: if (multi_element || ncoarse > 1) multilevel_allowed = PETSC_TRUE; /* found enough processes or local subdomains */
9048: else restr = full_restr = PETSC_TRUE; /* 1 subdomain, use a direct solver */
9049: }
9050: if (multilevel_allowed && have_void) restr = PETSC_TRUE;
9051: /* dump subassembling pattern */
9052: if (pcbddc->dbg_flag && (multilevel_allowed || dump_subassembling)) PetscCall(ISView(pcbddc->coarse_subassembling, pcbddc->dbg_viewer));
9054: /* compute dofs splitting and neumann boundaries for coarse dofs */
9055: corners = NULL;
9056: if (multilevel_allowed && !coarse_reuse && (pcbddc->n_ISForDofsLocal || pcbddc->NeumannBoundariesLocal || pcbddc->nedcG || pcbddc->corner_selected)) { /* protects from unneeded computations */
9057: PetscInt *tidxs, *tidxs2, nout, tsize, i;
9058: const PetscInt *idxs;
9059: ISLocalToGlobalMapping tmap;
9061: /* create map between primal indices (in local representative ordering) and local primal numbering */
9062: PetscCall(ISLocalToGlobalMappingCreate(PETSC_COMM_SELF, 1, pcbddc->local_primal_size, pcbddc->primal_indices_local_idxs, PETSC_COPY_VALUES, &tmap));
9063: /* allocate space for temporary storage */
9064: PetscCall(PetscMalloc1(pcbddc->local_primal_size, &tidxs));
9065: PetscCall(PetscMalloc1(pcbddc->local_primal_size, &tidxs2));
9066: /* allocate for IS array */
9067: nisdofs = pcbddc->n_ISForDofsLocal;
9068: nisneu = !!pcbddc->NeumannBoundariesLocal;
9069: nisvert = 0; /* nisvert is not used */
9070: nis = nisdofs + nisneu + nisvert;
9071: PetscCall(PetscMalloc1(nis, &isarray));
9072: /* dofs splitting */
9073: for (i = 0; i < nisdofs; i++) {
9074: PetscCall(ISGetLocalSize(pcbddc->ISForDofsLocal[i], &tsize));
9075: PetscCall(ISGetIndices(pcbddc->ISForDofsLocal[i], &idxs));
9076: PetscCall(ISGlobalToLocalMappingApply(tmap, IS_GTOLM_DROP, tsize, idxs, &nout, tidxs));
9077: PetscCall(ISRestoreIndices(pcbddc->ISForDofsLocal[i], &idxs));
9078: PetscCall(ISLocalToGlobalMappingApply(coarse_islg, nout, tidxs, tidxs2));
9079: PetscCall(ISCreateGeneral(PetscObjectComm((PetscObject)pc), nout, tidxs2, PETSC_COPY_VALUES, &isarray[i]));
9080: }
9081: /* neumann boundaries */
9082: if (pcbddc->NeumannBoundariesLocal) {
9083: PetscCall(ISGetLocalSize(pcbddc->NeumannBoundariesLocal, &tsize));
9084: PetscCall(ISGetIndices(pcbddc->NeumannBoundariesLocal, &idxs));
9085: PetscCall(ISGlobalToLocalMappingApply(tmap, IS_GTOLM_DROP, tsize, idxs, &nout, tidxs));
9086: PetscCall(ISRestoreIndices(pcbddc->NeumannBoundariesLocal, &idxs));
9087: PetscCall(ISLocalToGlobalMappingApply(coarse_islg, nout, tidxs, tidxs2));
9088: PetscCall(ISCreateGeneral(PetscObjectComm((PetscObject)pc), nout, tidxs2, PETSC_COPY_VALUES, &isarray[nisdofs]));
9089: }
9090: /* coordinates */
9091: if (pcbddc->corner_selected) {
9092: PetscCall(PCBDDCGraphGetCandidatesIS(pcbddc->mat_graph, NULL, NULL, NULL, NULL, &corners));
9093: PetscCall(ISGetLocalSize(corners, &tsize));
9094: PetscCall(ISGetIndices(corners, &idxs));
9095: PetscCall(ISGlobalToLocalMappingApply(tmap, IS_GTOLM_DROP, tsize, idxs, &nout, tidxs));
9096: PetscCheck(tsize == nout, PETSC_COMM_SELF, PETSC_ERR_PLIB, "Failed when mapping corners! %" PetscInt_FMT " != %" PetscInt_FMT, tsize, nout);
9097: PetscCall(ISRestoreIndices(corners, &idxs));
9098: PetscCall(PCBDDCGraphRestoreCandidatesIS(pcbddc->mat_graph, NULL, NULL, NULL, NULL, &corners));
9099: PetscCall(ISLocalToGlobalMappingApply(coarse_islg, nout, tidxs, tidxs2));
9100: PetscCall(ISCreateGeneral(PetscObjectComm((PetscObject)pc), nout, tidxs2, PETSC_COPY_VALUES, &corners));
9101: }
9102: /* Map the discrete gradient from the fine global ordering to the coarse global ordering */
9103: if (pcbddc->nedcG) {
9104: Mat tG;
9105: PetscSF sf;
9106: IS rows;
9107: PetscInt nrows, *frows;
9109: PetscCall(MatGetLocalSize(t_coarse_mat_is, &nrows, NULL));
9110: PetscCall(PetscMalloc1(nrows, &frows));
9111: for (i = 0; i < nrows; i++) frows[i] = -1;
9112: PetscCall(ISLocalToGlobalMappingApply(pcis->mapping, pcbddc->local_primal_size, pcbddc->primal_indices_local_idxs, tidxs));
9113: PetscCall(PetscSFCreate(PetscObjectComm((PetscObject)pc), &sf));
9114: PetscCall(PetscSFSetGraphLayout(sf, t_coarse_mat_is->rmap, pcbddc->local_primal_size, NULL, PETSC_USE_POINTER, pcbddc->global_primal_indices));
9115: PetscCall(PetscSFReduceBegin(sf, MPIU_INT, tidxs, frows, MPI_REPLACE));
9116: PetscCall(PetscSFReduceEnd(sf, MPIU_INT, tidxs, frows, MPI_REPLACE));
9117: PetscCall(PetscSFDestroy(&sf));
9118: for (i = 0; i < nrows; i++) PetscCheck(frows[i] >= 0, PETSC_COMM_SELF, PETSC_ERR_PLIB, "No fine representative for coarse dof %" PetscInt_FMT, i + t_coarse_mat_is->rmap->rstart);
9119: PetscCall(ISCreateGeneral(PetscObjectComm((PetscObject)pc), nrows, frows, PETSC_OWN_POINTER, &rows));
9120: PetscCall(MatAIJExtractRows(pcbddc->nedcG, rows, &tG));
9121: PetscCall(ISDestroy(&rows));
9122: PetscCall(MatDestroy(&pcbddc->nedcG));
9123: pcbddc->nedcG = tG;
9124: }
9126: PetscCall(PetscFree(tidxs));
9127: PetscCall(PetscFree(tidxs2));
9128: PetscCall(ISLocalToGlobalMappingDestroy(&tmap));
9129: } else {
9130: nis = 0;
9131: nisdofs = 0;
9132: nisneu = 0;
9133: nisvert = 0;
9134: isarray = NULL;
9135: }
9136: /* destroy no longer needed map */
9137: PetscCall(ISLocalToGlobalMappingDestroy(&coarse_islg));
9139: /* subassemble */
9140: if (multilevel_allowed) {
9141: Vec vp[1];
9142: PetscInt nvecs = 0;
9144: vp[0] = NULL;
9145: if (pcbddc->compute_nonetflux) { /* propagate no-net-flux quadrature to coarser level */
9146: Vec v, vB;
9148: PetscCheck(pcbddc->divudotp, PetscObjectComm((PetscObject)pc), PETSC_ERR_PLIB, "Missing divudotp operator");
9149: PetscCall(VecCreate(PetscObjectComm((PetscObject)pc), &vp[0]));
9150: PetscCall(VecSetSizes(vp[0], pcbddc->local_primal_size, PETSC_DECIDE));
9151: PetscCall(VecSetType(vp[0], VECSTANDARD));
9152: nvecs = 1;
9153: PetscCall(PCBDDCComputeLocalFluxWeights(pc->pmat, pcbddc->divudotp, pcbddc->divudotp_trans, pcbddc->divudotp_vl2l, &v));
9154: PetscCall(VecGetSubVector(v, pcis->is_B_local, &vB));
9155: PetscCall(VecGetArray(vp[0], &array));
9156: PetscCall(VecPlaceArray(pcbddc->vec1_P, array));
9157: PetscCall(MatMultTranspose(pcbddc->coarse_phi_B, vB, pcbddc->vec1_P));
9158: PetscCall(VecResetArray(pcbddc->vec1_P));
9159: PetscCall(VecRestoreArray(vp[0], &array));
9160: PetscCall(VecRestoreSubVector(v, pcis->is_B_local, &vB));
9161: PetscCall(VecDestroy(&v));
9162: }
9163: if (multi_element) {
9164: if (coarse_reuse) PetscCall(PCBDDCAggregateLocalCoarseMat(pc, t_coarse_mat_is, NULL, 0, MAT_REUSE_MATRIX, &vp[0], &coarse_mat));
9165: else {
9166: IS local_partition = NULL;
9167: PetscInt *local_xadj = NULL, *local_adjncy = NULL;
9168: PetscInt local_nsubs, local_ncoarse;
9170: PetscCall(PCBDDCGraphCreateLocalSubdomainAdjacency(graph, &local_nsubs, &local_xadj, &local_adjncy));
9171: if (pcbddc->dbg_flag) PetscCall(PetscIntCSRView(local_nsubs, local_xadj, local_adjncy, pcbddc->dbg_viewer));
9172: local_ncoarse = PetscCeilInt(local_nsubs, coarsening_ratio);
9173: PetscCall(PCBDDCGraphPartitionLocalSubdomains(graph, part_prefix, &local_ncoarse, local_nsubs, local_xadj, local_adjncy, &local_partition));
9174: if (pcbddc->dbg_flag) {
9175: IS is;
9177: PetscCall(ISOnComm(local_partition, PetscObjectComm((PetscObject)pc), PETSC_USE_POINTER, &is));
9178: PetscCall(ISView(is, pcbddc->dbg_viewer));
9179: PetscCall(ISDestroy(&is));
9180: }
9181: PetscCall(PetscFree(local_xadj));
9182: PetscCall(PetscFree(local_adjncy));
9183: PetscCall(PCBDDCAggregateLocalCoarseMat(pc, t_coarse_mat_is, local_partition, local_ncoarse, MAT_INITIAL_MATRIX, &vp[0], &coarse_mat_is));
9184: PetscCall(ISDestroy(&local_partition));
9185: }
9186: } else {
9187: PetscBool reuse = (PetscBool)!!coarse_mat;
9189: PetscCallMPI(MPIU_Allreduce(MPI_IN_PLACE, &reuse, 1, MPI_C_BOOL, MPI_LOR, PetscObjectComm((PetscObject)pc)));
9190: if (reuse) {
9191: PetscCall(PCBDDCMatISSubassemble(t_coarse_mat_is, pcbddc->coarse_subassembling, 0, restr, full_restr, PETSC_TRUE, &coarse_mat, nis, isarray, nvecs, vp));
9192: } else {
9193: PetscCall(PCBDDCMatISSubassemble(t_coarse_mat_is, pcbddc->coarse_subassembling, 0, restr, full_restr, PETSC_FALSE, &coarse_mat_is, nis, isarray, nvecs, vp));
9194: }
9195: }
9196: if (vp[0]) { /* vp[0] could have been placed on a different set of processes */
9197: PetscScalar *arraym;
9198: const PetscScalar *arrayv;
9199: PetscInt nl;
9201: PetscCall(VecGetLocalSize(vp[0], &nl));
9202: PetscCall(MatCreateSeqDense(PETSC_COMM_SELF, 1, nl, NULL, &coarsedivudotp));
9203: PetscCall(MatDenseGetArray(coarsedivudotp, &arraym));
9204: PetscCall(VecGetArrayRead(vp[0], &arrayv));
9205: PetscCall(PetscArraycpy(arraym, arrayv, nl));
9206: PetscCall(VecRestoreArrayRead(vp[0], &arrayv));
9207: PetscCall(MatDenseRestoreArray(coarsedivudotp, &arraym));
9208: PetscCall(VecDestroy(&vp[0]));
9209: }
9210: } else {
9211: PetscBool default_sub;
9213: PetscCall(PetscStrcmp(((PetscObject)pcbddc->coarse_subassembling)->name, "default subassembling", &default_sub));
9214: if (!default_sub) PetscCall(PCBDDCMatISSubassemble(t_coarse_mat_is, pcbddc->coarse_subassembling, 0, restr, full_restr, PETSC_FALSE, &coarse_mat_is, 0, NULL, 0, NULL));
9215: else {
9216: PetscCall(PetscObjectReference((PetscObject)t_coarse_mat_is));
9217: coarse_mat_is = t_coarse_mat_is;
9218: }
9219: }
9220: if (coarse_mat_is || coarse_mat) {
9221: if (!multilevel_allowed) {
9222: if (coarse_mat_reuse == MAT_REUSE_MATRIX) {
9223: MatState *state;
9225: /* HACK: Reuse preserves the local pattern and entry ordering, but the temporary
9226: MATIS may contain a different local matrix object. */
9227: PetscCall(PetscObjectContainerQuery((PetscObject)coarse_mat, "_MatIS_IS_XAIJ_lstate", &state));
9228: if (state) {
9229: Mat local_mat;
9231: PetscCall(MatISGetLocalMat(coarse_mat_is, &local_mat));
9232: PetscCall(MatGetState(local_mat, state));
9233: PetscCall(MatISRestoreLocalMat(coarse_mat_is, &local_mat));
9234: }
9235: }
9236: PetscCall(MatConvert(coarse_mat_is, MATAIJ, coarse_mat_reuse, &coarse_mat));
9237: } else {
9238: /* if this matrix is present, it means we are not reusing the coarse matrix */
9239: if (coarse_mat_is) {
9240: PetscCheck(!coarse_mat, PetscObjectComm((PetscObject)coarse_mat_is), PETSC_ERR_PLIB, "This should not happen");
9241: PetscCall(PetscObjectReference((PetscObject)coarse_mat_is));
9242: coarse_mat = coarse_mat_is;
9243: }
9244: }
9245: }
9246: PetscCall(PetscFree(part_prefix));
9247: PetscCall(MatDestroy(&t_coarse_mat_is));
9248: PetscCall(MatDestroy(&coarse_mat_is));
9250: /* create local to global scatters for coarse problem */
9251: if (compute_vecs) {
9252: PetscInt lrows;
9253: PetscCall(VecDestroy(&pcbddc->coarse_vec));
9254: if (coarse_mat) {
9255: PetscCall(MatGetLocalSize(coarse_mat, &lrows, NULL));
9256: } else {
9257: lrows = 0;
9258: }
9259: PetscCall(VecCreate(PetscObjectComm((PetscObject)pc), &pcbddc->coarse_vec));
9260: PetscCall(VecSetSizes(pcbddc->coarse_vec, lrows, PETSC_DECIDE));
9261: PetscCall(VecSetType(pcbddc->coarse_vec, coarse_mat ? coarse_mat->defaultvectype : VECSTANDARD));
9262: PetscCall(VecScatterDestroy(&pcbddc->coarse_loc_to_glob));
9263: PetscCall(VecScatterCreate(pcbddc->vec1_P, NULL, pcbddc->coarse_vec, coarse_is, &pcbddc->coarse_loc_to_glob));
9264: }
9265: PetscCall(ISDestroy(&coarse_is));
9267: /* set defaults for coarse KSP and PC */
9268: if (multilevel_allowed) {
9269: coarse_ksp_type = KSPRICHARDSON;
9270: coarse_pc_type = PCBDDC;
9271: } else {
9272: coarse_ksp_type = KSPPREONLY;
9273: coarse_pc_type = PCREDUNDANT;
9274: }
9276: /* print some info if requested */
9277: if (pcbddc->dbg_flag) {
9278: if (!multilevel_allowed) {
9279: PetscCall(PetscViewerASCIIPrintf(pcbddc->dbg_viewer, "--------------------------------------------------\n"));
9280: if (multilevel_requested) {
9281: PetscCall(PetscViewerASCIIPrintf(pcbddc->dbg_viewer, "Not enough active processes on level %" PetscInt_FMT " (active processes %" PetscInt_FMT ", coarsening ratio %" PetscInt_FMT ")\n", pcbddc->current_level, active_procs, coarsening_ratio));
9282: } else if (pcbddc->max_levels) {
9283: PetscCall(PetscViewerASCIIPrintf(pcbddc->dbg_viewer, "Maximum number of requested levels reached (%" PetscInt_FMT ")\n", pcbddc->max_levels));
9284: }
9285: PetscCall(PetscViewerFlush(pcbddc->dbg_viewer));
9286: }
9287: }
9289: /* communicate coarse discrete gradient */
9290: coarseG = NULL;
9291: if (pcbddc->nedcG && multilevel_allowed) {
9292: MPI_Comm ccomm;
9294: if (coarse_mat) ccomm = PetscObjectComm((PetscObject)coarse_mat);
9295: else ccomm = MPI_COMM_NULL;
9296: PetscCall(MatMPIAIJRestrict(pcbddc->nedcG, ccomm, &coarseG));
9297: }
9299: /* A different coarse MPI communicator requires destroying the KSP on all of its old ranks */
9300: if (pcbddc->coarse_ksp) {
9301: PetscMPIInt comparison = MPI_UNEQUAL;
9303: if (coarse_mat) PetscCallMPI(MPI_Comm_compare(PetscObjectComm((PetscObject)pcbddc->coarse_ksp), PetscObjectComm((PetscObject)coarse_mat), &comparison));
9304: if (comparison != MPI_IDENT && comparison != MPI_CONGRUENT) PetscCall(KSPDestroy(&pcbddc->coarse_ksp));
9305: }
9307: /* create the coarse KSP object with defaults when needed */
9308: if (coarse_mat) {
9309: PetscBool isredundant, isbddc, force, valid;
9310: PetscViewer dbg_viewer = NULL;
9311: PetscBool isset, issym, isher, isspd;
9313: if (pcbddc->dbg_flag) {
9314: dbg_viewer = PETSC_VIEWER_STDOUT_(PetscObjectComm((PetscObject)coarse_mat));
9315: PetscCall(PetscViewerASCIIAddTab(dbg_viewer, 2 * pcbddc->current_level));
9316: }
9317: if (!pcbddc->coarse_ksp) {
9318: char prefix[256], str_level[16];
9319: size_t len;
9321: PetscCall(KSPCreate(PetscObjectComm((PetscObject)coarse_mat), &pcbddc->coarse_ksp));
9322: PetscCall(KSPSetNestLevel(pcbddc->coarse_ksp, pc->kspnestlevel));
9323: PetscCall(KSPSetErrorIfNotConverged(pcbddc->coarse_ksp, pc->erroriffailure));
9324: PetscCall(PetscObjectIncrementTabLevel((PetscObject)pcbddc->coarse_ksp, (PetscObject)pc, 1));
9325: PetscCall(KSPSetTolerances(pcbddc->coarse_ksp, PETSC_CURRENT, PETSC_CURRENT, PETSC_CURRENT, 1));
9326: PetscCall(KSPSetOperators(pcbddc->coarse_ksp, coarse_mat, coarse_mat));
9327: PetscCall(KSPSetType(pcbddc->coarse_ksp, coarse_ksp_type));
9328: PetscCall(KSPSetNormType(pcbddc->coarse_ksp, KSP_NORM_NONE));
9329: PetscCall(KSPGetPC(pcbddc->coarse_ksp, &pc_temp));
9330: /* TODO is this logic correct? should check for coarse_mat type */
9331: PetscCall(PCSetType(pc_temp, coarse_pc_type));
9332: /* prefix */
9333: PetscCall(PetscStrncpy(prefix, "", sizeof(prefix)));
9334: PetscCall(PetscStrncpy(str_level, "", sizeof(str_level)));
9335: if (!pcbddc->current_level) {
9336: PetscCall(PetscStrncpy(prefix, ((PetscObject)pc)->prefix, sizeof(prefix)));
9337: PetscCall(PetscStrlcat(prefix, "pc_bddc_coarse_", sizeof(prefix)));
9338: } else {
9339: PetscCall(PetscStrlen(((PetscObject)pc)->prefix, &len));
9340: if (pcbddc->current_level > 1) len -= 3; /* remove "lX_" with X level number */
9341: if (pcbddc->current_level > 10) len -= 1; /* remove another char from level number */
9342: /* Nonstandard use of PetscStrncpy() to copy only a portion of the string */
9343: PetscCall(PetscStrncpy(prefix, ((PetscObject)pc)->prefix, len + 1));
9344: PetscCall(PetscSNPrintf(str_level, sizeof(str_level), "l%" PetscInt_FMT "_", pcbddc->current_level));
9345: PetscCall(PetscStrlcat(prefix, str_level, sizeof(prefix)));
9346: }
9347: PetscCall(KSPSetOptionsPrefix(pcbddc->coarse_ksp, prefix));
9348: /* propagate BDDC info to the next level (these are dummy calls if pc_temp is not of type PCBDDC) */
9349: PetscCall(PCBDDCSetLevel(pc_temp, pcbddc->current_level + 1));
9350: PetscCall(PCBDDCSetCoarseningRatio(pc_temp, pcbddc->coarsening_ratio));
9351: PetscCall(PCBDDCSetLevels(pc_temp, pcbddc->max_levels));
9352: /* allow user customization */
9353: PetscCall(KSPSetFromOptions(pcbddc->coarse_ksp));
9354: /* get some info after set from options */
9355: PetscCall(KSPGetPC(pcbddc->coarse_ksp, &pc_temp));
9356: /* multilevel cannot be done with coarse PC different from BDDC, NN, HPDDM, unless forced to */
9357: force = PETSC_FALSE;
9358: PetscCall(PetscOptionsGetBool(NULL, ((PetscObject)pc_temp)->prefix, "-pc_type_forced", &force, NULL));
9359: PetscCall(PetscObjectTypeCompareAny((PetscObject)pc_temp, &valid, PCBDDC, PCNN, PCHPDDM, ""));
9360: PetscCall(PetscObjectTypeCompare((PetscObject)pc_temp, PCBDDC, &isbddc));
9361: if (multilevel_allowed && !force && !valid) {
9362: isbddc = PETSC_TRUE;
9363: PetscCall(PCSetType(pc_temp, PCBDDC));
9364: PetscCall(PCBDDCSetLevel(pc_temp, pcbddc->current_level + 1));
9365: PetscCall(PCBDDCSetCoarseningRatio(pc_temp, pcbddc->coarsening_ratio));
9366: PetscCall(PCBDDCSetLevels(pc_temp, pcbddc->max_levels));
9367: if (pc_temp->ops->setfromoptions) { /* need to setfromoptions again, skipping the pc_type */
9368: PetscObjectOptionsBegin((PetscObject)pc_temp);
9369: PetscUseTypeMethod(pc_temp, setfromoptions, PetscOptionsObject);
9370: PetscCall(PetscObjectProcessOptionsHandlers((PetscObject)pc_temp, PetscOptionsObject));
9371: PetscOptionsEnd();
9372: pc_temp->setfromoptionscalled++;
9373: }
9374: }
9375: }
9376: /* propagate BDDC info to the next level (these are dummy calls if pc_temp is not of type PCBDDC) */
9377: PetscCall(KSPGetPC(pcbddc->coarse_ksp, &pc_temp));
9378: if (nisdofs) {
9379: PetscCall(PCBDDCSetDofsSplitting(pc_temp, nisdofs, isarray));
9380: for (i = 0; i < nisdofs; i++) PetscCall(ISDestroy(&isarray[i]));
9381: }
9382: if (nisneu) {
9383: PetscCall(PCBDDCSetNeumannBoundaries(pc_temp, isarray[nisdofs]));
9384: PetscCall(ISDestroy(&isarray[nisdofs]));
9385: }
9386: if (nisvert) {
9387: PetscCall(PCBDDCSetPrimalVerticesIS(pc_temp, isarray[nis - 1]));
9388: PetscCall(ISDestroy(&isarray[nis - 1]));
9389: }
9390: if (coarseG) PetscCall(PCBDDCSetDiscreteGradient(pc_temp, coarseG, 1, PETSC_DECIDE, PETSC_TRUE, PETSC_TRUE));
9392: /* get some info after set from options */
9393: PetscCall(PetscObjectTypeCompare((PetscObject)pc_temp, PCBDDC, &isbddc));
9395: /* multilevel can only be requested via -pc_bddc_levels or PCBDDCSetLevels */
9396: if (isbddc && !multilevel_allowed) PetscCall(PCSetType(pc_temp, coarse_pc_type));
9397: /* multilevel cannot be done with coarse PC different from BDDC, NN, HPDDM, unless forced to */
9398: force = PETSC_FALSE;
9399: PetscCall(PetscOptionsGetBool(NULL, ((PetscObject)pc_temp)->prefix, "-pc_type_forced", &force, NULL));
9400: PetscCall(PetscObjectTypeCompareAny((PetscObject)pc_temp, &valid, PCBDDC, PCNN, PCHPDDM, ""));
9401: if (multilevel_requested && multilevel_allowed && !valid && !force) PetscCall(PCSetType(pc_temp, PCBDDC));
9402: PetscCall(PetscObjectTypeCompare((PetscObject)pc_temp, PCREDUNDANT, &isredundant));
9403: if (isredundant) {
9404: KSP inner_ksp;
9405: PC inner_pc;
9407: PetscCall(PCRedundantGetKSP(pc_temp, &inner_ksp));
9408: PetscCall(KSPGetPC(inner_ksp, &inner_pc));
9409: }
9411: /* parameters which miss an API */
9412: PetscCall(PetscObjectTypeCompare((PetscObject)pc_temp, PCBDDC, &isbddc));
9413: if (isbddc) {
9414: PC_BDDC *pcbddc_coarse = (PC_BDDC *)pc_temp->data;
9416: pcbddc_coarse->detect_disconnected = PETSC_TRUE;
9417: pcbddc_coarse->detect_disconnected_filter = (PetscBool)(pcbddc->detect_disconnected_filter || pcbddc->coarsening_ratio == 1);
9418: pcbddc_coarse->coarse_eqs_per_proc = pcbddc->coarse_eqs_per_proc;
9419: pcbddc_coarse->coarse_eqs_limit = pcbddc->coarse_eqs_limit;
9420: pcbddc_coarse->benign_saddle_point = pcbddc->benign_have_null;
9421: pcbddc_coarse->use_local_adj = pcbddc->use_local_adj;
9422: if (coarsedivudotp) {
9423: Mat coarsedivudotp_is;
9424: ISLocalToGlobalMapping l2gmap, rl2g, cl2g;
9425: IS row, col;
9426: const PetscInt *gidxs;
9427: PetscInt n, st, M, N;
9429: PetscCall(MatGetSize(coarsedivudotp, &n, NULL));
9430: PetscCallMPI(MPI_Scan(&n, &st, 1, MPIU_INT, MPI_SUM, PetscObjectComm((PetscObject)coarse_mat)));
9431: st = st - n;
9432: PetscCall(ISCreateStride(PetscObjectComm((PetscObject)coarse_mat), 1, st, 1, &row));
9433: PetscCall(MatISGetLocalToGlobalMapping(coarse_mat, &l2gmap, NULL));
9434: PetscCall(ISLocalToGlobalMappingGetSize(l2gmap, &n));
9435: PetscCall(ISLocalToGlobalMappingGetIndices(l2gmap, &gidxs));
9436: PetscCall(ISCreateGeneral(PetscObjectComm((PetscObject)coarse_mat), n, gidxs, PETSC_COPY_VALUES, &col));
9437: PetscCall(ISLocalToGlobalMappingRestoreIndices(l2gmap, &gidxs));
9438: PetscCall(ISLocalToGlobalMappingCreateIS(row, &rl2g));
9439: PetscCall(ISLocalToGlobalMappingCreateIS(col, &cl2g));
9440: PetscCall(ISGetSize(row, &M));
9441: PetscCall(MatGetSize(coarse_mat, &N, NULL));
9442: PetscCall(ISDestroy(&row));
9443: PetscCall(ISDestroy(&col));
9444: PetscCall(MatCreate(PetscObjectComm((PetscObject)coarse_mat), &coarsedivudotp_is));
9445: PetscCall(MatSetType(coarsedivudotp_is, MATIS));
9446: PetscCall(MatSetSizes(coarsedivudotp_is, PETSC_DECIDE, PETSC_DECIDE, M, N));
9447: PetscCall(MatISSetAllowRepeated(coarsedivudotp_is, multi_element));
9448: PetscCall(MatSetLocalToGlobalMapping(coarsedivudotp_is, rl2g, cl2g));
9449: PetscCall(ISLocalToGlobalMappingDestroy(&rl2g));
9450: PetscCall(ISLocalToGlobalMappingDestroy(&cl2g));
9451: PetscCall(MatISSetLocalMat(coarsedivudotp_is, coarsedivudotp));
9452: PetscCall(MatDestroy(&coarsedivudotp));
9453: PetscCall(PCBDDCSetDivergenceMat(pc_temp, coarsedivudotp_is, PETSC_FALSE, NULL));
9454: PetscCall(MatDestroy(&coarsedivudotp_is));
9455: }
9456: if (pcbddc_coarse->benign_saddle_point) {
9457: pcbddc_coarse->adaptive_userdefined = PETSC_TRUE;
9458: if (pcbddc->adaptive_threshold[0] == 0.0) pcbddc_coarse->deluxe_zerorows = PETSC_TRUE;
9459: }
9460: }
9462: /* propagate symmetry info of coarse matrix */
9463: PetscCall(MatIsSymmetricKnown(pc->pmat, &isset, &issym));
9464: if (isset) PetscCall(MatSetOption(coarse_mat, MAT_SYMMETRIC, issym));
9465: PetscCall(MatIsHermitianKnown(pc->pmat, &isset, &isher));
9466: if (isset) PetscCall(MatSetOption(coarse_mat, MAT_HERMITIAN, isher));
9467: PetscCall(MatIsSPDKnown(pc->pmat, &isset, &isspd));
9468: if (isset) PetscCall(MatSetOption(coarse_mat, MAT_SPD, isspd));
9470: if (pcbddc->benign_saddle_point && !pcbddc->benign_have_null) PetscCall(MatSetOption(coarse_mat, MAT_SPD, PETSC_TRUE));
9471: /* set operators */
9472: PetscCall(MatViewFromOptions(coarse_mat, (PetscObject)pc, "-pc_bddc_coarse_mat_view"));
9473: PetscCall(MatSetOptionsPrefix(coarse_mat, ((PetscObject)pcbddc->coarse_ksp)->prefix));
9474: PetscCall(KSPSetOperators(pcbddc->coarse_ksp, coarse_mat, coarse_mat));
9475: if (pcbddc->dbg_flag) PetscCall(PetscViewerASCIISubtractTab(dbg_viewer, 2 * pcbddc->current_level));
9476: }
9477: PetscCall(MatDestroy(&coarseG));
9478: PetscCall(PetscFree(isarray));
9479: #if 0
9480: {
9481: PetscViewer viewer;
9482: char filename[256];
9483: PetscCall(PetscSNPrintf(filename, PETSC_STATIC_ARRAY_LENGTH(filename), "coarse_mat_level%d.m",pcbddc->current_level));
9484: PetscCall(PetscViewerASCIIOpen(PetscObjectComm((PetscObject)coarse_mat),filename,&viewer));
9485: PetscCall(PetscViewerPushFormat(viewer,PETSC_VIEWER_ASCII_MATLAB));
9486: PetscCall(MatView(coarse_mat,viewer));
9487: PetscCall(PetscViewerPopFormat(viewer));
9488: PetscCall(PetscViewerDestroy(&viewer));
9489: }
9490: #endif
9492: if (corners) {
9493: Vec gv;
9494: IS is;
9495: const PetscInt *idxs;
9496: PetscInt i, d, N, n, cdim = pcbddc->mat_graph->cdim;
9497: PetscScalar *coords;
9499: PetscCheck(pcbddc->mat_graph->cloc, PETSC_COMM_SELF, PETSC_ERR_PLIB, "Missing local coordinates");
9500: PetscCall(VecGetSize(pcbddc->coarse_vec, &N));
9501: PetscCall(VecGetLocalSize(pcbddc->coarse_vec, &n));
9502: PetscCall(VecCreate(PetscObjectComm((PetscObject)pcbddc->coarse_vec), &gv));
9503: PetscCall(VecSetBlockSize(gv, cdim));
9504: PetscCall(VecSetSizes(gv, n * cdim, N * cdim));
9505: PetscCall(VecSetType(gv, VECSTANDARD));
9506: PetscCall(VecSetFromOptions(gv));
9507: PetscCall(VecSet(gv, PETSC_MAX_REAL)); /* we only propagate coordinates from vertices constraints */
9509: PetscCall(PCBDDCGraphGetCandidatesIS(pcbddc->mat_graph, NULL, NULL, NULL, NULL, &is));
9510: PetscCall(ISGetLocalSize(is, &n));
9511: PetscCall(ISGetIndices(is, &idxs));
9512: PetscCall(PetscMalloc1(n * cdim, &coords));
9513: for (i = 0; i < n; i++) {
9514: for (d = 0; d < cdim; d++) coords[cdim * i + d] = pcbddc->mat_graph->coords[cdim * idxs[i] + d];
9515: }
9516: PetscCall(ISRestoreIndices(is, &idxs));
9517: PetscCall(PCBDDCGraphRestoreCandidatesIS(pcbddc->mat_graph, NULL, NULL, NULL, NULL, &is));
9519: PetscCall(ISGetLocalSize(corners, &n));
9520: PetscCall(ISGetIndices(corners, &idxs));
9521: PetscCall(VecSetValuesBlocked(gv, n, idxs, coords, INSERT_VALUES));
9522: PetscCall(ISRestoreIndices(corners, &idxs));
9523: PetscCall(PetscFree(coords));
9524: PetscCall(VecAssemblyBegin(gv));
9525: PetscCall(VecAssemblyEnd(gv));
9526: PetscCall(VecGetArray(gv, &coords));
9527: if (pcbddc->coarse_ksp) {
9528: PC coarse_pc;
9529: PetscBool isbddc;
9531: PetscCall(KSPGetPC(pcbddc->coarse_ksp, &coarse_pc));
9532: PetscCall(PetscObjectTypeCompare((PetscObject)coarse_pc, PCBDDC, &isbddc));
9533: if (isbddc) { /* coarse coordinates have PETSC_MAX_REAL, specific for BDDC */
9534: PetscReal *realcoords;
9536: PetscCall(VecGetLocalSize(gv, &n));
9537: #if PetscDefined(USE_COMPLEX)
9538: PetscCall(PetscMalloc1(n, &realcoords));
9539: for (i = 0; i < n; i++) realcoords[i] = PetscRealPart(coords[i]);
9540: #else
9541: realcoords = coords;
9542: #endif
9543: PetscCall(PCSetCoordinates(coarse_pc, cdim, n / cdim, realcoords));
9544: #if PetscDefined(USE_COMPLEX)
9545: PetscCall(PetscFree(realcoords));
9546: #endif
9547: }
9548: }
9549: PetscCall(VecRestoreArray(gv, &coords));
9550: PetscCall(VecDestroy(&gv));
9551: }
9552: PetscCall(ISDestroy(&corners));
9554: if (pcbddc->coarse_ksp) {
9555: Vec crhs, csol;
9557: PetscCall(KSPGetSolution(pcbddc->coarse_ksp, &csol));
9558: PetscCall(KSPGetRhs(pcbddc->coarse_ksp, &crhs));
9559: if (!csol) PetscCall(MatCreateVecs(coarse_mat, &pcbddc->coarse_ksp->vec_sol, NULL));
9560: if (!crhs) PetscCall(MatCreateVecs(coarse_mat, NULL, &pcbddc->coarse_ksp->vec_rhs));
9561: }
9562: PetscCall(MatDestroy(&coarsedivudotp));
9564: /* compute null space for coarse solver if the benign trick has been requested */
9565: if (pcbddc->benign_null) {
9566: PetscCall(VecSet(pcbddc->vec1_P, 0.));
9567: for (i = 0; i < pcbddc->benign_n; i++) PetscCall(VecSetValue(pcbddc->vec1_P, pcbddc->local_primal_size - pcbddc->benign_n + i, 1.0, INSERT_VALUES));
9568: PetscCall(VecAssemblyBegin(pcbddc->vec1_P));
9569: PetscCall(VecAssemblyEnd(pcbddc->vec1_P));
9570: PetscCall(VecScatterBegin(pcbddc->coarse_loc_to_glob, pcbddc->vec1_P, pcbddc->coarse_vec, INSERT_VALUES, SCATTER_FORWARD));
9571: PetscCall(VecScatterEnd(pcbddc->coarse_loc_to_glob, pcbddc->vec1_P, pcbddc->coarse_vec, INSERT_VALUES, SCATTER_FORWARD));
9572: if (coarse_mat) {
9573: Vec nullv;
9574: PetscScalar *array, *array2;
9575: PetscInt nl;
9577: PetscCall(MatCreateVecs(coarse_mat, &nullv, NULL));
9578: PetscCall(VecGetLocalSize(nullv, &nl));
9579: PetscCall(VecGetArrayRead(pcbddc->coarse_vec, (const PetscScalar **)&array));
9580: PetscCall(VecGetArray(nullv, &array2));
9581: PetscCall(PetscArraycpy(array2, array, nl));
9582: PetscCall(VecRestoreArray(nullv, &array2));
9583: PetscCall(VecRestoreArrayRead(pcbddc->coarse_vec, (const PetscScalar **)&array));
9584: PetscCall(VecNormalize(nullv, NULL));
9585: PetscCall(MatNullSpaceCreate(PetscObjectComm((PetscObject)coarse_mat), PETSC_FALSE, 1, &nullv, &CoarseNullSpace));
9586: PetscCall(VecDestroy(&nullv));
9587: }
9588: }
9589: PetscCall(PetscLogEventEnd(PC_BDDC_CoarseSetUp[pcbddc->current_level], pc, 0, 0, 0));
9591: PetscCall(PetscLogEventBegin(PC_BDDC_CoarseSolver[pcbddc->current_level], pc, 0, 0, 0));
9592: if (pcbddc->coarse_ksp) {
9593: PetscBool ispreonly;
9595: if (CoarseNullSpace) {
9596: PetscBool isnull;
9598: PetscCall(MatNullSpaceTest(CoarseNullSpace, coarse_mat, &isnull));
9599: if (isnull) PetscCall(MatSetNullSpace(coarse_mat, CoarseNullSpace));
9600: /* TODO: add local nullspaces (if any) */
9601: }
9602: /* setup coarse ksp */
9603: PetscCall(KSPSetUp(pcbddc->coarse_ksp));
9604: /* Check coarse problem if in debug mode or if solving with an iterative method */
9605: PetscCall(PetscObjectTypeCompare((PetscObject)pcbddc->coarse_ksp, KSPPREONLY, &ispreonly));
9606: if (pcbddc->dbg_flag || (!ispreonly && pcbddc->use_coarse_estimates)) {
9607: KSP check_ksp;
9608: KSPType check_ksp_type;
9609: PC check_pc;
9610: Vec check_vec, coarse_vec;
9611: PetscReal abs_infty_error, infty_error, lambda_min = 1.0, lambda_max = 1.0;
9612: PetscInt its;
9613: PetscBool compute_eigs;
9614: PetscReal *eigs_r, *eigs_c;
9615: PetscInt neigs;
9616: const char *prefix;
9618: /* Create ksp object suitable for estimation of extreme eigenvalues */
9619: PetscCall(KSPCreate(PetscObjectComm((PetscObject)pcbddc->coarse_ksp), &check_ksp));
9620: PetscCall(KSPSetNestLevel(check_ksp, pc->kspnestlevel));
9621: PetscCall(PetscObjectIncrementTabLevel((PetscObject)check_ksp, (PetscObject)pcbddc->coarse_ksp, 0));
9622: PetscCall(KSPSetErrorIfNotConverged(pcbddc->coarse_ksp, PETSC_FALSE));
9623: PetscCall(KSPSetOperators(check_ksp, coarse_mat, coarse_mat));
9624: PetscCall(KSPSetTolerances(check_ksp, 1.e-12, 1.e-12, PETSC_CURRENT, pcbddc->coarse_size));
9625: /* prevent from setup unneeded object */
9626: PetscCall(KSPGetPC(check_ksp, &check_pc));
9627: PetscCall(PCSetType(check_pc, PCNONE));
9628: if (ispreonly) {
9629: check_ksp_type = KSPPREONLY;
9630: compute_eigs = PETSC_FALSE;
9631: } else {
9632: check_ksp_type = KSPGMRES;
9633: compute_eigs = PETSC_TRUE;
9634: }
9635: PetscCall(KSPSetType(check_ksp, check_ksp_type));
9636: PetscCall(KSPSetComputeSingularValues(check_ksp, compute_eigs));
9637: PetscCall(KSPSetComputeEigenvalues(check_ksp, compute_eigs));
9638: PetscCall(KSPGMRESSetRestart(check_ksp, pcbddc->coarse_size + 1));
9639: PetscCall(KSPGetOptionsPrefix(pcbddc->coarse_ksp, &prefix));
9640: PetscCall(KSPSetOptionsPrefix(check_ksp, prefix));
9641: PetscCall(KSPAppendOptionsPrefix(check_ksp, "check_"));
9642: PetscCall(KSPSetFromOptions(check_ksp));
9643: PetscCall(KSPSetUp(check_ksp));
9644: PetscCall(KSPGetPC(pcbddc->coarse_ksp, &check_pc));
9645: PetscCall(KSPSetPC(check_ksp, check_pc));
9646: /* create random vec */
9647: PetscCall(MatCreateVecs(coarse_mat, &coarse_vec, &check_vec));
9648: PetscCall(VecSetRandom(check_vec, NULL));
9649: PetscCall(MatMult(coarse_mat, check_vec, coarse_vec));
9650: /* solve coarse problem */
9651: PetscCall(KSPSolve(check_ksp, coarse_vec, coarse_vec));
9652: PetscCall(KSPCheckSolve(check_ksp, pc, coarse_vec));
9653: /* set eigenvalue estimation if preonly has not been requested */
9654: if (compute_eigs) {
9655: PetscCall(PetscMalloc1(pcbddc->coarse_size + 1, &eigs_r));
9656: PetscCall(PetscMalloc1(pcbddc->coarse_size + 1, &eigs_c));
9657: PetscCall(KSPComputeEigenvalues(check_ksp, pcbddc->coarse_size + 1, eigs_r, eigs_c, &neigs));
9658: if (neigs) {
9659: lambda_max = eigs_r[neigs - 1];
9660: lambda_min = eigs_r[0];
9661: if (pcbddc->use_coarse_estimates) {
9662: if (lambda_max >= lambda_min) { /* using PETSC_SMALL since lambda_max == lambda_min is not allowed by KSPChebyshevSetEigenvalues */
9663: PetscCall(KSPChebyshevSetEigenvalues(pcbddc->coarse_ksp, lambda_max + PETSC_SMALL, lambda_min));
9664: PetscCall(KSPRichardsonSetScale(pcbddc->coarse_ksp, 2.0 / (lambda_max + lambda_min)));
9665: }
9666: }
9667: }
9668: }
9670: /* check coarse problem residual error */
9671: if (pcbddc->dbg_flag) {
9672: PetscViewer dbg_viewer = PETSC_VIEWER_STDOUT_(PetscObjectComm((PetscObject)pcbddc->coarse_ksp));
9673: PetscCall(PetscViewerASCIIAddTab(dbg_viewer, 2 * (pcbddc->current_level + 1)));
9674: PetscCall(VecAXPY(check_vec, -1.0, coarse_vec));
9675: PetscCall(VecNorm(check_vec, NORM_INFINITY, &infty_error));
9676: PetscCall(MatMult(coarse_mat, check_vec, coarse_vec));
9677: PetscCall(VecNorm(coarse_vec, NORM_INFINITY, &abs_infty_error));
9678: PetscCall(PetscViewerASCIIPrintf(dbg_viewer, "Coarse problem details (use estimates %d)\n", pcbddc->use_coarse_estimates));
9679: PetscCall(PetscObjectPrintClassNamePrefixType((PetscObject)pcbddc->coarse_ksp, dbg_viewer));
9680: PetscCall(PetscObjectPrintClassNamePrefixType((PetscObject)check_pc, dbg_viewer));
9681: PetscCall(PetscViewerASCIIPrintf(dbg_viewer, "Coarse problem exact infty_error : %1.6e\n", (double)infty_error));
9682: PetscCall(PetscViewerASCIIPrintf(dbg_viewer, "Coarse problem residual infty_error: %1.6e\n", (double)abs_infty_error));
9683: if (CoarseNullSpace) PetscCall(PetscViewerASCIIPrintf(dbg_viewer, "Coarse problem is singular\n"));
9684: if (compute_eigs) {
9685: PetscReal lambda_max_s, lambda_min_s;
9686: KSPConvergedReason reason;
9687: PetscCall(KSPGetType(check_ksp, &check_ksp_type));
9688: PetscCall(KSPGetIterationNumber(check_ksp, &its));
9689: PetscCall(KSPGetConvergedReason(check_ksp, &reason));
9690: PetscCall(KSPComputeExtremeSingularValues(check_ksp, &lambda_max_s, &lambda_min_s));
9691: PetscCall(PetscViewerASCIIPrintf(dbg_viewer, "Coarse problem eigenvalues (estimated with %" PetscInt_FMT " iterations of %s, conv reason %d): %1.6e %1.6e (%1.6e %1.6e)\n", its, check_ksp_type, reason, (double)lambda_min, (double)lambda_max, (double)lambda_min_s, (double)lambda_max_s));
9692: for (i = 0; i < neigs; i++) PetscCall(PetscViewerASCIIPrintf(dbg_viewer, "%1.6e %1.6ei\n", (double)eigs_r[i], (double)eigs_c[i]));
9693: }
9694: PetscCall(PetscViewerFlush(dbg_viewer));
9695: PetscCall(PetscViewerASCIISubtractTab(dbg_viewer, 2 * (pcbddc->current_level + 1)));
9696: }
9697: PetscCall(VecDestroy(&check_vec));
9698: PetscCall(VecDestroy(&coarse_vec));
9699: PetscCall(KSPDestroy(&check_ksp));
9700: if (compute_eigs) {
9701: PetscCall(PetscFree(eigs_r));
9702: PetscCall(PetscFree(eigs_c));
9703: }
9704: }
9705: }
9706: PetscCall(MatNullSpaceDestroy(&CoarseNullSpace));
9707: /* print additional info */
9708: if (pcbddc->dbg_flag) {
9709: /* waits until all processes reaches this point */
9710: PetscCall(PetscBarrier((PetscObject)pc));
9711: PetscCall(PetscViewerASCIIPrintf(pcbddc->dbg_viewer, "Coarse solver setup completed at level %" PetscInt_FMT "\n", pcbddc->current_level));
9712: PetscCall(PetscViewerFlush(pcbddc->dbg_viewer));
9713: }
9715: /* free memory */
9716: PetscCall(MatDestroy(&coarse_mat));
9717: PetscCall(PetscLogEventEnd(PC_BDDC_CoarseSolver[pcbddc->current_level], pc, 0, 0, 0));
9718: PetscFunctionReturn(PETSC_SUCCESS);
9719: }
9721: PetscErrorCode PCBDDCComputePrimalNumbering(PC pc, PetscInt *coarse_size_n, PetscInt **local_primal_indices_n)
9722: {
9723: PC_BDDC *pcbddc = (PC_BDDC *)pc->data;
9724: PC_IS *pcis = (PC_IS *)pc->data;
9725: IS subset, subset_mult, subset_n;
9726: PetscInt local_size, coarse_size = 0;
9727: PetscInt *local_primal_indices = NULL;
9728: const PetscInt *t_local_primal_indices;
9730: PetscFunctionBegin;
9731: /* Compute global number of coarse dofs */
9732: PetscCheck(!pcbddc->local_primal_size || pcbddc->local_primal_ref_node, PETSC_COMM_SELF, PETSC_ERR_PLIB, "BDDC ConstraintsSetUp should be called first");
9733: PetscCall(ISCreateGeneral(PetscObjectComm((PetscObject)pc->pmat), pcbddc->local_primal_size_cc, pcbddc->local_primal_ref_node, PETSC_COPY_VALUES, &subset_n));
9734: PetscCall(ISLocalToGlobalMappingApplyIS(pcis->mapping, subset_n, &subset));
9735: PetscCall(ISDestroy(&subset_n));
9736: PetscCall(ISCreateGeneral(PetscObjectComm((PetscObject)pc->pmat), pcbddc->local_primal_size_cc, pcbddc->local_primal_ref_mult, PETSC_COPY_VALUES, &subset_mult));
9737: PetscCall(ISRenumber(subset, subset_mult, &coarse_size, &subset_n));
9738: PetscCall(ISDestroy(&subset));
9739: PetscCall(ISDestroy(&subset_mult));
9740: PetscCall(ISGetLocalSize(subset_n, &local_size));
9741: PetscCheck(local_size == pcbddc->local_primal_size, PETSC_COMM_SELF, PETSC_ERR_PLIB, "Invalid number of local primal indices computed %" PetscInt_FMT " != %" PetscInt_FMT, local_size, pcbddc->local_primal_size);
9742: PetscCall(PetscMalloc1(local_size, &local_primal_indices));
9743: PetscCall(ISGetIndices(subset_n, &t_local_primal_indices));
9744: PetscCall(PetscArraycpy(local_primal_indices, t_local_primal_indices, local_size));
9745: PetscCall(ISRestoreIndices(subset_n, &t_local_primal_indices));
9746: PetscCall(ISDestroy(&subset_n));
9748: if (pcbddc->dbg_flag) {
9749: PetscCall(PetscViewerFlush(pcbddc->dbg_viewer));
9750: PetscCall(PetscViewerASCIIPrintf(pcbddc->dbg_viewer, "--------------------------------------------------\n"));
9751: PetscCall(PetscViewerASCIIPrintf(pcbddc->dbg_viewer, "Size of coarse problem is %" PetscInt_FMT "\n", coarse_size));
9752: PetscCall(PetscViewerFlush(pcbddc->dbg_viewer));
9753: }
9755: /* get back data */
9756: *coarse_size_n = coarse_size;
9757: *local_primal_indices_n = local_primal_indices;
9758: PetscFunctionReturn(PETSC_SUCCESS);
9759: }
9761: PetscErrorCode PCBDDCGlobalToLocal(VecScatter g2l_ctx, Vec gwork, Vec lwork, IS globalis, IS *localis)
9762: {
9763: IS localis_t;
9764: PetscInt i, lsize, *idxs, n;
9765: PetscScalar *vals;
9767: PetscFunctionBegin;
9768: /* get indices in local ordering exploiting local to global map */
9769: PetscCall(ISGetLocalSize(globalis, &lsize));
9770: PetscCall(PetscMalloc1(lsize, &vals));
9771: for (i = 0; i < lsize; i++) vals[i] = 1.0;
9772: PetscCall(ISGetIndices(globalis, (const PetscInt **)&idxs));
9773: PetscCall(VecSet(gwork, 0.0));
9774: PetscCall(VecSet(lwork, 0.0));
9775: if (idxs) { /* multilevel guard */
9776: PetscCall(VecSetOption(gwork, VEC_IGNORE_NEGATIVE_INDICES, PETSC_TRUE));
9777: PetscCall(VecSetValues(gwork, lsize, idxs, vals, INSERT_VALUES));
9778: }
9779: PetscCall(VecAssemblyBegin(gwork));
9780: PetscCall(ISRestoreIndices(globalis, (const PetscInt **)&idxs));
9781: PetscCall(PetscFree(vals));
9782: PetscCall(VecAssemblyEnd(gwork));
9783: /* now compute set in local ordering */
9784: PetscCall(VecScatterBegin(g2l_ctx, gwork, lwork, INSERT_VALUES, SCATTER_FORWARD));
9785: PetscCall(VecScatterEnd(g2l_ctx, gwork, lwork, INSERT_VALUES, SCATTER_FORWARD));
9786: PetscCall(VecGetArrayRead(lwork, (const PetscScalar **)&vals));
9787: PetscCall(VecGetSize(lwork, &n));
9788: for (i = 0, lsize = 0; i < n; i++) {
9789: if (PetscRealPart(vals[i]) > 0.5) lsize++;
9790: }
9791: PetscCall(PetscMalloc1(lsize, &idxs));
9792: for (i = 0, lsize = 0; i < n; i++) {
9793: if (PetscRealPart(vals[i]) > 0.5) idxs[lsize++] = i;
9794: }
9795: PetscCall(VecRestoreArrayRead(lwork, (const PetscScalar **)&vals));
9796: PetscCall(ISCreateGeneral(PetscObjectComm((PetscObject)gwork), lsize, idxs, PETSC_OWN_POINTER, &localis_t));
9797: *localis = localis_t;
9798: PetscFunctionReturn(PETSC_SUCCESS);
9799: }
9801: PetscErrorCode PCBDDCComputeFakeChange(PC pc, PetscBool constraints, PCBDDCGraph graph, PCBDDCSubSchurs schurs, Mat *change, IS *change_primal, IS *change_primal_mult, PetscBool *change_with_qr)
9802: {
9803: PC_IS *pcis = (PC_IS *)pc->data;
9804: PC_BDDC *pcbddc = (PC_BDDC *)pc->data;
9805: PC_IS *pcisf;
9806: PC_BDDC *pcbddcf;
9807: PC pcf;
9809: PetscFunctionBegin;
9810: PetscCall(PCCreate(PetscObjectComm((PetscObject)pc), &pcf));
9811: PetscCall(PCSetOperators(pcf, pc->mat, pc->pmat));
9812: PetscCall(PCSetType(pcf, PCBDDC));
9814: pcisf = (PC_IS *)pcf->data;
9815: pcbddcf = (PC_BDDC *)pcf->data;
9817: pcisf->is_B_local = pcis->is_B_local;
9818: pcisf->vec1_N = pcis->vec1_N;
9819: pcisf->BtoNmap = pcis->BtoNmap;
9820: pcisf->n = pcis->n;
9821: pcisf->n_B = pcis->n_B;
9823: PetscCall(PetscFree(pcbddcf->mat_graph));
9824: PetscCall(PetscFree(pcbddcf->sub_schurs));
9825: pcbddcf->mat_graph = graph ? graph : pcbddc->mat_graph;
9826: pcbddcf->sub_schurs = schurs;
9827: pcbddcf->adaptive_selection = schurs ? PETSC_TRUE : PETSC_FALSE;
9828: pcbddcf->adaptive_threshold[0] = pcbddc->adaptive_threshold[0];
9829: pcbddcf->adaptive_threshold[1] = pcbddc->adaptive_threshold[1];
9830: pcbddcf->adaptive_nmin = pcbddc->adaptive_nmin;
9831: pcbddcf->adaptive_nmax = pcbddc->adaptive_nmax;
9832: pcbddcf->use_faces = PETSC_TRUE;
9833: pcbddcf->use_change_of_basis = (PetscBool)!constraints;
9834: pcbddcf->use_change_on_faces = (PetscBool)!constraints;
9835: pcbddcf->use_qr_single = (PetscBool)!constraints;
9836: pcbddcf->fake_change = PETSC_TRUE;
9837: pcbddcf->dbg_flag = pcbddc->dbg_flag;
9839: PetscCall(PCBDDCAdaptiveSelection(pcf));
9840: PetscCall(PCBDDCConstraintsSetUp(pcf));
9842: *change = pcbddcf->ConstraintMatrix;
9843: if (change_primal) PetscCall(ISCreateGeneral(PetscObjectComm((PetscObject)pc->pmat), pcbddcf->local_primal_size_cc, pcbddcf->local_primal_ref_node, PETSC_COPY_VALUES, change_primal));
9844: if (change_primal_mult) PetscCall(ISCreateGeneral(PetscObjectComm((PetscObject)pc->pmat), pcbddcf->local_primal_size_cc, pcbddcf->local_primal_ref_mult, PETSC_COPY_VALUES, change_primal_mult));
9845: if (change_with_qr) *change_with_qr = pcbddcf->use_qr_single;
9847: if (schurs) pcbddcf->sub_schurs = NULL;
9848: pcbddcf->ConstraintMatrix = NULL;
9849: pcbddcf->mat_graph = NULL;
9850: pcisf->is_B_local = NULL;
9851: pcisf->vec1_N = NULL;
9852: pcisf->BtoNmap = NULL;
9853: PetscCall(PCDestroy(&pcf));
9854: PetscFunctionReturn(PETSC_SUCCESS);
9855: }
9857: PetscErrorCode PCBDDCSetUpSubSchurs(PC pc)
9858: {
9859: PC_IS *pcis = (PC_IS *)pc->data;
9860: PC_BDDC *pcbddc = (PC_BDDC *)pc->data;
9861: PCBDDCSubSchurs sub_schurs = pcbddc->sub_schurs;
9862: Mat S_j;
9863: PetscInt *used_xadj, *used_adjncy;
9864: PetscBool free_used_adj;
9866: PetscFunctionBegin;
9867: PetscCall(PetscLogEventBegin(PC_BDDC_Schurs[pcbddc->current_level], pc, 0, 0, 0));
9868: /* decide the adjacency to be used for determining internal problems for local schur on subsets */
9869: free_used_adj = PETSC_FALSE;
9870: if (pcbddc->sub_schurs_layers == -1) {
9871: used_xadj = NULL;
9872: used_adjncy = NULL;
9873: } else {
9874: if (pcbddc->sub_schurs_use_useradj && pcbddc->mat_graph->xadj) {
9875: used_xadj = pcbddc->mat_graph->xadj;
9876: used_adjncy = pcbddc->mat_graph->adjncy;
9877: } else if (pcbddc->computed_rowadj) {
9878: used_xadj = pcbddc->mat_graph->xadj;
9879: used_adjncy = pcbddc->mat_graph->adjncy;
9880: } else {
9881: PetscBool flg_row = PETSC_FALSE;
9882: const PetscInt *xadj, *adjncy;
9883: PetscInt nvtxs;
9885: PetscCall(MatGetRowIJ(pcbddc->local_mat, 0, PETSC_TRUE, PETSC_FALSE, &nvtxs, &xadj, &adjncy, &flg_row));
9886: if (flg_row) {
9887: PetscCall(PetscMalloc2(nvtxs + 1, &used_xadj, xadj[nvtxs], &used_adjncy));
9888: PetscCall(PetscArraycpy(used_xadj, xadj, nvtxs + 1));
9889: PetscCall(PetscArraycpy(used_adjncy, adjncy, xadj[nvtxs]));
9890: free_used_adj = PETSC_TRUE;
9891: } else {
9892: pcbddc->sub_schurs_layers = -1;
9893: used_xadj = NULL;
9894: used_adjncy = NULL;
9895: }
9896: PetscCall(MatRestoreRowIJ(pcbddc->local_mat, 0, PETSC_TRUE, PETSC_FALSE, &nvtxs, &xadj, &adjncy, &flg_row));
9897: }
9898: }
9900: /* setup sub_schurs data */
9901: PetscCall(MatCreateSchurComplement(pcis->A_II, pcis->pA_II, pcis->A_IB, pcis->A_BI, pcis->A_BB, &S_j));
9902: if (!sub_schurs->schur_explicit) {
9903: /* pcbddc->ksp_D up to date only if not using MatFactor with Schur complement support */
9904: PetscCall(MatSchurComplementSetKSP(S_j, pcbddc->ksp_D));
9905: PetscCall(PCBDDCSubSchursSetUp(sub_schurs, NULL, S_j, PETSC_FALSE, used_xadj, used_adjncy, pcbddc->sub_schurs_layers, NULL, pcbddc->adaptive_selection, PETSC_FALSE, PETSC_FALSE, 0, NULL, NULL, NULL, NULL));
9906: } else {
9907: Mat change = NULL;
9908: Vec scaling = NULL;
9909: IS change_primal = NULL, iP;
9910: PetscInt benign_n;
9911: PetscBool reuse_solvers = (PetscBool)!pcbddc->use_change_of_basis;
9912: PetscBool need_change = PETSC_FALSE;
9913: PetscBool discrete_harmonic = PETSC_FALSE;
9915: if (!pcbddc->use_vertices && reuse_solvers) {
9916: PetscInt n_vertices;
9918: PetscCall(ISGetLocalSize(sub_schurs->is_vertices, &n_vertices));
9919: reuse_solvers = (PetscBool)!n_vertices;
9920: }
9921: if (!pcbddc->benign_change_explicit) {
9922: benign_n = pcbddc->benign_n;
9923: } else {
9924: benign_n = 0;
9925: }
9926: /* sub_schurs->change is a local object; instead, PCBDDCConstraintsSetUp and the quantities used in the test below are logically collective on pc.
9927: We need a global reduction to avoid possible deadlocks.
9928: We assume that sub_schurs->change is created once, and then reused for different solves, unless the topography has been recomputed */
9929: if (pcbddc->adaptive_userdefined || (pcbddc->deluxe_zerorows && !pcbddc->use_change_of_basis)) {
9930: need_change = (PetscBool)(!!sub_schurs->change);
9931: PetscCallMPI(MPIU_Allreduce(MPI_IN_PLACE, &need_change, 1, MPI_C_BOOL, MPI_LOR, PetscObjectComm((PetscObject)pc)));
9932: need_change = (PetscBool)(!need_change);
9933: }
9934: /* If the user defines additional constraints, we import them here */
9935: if (need_change) {
9936: PetscCheck(!pcbddc->sub_schurs_rebuild, PETSC_COMM_SELF, PETSC_ERR_SUP, "Cannot compute change of basis with a different graph");
9937: PetscCall(PCBDDCComputeFakeChange(pc, PETSC_FALSE, NULL, NULL, &change, &change_primal, NULL, &sub_schurs->change_with_qr));
9938: }
9939: if (!pcbddc->use_deluxe_scaling) scaling = pcis->D;
9941: PetscCall(PetscObjectQuery((PetscObject)pc, "__KSPFETIDP_iP", (PetscObject *)&iP));
9942: if (iP) {
9943: PetscOptionsBegin(PetscObjectComm((PetscObject)iP), sub_schurs->prefix, "BDDC sub_schurs options", "PC");
9944: PetscCall(PetscOptionsBool("-sub_schurs_discrete_harmonic", NULL, NULL, discrete_harmonic, &discrete_harmonic, NULL));
9945: PetscOptionsEnd();
9946: }
9947: if (discrete_harmonic) {
9948: Mat A;
9949: PetscCall(MatDuplicate(pcbddc->local_mat, MAT_COPY_VALUES, &A));
9950: PetscCall(MatZeroRowsColumnsIS(A, iP, 1.0, NULL, NULL));
9951: PetscCall(PetscObjectCompose((PetscObject)A, "__KSPFETIDP_iP", (PetscObject)iP));
9952: PetscCall(PCBDDCSubSchursSetUp(sub_schurs, A, S_j, pcbddc->sub_schurs_exact_schur, used_xadj, used_adjncy, pcbddc->sub_schurs_layers, scaling, pcbddc->adaptive_selection, reuse_solvers, pcbddc->benign_saddle_point, benign_n, pcbddc->benign_p0_lidx,
9953: pcbddc->benign_zerodiag_subs, change, change_primal));
9954: PetscCall(MatDestroy(&A));
9955: } else {
9956: PetscCall(PCBDDCSubSchursSetUp(sub_schurs, pcbddc->local_mat, S_j, pcbddc->sub_schurs_exact_schur, used_xadj, used_adjncy, pcbddc->sub_schurs_layers, scaling, pcbddc->adaptive_selection, reuse_solvers, pcbddc->benign_saddle_point, benign_n,
9957: pcbddc->benign_p0_lidx, pcbddc->benign_zerodiag_subs, change, change_primal));
9958: }
9959: PetscCall(MatDestroy(&change));
9960: PetscCall(ISDestroy(&change_primal));
9961: }
9962: PetscCall(MatDestroy(&S_j));
9964: /* free adjacency */
9965: if (free_used_adj) PetscCall(PetscFree2(used_xadj, used_adjncy));
9966: PetscCall(PetscLogEventEnd(PC_BDDC_Schurs[pcbddc->current_level], pc, 0, 0, 0));
9967: PetscFunctionReturn(PETSC_SUCCESS);
9968: }
9970: PetscErrorCode PCBDDCInitSubSchurs(PC pc)
9971: {
9972: PC_IS *pcis = (PC_IS *)pc->data;
9973: PC_BDDC *pcbddc = (PC_BDDC *)pc->data;
9974: PCBDDCGraph graph;
9976: PetscFunctionBegin;
9977: /* attach interface graph for determining subsets */
9978: if (pcbddc->sub_schurs_rebuild) { /* in case rebuild has been requested, it uses a graph generated only by the neighboring information */
9979: IS verticesIS, verticescomm;
9980: PetscInt vsize, *idxs;
9982: PetscCall(PCBDDCGraphGetCandidatesIS(pcbddc->mat_graph, NULL, NULL, NULL, NULL, &verticesIS));
9983: PetscCall(ISGetSize(verticesIS, &vsize));
9984: PetscCall(ISGetIndices(verticesIS, (const PetscInt **)&idxs));
9985: PetscCall(ISCreateGeneral(PetscObjectComm((PetscObject)pc), vsize, idxs, PETSC_COPY_VALUES, &verticescomm));
9986: PetscCall(ISRestoreIndices(verticesIS, (const PetscInt **)&idxs));
9987: PetscCall(PCBDDCGraphRestoreCandidatesIS(pcbddc->mat_graph, NULL, NULL, NULL, NULL, &verticesIS));
9988: PetscCall(PCBDDCGraphCreate(&graph));
9989: PetscCall(PCBDDCGraphInit(graph, pcbddc->mat_graph->l2gmap, pcbddc->mat_graph->nvtxs_global, pcbddc->graphmaxcount));
9990: PetscCall(PCBDDCGraphSetUp(graph, pcbddc->mat_graph->custom_minimal_size, NULL, pcbddc->DirichletBoundariesLocal, 0, NULL, verticescomm));
9991: PetscCall(ISDestroy(&verticescomm));
9992: PetscCall(PCBDDCGraphComputeConnectedComponents(graph));
9993: } else {
9994: graph = pcbddc->mat_graph;
9995: }
9996: /* print some info */
9997: if (pcbddc->dbg_flag && !pcbddc->sub_schurs_rebuild) {
9998: IS vertices;
9999: PetscInt nv, nedges, nfaces;
10000: PetscCall(PCBDDCGraphASCIIView(graph, pcbddc->dbg_flag, pcbddc->dbg_viewer));
10001: PetscCall(PCBDDCGraphGetCandidatesIS(graph, &nfaces, NULL, &nedges, NULL, &vertices));
10002: PetscCall(ISGetSize(vertices, &nv));
10003: PetscCall(PetscViewerASCIIPushSynchronized(pcbddc->dbg_viewer));
10004: PetscCall(PetscViewerASCIISynchronizedPrintf(pcbddc->dbg_viewer, "--------------------------------------------------------------\n"));
10005: PetscCall(PetscViewerASCIISynchronizedPrintf(pcbddc->dbg_viewer, "Subdomain %04d got %02" PetscInt_FMT " local candidate vertices (%d)\n", PetscGlobalRank, nv, pcbddc->use_vertices));
10006: PetscCall(PetscViewerASCIISynchronizedPrintf(pcbddc->dbg_viewer, "Subdomain %04d got %02" PetscInt_FMT " local candidate edges (%d)\n", PetscGlobalRank, nedges, pcbddc->use_edges));
10007: PetscCall(PetscViewerASCIISynchronizedPrintf(pcbddc->dbg_viewer, "Subdomain %04d got %02" PetscInt_FMT " local candidate faces (%d)\n", PetscGlobalRank, nfaces, pcbddc->use_faces));
10008: PetscCall(PetscViewerFlush(pcbddc->dbg_viewer));
10009: PetscCall(PetscViewerASCIIPopSynchronized(pcbddc->dbg_viewer));
10010: PetscCall(PCBDDCGraphRestoreCandidatesIS(graph, &nfaces, NULL, &nedges, NULL, &vertices));
10011: }
10013: /* sub_schurs init */
10014: if (!pcbddc->sub_schurs) PetscCall(PCBDDCSubSchursCreate(&pcbddc->sub_schurs));
10015: PetscCall(PCBDDCSubSchursInit(pcbddc->sub_schurs, ((PetscObject)pc)->prefix, pcis->is_I_local, pcis->is_B_local, graph, pcis->BtoNmap, pcbddc->sub_schurs_rebuild, PETSC_FALSE));
10017: /* free graph struct */
10018: if (pcbddc->sub_schurs_rebuild) PetscCall(PCBDDCGraphDestroy(&graph));
10019: PetscFunctionReturn(PETSC_SUCCESS);
10020: }
10022: PetscErrorCode PCBDDCViewGlobalIS(PC pc, IS is, PetscViewer viewer)
10023: {
10024: Mat_IS *matis = (Mat_IS *)pc->pmat->data;
10025: PetscInt n = pc->pmat->rmap->n, ln, ni, st;
10026: const PetscInt *idxs;
10027: IS gis;
10029: PetscFunctionBegin;
10030: if (!is) PetscFunctionReturn(PETSC_SUCCESS);
10031: PetscCall(MatGetOwnershipRange(pc->pmat, &st, NULL));
10032: PetscCall(MatGetLocalSize(matis->A, NULL, &ln));
10033: PetscCall(PetscArrayzero(matis->sf_leafdata, ln));
10034: PetscCall(PetscArrayzero(matis->sf_rootdata, n));
10035: PetscCall(ISGetLocalSize(is, &ni));
10036: PetscCall(ISGetIndices(is, &idxs));
10037: for (PetscInt i = 0; i < ni; i++) {
10038: if (idxs[i] < 0 || idxs[i] >= ln) continue;
10039: matis->sf_leafdata[idxs[i]] = 1;
10040: }
10041: PetscCall(ISRestoreIndices(is, &idxs));
10042: PetscCall(PetscSFReduceBegin(matis->sf, MPIU_INT, matis->sf_leafdata, matis->sf_rootdata, MPI_SUM));
10043: PetscCall(PetscSFReduceEnd(matis->sf, MPIU_INT, matis->sf_leafdata, matis->sf_rootdata, MPI_SUM));
10044: ln = 0;
10045: for (PetscInt i = 0; i < n; i++) {
10046: if (matis->sf_rootdata[i]) matis->sf_rootdata[ln++] = i + st;
10047: }
10048: PetscCall(ISCreateGeneral(PetscObjectComm((PetscObject)pc), ln, matis->sf_rootdata, PETSC_USE_POINTER, &gis));
10049: PetscCall(ISView(gis, viewer));
10050: PetscCall(ISDestroy(&gis));
10051: PetscFunctionReturn(PETSC_SUCCESS);
10052: }
10054: #include <../src/mat/impls/aij/mpi/mpiaij.h>
10055: static PetscErrorCode MatMPIAIJRestrict(Mat A, MPI_Comm ccomm, Mat *B)
10056: {
10057: Mat At;
10058: IS rows;
10059: PetscInt rst, ren;
10060: PetscLayout rmap;
10061: MPI_Comm comm;
10062: PetscMPIInt size, issamecomm = MPI_UNEQUAL;
10064: PetscFunctionBegin;
10065: PetscCall(PetscObjectGetComm((PetscObject)A, &comm));
10066: PetscCallMPI(MPI_Comm_size(comm, &size));
10067: if (ccomm != MPI_COMM_NULL) PetscCallMPI(MPI_Comm_compare(comm, ccomm, &issamecomm));
10069: if (size == 1 || issamecomm == MPI_IDENT) {
10070: PetscCall(PetscObjectReference((PetscObject)A));
10071: *B = A;
10072: PetscFunctionReturn(PETSC_SUCCESS);
10073: }
10074: rst = ren = 0;
10075: if (ccomm != MPI_COMM_NULL) {
10076: PetscCall(PetscLayoutCreate(ccomm, &rmap));
10077: PetscCall(PetscLayoutSetSize(rmap, A->rmap->N));
10078: PetscCall(PetscLayoutSetBlockSize(rmap, 1));
10079: PetscCall(PetscLayoutSetUp(rmap));
10080: PetscCall(PetscLayoutGetRange(rmap, &rst, &ren));
10081: }
10082: PetscCall(ISCreateStride(comm, ren - rst, rst, 1, &rows));
10083: PetscCall(MatCreateSubMatrix(A, rows, NULL, MAT_INITIAL_MATRIX, &At));
10084: PetscCall(ISDestroy(&rows));
10086: if (ccomm != MPI_COMM_NULL) {
10087: Mat_MPIAIJ *a, *b;
10088: IS from, to;
10089: Vec gvec;
10090: PetscInt lsize;
10092: PetscCall(MatCreate(ccomm, B));
10093: PetscCall(MatSetSizes(*B, ren - rst, PETSC_DECIDE, PETSC_DECIDE, At->cmap->N));
10094: PetscCall(MatSetType(*B, MATAIJ));
10095: PetscCall(PetscLayoutDestroy(&(*B)->rmap));
10096: PetscCall(PetscLayoutSetUp((*B)->cmap));
10097: a = (Mat_MPIAIJ *)At->data;
10098: b = (Mat_MPIAIJ *)(*B)->data;
10099: PetscCallMPI(MPI_Comm_size(ccomm, &b->size));
10100: PetscCallMPI(MPI_Comm_rank(ccomm, &b->rank));
10101: PetscCall(PetscObjectReference((PetscObject)a->A));
10102: PetscCall(PetscObjectReference((PetscObject)a->B));
10103: b->A = a->A;
10104: b->B = a->B;
10106: b->donotstash = a->donotstash;
10107: b->roworiented = a->roworiented;
10108: b->rowindices = NULL;
10109: b->rowvalues = NULL;
10110: b->getrowactive = PETSC_FALSE;
10112: (*B)->rmap = rmap;
10113: (*B)->factortype = A->factortype;
10114: (*B)->assembled = PETSC_TRUE;
10115: (*B)->insertmode = NOT_SET_VALUES;
10116: (*B)->preallocated = PETSC_TRUE;
10118: if (a->colmap) {
10119: #if PetscDefined(USE_CTABLE)
10120: PetscCall(PetscHMapIDuplicate(a->colmap, &b->colmap));
10121: #else
10122: PetscCall(PetscMalloc1(At->cmap->N, &b->colmap));
10123: PetscCall(PetscArraycpy(b->colmap, a->colmap, At->cmap->N));
10124: #endif
10125: } else b->colmap = NULL;
10126: if (a->garray) {
10127: PetscInt len;
10128: len = a->B->cmap->n;
10129: PetscCall(PetscMalloc1(len + 1, &b->garray));
10130: if (len) PetscCall(PetscArraycpy(b->garray, a->garray, len));
10131: } else b->garray = NULL;
10133: PetscCall(PetscObjectReference((PetscObject)a->lvec));
10134: b->lvec = a->lvec;
10136: /* cannot use VecScatterCopy */
10137: PetscCall(VecGetLocalSize(b->lvec, &lsize));
10138: PetscCall(ISCreateGeneral(ccomm, lsize, b->garray, PETSC_USE_POINTER, &from));
10139: PetscCall(ISCreateStride(PETSC_COMM_SELF, lsize, 0, 1, &to));
10140: PetscCall(MatCreateVecs(*B, &gvec, NULL));
10141: PetscCall(VecScatterCreate(gvec, from, b->lvec, to, &b->Mvctx));
10142: PetscCall(ISDestroy(&from));
10143: PetscCall(ISDestroy(&to));
10144: PetscCall(VecDestroy(&gvec));
10145: }
10146: PetscCall(MatDestroy(&At));
10147: PetscFunctionReturn(PETSC_SUCCESS);
10148: }
10150: /* same as MatCreateSubMatrix(A, rows, NULL,...) but allows repeated rows */
10151: static PetscErrorCode MatAIJExtractRows(Mat A, IS rows, Mat *sA)
10152: {
10153: PetscBool isaij;
10154: MPI_Comm comm;
10156: PetscFunctionBegin;
10157: PetscCall(PetscObjectGetComm((PetscObject)A, &comm));
10158: PetscCall(PetscObjectBaseTypeCompareAny((PetscObject)A, &isaij, MATSEQAIJ, MATMPIAIJ, ""));
10159: PetscCheck(isaij, comm, PETSC_ERR_SUP, "Not implemented");
10160: PetscCall(PetscObjectBaseTypeCompare((PetscObject)A, MATSEQAIJ, &isaij));
10161: if (isaij) { /* SeqAIJ supports repeated rows */
10162: PetscCall(MatCreateSubMatrix(A, rows, NULL, MAT_INITIAL_MATRIX, sA));
10163: } else {
10164: Mat A_loc;
10165: Mat_SeqAIJ *da;
10166: PetscSF sf;
10167: PetscInt ni, *di, *dj, m = A->rmap->n, c, *ldata, *rdata;
10168: PetscScalar *daa;
10169: const PetscInt *idxs;
10170: const PetscSFNode *iremotes;
10171: PetscSFNode *remotes;
10173: /* SF for incoming rows */
10174: PetscCall(PetscSFCreate(comm, &sf));
10175: PetscCall(ISGetLocalSize(rows, &ni));
10176: PetscCall(ISGetIndices(rows, &idxs));
10177: PetscCall(PetscSFSetGraphLayout(sf, A->rmap, ni, NULL, PETSC_USE_POINTER, idxs));
10178: PetscCall(ISRestoreIndices(rows, &idxs));
10180: PetscCall(MatMPIAIJGetLocalMat(A, MAT_INITIAL_MATRIX, &A_loc));
10181: da = (Mat_SeqAIJ *)A_loc->data;
10182: PetscCall(PetscMalloc2(2 * ni, &ldata, 2 * m, &rdata));
10183: for (PetscInt i = 0; i < m; i++) {
10184: rdata[2 * i + 0] = da->i[i + 1] - da->i[i];
10185: rdata[2 * i + 1] = da->i[i];
10186: }
10187: PetscCall(PetscSFBcastBegin(sf, MPIU_2INT, rdata, ldata, MPI_REPLACE));
10188: PetscCall(PetscSFBcastEnd(sf, MPIU_2INT, rdata, ldata, MPI_REPLACE));
10189: PetscCall(PetscMalloc1(ni + 1, &di));
10190: di[0] = 0;
10191: for (PetscInt i = 0; i < ni; i++) di[i + 1] = di[i] + ldata[2 * i + 0];
10192: PetscCall(PetscMalloc1(di[ni], &dj));
10193: PetscCall(PetscMalloc1(di[ni], &daa));
10194: PetscCall(PetscMalloc1(di[ni], &remotes));
10196: PetscCall(PetscSFGetGraph(sf, NULL, NULL, NULL, &iremotes));
10198: /* SF graph for nonzeros */
10199: c = 0;
10200: for (PetscInt i = 0; i < ni; i++) {
10201: const PetscInt rank = iremotes[i].rank;
10202: const PetscInt rsize = ldata[2 * i];
10203: for (PetscInt j = 0; j < rsize; j++) {
10204: remotes[c].rank = rank;
10205: remotes[c].index = ldata[2 * i + 1] + j;
10206: c++;
10207: }
10208: }
10209: PetscCheck(c == di[ni], PETSC_COMM_SELF, PETSC_ERR_PLIB, "Invalid number of local nonzeros %" PetscInt_FMT " != %" PetscInt_FMT, c, di[ni]);
10210: PetscCall(PetscSFSetGraph(sf, da->i[m], di[ni], NULL, PETSC_USE_POINTER, remotes, PETSC_USE_POINTER));
10211: PetscCall(PetscSFBcastBegin(sf, MPIU_INT, da->j, dj, MPI_REPLACE));
10212: PetscCall(PetscSFBcastEnd(sf, MPIU_INT, da->j, dj, MPI_REPLACE));
10213: PetscCall(PetscSFBcastBegin(sf, MPIU_SCALAR, da->a, daa, MPI_REPLACE));
10214: PetscCall(PetscSFBcastEnd(sf, MPIU_SCALAR, da->a, daa, MPI_REPLACE));
10216: PetscCall(MatCreateMPIAIJWithArrays(comm, ni, A->cmap->n, PETSC_DECIDE, A->cmap->N, di, dj, daa, sA));
10217: PetscCall(MatDestroy(&A_loc));
10218: PetscCall(PetscSFDestroy(&sf));
10219: PetscCall(PetscFree(di));
10220: PetscCall(PetscFree(dj));
10221: PetscCall(PetscFree(daa));
10222: PetscCall(PetscFree(remotes));
10223: PetscCall(PetscFree2(ldata, rdata));
10224: }
10225: PetscFunctionReturn(PETSC_SUCCESS);
10226: }