Date: 2016-07-24T17:03:40+00:00

Actual source code: asm.c
petsc-3.7.3 2016-07-24
Report Typos and Errors

      2: /*
      3:   This file defines an additive Schwarz preconditioner for any Mat implementation.

      5:   Note that each processor may have any number of subdomains. But in order to
      6:   deal easily with the VecScatter(), we treat each processor as if it has the
      7:   same number of subdomains.

      9:        n - total number of true subdomains on all processors
     10:        n_local_true - actual number of subdomains on this processor
     11:        n_local = maximum over all processors of n_local_true
     12: */
     13: #include <petsc/private/pcimpl.h>     /*I "petscpc.h" I*/
     14: #include <petscdm.h>

     16: typedef struct {
     17:   PetscInt   n, n_local, n_local_true;
     18:   PetscInt   overlap;             /* overlap requested by user */
     19:   KSP        *ksp;                /* linear solvers for each block */
     20:   VecScatter *restriction;        /* mapping from global to subregion */
     21:   VecScatter *localization;       /* mapping from overlapping to non-overlapping subregion */
     22:   VecScatter *prolongation;       /* mapping from subregion to global */
     23:   Vec        *x,*y,*y_local;      /* work vectors */
     24:   IS         *is;                 /* index set that defines each overlapping subdomain */
     25:   IS         *is_local;           /* index set that defines each non-overlapping subdomain, may be NULL */
     26:   Mat        *mat,*pmat;          /* mat is not currently used */
     27:   PCASMType  type;                /* use reduced interpolation, restriction or both */
     28:   PetscBool  type_set;            /* if user set this value (so won't change it for symmetric problems) */
     29:   PetscBool  same_local_solves;   /* flag indicating whether all local solvers are same */
     30:   PetscBool  sort_indices;        /* flag to sort subdomain indices */
     31:   PetscBool  dm_subdomains;       /* whether DM is allowed to define subdomains */
     32:   PCCompositeType loctype;        /* the type of composition for local solves */
     33:   /* For multiplicative solve */
     34:   Mat       *lmats;               /* submatrices for overlapping multiplicative (process) subdomain */
     35:   Vec        lx, ly;              /* work vectors */
     36:   IS         lis;                 /* index set that defines each overlapping multiplicative (process) subdomain */
     37: } PC_ASM;

     41: static PetscErrorCode PCView_ASM(PC pc,PetscViewer viewer)
     42: {
     43:   PC_ASM         *osm = (PC_ASM*)pc->data;
     45:   PetscMPIInt    rank;
     46:   PetscInt       i,bsz;
     47:   PetscBool      iascii,isstring;
     48:   PetscViewer    sviewer;

     51:   PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERASCII,&iascii);
     52:   PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERSTRING,&isstring);
     53:   if (iascii) {
     54:     char overlaps[256] = "user-defined overlap",blocks[256] = "total subdomain blocks not yet set";
     55:     if (osm->overlap >= 0) {PetscSNPrintf(overlaps,sizeof(overlaps),"amount of overlap = %D",osm->overlap);}
     56:     if (osm->n > 0) {PetscSNPrintf(blocks,sizeof(blocks),"total subdomain blocks = %D",osm->n);}
     57:     PetscViewerASCIIPrintf(viewer,"  Additive Schwarz: %s, %s\n",blocks,overlaps);
     58:     PetscViewerASCIIPrintf(viewer,"  Additive Schwarz: restriction/interpolation type - %s\n",PCASMTypes[osm->type]);
     59:     if (osm->loctype != PC_COMPOSITE_ADDITIVE) {PetscViewerASCIIPrintf(viewer,"  Additive Schwarz: local solve composition type - %s\n",PCCompositeTypes[osm->loctype]);}
     60:     MPI_Comm_rank(PetscObjectComm((PetscObject)pc),&rank);
     61:     if (osm->same_local_solves) {
     62:       if (osm->ksp) {
     63:         PetscViewerASCIIPrintf(viewer,"  Local solve is same for all blocks, in the following KSP and PC objects:\n");
     64:         PetscViewerGetSubViewer(viewer,PETSC_COMM_SELF,&sviewer);
     65:         if (!rank) {
     66:           PetscViewerASCIIPushTab(viewer);
     67:           KSPView(osm->ksp[0],sviewer);
     68:           PetscViewerASCIIPopTab(viewer);
     69:         }
     70:         PetscViewerRestoreSubViewer(viewer,PETSC_COMM_SELF,&sviewer);
     71:       }
     72:     } else {
     73:       PetscViewerASCIIPushSynchronized(viewer);
     74:       PetscViewerASCIISynchronizedPrintf(viewer,"  [%d] number of local blocks = %D\n",(int)rank,osm->n_local_true);
     75:       PetscViewerFlush(viewer);
     76:       PetscViewerASCIIPrintf(viewer,"  Local solve info for each block is in the following KSP and PC objects:\n");
     77:       PetscViewerASCIIPushTab(viewer);
     78:       PetscViewerASCIIPrintf(viewer,"- - - - - - - - - - - - - - - - - -\n");
     79:       PetscViewerGetSubViewer(viewer,PETSC_COMM_SELF,&sviewer);
     80:       for (i=0; i<osm->n_local_true; i++) {
     81:         ISGetLocalSize(osm->is[i],&bsz);
     82:         PetscViewerASCIISynchronizedPrintf(sviewer,"[%d] local block number %D, size = %D\n",(int)rank,i,bsz);
     83:         KSPView(osm->ksp[i],sviewer);
     84:         PetscViewerASCIISynchronizedPrintf(sviewer,"- - - - - - - - - - - - - - - - - -\n");
     85:       }
     86:       PetscViewerRestoreSubViewer(viewer,PETSC_COMM_SELF,&sviewer);
     87:       PetscViewerASCIIPopTab(viewer);
     88:       PetscViewerFlush(viewer);
     89:       PetscViewerASCIIPopSynchronized(viewer);
     90:     }
     91:   } else if (isstring) {
     92:     PetscViewerStringSPrintf(viewer," blocks=%D, overlap=%D, type=%s",osm->n,osm->overlap,PCASMTypes[osm->type]);
     93:     PetscViewerGetSubViewer(viewer,PETSC_COMM_SELF,&sviewer);
     94:     if (osm->ksp) {KSPView(osm->ksp[0],sviewer);}
     95:     PetscViewerRestoreSubViewer(viewer,PETSC_COMM_SELF,&sviewer);
     96:   }
     97:   return(0);
     98: }

    102: static PetscErrorCode PCASMPrintSubdomains(PC pc)
    103: {
    104:   PC_ASM         *osm = (PC_ASM*)pc->data;
    105:   const char     *prefix;
    106:   char           fname[PETSC_MAX_PATH_LEN+1];
    107:   PetscViewer    viewer, sviewer;
    108:   char           *s;
    109:   PetscInt       i,j,nidx;
    110:   const PetscInt *idx;
    111:   PetscMPIInt    rank, size;

    115:   MPI_Comm_size(PetscObjectComm((PetscObject)pc), &size);
    116:   MPI_Comm_rank(PetscObjectComm((PetscObject)pc), &rank);
    117:   PCGetOptionsPrefix(pc,&prefix);
    118:   PetscOptionsGetString(NULL,prefix,"-pc_asm_print_subdomains",fname,PETSC_MAX_PATH_LEN,NULL);
    119:   if (fname[0] == 0) { PetscStrcpy(fname,"stdout"); };
    120:   PetscViewerASCIIOpen(PetscObjectComm((PetscObject)pc),fname,&viewer);
    121:   for (i=0; i<osm->n_local; i++) {
    122:     if (i < osm->n_local_true) {
    123:       ISGetLocalSize(osm->is[i],&nidx);
    124:       ISGetIndices(osm->is[i],&idx);
    125:       /* Print to a string viewer; no more than 15 characters per index plus 512 char for the header.*/
    126:       PetscMalloc1(16*(nidx+1)+512, &s);
    127:       PetscViewerStringOpen(PETSC_COMM_SELF, s, 16*(nidx+1)+512, &sviewer);
    128:       PetscViewerStringSPrintf(sviewer, "[%D:%D] Subdomain %D with overlap:\n", rank, size, i);
    129:       for (j=0; j<nidx; j++) {
    130:         PetscViewerStringSPrintf(sviewer,"%D ",idx[j]);
    131:       }
    132:       ISRestoreIndices(osm->is[i],&idx);
    133:       PetscViewerStringSPrintf(sviewer,"\n");
    134:       PetscViewerDestroy(&sviewer);
    135:       PetscViewerASCIIPushSynchronized(viewer);
    136:       PetscViewerASCIISynchronizedPrintf(viewer, s);
    137:       PetscViewerFlush(viewer);
    138:       PetscViewerASCIIPopSynchronized(viewer);
    139:       PetscFree(s);
    140:       if (osm->is_local) {
    141:         /* Print to a string viewer; no more than 15 characters per index plus 512 char for the header.*/
    142:         PetscMalloc1(16*(nidx+1)+512, &s);
    143:         PetscViewerStringOpen(PETSC_COMM_SELF, s, 16*(nidx+1)+512, &sviewer);
    144:         PetscViewerStringSPrintf(sviewer, "[%D:%D] Subdomain %D without overlap:\n", rank, size, i);
    145:         ISGetLocalSize(osm->is_local[i],&nidx);
    146:         ISGetIndices(osm->is_local[i],&idx);
    147:         for (j=0; j<nidx; j++) {
    148:           PetscViewerStringSPrintf(sviewer,"%D ",idx[j]);
    149:         }
    150:         ISRestoreIndices(osm->is_local[i],&idx);
    151:         PetscViewerStringSPrintf(sviewer,"\n");
    152:         PetscViewerDestroy(&sviewer);
    153:         PetscViewerASCIIPushSynchronized(viewer);
    154:         PetscViewerASCIISynchronizedPrintf(viewer, s);
    155:         PetscViewerFlush(viewer);
    156:         PetscViewerASCIIPopSynchronized(viewer);
    157:         PetscFree(s);
    158:       }
    159:     } else {
    160:       /* Participate in collective viewer calls. */
    161:       PetscViewerASCIIPushSynchronized(viewer);
    162:       PetscViewerFlush(viewer);
    163:       PetscViewerASCIIPopSynchronized(viewer);
    164:       /* Assume either all ranks have is_local or none do. */
    165:       if (osm->is_local) {
    166:         PetscViewerASCIIPushSynchronized(viewer);
    167:         PetscViewerFlush(viewer);
    168:         PetscViewerASCIIPopSynchronized(viewer);
    169:       }
    170:     }
    171:   }
    172:   PetscViewerFlush(viewer);
    173:   PetscViewerDestroy(&viewer);
    174:   return(0);
    175: }

    179: static PetscErrorCode PCSetUp_ASM(PC pc)
    180: {
    181:   PC_ASM         *osm = (PC_ASM*)pc->data;
    183:   PetscBool      symset,flg;
    184:   PetscInt       i,m,m_local;
    185:   MatReuse       scall = MAT_REUSE_MATRIX;
    186:   IS             isl;
    187:   KSP            ksp;
    188:   PC             subpc;
    189:   const char     *prefix,*pprefix;
    190:   Vec            vec;
    191:   DM             *domain_dm = NULL;

    194:   if (!pc->setupcalled) {

    196:     if (!osm->type_set) {
    197:       MatIsSymmetricKnown(pc->pmat,&symset,&flg);
    198:       if (symset && flg) osm->type = PC_ASM_BASIC;
    199:     }

    201:     /* Note: if subdomains have been set either via PCASMSetTotalSubdomains() or via PCASMSetLocalSubdomains(), osm->n_local_true will not be PETSC_DECIDE */
    202:     if (osm->n_local_true == PETSC_DECIDE) {
    203:       /* no subdomains given */
    204:       /* try pc->dm first, if allowed */
    205:       if (osm->dm_subdomains && pc->dm) {
    206:         PetscInt  num_domains, d;
    207:         char      **domain_names;
    208:         IS        *inner_domain_is, *outer_domain_is;
    209:         DMCreateDomainDecomposition(pc->dm, &num_domains, &domain_names, &inner_domain_is, &outer_domain_is, &domain_dm);
    210:         if (num_domains) {
    211:           PCASMSetLocalSubdomains(pc, num_domains, outer_domain_is, inner_domain_is);
    212:         }
    213:         for (d = 0; d < num_domains; ++d) {
    214:           if (domain_names)    {PetscFree(domain_names[d]);}
    215:           if (inner_domain_is) {ISDestroy(&inner_domain_is[d]);}
    216:           if (outer_domain_is) {ISDestroy(&outer_domain_is[d]);}
    217:         }
    218:         PetscFree(domain_names);
    219:         PetscFree(inner_domain_is);
    220:         PetscFree(outer_domain_is);
    221:       }
    222:       if (osm->n_local_true == PETSC_DECIDE) {
    223:         /* still no subdomains; use one subdomain per processor */
    224:         osm->n_local_true = 1;
    225:       }
    226:     }
    227:     { /* determine the global and max number of subdomains */
    228:       struct {PetscInt max,sum;} inwork,outwork;
    229:       inwork.max   = osm->n_local_true;
    230:       inwork.sum   = osm->n_local_true;
    231:       MPIU_Allreduce(&inwork,&outwork,1,MPIU_2INT,PetscMaxSum_Op,PetscObjectComm((PetscObject)pc));
    232:       osm->n_local = outwork.max;
    233:       osm->n       = outwork.sum;
    234:     }
    235:     if (!osm->is) { /* create the index sets */
    236:       PCASMCreateSubdomains(pc->pmat,osm->n_local_true,&osm->is);
    237:     }
    238:     if (osm->n_local_true > 1 && !osm->is_local) {
    239:       PetscMalloc1(osm->n_local_true,&osm->is_local);
    240:       for (i=0; i<osm->n_local_true; i++) {
    241:         if (osm->overlap > 0) { /* With positive overlap, osm->is[i] will be modified */
    242:           ISDuplicate(osm->is[i],&osm->is_local[i]);
    243:           ISCopy(osm->is[i],osm->is_local[i]);
    244:         } else {
    245:           PetscObjectReference((PetscObject)osm->is[i]);
    246:           osm->is_local[i] = osm->is[i];
    247:         }
    248:       }
    249:     }
    250:     PCGetOptionsPrefix(pc,&prefix);
    251:     flg  = PETSC_FALSE;
    252:     PetscOptionsGetBool(NULL,prefix,"-pc_asm_print_subdomains",&flg,NULL);
    253:     if (flg) { PCASMPrintSubdomains(pc); }

    255:     if (osm->overlap > 0) {
    256:       /* Extend the "overlapping" regions by a number of steps */
    257:       MatIncreaseOverlap(pc->pmat,osm->n_local_true,osm->is,osm->overlap);
    258:     }
    259:     if (osm->sort_indices) {
    260:       for (i=0; i<osm->n_local_true; i++) {
    261:         ISSort(osm->is[i]);
    262:         if (osm->is_local) {
    263:           ISSort(osm->is_local[i]);
    264:         }
    265:       }
    266:     }
    267:     /* Create the local work vectors and scatter contexts */
    268:     MatCreateVecs(pc->pmat,&vec,0);
    269:     PetscMalloc1(osm->n_local,&osm->restriction);
    270:     if (osm->is_local) {PetscMalloc1(osm->n_local,&osm->localization);}
    271:     PetscMalloc1(osm->n_local,&osm->prolongation);
    272:     PetscMalloc1(osm->n_local,&osm->x);
    273:     PetscMalloc1(osm->n_local,&osm->y);
    274:     PetscMalloc1(osm->n_local,&osm->y_local);
    275:     for (i=0; i<osm->n_local_true; ++i) {
    276:       ISGetLocalSize(osm->is[i],&m);
    277:       VecCreateSeq(PETSC_COMM_SELF,m,&osm->x[i]);
    278:       ISCreateStride(PETSC_COMM_SELF,m,0,1,&isl);
    279:       VecScatterCreate(vec,osm->is[i],osm->x[i],isl,&osm->restriction[i]);
    280:       ISDestroy(&isl);
    281:       VecDuplicate(osm->x[i],&osm->y[i]);
    282:       if (osm->is_local) {
    283:         ISLocalToGlobalMapping ltog;
    284:         IS                     isll;
    285:         const PetscInt         *idx_local;
    286:         PetscInt               *idx,nout;

    288:         ISLocalToGlobalMappingCreateIS(osm->is[i],&ltog);
    289:         ISGetLocalSize(osm->is_local[i],&m_local);
    290:         ISGetIndices(osm->is_local[i], &idx_local);
    291:         PetscMalloc1(m_local,&idx);
    292:         ISGlobalToLocalMappingApply(ltog,IS_GTOLM_DROP,m_local,idx_local,&nout,idx);
    293:         ISLocalToGlobalMappingDestroy(&ltog);
    294:         if (nout != m_local) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_PLIB,"is_local not a subset of is");
    295:         ISRestoreIndices(osm->is_local[i], &idx_local);
    296:         ISCreateGeneral(PETSC_COMM_SELF,m_local,idx,PETSC_OWN_POINTER,&isll);
    297:         ISCreateStride(PETSC_COMM_SELF,m_local,0,1,&isl);
    298:         VecCreateSeq(PETSC_COMM_SELF,m_local,&osm->y_local[i]);
    299:         VecScatterCreate(osm->y[i],isll,osm->y_local[i],isl,&osm->localization[i]);
    300:         ISDestroy(&isll);

    302:         VecScatterCreate(vec,osm->is_local[i],osm->y_local[i],isl,&osm->prolongation[i]);
    303:         ISDestroy(&isl);
    304:       } else {
    305:         VecGetLocalSize(vec,&m_local);

    307:         osm->y_local[i] = osm->y[i];

    309:         PetscObjectReference((PetscObject) osm->y[i]);

    311:         osm->prolongation[i] = osm->restriction[i];

    313:         PetscObjectReference((PetscObject) osm->restriction[i]);
    314:       }
    315:     }
    316:     for (i=osm->n_local_true; i<osm->n_local; i++) {
    317:       VecCreateSeq(PETSC_COMM_SELF,0,&osm->x[i]);
    318:       VecDuplicate(osm->x[i],&osm->y[i]);
    319:       VecDuplicate(osm->x[i],&osm->y_local[i]);
    320:       ISCreateStride(PETSC_COMM_SELF,0,0,1,&isl);
    321:       VecScatterCreate(vec,isl,osm->x[i],isl,&osm->restriction[i]);
    322:       if (osm->is_local) {
    323:         VecScatterCreate(osm->y[i],isl,osm->y_local[i],isl,&osm->localization[i]);
    324:         VecScatterCreate(vec,isl,osm->x[i],isl,&osm->prolongation[i]);
    325:       } else {
    326:         osm->prolongation[i] = osm->restriction[i];
    327:         PetscObjectReference((PetscObject) osm->restriction[i]);
    328:       }
    329:       ISDestroy(&isl);
    330:     }
    331:     VecDestroy(&vec);

    333:     if (!osm->ksp) {
    334:       /* Create the local solvers */
    335:       PetscMalloc1(osm->n_local_true,&osm->ksp);
    336:       if (domain_dm) {
    337:         PetscInfo(pc,"Setting up ASM subproblems using the embedded DM\n");
    338:       }
    339:       for (i=0; i<osm->n_local_true; i++) {
    340:         KSPCreate(PETSC_COMM_SELF,&ksp);
    341:         KSPSetErrorIfNotConverged(ksp,pc->erroriffailure);
    342:         PetscLogObjectParent((PetscObject)pc,(PetscObject)ksp);
    343:         PetscObjectIncrementTabLevel((PetscObject)ksp,(PetscObject)pc,1);
    344:         KSPSetType(ksp,KSPPREONLY);
    345:         KSPGetPC(ksp,&subpc);
    346:         PCGetOptionsPrefix(pc,&prefix);
    347:         KSPSetOptionsPrefix(ksp,prefix);
    348:         KSPAppendOptionsPrefix(ksp,"sub_");
    349:         if (domain_dm) {
    350:           KSPSetDM(ksp, domain_dm[i]);
    351:           KSPSetDMActive(ksp, PETSC_FALSE);
    352:           DMDestroy(&domain_dm[i]);
    353:         }
    354:         osm->ksp[i] = ksp;
    355:       }
    356:       if (domain_dm) {
    357:         PetscFree(domain_dm);
    358:       }
    359:     }
    360:     if (osm->loctype == PC_COMPOSITE_MULTIPLICATIVE) {
    361:       PetscInt m;

    363:       ISConcatenate(PETSC_COMM_SELF, osm->n_local_true, osm->is, &osm->lis);
    364:       ISSortRemoveDups(osm->lis);
    365:       ISGetLocalSize(osm->lis, &m);
    366:       VecCreateSeq(PETSC_COMM_SELF, m, &osm->lx);
    367:       VecDuplicate(osm->lx, &osm->ly);
    368:     }
    369:     scall = MAT_INITIAL_MATRIX;
    370:   } else {
    371:     /*
    372:        Destroy the blocks from the previous iteration
    373:     */
    374:     if (pc->flag == DIFFERENT_NONZERO_PATTERN) {
    375:       MatDestroyMatrices(osm->n_local_true,&osm->pmat);
    376:       scall = MAT_INITIAL_MATRIX;
    377:     }
    378:   }

    380:   /*
    381:      Extract out the submatrices
    382:   */
    383:   MatGetSubMatrices(pc->pmat,osm->n_local_true,osm->is,osm->is,scall,&osm->pmat);
    384:   if (scall == MAT_INITIAL_MATRIX) {
    385:     PetscObjectGetOptionsPrefix((PetscObject)pc->pmat,&pprefix);
    386:     for (i=0; i<osm->n_local_true; i++) {
    387:       PetscLogObjectParent((PetscObject)pc,(PetscObject)osm->pmat[i]);
    388:       PetscObjectSetOptionsPrefix((PetscObject)osm->pmat[i],pprefix);
    389:     }
    390:   }
    391:   if (osm->loctype == PC_COMPOSITE_MULTIPLICATIVE) {
    392:     IS      *cis;
    393:     PetscInt c;

    395:     PetscMalloc1(osm->n_local_true, &cis);
    396:     for (c = 0; c < osm->n_local_true; ++c) cis[c] = osm->lis;
    397:     MatGetSubMatrices(pc->pmat, osm->n_local_true, osm->is, cis, scall, &osm->lmats);
    398:     PetscFree(cis);
    399:   }

    401:   /* Return control to the user so that the submatrices can be modified (e.g., to apply
    402:      different boundary conditions for the submatrices than for the global problem) */
    403:   PCModifySubMatrices(pc,osm->n_local_true,osm->is,osm->is,osm->pmat,pc->modifysubmatricesP);

    405:   /*
    406:      Loop over subdomains putting them into local ksp
    407:   */
    408:   for (i=0; i<osm->n_local_true; i++) {
    409:     KSPSetOperators(osm->ksp[i],osm->pmat[i],osm->pmat[i]);
    410:     if (!pc->setupcalled) {
    411:       KSPSetFromOptions(osm->ksp[i]);
    412:     }
    413:   }
    414:   return(0);
    415: }

    417: #include <petsc/private/kspimpl.h>
    420: static PetscErrorCode PCSetUpOnBlocks_ASM(PC pc)
    421: {
    422:   PC_ASM         *osm = (PC_ASM*)pc->data;
    424:   PetscInt       i;

    427:   for (i=0; i<osm->n_local_true; i++) {
    428:     KSPSetUp(osm->ksp[i]);
    429:     if (osm->ksp[i]->reason == KSP_DIVERGED_PCSETUP_FAILED) {
    430:       pc->failedreason = PC_SUBPC_ERROR;
    431:     }
    432:   }
    433:   return(0);
    434: }

    438: static PetscErrorCode PCApply_ASM(PC pc,Vec x,Vec y)
    439: {
    440:   PC_ASM         *osm = (PC_ASM*)pc->data;
    442:   PetscInt       i,n_local = osm->n_local,n_local_true = osm->n_local_true;
    443:   ScatterMode    forward = SCATTER_FORWARD,reverse = SCATTER_REVERSE;

    446:   /*
    447:      Support for limiting the restriction or interpolation to only local
    448:      subdomain values (leaving the other values 0).
    449:   */
    450:   if (!(osm->type & PC_ASM_RESTRICT)) {
    451:     forward = SCATTER_FORWARD_LOCAL;
    452:     /* have to zero the work RHS since scatter may leave some slots empty */
    453:     for (i=0; i<n_local_true; i++) {
    454:       VecZeroEntries(osm->x[i]);
    455:     }
    456:   }
    457:   if (!(osm->type & PC_ASM_INTERPOLATE)) reverse = SCATTER_REVERSE_LOCAL;

    459:   switch (osm->loctype)
    460:   {
    461:   case PC_COMPOSITE_ADDITIVE:
    462:     for (i=0; i<n_local; i++) {
    463:       VecScatterBegin(osm->restriction[i],x,osm->x[i],INSERT_VALUES,forward);
    464:     }
    465:     VecZeroEntries(y);
    466:     /* do the local solves */
    467:     for (i=0; i<n_local_true; i++) {
    468:       VecScatterEnd(osm->restriction[i],x,osm->x[i],INSERT_VALUES,forward);
    469:       KSPSolve(osm->ksp[i],osm->x[i],osm->y[i]);
    470:       if (osm->localization) {
    471:         VecScatterBegin(osm->localization[i],osm->y[i],osm->y_local[i],INSERT_VALUES,forward);
    472:         VecScatterEnd(osm->localization[i],osm->y[i],osm->y_local[i],INSERT_VALUES,forward);
    473:       }
    474:       VecScatterBegin(osm->prolongation[i],osm->y_local[i],y,ADD_VALUES,reverse);
    475:     }
    476:     /* handle the rest of the scatters that do not have local solves */
    477:     for (i=n_local_true; i<n_local; i++) {
    478:       VecScatterEnd(osm->restriction[i],x,osm->x[i],INSERT_VALUES,forward);
    479:       VecScatterBegin(osm->prolongation[i],osm->y_local[i],y,ADD_VALUES,reverse);
    480:     }
    481:     for (i=0; i<n_local; i++) {
    482:       VecScatterEnd(osm->prolongation[i],osm->y_local[i],y,ADD_VALUES,reverse);
    483:     }
    484:     break;
    485:   case PC_COMPOSITE_MULTIPLICATIVE:
    486:     VecZeroEntries(y);
    487:     /* do the local solves */
    488:     for (i = 0; i < n_local_true; ++i) {
    489:       if (i > 0) {
    490:         /* Update rhs */
    491:         VecScatterBegin(osm->restriction[i], osm->lx, osm->x[i], INSERT_VALUES, forward);
    492:         VecScatterEnd(osm->restriction[i], osm->lx, osm->x[i], INSERT_VALUES, forward);
    493:       } else {
    494:         VecZeroEntries(osm->x[i]);
    495:       }
    496:       VecScatterBegin(osm->restriction[i], x, osm->x[i], ADD_VALUES, forward);
    497:       VecScatterEnd(osm->restriction[i], x, osm->x[i], ADD_VALUES, forward);
    498:       KSPSolve(osm->ksp[i], osm->x[i], osm->y[i]);
    499:       if (osm->localization) {
    500:         VecScatterBegin(osm->localization[i], osm->y[i], osm->y_local[i], INSERT_VALUES, forward);
    501:         VecScatterEnd(osm->localization[i], osm->y[i], osm->y_local[i], INSERT_VALUES, forward);
    502:       }
    503:       VecScatterBegin(osm->prolongation[i], osm->y_local[i], y, ADD_VALUES, reverse);
    504:       VecScatterEnd(osm->prolongation[i], osm->y_local[i], y, ADD_VALUES, reverse);
    505:       if (i < n_local_true-1) {
    506:         VecSet(osm->ly, 0.0);
    507:         VecScatterBegin(osm->prolongation[i], osm->y_local[i], osm->ly, INSERT_VALUES, reverse);
    508:         VecScatterEnd(osm->prolongation[i], osm->y_local[i], osm->ly, INSERT_VALUES, reverse);
    509:         VecScale(osm->ly, -1.0);
    510:         MatMult(osm->lmats[i+1], osm->ly, osm->y[i+1]);
    511:         VecScatterBegin(osm->restriction[i+1], osm->y[i+1], osm->lx, INSERT_VALUES, reverse);
    512:         VecScatterEnd(osm->restriction[i+1], osm->y[i+1], osm->lx, INSERT_VALUES, reverse);
    513:       }
    514:     }
    515:     /* handle the rest of the scatters that do not have local solves */
    516:     for (i = n_local_true; i < n_local; ++i) {
    517:       VecScatterBegin(osm->restriction[i], x, osm->x[i], INSERT_VALUES, forward);
    518:       VecScatterEnd(osm->restriction[i], x, osm->x[i], INSERT_VALUES, forward);
    519:       VecScatterBegin(osm->prolongation[i], osm->y_local[i], y, ADD_VALUES, reverse);
    520:       VecScatterEnd(osm->prolongation[i], osm->y_local[i], y, ADD_VALUES, reverse);
    521:     }
    522:     break;
    523:   default: SETERRQ1(PetscObjectComm((PetscObject) pc), PETSC_ERR_ARG_WRONG, "Invalid local composition type: %s", PCCompositeTypes[osm->loctype]);
    524:   }
    525:   return(0);
    526: }

    530: static PetscErrorCode PCApplyTranspose_ASM(PC pc,Vec x,Vec y)
    531: {
    532:   PC_ASM         *osm = (PC_ASM*)pc->data;
    534:   PetscInt       i,n_local = osm->n_local,n_local_true = osm->n_local_true;
    535:   ScatterMode    forward = SCATTER_FORWARD,reverse = SCATTER_REVERSE;

    538:   /*
    539:      Support for limiting the restriction or interpolation to only local
    540:      subdomain values (leaving the other values 0).

    542:      Note: these are reversed from the PCApply_ASM() because we are applying the
    543:      transpose of the three terms
    544:   */
    545:   if (!(osm->type & PC_ASM_INTERPOLATE)) {
    546:     forward = SCATTER_FORWARD_LOCAL;
    547:     /* have to zero the work RHS since scatter may leave some slots empty */
    548:     for (i=0; i<n_local_true; i++) {
    549:       VecZeroEntries(osm->x[i]);
    550:     }
    551:   }
    552:   if (!(osm->type & PC_ASM_RESTRICT)) reverse = SCATTER_REVERSE_LOCAL;

    554:   for (i=0; i<n_local; i++) {
    555:     VecScatterBegin(osm->restriction[i],x,osm->x[i],INSERT_VALUES,forward);
    556:   }
    557:   VecZeroEntries(y);
    558:   /* do the local solves */
    559:   for (i=0; i<n_local_true; i++) {
    560:     VecScatterEnd(osm->restriction[i],x,osm->x[i],INSERT_VALUES,forward);
    561:     KSPSolveTranspose(osm->ksp[i],osm->x[i],osm->y[i]);
    562:     if (osm->localization) {
    563:       VecScatterBegin(osm->localization[i],osm->y[i],osm->y_local[i],INSERT_VALUES,forward);
    564:       VecScatterEnd(osm->localization[i],osm->y[i],osm->y_local[i],INSERT_VALUES,forward);
    565:     }
    566:     VecScatterBegin(osm->prolongation[i],osm->y_local[i],y,ADD_VALUES,reverse);
    567:   }
    568:   /* handle the rest of the scatters that do not have local solves */
    569:   for (i=n_local_true; i<n_local; i++) {
    570:     VecScatterEnd(osm->restriction[i],x,osm->x[i],INSERT_VALUES,forward);
    571:     VecScatterBegin(osm->prolongation[i],osm->y_local[i],y,ADD_VALUES,reverse);
    572:   }
    573:   for (i=0; i<n_local; i++) {
    574:     VecScatterEnd(osm->prolongation[i],osm->y_local[i],y,ADD_VALUES,reverse);
    575:   }
    576:   return(0);
    577: }

    581: static PetscErrorCode PCReset_ASM(PC pc)
    582: {
    583:   PC_ASM         *osm = (PC_ASM*)pc->data;
    585:   PetscInt       i;

    588:   if (osm->ksp) {
    589:     for (i=0; i<osm->n_local_true; i++) {
    590:       KSPReset(osm->ksp[i]);
    591:     }
    592:   }
    593:   if (osm->pmat) {
    594:     if (osm->n_local_true > 0) {
    595:       MatDestroyMatrices(osm->n_local_true,&osm->pmat);
    596:     }
    597:   }
    598:   if (osm->restriction) {
    599:     for (i=0; i<osm->n_local; i++) {
    600:       VecScatterDestroy(&osm->restriction[i]);
    601:       if (osm->localization) {VecScatterDestroy(&osm->localization[i]);}
    602:       VecScatterDestroy(&osm->prolongation[i]);
    603:       VecDestroy(&osm->x[i]);
    604:       VecDestroy(&osm->y[i]);
    605:       VecDestroy(&osm->y_local[i]);
    606:     }
    607:     PetscFree(osm->restriction);
    608:     if (osm->localization) {PetscFree(osm->localization);}
    609:     PetscFree(osm->prolongation);
    610:     PetscFree(osm->x);
    611:     PetscFree(osm->y);
    612:     PetscFree(osm->y_local);
    613:   }
    614:   PCASMDestroySubdomains(osm->n_local_true,osm->is,osm->is_local);
    615:   if (osm->loctype == PC_COMPOSITE_MULTIPLICATIVE) {
    616:     ISDestroy(&osm->lis);
    617:     MatDestroyMatrices(osm->n_local_true, &osm->lmats);
    618:     VecDestroy(&osm->lx);
    619:     VecDestroy(&osm->ly);
    620:   }

    622:   osm->is       = 0;
    623:   osm->is_local = 0;
    624:   return(0);
    625: }

    629: static PetscErrorCode PCDestroy_ASM(PC pc)
    630: {
    631:   PC_ASM         *osm = (PC_ASM*)pc->data;
    633:   PetscInt       i;

    636:   PCReset_ASM(pc);
    637:   if (osm->ksp) {
    638:     for (i=0; i<osm->n_local_true; i++) {
    639:       KSPDestroy(&osm->ksp[i]);
    640:     }
    641:     PetscFree(osm->ksp);
    642:   }
    643:   PetscFree(pc->data);
    644:   return(0);
    645: }

    649: static PetscErrorCode PCSetFromOptions_ASM(PetscOptionItems *PetscOptionsObject,PC pc)
    650: {
    651:   PC_ASM         *osm = (PC_ASM*)pc->data;
    653:   PetscInt       blocks,ovl;
    654:   PetscBool      symset,flg;
    655:   PCASMType      asmtype;
    656:   PCCompositeType loctype;

    659:   /* set the type to symmetric if matrix is symmetric */
    660:   if (!osm->type_set && pc->pmat) {
    661:     MatIsSymmetricKnown(pc->pmat,&symset,&flg);
    662:     if (symset && flg) osm->type = PC_ASM_BASIC;
    663:   }
    664:   PetscOptionsHead(PetscOptionsObject,"Additive Schwarz options");
    665:   PetscOptionsBool("-pc_asm_dm_subdomains","Use DMCreateDomainDecomposition() to define subdomains","PCASMSetDMSubdomains",osm->dm_subdomains,&osm->dm_subdomains,&flg);
    666:   PetscOptionsInt("-pc_asm_blocks","Number of subdomains","PCASMSetTotalSubdomains",osm->n,&blocks,&flg);
    667:   if (flg) {
    668:     PCASMSetTotalSubdomains(pc,blocks,NULL,NULL);
    669:     osm->dm_subdomains = PETSC_FALSE;
    670:   }
    671:   PetscOptionsInt("-pc_asm_overlap","Number of grid points overlap","PCASMSetOverlap",osm->overlap,&ovl,&flg);
    672:   if (flg) {
    673:     PCASMSetOverlap(pc,ovl);
    674:     osm->dm_subdomains = PETSC_FALSE;
    675:   }
    676:   flg  = PETSC_FALSE;
    677:   PetscOptionsEnum("-pc_asm_type","Type of restriction/extension","PCASMSetType",PCASMTypes,(PetscEnum)osm->type,(PetscEnum*)&asmtype,&flg);
    678:   if (flg) {PCASMSetType(pc,asmtype); }
    679:   flg  = PETSC_FALSE;
    680:   PetscOptionsEnum("-pc_asm_local_type","Type of local solver composition","PCASMSetLocalType",PCCompositeTypes,(PetscEnum)osm->loctype,(PetscEnum*)&loctype,&flg);
    681:   if (flg) {PCASMSetLocalType(pc,loctype); }
    682:   PetscOptionsTail();
    683:   return(0);
    684: }

    686: /*------------------------------------------------------------------------------------*/

    690: static PetscErrorCode  PCASMSetLocalSubdomains_ASM(PC pc,PetscInt n,IS is[],IS is_local[])
    691: {
    692:   PC_ASM         *osm = (PC_ASM*)pc->data;
    694:   PetscInt       i;

    697:   if (n < 1) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"Each process must have 1 or more blocks, n = %D",n);
    698:   if (pc->setupcalled && (n != osm->n_local_true || is)) SETERRQ(PetscObjectComm((PetscObject)pc),PETSC_ERR_ARG_WRONGSTATE,"PCASMSetLocalSubdomains() should be called before calling PCSetUp().");

    700:   if (!pc->setupcalled) {
    701:     if (is) {
    702:       for (i=0; i<n; i++) {PetscObjectReference((PetscObject)is[i]);}
    703:     }
    704:     if (is_local) {
    705:       for (i=0; i<n; i++) {PetscObjectReference((PetscObject)is_local[i]);}
    706:     }
    707:     PCASMDestroySubdomains(osm->n_local_true,osm->is,osm->is_local);

    709:     osm->n_local_true = n;
    710:     osm->is           = 0;
    711:     osm->is_local     = 0;
    712:     if (is) {
    713:       PetscMalloc1(n,&osm->is);
    714:       for (i=0; i<n; i++) osm->is[i] = is[i];
    715:       /* Flag indicating that the user has set overlapping subdomains so PCASM should not increase their size. */
    716:       osm->overlap = -1;
    717:     }
    718:     if (is_local) {
    719:       PetscMalloc1(n,&osm->is_local);
    720:       for (i=0; i<n; i++) osm->is_local[i] = is_local[i];
    721:       if (!is) {
    722:         PetscMalloc1(osm->n_local_true,&osm->is);
    723:         for (i=0; i<osm->n_local_true; i++) {
    724:           if (osm->overlap > 0) { /* With positive overlap, osm->is[i] will be modified */
    725:             ISDuplicate(osm->is_local[i],&osm->is[i]);
    726:             ISCopy(osm->is_local[i],osm->is[i]);
    727:           } else {
    728:             PetscObjectReference((PetscObject)osm->is_local[i]);
    729:             osm->is[i] = osm->is_local[i];
    730:           }
    731:         }
    732:       }
    733:     }
    734:   }
    735:   return(0);
    736: }

    740: static PetscErrorCode  PCASMSetTotalSubdomains_ASM(PC pc,PetscInt N,IS *is,IS *is_local)
    741: {
    742:   PC_ASM         *osm = (PC_ASM*)pc->data;
    744:   PetscMPIInt    rank,size;
    745:   PetscInt       n;

    748:   if (N < 1) SETERRQ1(PetscObjectComm((PetscObject)pc),PETSC_ERR_ARG_OUTOFRANGE,"Number of total blocks must be > 0, N = %D",N);
    749:   if (is || is_local) SETERRQ(PetscObjectComm((PetscObject)pc),PETSC_ERR_SUP,"Use PCASMSetLocalSubdomains() to set specific index sets\n\they cannot be set globally yet.");

    751:   /*
    752:      Split the subdomains equally among all processors
    753:   */
    754:   MPI_Comm_rank(PetscObjectComm((PetscObject)pc),&rank);
    755:   MPI_Comm_size(PetscObjectComm((PetscObject)pc),&size);
    756:   n    = N/size + ((N % size) > rank);
    757:   if (!n) SETERRQ3(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"Process %d must have at least one block: total processors %d total blocks %D",(int)rank,(int)size,N);
    758:   if (pc->setupcalled && n != osm->n_local_true) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONGSTATE,"PCASMSetTotalSubdomains() should be called before PCSetUp().");
    759:   if (!pc->setupcalled) {
    760:     PCASMDestroySubdomains(osm->n_local_true,osm->is,osm->is_local);

    762:     osm->n_local_true = n;
    763:     osm->is           = 0;
    764:     osm->is_local     = 0;
    765:   }
    766:   return(0);
    767: }

    771: static PetscErrorCode  PCASMSetOverlap_ASM(PC pc,PetscInt ovl)
    772: {
    773:   PC_ASM *osm = (PC_ASM*)pc->data;

    776:   if (ovl < 0) SETERRQ(PetscObjectComm((PetscObject)pc),PETSC_ERR_ARG_OUTOFRANGE,"Negative overlap value requested");
    777:   if (pc->setupcalled && ovl != osm->overlap) SETERRQ(PetscObjectComm((PetscObject)pc),PETSC_ERR_ARG_WRONGSTATE,"PCASMSetOverlap() should be called before PCSetUp().");
    778:   if (!pc->setupcalled) osm->overlap = ovl;
    779:   return(0);
    780: }

    784: static PetscErrorCode  PCASMSetType_ASM(PC pc,PCASMType type)
    785: {
    786:   PC_ASM *osm = (PC_ASM*)pc->data;

    789:   osm->type     = type;
    790:   osm->type_set = PETSC_TRUE;
    791:   return(0);
    792: }

    796: static PetscErrorCode  PCASMGetType_ASM(PC pc,PCASMType *type)
    797: {
    798:   PC_ASM *osm = (PC_ASM*)pc->data;

    801:   *type = osm->type;
    802:   return(0);
    803: }

    807: static PetscErrorCode  PCASMSetLocalType_ASM(PC pc, PCCompositeType type)
    808: {
    809:   PC_ASM *osm = (PC_ASM *) pc->data;

    812:   osm->loctype = type;
    813:   return(0);
    814: }

    818: static PetscErrorCode  PCASMGetLocalType_ASM(PC pc, PCCompositeType *type)
    819: {
    820:   PC_ASM *osm = (PC_ASM *) pc->data;

    823:   *type = osm->loctype;
    824:   return(0);
    825: }

    829: static PetscErrorCode  PCASMSetSortIndices_ASM(PC pc,PetscBool  doSort)
    830: {
    831:   PC_ASM *osm = (PC_ASM*)pc->data;

    834:   osm->sort_indices = doSort;
    835:   return(0);
    836: }

    840: static PetscErrorCode  PCASMGetSubKSP_ASM(PC pc,PetscInt *n_local,PetscInt *first_local,KSP **ksp)
    841: {
    842:   PC_ASM         *osm = (PC_ASM*)pc->data;

    846:   if (osm->n_local_true < 1) SETERRQ(PetscObjectComm((PetscObject)pc),PETSC_ERR_ORDER,"Need to call PCSetUP() on PC (or KSPSetUp() on the outer KSP object) before calling here");

    848:   if (n_local) *n_local = osm->n_local_true;
    849:   if (first_local) {
    850:     MPI_Scan(&osm->n_local_true,first_local,1,MPIU_INT,MPI_SUM,PetscObjectComm((PetscObject)pc));
    851:     *first_local -= osm->n_local_true;
    852:   }
    853:   if (ksp) {
    854:     /* Assume that local solves are now different; not necessarily
    855:        true though!  This flag is used only for PCView_ASM() */
    856:     *ksp                   = osm->ksp;
    857:     osm->same_local_solves = PETSC_FALSE;
    858:   }
    859:   return(0);
    860: }

    864: /*@C
    865:     PCASMSetLocalSubdomains - Sets the local subdomains (for this processor only) for the additive Schwarz preconditioner.

    867:     Collective on PC

    869:     Input Parameters:
    870: +   pc - the preconditioner context
    871: .   n - the number of subdomains for this processor (default value = 1)
    872: .   is - the index set that defines the subdomains for this processor
    873:          (or NULL for PETSc to determine subdomains)
    874: -   is_local - the index sets that define the local part of the subdomains for this processor
    875:          (or NULL to use the default of 1 subdomain per process)

    877:     Notes:
    878:     The IS numbering is in the parallel, global numbering of the vector for both is and is_local

    880:     By default the ASM preconditioner uses 1 block per processor.

    882:     Use PCASMSetTotalSubdomains() to set the subdomains for all processors.

    884:     Level: advanced

    886: .keywords: PC, ASM, set, local, subdomains, additive Schwarz

    888: .seealso: PCASMSetTotalSubdomains(), PCASMSetOverlap(), PCASMGetSubKSP(),
    889:           PCASMCreateSubdomains2D(), PCASMGetLocalSubdomains()
    890: @*/
    891: PetscErrorCode  PCASMSetLocalSubdomains(PC pc,PetscInt n,IS is[],IS is_local[])
    892: {

    897:   PetscTryMethod(pc,"PCASMSetLocalSubdomains_C",(PC,PetscInt,IS[],IS[]),(pc,n,is,is_local));
    898:   return(0);
    899: }

    903: /*@C
    904:     PCASMSetTotalSubdomains - Sets the subdomains for all processors for the
    905:     additive Schwarz preconditioner.  Either all or no processors in the
    906:     PC communicator must call this routine, with the same index sets.

    908:     Collective on PC

    910:     Input Parameters:
    911: +   pc - the preconditioner context
    912: .   N  - the number of subdomains for all processors
    913: .   is - the index sets that define the subdomains for all processors
    914:          (or NULL to ask PETSc to compe up with subdomains)
    915: -   is_local - the index sets that define the local part of the subdomains for this processor
    916:          (or NULL to use the default of 1 subdomain per process)

    918:     Options Database Key:
    919:     To set the total number of subdomain blocks rather than specify the
    920:     index sets, use the option
    921: .    -pc_asm_blocks <blks> - Sets total blocks

    923:     Notes:
    924:     Currently you cannot use this to set the actual subdomains with the argument is.

    926:     By default the ASM preconditioner uses 1 block per processor.

    928:     These index sets cannot be destroyed until after completion of the
    929:     linear solves for which the ASM preconditioner is being used.

    931:     Use PCASMSetLocalSubdomains() to set local subdomains.

    933:     The IS numbering is in the parallel, global numbering of the vector for both is and is_local

    935:     Level: advanced

    937: .keywords: PC, ASM, set, total, global, subdomains, additive Schwarz

    939: .seealso: PCASMSetLocalSubdomains(), PCASMSetOverlap(), PCASMGetSubKSP(),
    940:           PCASMCreateSubdomains2D()
    941: @*/
    942: PetscErrorCode  PCASMSetTotalSubdomains(PC pc,PetscInt N,IS is[],IS is_local[])
    943: {

    948:   PetscTryMethod(pc,"PCASMSetTotalSubdomains_C",(PC,PetscInt,IS[],IS[]),(pc,N,is,is_local));
    949:   return(0);
    950: }

    954: /*@
    955:     PCASMSetOverlap - Sets the overlap between a pair of subdomains for the
    956:     additive Schwarz preconditioner.  Either all or no processors in the
    957:     PC communicator must call this routine. If MatIncreaseOverlap is used,
    958:     use option -mat_increase_overlap when the problem size large.

    960:     Logically Collective on PC

    962:     Input Parameters:
    963: +   pc  - the preconditioner context
    964: -   ovl - the amount of overlap between subdomains (ovl >= 0, default value = 1)

    966:     Options Database Key:
    967: .   -pc_asm_overlap <ovl> - Sets overlap

    969:     Notes:
    970:     By default the ASM preconditioner uses 1 block per processor.  To use
    971:     multiple blocks per perocessor, see PCASMSetTotalSubdomains() and
    972:     PCASMSetLocalSubdomains() (and the option -pc_asm_blocks <blks>).

    974:     The overlap defaults to 1, so if one desires that no additional
    975:     overlap be computed beyond what may have been set with a call to
    976:     PCASMSetTotalSubdomains() or PCASMSetLocalSubdomains(), then ovl
    977:     must be set to be 0.  In particular, if one does not explicitly set
    978:     the subdomains an application code, then all overlap would be computed
    979:     internally by PETSc, and using an overlap of 0 would result in an ASM
    980:     variant that is equivalent to the block Jacobi preconditioner.

    982:     Note that one can define initial index sets with any overlap via
    983:     PCASMSetTotalSubdomains() or PCASMSetLocalSubdomains(); the routine
    984:     PCASMSetOverlap() merely allows PETSc to extend that overlap further
    985:     if desired.

    987:     Level: intermediate

    989: .keywords: PC, ASM, set, overlap

    991: .seealso: PCASMSetTotalSubdomains(), PCASMSetLocalSubdomains(), PCASMGetSubKSP(),
    992:           PCASMCreateSubdomains2D(), PCASMGetLocalSubdomains()
    993: @*/
    994: PetscErrorCode  PCASMSetOverlap(PC pc,PetscInt ovl)
    995: {

    1001:   PetscTryMethod(pc,"PCASMSetOverlap_C",(PC,PetscInt),(pc,ovl));
    1002:   return(0);
    1003: }

    1007: /*@
    1008:     PCASMSetType - Sets the type of restriction and interpolation used
    1009:     for local problems in the additive Schwarz method.

    1011:     Logically Collective on PC

    1013:     Input Parameters:
    1014: +   pc  - the preconditioner context
    1015: -   type - variant of ASM, one of
    1016: .vb
    1017:       PC_ASM_BASIC       - full interpolation and restriction
    1018:       PC_ASM_RESTRICT    - full restriction, local processor interpolation
    1019:       PC_ASM_INTERPOLATE - full interpolation, local processor restriction
    1020:       PC_ASM_NONE        - local processor restriction and interpolation
    1021: .ve

    1023:     Options Database Key:
    1024: .   -pc_asm_type [basic,restrict,interpolate,none] - Sets ASM type

    1026:     Level: intermediate

    1028: .keywords: PC, ASM, set, type

    1030: .seealso: PCASMSetTotalSubdomains(), PCASMSetTotalSubdomains(), PCASMGetSubKSP(),
    1031:           PCASMCreateSubdomains2D()
    1032: @*/
    1033: PetscErrorCode  PCASMSetType(PC pc,PCASMType type)
    1034: {

    1040:   PetscTryMethod(pc,"PCASMSetType_C",(PC,PCASMType),(pc,type));
    1041:   return(0);
    1042: }

    1046: /*@
    1047:     PCASMGetType - Gets the type of restriction and interpolation used
    1048:     for local problems in the additive Schwarz method.

    1050:     Logically Collective on PC

    1052:     Input Parameter:
    1053: .   pc  - the preconditioner context

    1055:     Output Parameter:
    1056: .   type - variant of ASM, one of

    1058: .vb
    1059:       PC_ASM_BASIC       - full interpolation and restriction
    1060:       PC_ASM_RESTRICT    - full restriction, local processor interpolation
    1061:       PC_ASM_INTERPOLATE - full interpolation, local processor restriction
    1062:       PC_ASM_NONE        - local processor restriction and interpolation
    1063: .ve

    1065:     Options Database Key:
    1066: .   -pc_asm_type [basic,restrict,interpolate,none] - Sets ASM type

    1068:     Level: intermediate

    1070: .keywords: PC, ASM, set, type

    1072: .seealso: PCASMSetTotalSubdomains(), PCASMSetTotalSubdomains(), PCASMGetSubKSP(),
    1073:           PCASMCreateSubdomains2D()
    1074: @*/
    1075: PetscErrorCode  PCASMGetType(PC pc,PCASMType *type)
    1076: {

    1081:   PetscUseMethod(pc,"PCASMGetType_C",(PC,PCASMType*),(pc,type));
    1082:   return(0);
    1083: }

    1087: /*@
    1088:   PCASMSetLocalType - Sets the type of composition used for local problems in the additive Schwarz method.

    1090:   Logically Collective on PC

    1092:   Input Parameters:
    1093: + pc  - the preconditioner context
    1094: - type - type of composition, one of
    1095: .vb
    1096:   PC_COMPOSITE_ADDITIVE       - local additive combination
    1097:   PC_COMPOSITE_MULTIPLICATIVE - local multiplicative combination
    1098: .ve

    1100:   Options Database Key:
    1101: . -pc_asm_local_type [additive,multiplicative] - Sets local solver composition type

    1103:   Level: intermediate

    1105: .seealso: PCASMSetType(), PCASMGetType(), PCASMGetLocalType(), PCASMCreate()
    1106: @*/
    1107: PetscErrorCode PCASMSetLocalType(PC pc, PCCompositeType type)
    1108: {

    1114:   PetscTryMethod(pc, "PCASMSetLocalType_C", (PC, PCCompositeType), (pc, type));
    1115:   return(0);
    1116: }

    1120: /*@
    1121:   PCASMGetLocalType - Gets the type of composition used for local problems in the additive Schwarz method.

    1123:   Logically Collective on PC

    1125:   Input Parameter:
    1126: . pc  - the preconditioner context

    1128:   Output Parameter:
    1129: . type - type of composition, one of
    1130: .vb
    1131:   PC_COMPOSITE_ADDITIVE       - local additive combination
    1132:   PC_COMPOSITE_MULTIPLICATIVE - local multiplicative combination
    1133: .ve

    1135:   Options Database Key:
    1136: . -pc_asm_local_type [additive,multiplicative] - Sets local solver composition type

    1138:   Level: intermediate

    1140: .seealso: PCASMSetType(), PCASMGetType(), PCASMSetLocalType(), PCASMCreate()
    1141: @*/
    1142: PetscErrorCode PCASMGetLocalType(PC pc, PCCompositeType *type)
    1143: {

    1149:   PetscUseMethod(pc, "PCASMGetLocalType_C", (PC, PCCompositeType *), (pc, type));
    1150:   return(0);
    1151: }

    1155: /*@
    1156:     PCASMSetSortIndices - Determines whether subdomain indices are sorted.

    1158:     Logically Collective on PC

    1160:     Input Parameters:
    1161: +   pc  - the preconditioner context
    1162: -   doSort - sort the subdomain indices

    1164:     Level: intermediate

    1166: .keywords: PC, ASM, set, type

    1168: .seealso: PCASMSetLocalSubdomains(), PCASMSetTotalSubdomains(), PCASMGetSubKSP(),
    1169:           PCASMCreateSubdomains2D()
    1170: @*/
    1171: PetscErrorCode  PCASMSetSortIndices(PC pc,PetscBool doSort)
    1172: {

    1178:   PetscTryMethod(pc,"PCASMSetSortIndices_C",(PC,PetscBool),(pc,doSort));
    1179:   return(0);
    1180: }

    1184: /*@C
    1185:    PCASMGetSubKSP - Gets the local KSP contexts for all blocks on
    1186:    this processor.

    1188:    Collective on PC iff first_local is requested

    1190:    Input Parameter:
    1191: .  pc - the preconditioner context

    1193:    Output Parameters:
    1194: +  n_local - the number of blocks on this processor or NULL
    1195: .  first_local - the global number of the first block on this processor or NULL,
    1196:                  all processors must request or all must pass NULL
    1197: -  ksp - the array of KSP contexts

    1199:    Note:
    1200:    After PCASMGetSubKSP() the array of KSPes is not to be freed.

    1202:    Currently for some matrix implementations only 1 block per processor
    1203:    is supported.

    1205:    You must call KSPSetUp() before calling PCASMGetSubKSP().

    1207:    Fortran note:
    1208:    The output argument 'ksp' must be an array of sufficient length or NULL_OBJECT. The latter can be used to learn the necessary length.

    1210:    Level: advanced

    1212: .keywords: PC, ASM, additive Schwarz, get, sub, KSP, context

    1214: .seealso: PCASMSetTotalSubdomains(), PCASMSetTotalSubdomains(), PCASMSetOverlap(),
    1215:           PCASMCreateSubdomains2D(),
    1216: @*/
    1217: PetscErrorCode  PCASMGetSubKSP(PC pc,PetscInt *n_local,PetscInt *first_local,KSP *ksp[])
    1218: {

    1223:   PetscUseMethod(pc,"PCASMGetSubKSP_C",(PC,PetscInt*,PetscInt*,KSP **),(pc,n_local,first_local,ksp));
    1224:   return(0);
    1225: }

    1227: /* -------------------------------------------------------------------------------------*/
    1228: /*MC
    1229:    PCASM - Use the (restricted) additive Schwarz method, each block is (approximately) solved with
    1230:            its own KSP object.

    1232:    Options Database Keys:
    1233: +  -pc_asm_blocks <blks> - Sets total blocks
    1234: .  -pc_asm_overlap <ovl> - Sets overlap
    1235: -  -pc_asm_type [basic,restrict,interpolate,none] - Sets ASM type

    1237:      IMPORTANT: If you run with, for example, 3 blocks on 1 processor or 3 blocks on 3 processors you
    1238:       will get a different convergence rate due to the default option of -pc_asm_type restrict. Use
    1239:       -pc_asm_type basic to use the standard ASM.

    1241:    Notes: Each processor can have one or more blocks, but a block cannot be shared by more
    1242:      than one processor. Defaults to one block per processor.

    1244:      To set options on the solvers for each block append -sub_ to all the KSP, and PC
    1245:         options database keys. For example, -sub_pc_type ilu -sub_pc_factor_levels 1 -sub_ksp_type preonly

    1247:      To set the options on the solvers separate for each block call PCASMGetSubKSP()
    1248:          and set the options directly on the resulting KSP object (you can access its PC
    1249:          with KSPGetPC())

    1252:    Level: beginner

    1254:    Concepts: additive Schwarz method

    1256:     References:
    1257: +   1. - M Dryja, OB Widlund, An additive variant of the Schwarz alternating method for the case of many subregions
    1258:      Courant Institute, New York University Technical report
    1259: -   1. - Barry Smith, Petter Bjorstad, and William Gropp, Domain Decompositions: Parallel Multilevel Methods for Elliptic Partial Differential Equations,
    1260:     Cambridge University Press.

    1262: .seealso:  PCCreate(), PCSetType(), PCType (for list of available types), PC,
    1263:            PCBJACOBI, PCASMGetSubKSP(), PCASMSetLocalSubdomains(),
    1264:            PCASMSetTotalSubdomains(), PCSetModifySubmatrices(), PCASMSetOverlap(), PCASMSetType()

    1266: M*/

    1270: PETSC_EXTERN PetscErrorCode PCCreate_ASM(PC pc)
    1271: {
    1273:   PC_ASM         *osm;

    1276:   PetscNewLog(pc,&osm);

    1278:   osm->n                 = PETSC_DECIDE;
    1279:   osm->n_local           = 0;
    1280:   osm->n_local_true      = PETSC_DECIDE;
    1281:   osm->overlap           = 1;
    1282:   osm->ksp               = 0;
    1283:   osm->restriction       = 0;
    1284:   osm->localization      = 0;
    1285:   osm->prolongation      = 0;
    1286:   osm->x                 = 0;
    1287:   osm->y                 = 0;
    1288:   osm->y_local           = 0;
    1289:   osm->is                = 0;
    1290:   osm->is_local          = 0;
    1291:   osm->mat               = 0;
    1292:   osm->pmat              = 0;
    1293:   osm->type              = PC_ASM_RESTRICT;
    1294:   osm->loctype           = PC_COMPOSITE_ADDITIVE;
    1295:   osm->same_local_solves = PETSC_TRUE;
    1296:   osm->sort_indices      = PETSC_TRUE;
    1297:   osm->dm_subdomains     = PETSC_FALSE;

    1299:   pc->data                 = (void*)osm;
    1300:   pc->ops->apply           = PCApply_ASM;
    1301:   pc->ops->applytranspose  = PCApplyTranspose_ASM;
    1302:   pc->ops->setup           = PCSetUp_ASM;
    1303:   pc->ops->reset           = PCReset_ASM;
    1304:   pc->ops->destroy         = PCDestroy_ASM;
    1305:   pc->ops->setfromoptions  = PCSetFromOptions_ASM;
    1306:   pc->ops->setuponblocks   = PCSetUpOnBlocks_ASM;
    1307:   pc->ops->view            = PCView_ASM;
    1308:   pc->ops->applyrichardson = 0;

    1310:   PetscObjectComposeFunction((PetscObject)pc,"PCASMSetLocalSubdomains_C",PCASMSetLocalSubdomains_ASM);
    1311:   PetscObjectComposeFunction((PetscObject)pc,"PCASMSetTotalSubdomains_C",PCASMSetTotalSubdomains_ASM);
    1312:   PetscObjectComposeFunction((PetscObject)pc,"PCASMSetOverlap_C",PCASMSetOverlap_ASM);
    1313:   PetscObjectComposeFunction((PetscObject)pc,"PCASMSetType_C",PCASMSetType_ASM);
    1314:   PetscObjectComposeFunction((PetscObject)pc,"PCASMGetType_C",PCASMGetType_ASM);
    1315:   PetscObjectComposeFunction((PetscObject)pc,"PCASMSetLocalType_C",PCASMSetLocalType_ASM);
    1316:   PetscObjectComposeFunction((PetscObject)pc,"PCASMGetLocalType_C",PCASMGetLocalType_ASM);
    1317:   PetscObjectComposeFunction((PetscObject)pc,"PCASMSetSortIndices_C",PCASMSetSortIndices_ASM);
    1318:   PetscObjectComposeFunction((PetscObject)pc,"PCASMGetSubKSP_C",PCASMGetSubKSP_ASM);
    1319:   return(0);
    1320: }

    1324: /*@C
    1325:    PCASMCreateSubdomains - Creates the index sets for the overlapping Schwarz
    1326:    preconditioner for a any problem on a general grid.

    1328:    Collective

    1330:    Input Parameters:
    1331: +  A - The global matrix operator
    1332: -  n - the number of local blocks

    1334:    Output Parameters:
    1335: .  outis - the array of index sets defining the subdomains

    1337:    Level: advanced

    1339:    Note: this generates nonoverlapping subdomains; the PCASM will generate the overlap
    1340:     from these if you use PCASMSetLocalSubdomains()

    1342:     In the Fortran version you must provide the array outis[] already allocated of length n.

    1344: .keywords: PC, ASM, additive Schwarz, create, subdomains, unstructured grid

    1346: .seealso: PCASMSetLocalSubdomains(), PCASMDestroySubdomains()
    1347: @*/
    1348: PetscErrorCode  PCASMCreateSubdomains(Mat A, PetscInt n, IS* outis[])
    1349: {
    1350:   MatPartitioning mpart;
    1351:   const char      *prefix;
    1352:   PetscErrorCode  (*f)(Mat,Mat*);
    1353:   PetscMPIInt     size;
    1354:   PetscInt        i,j,rstart,rend,bs;
    1355:   PetscBool       isbaij = PETSC_FALSE,foundpart = PETSC_FALSE;
    1356:   Mat             Ad     = NULL, adj;
    1357:   IS              ispart,isnumb,*is;
    1358:   PetscErrorCode  ierr;

    1363:   if (n < 1) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONG,"number of local blocks must be > 0, n = %D",n);

    1365:   /* Get prefix, row distribution, and block size */
    1366:   MatGetOptionsPrefix(A,&prefix);
    1367:   MatGetOwnershipRange(A,&rstart,&rend);
    1368:   MatGetBlockSize(A,&bs);
    1369:   if (rstart/bs*bs != rstart || rend/bs*bs != rend) SETERRQ3(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONG,"bad row distribution [%D,%D) for matrix block size %D",rstart,rend,bs);

    1371:   /* Get diagonal block from matrix if possible */
    1372:   MPI_Comm_size(PetscObjectComm((PetscObject)A),&size);
    1373:   PetscObjectQueryFunction((PetscObject)A,"MatGetDiagonalBlock_C",&f);
    1374:   if (f) {
    1375:     MatGetDiagonalBlock(A,&Ad);
    1376:   } else if (size == 1) {
    1377:     Ad = A;
    1378:   }
    1379:   if (Ad) {
    1380:     PetscObjectTypeCompare((PetscObject)Ad,MATSEQBAIJ,&isbaij);
    1381:     if (!isbaij) {PetscObjectTypeCompare((PetscObject)Ad,MATSEQSBAIJ,&isbaij);}
    1382:   }
    1383:   if (Ad && n > 1) {
    1384:     PetscBool match,done;
    1385:     /* Try to setup a good matrix partitioning if available */
    1386:     MatPartitioningCreate(PETSC_COMM_SELF,&mpart);
    1387:     PetscObjectSetOptionsPrefix((PetscObject)mpart,prefix);
    1388:     MatPartitioningSetFromOptions(mpart);
    1389:     PetscObjectTypeCompare((PetscObject)mpart,MATPARTITIONINGCURRENT,&match);
    1390:     if (!match) {
    1391:       PetscObjectTypeCompare((PetscObject)mpart,MATPARTITIONINGSQUARE,&match);
    1392:     }
    1393:     if (!match) { /* assume a "good" partitioner is available */
    1394:       PetscInt       na;
    1395:       const PetscInt *ia,*ja;
    1396:       MatGetRowIJ(Ad,0,PETSC_TRUE,isbaij,&na,&ia,&ja,&done);
    1397:       if (done) {
    1398:         /* Build adjacency matrix by hand. Unfortunately a call to
    1399:            MatConvert(Ad,MATMPIADJ,MAT_INITIAL_MATRIX,&adj) will
    1400:            remove the block-aij structure and we cannot expect
    1401:            MatPartitioning to split vertices as we need */
    1402:         PetscInt       i,j,len,nnz,cnt,*iia=0,*jja=0;
    1403:         const PetscInt *row;
    1404:         nnz = 0;
    1405:         for (i=0; i<na; i++) { /* count number of nonzeros */
    1406:           len = ia[i+1] - ia[i];
    1407:           row = ja + ia[i];
    1408:           for (j=0; j<len; j++) {
    1409:             if (row[j] == i) { /* don't count diagonal */
    1410:               len--; break;
    1411:             }
    1412:           }
    1413:           nnz += len;
    1414:         }
    1415:         PetscMalloc1(na+1,&iia);
    1416:         PetscMalloc1(nnz,&jja);
    1417:         nnz    = 0;
    1418:         iia[0] = 0;
    1419:         for (i=0; i<na; i++) { /* fill adjacency */
    1420:           cnt = 0;
    1421:           len = ia[i+1] - ia[i];
    1422:           row = ja + ia[i];
    1423:           for (j=0; j<len; j++) {
    1424:             if (row[j] != i) { /* if not diagonal */
    1425:               jja[nnz+cnt++] = row[j];
    1426:             }
    1427:           }
    1428:           nnz     += cnt;
    1429:           iia[i+1] = nnz;
    1430:         }
    1431:         /* Partitioning of the adjacency matrix */
    1432:         MatCreateMPIAdj(PETSC_COMM_SELF,na,na,iia,jja,NULL,&adj);
    1433:         MatPartitioningSetAdjacency(mpart,adj);
    1434:         MatPartitioningSetNParts(mpart,n);
    1435:         MatPartitioningApply(mpart,&ispart);
    1436:         ISPartitioningToNumbering(ispart,&isnumb);
    1437:         MatDestroy(&adj);
    1438:         foundpart = PETSC_TRUE;
    1439:       }
    1440:       MatRestoreRowIJ(Ad,0,PETSC_TRUE,isbaij,&na,&ia,&ja,&done);
    1441:     }
    1442:     MatPartitioningDestroy(&mpart);
    1443:   }

    1445:   PetscMalloc1(n,&is);
    1446:   *outis = is;

    1448:   if (!foundpart) {

    1450:     /* Partitioning by contiguous chunks of rows */

    1452:     PetscInt mbs   = (rend-rstart)/bs;
    1453:     PetscInt start = rstart;
    1454:     for (i=0; i<n; i++) {
    1455:       PetscInt count = (mbs/n + ((mbs % n) > i)) * bs;
    1456:       ISCreateStride(PETSC_COMM_SELF,count,start,1,&is[i]);
    1457:       start += count;
    1458:     }

    1460:   } else {

    1462:     /* Partitioning by adjacency of diagonal block  */

    1464:     const PetscInt *numbering;
    1465:     PetscInt       *count,nidx,*indices,*newidx,start=0;
    1466:     /* Get node count in each partition */
    1467:     PetscMalloc1(n,&count);
    1468:     ISPartitioningCount(ispart,n,count);
    1469:     if (isbaij && bs > 1) { /* adjust for the block-aij case */
    1470:       for (i=0; i<n; i++) count[i] *= bs;
    1471:     }
    1472:     /* Build indices from node numbering */
    1473:     ISGetLocalSize(isnumb,&nidx);
    1474:     PetscMalloc1(nidx,&indices);
    1475:     for (i=0; i<nidx; i++) indices[i] = i; /* needs to be initialized */
    1476:     ISGetIndices(isnumb,&numbering);
    1477:     PetscSortIntWithPermutation(nidx,numbering,indices);
    1478:     ISRestoreIndices(isnumb,&numbering);
    1479:     if (isbaij && bs > 1) { /* adjust for the block-aij case */
    1480:       PetscMalloc1(nidx*bs,&newidx);
    1481:       for (i=0; i<nidx; i++) {
    1482:         for (j=0; j<bs; j++) newidx[i*bs+j] = indices[i]*bs + j;
    1483:       }
    1484:       PetscFree(indices);
    1485:       nidx   *= bs;
    1486:       indices = newidx;
    1487:     }
    1488:     /* Shift to get global indices */
    1489:     for (i=0; i<nidx; i++) indices[i] += rstart;

    1491:     /* Build the index sets for each block */
    1492:     for (i=0; i<n; i++) {
    1493:       ISCreateGeneral(PETSC_COMM_SELF,count[i],&indices[start],PETSC_COPY_VALUES,&is[i]);
    1494:       ISSort(is[i]);
    1495:       start += count[i];
    1496:     }

    1498:     PetscFree(count);
    1499:     PetscFree(indices);
    1500:     ISDestroy(&isnumb);
    1501:     ISDestroy(&ispart);

    1503:   }
    1504:   return(0);
    1505: }

    1509: /*@C
    1510:    PCASMDestroySubdomains - Destroys the index sets created with
    1511:    PCASMCreateSubdomains(). Should be called after setting subdomains
    1512:    with PCASMSetLocalSubdomains().

    1514:    Collective

    1516:    Input Parameters:
    1517: +  n - the number of index sets
    1518: .  is - the array of index sets
    1519: -  is_local - the array of local index sets, can be NULL

    1521:    Level: advanced

    1523: .keywords: PC, ASM, additive Schwarz, create, subdomains, unstructured grid

    1525: .seealso: PCASMCreateSubdomains(), PCASMSetLocalSubdomains()
    1526: @*/
    1527: PetscErrorCode  PCASMDestroySubdomains(PetscInt n, IS is[], IS is_local[])
    1528: {
    1529:   PetscInt       i;

    1533:   if (n <= 0) return(0);
    1534:   if (is) {
    1536:     for (i=0; i<n; i++) { ISDestroy(&is[i]); }
    1537:     PetscFree(is);
    1538:   }
    1539:   if (is_local) {
    1541:     for (i=0; i<n; i++) { ISDestroy(&is_local[i]); }
    1542:     PetscFree(is_local);
    1543:   }
    1544:   return(0);
    1545: }

    1549: /*@
    1550:    PCASMCreateSubdomains2D - Creates the index sets for the overlapping Schwarz
    1551:    preconditioner for a two-dimensional problem on a regular grid.

    1553:    Not Collective

    1555:    Input Parameters:
    1556: +  m, n - the number of mesh points in the x and y directions
    1557: .  M, N - the number of subdomains in the x and y directions
    1558: .  dof - degrees of freedom per node
    1559: -  overlap - overlap in mesh lines

    1561:    Output Parameters:
    1562: +  Nsub - the number of subdomains created
    1563: .  is - array of index sets defining overlapping (if overlap > 0) subdomains
    1564: -  is_local - array of index sets defining non-overlapping subdomains

    1566:    Note:
    1567:    Presently PCAMSCreateSubdomains2d() is valid only for sequential
    1568:    preconditioners.  More general related routines are
    1569:    PCASMSetTotalSubdomains() and PCASMSetLocalSubdomains().

    1571:    Level: advanced

    1573: .keywords: PC, ASM, additive Schwarz, create, subdomains, 2D, regular grid

    1575: .seealso: PCASMSetTotalSubdomains(), PCASMSetLocalSubdomains(), PCASMGetSubKSP(),
    1576:           PCASMSetOverlap()
    1577: @*/
    1578: PetscErrorCode  PCASMCreateSubdomains2D(PetscInt m,PetscInt n,PetscInt M,PetscInt N,PetscInt dof,PetscInt overlap,PetscInt *Nsub,IS **is,IS **is_local)
    1579: {
    1580:   PetscInt       i,j,height,width,ystart,xstart,yleft,yright,xleft,xright,loc_outer;
    1582:   PetscInt       nidx,*idx,loc,ii,jj,count;

    1585:   if (dof != 1) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_SUP," ");

    1587:   *Nsub     = N*M;
    1588:   PetscMalloc1(*Nsub,is);
    1589:   PetscMalloc1(*Nsub,is_local);
    1590:   ystart    = 0;
    1591:   loc_outer = 0;
    1592:   for (i=0; i<N; i++) {
    1593:     height = n/N + ((n % N) > i); /* height of subdomain */
    1594:     if (height < 2) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"Too many N subdomains for mesh dimension n");
    1595:     yleft  = ystart - overlap; if (yleft < 0) yleft = 0;
    1596:     yright = ystart + height + overlap; if (yright > n) yright = n;
    1597:     xstart = 0;
    1598:     for (j=0; j<M; j++) {
    1599:       width = m/M + ((m % M) > j); /* width of subdomain */
    1600:       if (width < 2) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"Too many M subdomains for mesh dimension m");
    1601:       xleft  = xstart - overlap; if (xleft < 0) xleft = 0;
    1602:       xright = xstart + width + overlap; if (xright > m) xright = m;
    1603:       nidx   = (xright - xleft)*(yright - yleft);
    1604:       PetscMalloc1(nidx,&idx);
    1605:       loc    = 0;
    1606:       for (ii=yleft; ii<yright; ii++) {
    1607:         count = m*ii + xleft;
    1608:         for (jj=xleft; jj<xright; jj++) idx[loc++] = count++;
    1609:       }
    1610:       ISCreateGeneral(PETSC_COMM_SELF,nidx,idx,PETSC_COPY_VALUES,(*is)+loc_outer);
    1611:       if (overlap == 0) {
    1612:         PetscObjectReference((PetscObject)(*is)[loc_outer]);

    1614:         (*is_local)[loc_outer] = (*is)[loc_outer];
    1615:       } else {
    1616:         for (loc=0,ii=ystart; ii<ystart+height; ii++) {
    1617:           for (jj=xstart; jj<xstart+width; jj++) {
    1618:             idx[loc++] = m*ii + jj;
    1619:           }
    1620:         }
    1621:         ISCreateGeneral(PETSC_COMM_SELF,loc,idx,PETSC_COPY_VALUES,*is_local+loc_outer);
    1622:       }
    1623:       PetscFree(idx);
    1624:       xstart += width;
    1625:       loc_outer++;
    1626:     }
    1627:     ystart += height;
    1628:   }
    1629:   for (i=0; i<*Nsub; i++) { ISSort((*is)[i]); }
    1630:   return(0);
    1631: }

    1635: /*@C
    1636:     PCASMGetLocalSubdomains - Gets the local subdomains (for this processor
    1637:     only) for the additive Schwarz preconditioner.

    1639:     Not Collective

    1641:     Input Parameter:
    1642: .   pc - the preconditioner context

    1644:     Output Parameters:
    1645: +   n - the number of subdomains for this processor (default value = 1)
    1646: .   is - the index sets that define the subdomains for this processor
    1647: -   is_local - the index sets that define the local part of the subdomains for this processor (can be NULL)

    1650:     Notes:
    1651:     The IS numbering is in the parallel, global numbering of the vector.

    1653:     Level: advanced

    1655: .keywords: PC, ASM, set, local, subdomains, additive Schwarz

    1657: .seealso: PCASMSetTotalSubdomains(), PCASMSetOverlap(), PCASMGetSubKSP(),
    1658:           PCASMCreateSubdomains2D(), PCASMSetLocalSubdomains(), PCASMGetLocalSubmatrices()
    1659: @*/
    1660: PetscErrorCode  PCASMGetLocalSubdomains(PC pc,PetscInt *n,IS *is[],IS *is_local[])
    1661: {
    1662:   PC_ASM         *osm;
    1664:   PetscBool      match;

    1670:   PetscObjectTypeCompare((PetscObject)pc,PCASM,&match);
    1671:   if (!match) {
    1672:     if (n) *n = 0;
    1673:     if (is) *is = NULL;
    1674:   } else {
    1675:     osm = (PC_ASM*)pc->data;
    1676:     if (n) *n = osm->n_local_true;
    1677:     if (is) *is = osm->is;
    1678:     if (is_local) *is_local = osm->is_local;
    1679:   }
    1680:   return(0);
    1681: }

    1685: /*@C
    1686:     PCASMGetLocalSubmatrices - Gets the local submatrices (for this processor
    1687:     only) for the additive Schwarz preconditioner.

    1689:     Not Collective

    1691:     Input Parameter:
    1692: .   pc - the preconditioner context

    1694:     Output Parameters:
    1695: +   n - the number of matrices for this processor (default value = 1)
    1696: -   mat - the matrices

    1699:     Level: advanced

    1701:     Notes: Call after PCSetUp() (or KSPSetUp()) but before PCApply() (or KSPApply()) and before PCSetUpOnBlocks())

    1703:            Usually one would use PCSetModifySubmatrices() to change the submatrices in building the preconditioner.

    1705: .keywords: PC, ASM, set, local, subdomains, additive Schwarz, block Jacobi

    1707: .seealso: PCASMSetTotalSubdomains(), PCASMSetOverlap(), PCASMGetSubKSP(),
    1708:           PCASMCreateSubdomains2D(), PCASMSetLocalSubdomains(), PCASMGetLocalSubdomains(), PCSetModifySubmatrices()
    1709: @*/
    1710: PetscErrorCode  PCASMGetLocalSubmatrices(PC pc,PetscInt *n,Mat *mat[])
    1711: {
    1712:   PC_ASM         *osm;
    1714:   PetscBool      match;

    1720:   if (!pc->setupcalled) SETERRQ(PetscObjectComm((PetscObject)pc),PETSC_ERR_ARG_WRONGSTATE,"Must call after KSPSetUP() or PCSetUp().");
    1721:   PetscObjectTypeCompare((PetscObject)pc,PCASM,&match);
    1722:   if (!match) {
    1723:     if (n) *n = 0;
    1724:     if (mat) *mat = NULL;
    1725:   } else {
    1726:     osm = (PC_ASM*)pc->data;
    1727:     if (n) *n = osm->n_local_true;
    1728:     if (mat) *mat = osm->pmat;
    1729:   }
    1730:   return(0);
    1731: }

    1735: /*@
    1736:     PCASMSetDMSubdomains - Indicates whether to use DMCreateDomainDecomposition() to define the subdomains, whenever possible.
    1737:     Logically Collective

    1739:     Input Parameter:
    1740: +   pc  - the preconditioner
    1741: -   flg - boolean indicating whether to use subdomains defined by the DM

    1743:     Options Database Key:
    1744: .   -pc_asm_dm_subdomains

    1746:     Level: intermediate

    1748:     Notes:
    1749:     PCASMSetTotalSubdomains() and PCASMSetOverlap() take precedence over PCASMSetDMSubdomains(),
    1750:     so setting either of the first two effectively turns the latter off.

    1752: .keywords: PC, ASM, DM, set, subdomains, additive Schwarz

    1754: .seealso: PCASMGetDMSubdomains(), PCASMSetTotalSubdomains(), PCASMSetOverlap()
    1755:           PCASMCreateSubdomains2D(), PCASMSetLocalSubdomains(), PCASMGetLocalSubdomains()
    1756: @*/
    1757: PetscErrorCode  PCASMSetDMSubdomains(PC pc,PetscBool flg)
    1758: {
    1759:   PC_ASM         *osm = (PC_ASM*)pc->data;
    1761:   PetscBool      match;

    1766:   if (pc->setupcalled) SETERRQ(((PetscObject)pc)->comm,PETSC_ERR_ARG_WRONGSTATE,"Not for a setup PC.");
    1767:   PetscObjectTypeCompare((PetscObject)pc,PCASM,&match);
    1768:   if (match) {
    1769:     osm->dm_subdomains = flg;
    1770:   }
    1771:   return(0);
    1772: }

    1776: /*@
    1777:     PCASMGetDMSubdomains - Returns flag indicating whether to use DMCreateDomainDecomposition() to define the subdomains, whenever possible.
    1778:     Not Collective

    1780:     Input Parameter:
    1781: .   pc  - the preconditioner

    1783:     Output Parameter:
    1784: .   flg - boolean indicating whether to use subdomains defined by the DM

    1786:     Level: intermediate

    1788: .keywords: PC, ASM, DM, set, subdomains, additive Schwarz

    1790: .seealso: PCASMSetDMSubdomains(), PCASMSetTotalSubdomains(), PCASMSetOverlap()
    1791:           PCASMCreateSubdomains2D(), PCASMSetLocalSubdomains(), PCASMGetLocalSubdomains()
    1792: @*/
    1793: PetscErrorCode  PCASMGetDMSubdomains(PC pc,PetscBool* flg)
    1794: {
    1795:   PC_ASM         *osm = (PC_ASM*)pc->data;
    1797:   PetscBool      match;

    1802:   PetscObjectTypeCompare((PetscObject)pc,PCASM,&match);
    1803:   if (match) {
    1804:     if (flg) *flg = osm->dm_subdomains;
    1805:   }
    1806:   return(0);
    1807: }