Actual source code: pcis.c
1: /*$Id: is.c,v 1.9 2001/08/07 03:03:41 balay Exp $*/
2: #include src/ksp/pc/impls/is/pcis.h
4: /* -------------------------------------------------------------------------- */
5: /*
6: PCISSetUp -
7: */
10: int PCISSetUp(PC pc)
11: {
12: PC_IS *pcis = (PC_IS*)(pc->data);
13: Mat_IS *matis = (Mat_IS*)pc->mat->data;
14: int i, ierr;
15: PetscTruth flg;
16:
18: PetscTypeCompare((PetscObject)pc->mat,MATIS,&flg);
19: if (!flg){
20: SETERRQ(1,"Preconditioner type of Neumann Neumman requires matrix of type MATIS");
21: }
23: pcis->pure_neumann = matis->pure_neumann;
25: /*
26: Creating the local vector vec1_N, containing the inverse of the number
27: of subdomains to which each local node (either owned or ghost)
28: pertains. To accomplish that, we scatter local vectors of 1's to
29: a global vector (adding the values); scatter the result back to
30: local vectors and finally invert the result.
31: */
32: {
33: Vec counter;
34: PetscScalar one=1.0, zero=0.0;
35: VecDuplicate(matis->x,&pcis->vec1_N);
36: VecDuplicate(pc->vec,&counter); /* temporary auxiliar vector */
37: VecSet(&zero,counter);
38: VecSet(&one,pcis->vec1_N);
39: VecScatterBegin(pcis->vec1_N,counter,ADD_VALUES,SCATTER_REVERSE,matis->ctx);
40: VecScatterEnd (pcis->vec1_N,counter,ADD_VALUES,SCATTER_REVERSE,matis->ctx);
41: VecScatterBegin(counter,pcis->vec1_N,INSERT_VALUES,SCATTER_FORWARD,matis->ctx);
42: VecScatterEnd (counter,pcis->vec1_N,INSERT_VALUES,SCATTER_FORWARD,matis->ctx);
43: VecDestroy(counter);
44: }
45: /*
46: Creating local and global index sets for interior and
47: inteface nodes. Notice that interior nodes have D[i]==1.0.
48: */
49: {
50: int n_I;
51: int *idx_I_local,*idx_B_local,*idx_I_global,*idx_B_global;
52: PetscScalar *array;
53: /* Identifying interior and interface nodes, in local numbering */
54: VecGetSize(pcis->vec1_N,&pcis->n);
55: VecGetArray(pcis->vec1_N,&array);
56: PetscMalloc(pcis->n*sizeof(int),&idx_I_local);
57: PetscMalloc(pcis->n*sizeof(int),&idx_B_local);
58: for (i=0, pcis->n_B=0, n_I=0; i<pcis->n; i++) {
59: if (array[i] == 1.0) { idx_I_local[n_I] = i; n_I++; }
60: else { idx_B_local[pcis->n_B] = i; pcis->n_B++; }
61: }
62: /* Getting the global numbering */
63: idx_B_global = idx_I_local + n_I; /* Just avoiding allocating extra memory, since we have vacant space */
64: idx_I_global = idx_B_local + pcis->n_B;
65: ISLocalToGlobalMappingApply(matis->mapping,pcis->n_B,idx_B_local,idx_B_global);
66: ISLocalToGlobalMappingApply(matis->mapping,n_I, idx_I_local,idx_I_global);
67: /* Creating the index sets. */
68: ISCreateGeneral(MPI_COMM_SELF,pcis->n_B,idx_B_local, &pcis->is_B_local);
69: ISCreateGeneral(MPI_COMM_SELF,pcis->n_B,idx_B_global,&pcis->is_B_global);
70: ISCreateGeneral(MPI_COMM_SELF,n_I ,idx_I_local, &pcis->is_I_local);
71: ISCreateGeneral(MPI_COMM_SELF,n_I ,idx_I_global,&pcis->is_I_global);
72: /* Freeing memory and restoring arrays */
73: PetscFree(idx_B_local);
74: PetscFree(idx_I_local);
75: VecRestoreArray(pcis->vec1_N,&array);
76: }
78: /*
79: Extracting the blocks A_II, A_BI, A_IB and A_BB from A. If the numbering
80: is such that interior nodes come first than the interface ones, we have
82: [ | ]
83: [ A_II | A_IB ]
84: A = [ | ]
85: [-----------+------]
86: [ A_BI | A_BB ]
87: */
89: MatGetSubMatrix(matis->A,pcis->is_I_local,pcis->is_I_local,PETSC_DECIDE,MAT_INITIAL_MATRIX,&pcis->A_II);
90: MatGetSubMatrix(matis->A,pcis->is_I_local,pcis->is_B_local,PETSC_DECIDE,MAT_INITIAL_MATRIX,&pcis->A_IB);
91: MatGetSubMatrix(matis->A,pcis->is_B_local,pcis->is_I_local,PETSC_DECIDE,MAT_INITIAL_MATRIX,&pcis->A_BI);
92: MatGetSubMatrix(matis->A,pcis->is_B_local,pcis->is_B_local,PETSC_DECIDE,MAT_INITIAL_MATRIX,&pcis->A_BB);
94: /*
95: Creating work vectors and arrays
96: */
97: /* pcis->vec1_N has already been created */
98: VecDuplicate(pcis->vec1_N,&pcis->vec2_N);
99: VecCreateSeq(PETSC_COMM_SELF,pcis->n-pcis->n_B,&pcis->vec1_D);
100: VecDuplicate(pcis->vec1_D,&pcis->vec2_D);
101: VecDuplicate(pcis->vec1_D,&pcis->vec3_D);
102: VecCreateSeq(PETSC_COMM_SELF,pcis->n_B,&pcis->vec1_B);
103: VecDuplicate(pcis->vec1_B,&pcis->vec2_B);
104: VecDuplicate(pcis->vec1_B,&pcis->vec3_B);
105: {
106: Vec global;
107: PCGetVector(pc,&global);
108: VecDuplicate(global,&pcis->vec1_global);
109: }
110: PetscMalloc((pcis->n)*sizeof(PetscScalar),&pcis->work_N);
112: /* Creating the scatter contexts */
113: VecScatterCreate(pc->vec,pcis->is_I_global,pcis->vec1_D,(IS)0,&pcis->global_to_D);
114: VecScatterCreate(pcis->vec1_N,pcis->is_B_local,pcis->vec1_B,(IS)0,&pcis->N_to_B);
115: VecScatterCreate(pc->vec,pcis->is_B_global,pcis->vec1_B,(IS)0,&pcis->global_to_B);
117: /* Creating scaling "matrix" D, from information in vec1_N */
118: VecDuplicate(pcis->vec1_B,&pcis->D);
119: VecScatterBegin(pcis->vec1_N,pcis->D,INSERT_VALUES,SCATTER_FORWARD,pcis->N_to_B);
120: VecScatterEnd (pcis->vec1_N,pcis->D,INSERT_VALUES,SCATTER_FORWARD,pcis->N_to_B);
121: VecReciprocal(pcis->D);
123: /* See historical note 01, at the bottom of this file. */
125: /*
126: Creating the KSP contexts for the local Dirichlet and Neumann problems.
127: */
128: {
129: PC pc_ctx;
130: /* Dirichlet */
131: KSPCreate(PETSC_COMM_SELF,&pcis->ksp_D);
132: KSPSetOperators(pcis->ksp_D,pcis->A_II,pcis->A_II,SAME_PRECONDITIONER);
133: KSPSetOptionsPrefix(pcis->ksp_D,"is_localD_");
134: KSPGetPC(pcis->ksp_D,&pc_ctx);
135: PCSetType(pc_ctx,PCLU);
136: KSPSetType(pcis->ksp_D,KSPPREONLY);
137: KSPSetFromOptions(pcis->ksp_D);
138: /* the vectors in the following line are dummy arguments, just telling the KSP the vector size. Values are not used */
139: KSPSetRhs(pcis->ksp_D,pcis->vec1_D);
140: KSPSetSolution(pcis->ksp_D,pcis->vec2_D);
141: KSPSetUp(pcis->ksp_D);
142: /* Neumann */
143: KSPCreate(PETSC_COMM_SELF,&pcis->ksp_N);
144: KSPSetOperators(pcis->ksp_N,matis->A,matis->A,SAME_PRECONDITIONER);
145: KSPSetOptionsPrefix(pcis->ksp_N,"is_localN_");
146: KSPGetPC(pcis->ksp_N,&pc_ctx);
147: PCSetType(pc_ctx,PCLU);
148: KSPSetType(pcis->ksp_N,KSPPREONLY);
149: KSPSetFromOptions(pcis->ksp_N);
150: {
151: PetscTruth damp_fixed,
152: remove_nullspace_fixed,
153: set_damping_factor_floating,
154: not_damp_floating,
155: not_remove_nullspace_floating;
156: PetscReal fixed_factor,
157: floating_factor;
159: PetscOptionsGetReal(pc_ctx->prefix,"-pc_is_damp_fixed",&fixed_factor,&damp_fixed);
160: if (!damp_fixed) { fixed_factor = 0.0; }
161: PetscOptionsHasName(pc_ctx->prefix,"-pc_is_damp_fixed",&damp_fixed);
163: PetscOptionsHasName(pc_ctx->prefix,"-pc_is_remove_nullspace_fixed",&remove_nullspace_fixed);
165: PetscOptionsGetReal(pc_ctx->prefix,"-pc_is_set_damping_factor_floating",
166: &floating_factor,&set_damping_factor_floating);
167: if (!set_damping_factor_floating) { floating_factor = 0.0; }
168: PetscOptionsHasName(pc_ctx->prefix,"-pc_is_set_damping_factor_floating",&set_damping_factor_floating);
169: if (!set_damping_factor_floating) { floating_factor = 1.e-12; }
171: PetscOptionsHasName(pc_ctx->prefix,"-pc_is_not_damp_floating",¬_damp_floating);
173: PetscOptionsHasName(pc_ctx->prefix,"-pc_is_not_remove_nullspace_floating",¬_remove_nullspace_floating);
175: if (pcis->pure_neumann) { /* floating subdomain */
176: if (!(not_damp_floating)) {
177: PCLUSetDamping (pc_ctx,floating_factor);
178: PCILUSetDamping(pc_ctx,floating_factor);
179: }
180: if (!(not_remove_nullspace_floating)){
181: MatNullSpace nullsp;
182: MatNullSpaceCreate(PETSC_COMM_SELF,1,0,PETSC_NULL,&nullsp);
183: PCNullSpaceAttach(pc_ctx,nullsp);
184: MatNullSpaceDestroy(nullsp);
185: }
186: } else { /* fixed subdomain */
187: if (damp_fixed) {
188: PCLUSetDamping (pc_ctx,fixed_factor);
189: PCILUSetDamping(pc_ctx,fixed_factor);
190: }
191: if (remove_nullspace_fixed) {
192: MatNullSpace nullsp;
193: MatNullSpaceCreate(PETSC_COMM_SELF,1,0,PETSC_NULL,&nullsp);
194: PCNullSpaceAttach(pc_ctx,nullsp);
195: MatNullSpaceDestroy(nullsp);
196: }
197: }
198: }
199: /* the vectors in the following line are dummy arguments, just telling the KSP the vector size. Values are not used */
200: KSPSetRhs(pcis->ksp_N,pcis->vec1_N);
201: KSPSetSolution(pcis->ksp_N,pcis->vec2_N);
202: KSPSetUp(pcis->ksp_N);
203: }
205: ISLocalToGlobalMappingGetInfo(((Mat_IS*)(pc->mat->data))->mapping,&(pcis->n_neigh),&(pcis->neigh),
206: &(pcis->n_shared),&(pcis->shared));
207: pcis->ISLocalToGlobalMappingGetInfoWasCalled = PETSC_TRUE;
209: return(0);
210: }
212: /* -------------------------------------------------------------------------- */
213: /*
214: PCISDestroy -
215: */
218: int PCISDestroy(PC pc)
219: {
220: PC_IS *pcis = (PC_IS*)(pc->data);
221: int ierr;
225: if (pcis->is_B_local) {ISDestroy(pcis->is_B_local);}
226: if (pcis->is_I_local) {ISDestroy(pcis->is_I_local);}
227: if (pcis->is_B_global) {ISDestroy(pcis->is_B_global);}
228: if (pcis->is_I_global) {ISDestroy(pcis->is_I_global);}
229: if (pcis->A_II) {MatDestroy(pcis->A_II);}
230: if (pcis->A_IB) {MatDestroy(pcis->A_IB);}
231: if (pcis->A_BI) {MatDestroy(pcis->A_BI);}
232: if (pcis->A_BB) {MatDestroy(pcis->A_BB);}
233: if (pcis->D) {VecDestroy(pcis->D);}
234: if (pcis->ksp_N) {KSPDestroy(pcis->ksp_N);}
235: if (pcis->ksp_D) {KSPDestroy(pcis->ksp_D);}
236: if (pcis->vec1_N) {VecDestroy(pcis->vec1_N);}
237: if (pcis->vec2_N) {VecDestroy(pcis->vec2_N);}
238: if (pcis->vec1_D) {VecDestroy(pcis->vec1_D);}
239: if (pcis->vec2_D) {VecDestroy(pcis->vec2_D);}
240: if (pcis->vec3_D) {VecDestroy(pcis->vec3_D);}
241: if (pcis->vec1_B) {VecDestroy(pcis->vec1_B);}
242: if (pcis->vec2_B) {VecDestroy(pcis->vec2_B);}
243: if (pcis->vec3_B) {VecDestroy(pcis->vec3_B);}
244: if (pcis->vec1_global) {VecDestroy(pcis->vec1_global);}
245: if (pcis->work_N) {PetscFree(pcis->work_N);}
246: if (pcis->global_to_D) {VecScatterDestroy(pcis->global_to_D);}
247: if (pcis->N_to_B) {VecScatterDestroy(pcis->N_to_B);}
248: if (pcis->global_to_B) {VecScatterDestroy(pcis->global_to_B);}
249: if (pcis->ISLocalToGlobalMappingGetInfoWasCalled) {
250: ISLocalToGlobalMappingRestoreInfo((ISLocalToGlobalMapping)0,&(pcis->n_neigh),&(pcis->neigh),&(pcis->n_shared),&(pcis->shared));
251: }
253: return(0);
254: }
256: /* -------------------------------------------------------------------------- */
257: /*
258: PCISCreate -
259: */
262: int PCISCreate(PC pc)
263: {
264: PC_IS *pcis = (PC_IS*)(pc->data);
268: pcis->is_B_local = 0;
269: pcis->is_I_local = 0;
270: pcis->is_B_global = 0;
271: pcis->is_I_global = 0;
272: pcis->A_II = 0;
273: pcis->A_IB = 0;
274: pcis->A_BI = 0;
275: pcis->A_BB = 0;
276: pcis->D = 0;
277: pcis->ksp_N = 0;
278: pcis->ksp_D = 0;
279: pcis->vec1_N = 0;
280: pcis->vec2_N = 0;
281: pcis->vec1_D = 0;
282: pcis->vec2_D = 0;
283: pcis->vec3_D = 0;
284: pcis->vec1_B = 0;
285: pcis->vec2_B = 0;
286: pcis->vec3_B = 0;
287: pcis->vec1_global = 0;
288: pcis->work_N = 0;
289: pcis->global_to_D = 0;
290: pcis->N_to_B = 0;
291: pcis->global_to_B = 0;
292: pcis->ISLocalToGlobalMappingGetInfoWasCalled = PETSC_FALSE;
294: return(0);
295: }
297: /* -------------------------------------------------------------------------- */
298: /*
299: PCISApplySchur -
301: Input parameters:
302: . pc - preconditioner context
303: . v - vector to which the Schur complement is to be applied (it is NOT modified inside this function, UNLESS vec2_B is null)
305: Output parameters:
306: . vec1_B - result of Schur complement applied to chunk
307: . vec2_B - garbage (used as work space), or null (and v is used as workspace)
308: . vec1_D - garbage (used as work space)
309: . vec2_D - garbage (used as work space)
311: */
314: int PCISApplySchur(PC pc, Vec v, Vec vec1_B, Vec vec2_B, Vec vec1_D, Vec vec2_D)
315: {
316: int ierr;
317: PetscScalar m_one = -1.0;
318: PC_IS *pcis = (PC_IS*)(pc->data);
322: if (vec2_B == (Vec)0) { vec2_B = v; }
324: MatMult(pcis->A_BB,v,vec1_B);
325: MatMult(pcis->A_IB,v,vec1_D);
326: KSPSetRhs(pcis->ksp_D,vec1_D);
327: KSPSetSolution(pcis->ksp_D,vec2_D);
328: KSPSolve(pcis->ksp_D);
329: MatMult(pcis->A_BI,vec2_D,vec2_B);
330: VecAXPY(&m_one,vec2_B,vec1_B);
332: return(0);
333: }
335: /* -------------------------------------------------------------------------- */
336: /*
337: PCISScatterArrayNToVecB - Scatters interface node values from a big array (of all local nodes, interior or interface,
338: including ghosts) into an interface vector, when in SCATTER_FORWARD mode, or vice-versa, when in SCATTER_REVERSE
339: mode.
341: Input parameters:
342: . pc - preconditioner context
343: . array_N - [when in SCATTER_FORWARD mode] Array to be scattered into the vector
344: . v_B - [when in SCATTER_REVERSE mode] Vector to be scattered into the array
346: Output parameter:
347: . array_N - [when in SCATTER_REVERSE mode] Array to receive the scattered vector
348: . v_B - [when in SCATTER_FORWARD mode] Vector to receive the scattered array
350: Notes:
351: The entries in the array that do not correspond to interface nodes remain unaltered.
352: */
355: int PCISScatterArrayNToVecB (PetscScalar *array_N, Vec v_B, InsertMode imode, ScatterMode smode, PC pc)
356: {
357: int i, ierr, *idex;
358: PetscScalar *array_B;
359: PC_IS *pcis = (PC_IS*)(pc->data);
363: VecGetArray(v_B,&array_B);
364: ISGetIndices(pcis->is_B_local,&idex);
366: if (smode == SCATTER_FORWARD) {
367: if (imode == INSERT_VALUES) {
368: for (i=0; i<pcis->n_B; i++) { array_B[i] = array_N[idex[i]]; }
369: } else { /* ADD_VALUES */
370: for (i=0; i<pcis->n_B; i++) { array_B[i] += array_N[idex[i]]; }
371: }
372: } else { /* SCATTER_REVERSE */
373: if (imode == INSERT_VALUES) {
374: for (i=0; i<pcis->n_B; i++) { array_N[idex[i]] = array_B[i]; }
375: } else { /* ADD_VALUES */
376: for (i=0; i<pcis->n_B; i++) { array_N[idex[i]] += array_B[i]; }
377: }
378: }
380: ISRestoreIndices(pcis->is_B_local,&idex);
381: VecRestoreArray(v_B,&array_B);
383: return(0);
384: }
386: /* -------------------------------------------------------------------------- */
387: /*
388: PCISApplyInvSchur - Solves the Neumann problem related to applying the inverse of the Schur complement.
389: More precisely, solves the problem:
390: [ A_II A_IB ] [ . ] [ 0 ]
391: [ ] [ ] = [ ]
392: [ A_BI A_BB ] [ x ] [ b ]
394: Input parameters:
395: . pc - preconditioner context
396: . b - vector of local interface nodes (including ghosts)
398: Output parameters:
399: . x - vector of local interface nodes (including ghosts); returns the application of the inverse of the Schur
400: complement to b
401: . vec1_N - vector of local nodes (interior and interface, including ghosts); returns garbage (used as work space)
402: . vec2_N - vector of local nodes (interior and interface, including ghosts); returns garbage (used as work space)
404: */
407: int PCISApplyInvSchur (PC pc, Vec b, Vec x, Vec vec1_N, Vec vec2_N)
408: {
409: int ierr;
410: PC_IS *pcis = (PC_IS*)(pc->data);
411: PetscScalar zero = 0.0;
415: /*
416: Neumann solvers.
417: Applying the inverse of the local Schur complement, i.e, solving a Neumann
418: Problem with zero at the interior nodes of the RHS and extracting the interface
419: part of the solution. inverse Schur complement is applied to b and the result
420: is stored in x.
421: */
422: /* Setting the RHS vec1_N */
423: VecSet(&zero,vec1_N);
424: VecScatterBegin(b,vec1_N,INSERT_VALUES,SCATTER_REVERSE,pcis->N_to_B);
425: VecScatterEnd (b,vec1_N,INSERT_VALUES,SCATTER_REVERSE,pcis->N_to_B);
426: /* Checking for consistency of the RHS */
427: {
428: PetscTruth flg;
429: PetscOptionsHasName(PETSC_NULL,"-pc_is_check_consistency",&flg);
430: if (flg) {
431: PetscScalar average;
432: VecSum(vec1_N,&average);
433: average = average / ((PetscReal)pcis->n);
434: if (pcis->pure_neumann) {
435: PetscViewerASCIISynchronizedPrintf(PETSC_VIEWER_STDOUT_(pc->comm),"Subdomain %04d is floating. Average = % 1.14e\n",
436: PetscGlobalRank,PetscAbsScalar(average));
437: } else {
438: PetscViewerASCIISynchronizedPrintf(PETSC_VIEWER_STDOUT_(pc->comm),"Subdomain %04d is fixed. Average = % 1.14e\n",
439: PetscGlobalRank,PetscAbsScalar(average));
440: }
441: PetscViewerFlush(PETSC_VIEWER_STDOUT_(pc->comm));
442: }
443: }
444: /* Solving the system for vec2_N */
445: KSPSetRhs(pcis->ksp_N,vec1_N);
446: KSPSetSolution(pcis->ksp_N,vec2_N);
447: KSPSolve(pcis->ksp_N);
448: /* Extracting the local interface vector out of the solution */
449: VecScatterBegin(vec2_N,x,INSERT_VALUES,SCATTER_FORWARD,pcis->N_to_B);
450: VecScatterEnd (vec2_N,x,INSERT_VALUES,SCATTER_FORWARD,pcis->N_to_B);
452: return(0);
453: }