Date: 2015-10-02T22:13:38+00:00

Actual source code: fdda.c
petsc-3.6.2 2015-10-02
Report Typos and Errors

      2: #include <petsc/private/dmdaimpl.h> /*I      "petscdmda.h"     I*/
      3: #include <petscmat.h>
      4: #include <petsc/private/matimpl.h>

      6: extern PetscErrorCode DMCreateColoring_DA_1d_MPIAIJ(DM,ISColoringType,ISColoring*);
      7: extern PetscErrorCode DMCreateColoring_DA_2d_MPIAIJ(DM,ISColoringType,ISColoring*);
      8: extern PetscErrorCode DMCreateColoring_DA_2d_5pt_MPIAIJ(DM,ISColoringType,ISColoring*);
      9: extern PetscErrorCode DMCreateColoring_DA_3d_MPIAIJ(DM,ISColoringType,ISColoring*);

     11: /*
     12:    For ghost i that may be negative or greater than the upper bound this
     13:   maps it into the 0:m-1 range using periodicity
     14: */
     15: #define SetInRange(i,m) ((i < 0) ? m+i : ((i >= m) ? i-m : i))

     19: static PetscErrorCode DMDASetBlockFills_Private(const PetscInt *dfill,PetscInt w,PetscInt **rfill)
     20: {
     22:   PetscInt       i,j,nz,*fill;

     25:   if (!dfill) return(0);

     27:   /* count number nonzeros */
     28:   nz = 0;
     29:   for (i=0; i<w; i++) {
     30:     for (j=0; j<w; j++) {
     31:       if (dfill[w*i+j]) nz++;
     32:     }
     33:   }
     34:   PetscMalloc1(nz + w + 1,&fill);
     35:   /* construct modified CSR storage of nonzero structure */
     36:   /*  fill[0 -- w] marks starts of each row of column indices (and end of last row)
     37:    so fill[1] - fill[0] gives number of nonzeros in first row etc */
     38:   nz = w + 1;
     39:   for (i=0; i<w; i++) {
     40:     fill[i] = nz;
     41:     for (j=0; j<w; j++) {
     42:       if (dfill[w*i+j]) {
     43:         fill[nz] = j;
     44:         nz++;
     45:       }
     46:     }
     47:   }
     48:   fill[w] = nz;

     50:   *rfill = fill;
     51:   return(0);
     52: }

     56: /*@
     57:     DMDASetBlockFills - Sets the fill pattern in each block for a multi-component problem
     58:     of the matrix returned by DMCreateMatrix().

     60:     Logically Collective on DMDA

     62:     Input Parameter:
     63: +   da - the distributed array
     64: .   dfill - the fill pattern in the diagonal block (may be NULL, means use dense block)
     65: -   ofill - the fill pattern in the off-diagonal blocks

     68:     Level: developer

     70:     Notes: This only makes sense when you are doing multicomponent problems but using the
     71:        MPIAIJ matrix format

     73:            The format for dfill and ofill is a 2 dimensional dof by dof matrix with 1 entries
     74:        representing coupling and 0 entries for missing coupling. For example
     75: $             dfill[9] = {1, 0, 0,
     76: $                         1, 1, 0,
     77: $                         0, 1, 1}
     78:        means that row 0 is coupled with only itself in the diagonal block, row 1 is coupled with
     79:        itself and row 0 (in the diagonal block) and row 2 is coupled with itself and row 1 (in the
     80:        diagonal block).

     82:      DMDASetGetMatrix() allows you to provide general code for those more complicated nonzero patterns then
     83:      can be represented in the dfill, ofill format

     85:    Contributed by Glenn Hammond

     87: .seealso DMCreateMatrix(), DMDASetGetMatrix(), DMSetMatrixPreallocateOnly()

     89: @*/
     90: PetscErrorCode  DMDASetBlockFills(DM da,const PetscInt *dfill,const PetscInt *ofill)
     91: {
     92:   DM_DA          *dd = (DM_DA*)da->data;
     94:   PetscInt       i,k,cnt = 1;

     97:   DMDASetBlockFills_Private(dfill,dd->w,&dd->dfill);
     98:   DMDASetBlockFills_Private(ofill,dd->w,&dd->ofill);

    100:   /* ofillcount tracks the columns of ofill that have any nonzero in thems; the value in each location is the number of
    101:    columns to the left with any nonzeros in them plus 1 */
    102:   PetscCalloc1(dd->w,&dd->ofillcols);
    103:   for (i=0; i<dd->w; i++) {
    104:     for (k=dd->ofill[i]; k<dd->ofill[i+1]; k++) dd->ofillcols[dd->ofill[k]] = 1;
    105:   }
    106:   for (i=0; i<dd->w; i++) {
    107:     if (dd->ofillcols[i]) {
    108:       dd->ofillcols[i] = cnt++;
    109:     }
    110:   }
    111:   return(0);
    112: }

    117: PetscErrorCode  DMCreateColoring_DA(DM da,ISColoringType ctype,ISColoring *coloring)
    118: {
    119:   PetscErrorCode   ierr;
    120:   PetscInt         dim,m,n,p,nc;
    121:   DMBoundaryType bx,by,bz;
    122:   MPI_Comm         comm;
    123:   PetscMPIInt      size;
    124:   PetscBool        isBAIJ;
    125:   DM_DA            *dd = (DM_DA*)da->data;

    128:   /*
    129:                                   m
    130:           ------------------------------------------------------
    131:          |                                                     |
    132:          |                                                     |
    133:          |               ----------------------                |
    134:          |               |                    |                |
    135:       n  |           yn  |                    |                |
    136:          |               |                    |                |
    137:          |               .---------------------                |
    138:          |             (xs,ys)     xn                          |
    139:          |            .                                        |
    140:          |         (gxs,gys)                                   |
    141:          |                                                     |
    142:           -----------------------------------------------------
    143:   */

    145:   /*
    146:          nc - number of components per grid point
    147:          col - number of colors needed in one direction for single component problem

    149:   */
    150:   DMDAGetInfo(da,&dim,0,0,0,&m,&n,&p,&nc,0,&bx,&by,&bz,0);

    152:   PetscObjectGetComm((PetscObject)da,&comm);
    153:   MPI_Comm_size(comm,&size);
    154:   if (ctype == IS_COLORING_GHOSTED) {
    155:     if (size == 1) {
    156:       ctype = IS_COLORING_GLOBAL;
    157:     } else if (dim > 1) {
    158:       if ((m==1 && bx == DM_BOUNDARY_PERIODIC) || (n==1 && by == DM_BOUNDARY_PERIODIC) || (p==1 && bz == DM_BOUNDARY_PERIODIC)) {
    159:         SETERRQ(PetscObjectComm((PetscObject)da),PETSC_ERR_SUP,"IS_COLORING_GHOSTED cannot be used for periodic boundary condition having both ends of the domain  on the same process");
    160:       }
    161:     }
    162:   }

    164:   /* Tell the DMDA it has 1 degree of freedom per grid point so that the coloring for BAIJ
    165:      matrices is for the blocks, not the individual matrix elements  */
    166:   PetscStrcmp(da->mattype,MATBAIJ,&isBAIJ);
    167:   if (!isBAIJ) {PetscStrcmp(da->mattype,MATMPIBAIJ,&isBAIJ);}
    168:   if (!isBAIJ) {PetscStrcmp(da->mattype,MATSEQBAIJ,&isBAIJ);}
    169:   if (isBAIJ) {
    170:     dd->w  = 1;
    171:     dd->xs = dd->xs/nc;
    172:     dd->xe = dd->xe/nc;
    173:     dd->Xs = dd->Xs/nc;
    174:     dd->Xe = dd->Xe/nc;
    175:   }

    177:   /*
    178:      We do not provide a getcoloring function in the DMDA operations because
    179:    the basic DMDA does not know about matrices. We think of DMDA as being more
    180:    more low-level then matrices.
    181:   */
    182:   if (dim == 1) {
    183:     DMCreateColoring_DA_1d_MPIAIJ(da,ctype,coloring);
    184:   } else if (dim == 2) {
    185:      DMCreateColoring_DA_2d_MPIAIJ(da,ctype,coloring);
    186:   } else if (dim == 3) {
    187:      DMCreateColoring_DA_3d_MPIAIJ(da,ctype,coloring);
    188:   } else SETERRQ1(PetscObjectComm((PetscObject)da),PETSC_ERR_SUP,"Not done for %D dimension, send us mail petsc-maint@mcs.anl.gov for code",dim);
    189:   if (isBAIJ) {
    190:     dd->w  = nc;
    191:     dd->xs = dd->xs*nc;
    192:     dd->xe = dd->xe*nc;
    193:     dd->Xs = dd->Xs*nc;
    194:     dd->Xe = dd->Xe*nc;
    195:   }
    196:   return(0);
    197: }

    199: /* ---------------------------------------------------------------------------------*/

    203: PetscErrorCode DMCreateColoring_DA_2d_MPIAIJ(DM da,ISColoringType ctype,ISColoring *coloring)
    204: {
    205:   PetscErrorCode   ierr;
    206:   PetscInt         xs,ys,nx,ny,i,j,ii,gxs,gys,gnx,gny,m,n,M,N,dim,s,k,nc,col;
    207:   PetscInt         ncolors;
    208:   MPI_Comm         comm;
    209:   DMBoundaryType bx,by;
    210:   DMDAStencilType  st;
    211:   ISColoringValue  *colors;
    212:   DM_DA            *dd = (DM_DA*)da->data;

    215:   /*
    216:          nc - number of components per grid point
    217:          col - number of colors needed in one direction for single component problem

    219:   */
    220:   DMDAGetInfo(da,&dim,&m,&n,0,&M,&N,0,&nc,&s,&bx,&by,0,&st);
    221:   col  = 2*s + 1;
    222:   DMDAGetCorners(da,&xs,&ys,0,&nx,&ny,0);
    223:   DMDAGetGhostCorners(da,&gxs,&gys,0,&gnx,&gny,0);
    224:   PetscObjectGetComm((PetscObject)da,&comm);

    226:   /* special case as taught to us by Paul Hovland */
    227:   if (st == DMDA_STENCIL_STAR && s == 1) {
    228:     DMCreateColoring_DA_2d_5pt_MPIAIJ(da,ctype,coloring);
    229:   } else {

    231:     if (bx == DM_BOUNDARY_PERIODIC && (m % col)) SETERRQ2(PetscObjectComm((PetscObject)da),PETSC_ERR_SUP,"For coloring efficiency ensure number of grid points in X (%d) is divisible\n\
    232:                                                             by 2*stencil_width + 1 (%d)\n", m, col);
    233:     if (by == DM_BOUNDARY_PERIODIC && (n % col)) SETERRQ2(PetscObjectComm((PetscObject)da),PETSC_ERR_SUP,"For coloring efficiency ensure number of grid points in Y (%d) is divisible\n\
    234:                                                             by 2*stencil_width + 1 (%d)\n", n, col);
    235:     if (ctype == IS_COLORING_GLOBAL) {
    236:       if (!dd->localcoloring) {
    237:         PetscMalloc1(nc*nx*ny,&colors);
    238:         ii   = 0;
    239:         for (j=ys; j<ys+ny; j++) {
    240:           for (i=xs; i<xs+nx; i++) {
    241:             for (k=0; k<nc; k++) {
    242:               colors[ii++] = k + nc*((i % col) + col*(j % col));
    243:             }
    244:           }
    245:         }
    246:         ncolors = nc + nc*(col-1 + col*(col-1));
    247:         ISColoringCreate(comm,ncolors,nc*nx*ny,colors,PETSC_OWN_POINTER,&dd->localcoloring);
    248:       }
    249:       *coloring = dd->localcoloring;
    250:     } else if (ctype == IS_COLORING_GHOSTED) {
    251:       if (!dd->ghostedcoloring) {
    252:         PetscMalloc1(nc*gnx*gny,&colors);
    253:         ii   = 0;
    254:         for (j=gys; j<gys+gny; j++) {
    255:           for (i=gxs; i<gxs+gnx; i++) {
    256:             for (k=0; k<nc; k++) {
    257:               /* the complicated stuff is to handle periodic boundaries */
    258:               colors[ii++] = k + nc*((SetInRange(i,m) % col) + col*(SetInRange(j,n) % col));
    259:             }
    260:           }
    261:         }
    262:         ncolors = nc + nc*(col - 1 + col*(col-1));
    263:         ISColoringCreate(comm,ncolors,nc*gnx*gny,colors,PETSC_OWN_POINTER,&dd->ghostedcoloring);
    264:         /* PetscIntView(ncolors,(PetscInt*)colors,0); */

    266:         ISColoringSetType(dd->ghostedcoloring,IS_COLORING_GHOSTED);
    267:       }
    268:       *coloring = dd->ghostedcoloring;
    269:     } else SETERRQ1(PetscObjectComm((PetscObject)da),PETSC_ERR_ARG_WRONG,"Unknown ISColoringType %d",(int)ctype);
    270:   }
    271:   ISColoringReference(*coloring);
    272:   return(0);
    273: }

    275: /* ---------------------------------------------------------------------------------*/

    279: PetscErrorCode DMCreateColoring_DA_3d_MPIAIJ(DM da,ISColoringType ctype,ISColoring *coloring)
    280: {
    281:   PetscErrorCode   ierr;
    282:   PetscInt         xs,ys,nx,ny,i,j,gxs,gys,gnx,gny,m,n,p,dim,s,k,nc,col,zs,gzs,ii,l,nz,gnz,M,N,P;
    283:   PetscInt         ncolors;
    284:   MPI_Comm         comm;
    285:   DMBoundaryType bx,by,bz;
    286:   DMDAStencilType  st;
    287:   ISColoringValue  *colors;
    288:   DM_DA            *dd = (DM_DA*)da->data;

    291:   /*
    292:          nc - number of components per grid point
    293:          col - number of colors needed in one direction for single component problem

    295:   */
    296:   DMDAGetInfo(da,&dim,&m,&n,&p,&M,&N,&P,&nc,&s,&bx,&by,&bz,&st);
    297:   col  = 2*s + 1;
    298:   if (bx == DM_BOUNDARY_PERIODIC && (m % col)) SETERRQ(PetscObjectComm((PetscObject)da),PETSC_ERR_SUP,"For coloring efficiency ensure number of grid points in X is divisible\n\
    299:                                                          by 2*stencil_width + 1\n");
    300:   if (by == DM_BOUNDARY_PERIODIC && (n % col)) SETERRQ(PetscObjectComm((PetscObject)da),PETSC_ERR_SUP,"For coloring efficiency ensure number of grid points in Y is divisible\n\
    301:                                                          by 2*stencil_width + 1\n");
    302:   if (bz == DM_BOUNDARY_PERIODIC && (p % col)) SETERRQ(PetscObjectComm((PetscObject)da),PETSC_ERR_SUP,"For coloring efficiency ensure number of grid points in Z is divisible\n\
    303:                                                          by 2*stencil_width + 1\n");

    305:   DMDAGetCorners(da,&xs,&ys,&zs,&nx,&ny,&nz);
    306:   DMDAGetGhostCorners(da,&gxs,&gys,&gzs,&gnx,&gny,&gnz);
    307:   PetscObjectGetComm((PetscObject)da,&comm);

    309:   /* create the coloring */
    310:   if (ctype == IS_COLORING_GLOBAL) {
    311:     if (!dd->localcoloring) {
    312:       PetscMalloc1(nc*nx*ny*nz,&colors);
    313:       ii   = 0;
    314:       for (k=zs; k<zs+nz; k++) {
    315:         for (j=ys; j<ys+ny; j++) {
    316:           for (i=xs; i<xs+nx; i++) {
    317:             for (l=0; l<nc; l++) {
    318:               colors[ii++] = l + nc*((i % col) + col*(j % col) + col*col*(k % col));
    319:             }
    320:           }
    321:         }
    322:       }
    323:       ncolors = nc + nc*(col-1 + col*(col-1)+ col*col*(col-1));
    324:       ISColoringCreate(comm,ncolors,nc*nx*ny*nz,colors,PETSC_OWN_POINTER,&dd->localcoloring);
    325:     }
    326:     *coloring = dd->localcoloring;
    327:   } else if (ctype == IS_COLORING_GHOSTED) {
    328:     if (!dd->ghostedcoloring) {
    329:       PetscMalloc1(nc*gnx*gny*gnz,&colors);
    330:       ii   = 0;
    331:       for (k=gzs; k<gzs+gnz; k++) {
    332:         for (j=gys; j<gys+gny; j++) {
    333:           for (i=gxs; i<gxs+gnx; i++) {
    334:             for (l=0; l<nc; l++) {
    335:               /* the complicated stuff is to handle periodic boundaries */
    336:               colors[ii++] = l + nc*((SetInRange(i,m) % col) + col*(SetInRange(j,n) % col) + col*col*(SetInRange(k,p) % col));
    337:             }
    338:           }
    339:         }
    340:       }
    341:       ncolors = nc + nc*(col-1 + col*(col-1)+ col*col*(col-1));
    342:       ISColoringCreate(comm,ncolors,nc*gnx*gny*gnz,colors,PETSC_OWN_POINTER,&dd->ghostedcoloring);
    343:       ISColoringSetType(dd->ghostedcoloring,IS_COLORING_GHOSTED);
    344:     }
    345:     *coloring = dd->ghostedcoloring;
    346:   } else SETERRQ1(PetscObjectComm((PetscObject)da),PETSC_ERR_ARG_WRONG,"Unknown ISColoringType %d",(int)ctype);
    347:   ISColoringReference(*coloring);
    348:   return(0);
    349: }

    351: /* ---------------------------------------------------------------------------------*/

    355: PetscErrorCode DMCreateColoring_DA_1d_MPIAIJ(DM da,ISColoringType ctype,ISColoring *coloring)
    356: {
    357:   PetscErrorCode   ierr;
    358:   PetscInt         xs,nx,i,i1,gxs,gnx,l,m,M,dim,s,nc,col;
    359:   PetscInt         ncolors;
    360:   MPI_Comm         comm;
    361:   DMBoundaryType bx;
    362:   ISColoringValue  *colors;
    363:   DM_DA            *dd = (DM_DA*)da->data;

    366:   /*
    367:          nc - number of components per grid point
    368:          col - number of colors needed in one direction for single component problem

    370:   */
    371:   DMDAGetInfo(da,&dim,&m,0,0,&M,0,0,&nc,&s,&bx,0,0,0);
    372:   col  = 2*s + 1;

    374:   if (bx == DM_BOUNDARY_PERIODIC && (m % col)) SETERRQ2(PetscObjectComm((PetscObject)da),PETSC_ERR_SUP,"For coloring efficiency ensure number of grid points %d is divisible\n\
    375:                                                           by 2*stencil_width + 1 %d\n",(int)m,(int)col);

    377:   DMDAGetCorners(da,&xs,0,0,&nx,0,0);
    378:   DMDAGetGhostCorners(da,&gxs,0,0,&gnx,0,0);
    379:   PetscObjectGetComm((PetscObject)da,&comm);

    381:   /* create the coloring */
    382:   if (ctype == IS_COLORING_GLOBAL) {
    383:     if (!dd->localcoloring) {
    384:       PetscMalloc1(nc*nx,&colors);
    385:       if (dd->ofillcols) {
    386:         PetscInt tc = 0;
    387:         for (i=0; i<nc; i++) tc += (PetscInt) (dd->ofillcols[i] > 0);
    388:         i1 = 0;
    389:         for (i=xs; i<xs+nx; i++) {
    390:           for (l=0; l<nc; l++) {
    391:             if (dd->ofillcols[l] && (i % col)) {
    392:               colors[i1++] =  nc - 1 + tc*((i % col) - 1) + dd->ofillcols[l];
    393:             } else {
    394:               colors[i1++] = l;
    395:             }
    396:           }
    397:         }
    398:         ncolors = nc + 2*s*tc;
    399:       } else {
    400:         i1 = 0;
    401:         for (i=xs; i<xs+nx; i++) {
    402:           for (l=0; l<nc; l++) {
    403:             colors[i1++] = l + nc*(i % col);
    404:           }
    405:         }
    406:         ncolors = nc + nc*(col-1);
    407:       }
    408:       ISColoringCreate(comm,ncolors,nc*nx,colors,PETSC_OWN_POINTER,&dd->localcoloring);
    409:     }
    410:     *coloring = dd->localcoloring;
    411:   } else if (ctype == IS_COLORING_GHOSTED) {
    412:     if (!dd->ghostedcoloring) {
    413:       PetscMalloc1(nc*gnx,&colors);
    414:       i1   = 0;
    415:       for (i=gxs; i<gxs+gnx; i++) {
    416:         for (l=0; l<nc; l++) {
    417:           /* the complicated stuff is to handle periodic boundaries */
    418:           colors[i1++] = l + nc*(SetInRange(i,m) % col);
    419:         }
    420:       }
    421:       ncolors = nc + nc*(col-1);
    422:       ISColoringCreate(comm,ncolors,nc*gnx,colors,PETSC_OWN_POINTER,&dd->ghostedcoloring);
    423:       ISColoringSetType(dd->ghostedcoloring,IS_COLORING_GHOSTED);
    424:     }
    425:     *coloring = dd->ghostedcoloring;
    426:   } else SETERRQ1(PetscObjectComm((PetscObject)da),PETSC_ERR_ARG_WRONG,"Unknown ISColoringType %d",(int)ctype);
    427:   ISColoringReference(*coloring);
    428:   return(0);
    429: }

    433: PetscErrorCode DMCreateColoring_DA_2d_5pt_MPIAIJ(DM da,ISColoringType ctype,ISColoring *coloring)
    434: {
    435:   PetscErrorCode   ierr;
    436:   PetscInt         xs,ys,nx,ny,i,j,ii,gxs,gys,gnx,gny,m,n,dim,s,k,nc;
    437:   PetscInt         ncolors;
    438:   MPI_Comm         comm;
    439:   DMBoundaryType bx,by;
    440:   ISColoringValue  *colors;
    441:   DM_DA            *dd = (DM_DA*)da->data;

    444:   /*
    445:          nc - number of components per grid point
    446:          col - number of colors needed in one direction for single component problem

    448:   */
    449:   DMDAGetInfo(da,&dim,&m,&n,0,0,0,0,&nc,&s,&bx,&by,0,0);
    450:   DMDAGetCorners(da,&xs,&ys,0,&nx,&ny,0);
    451:   DMDAGetGhostCorners(da,&gxs,&gys,0,&gnx,&gny,0);
    452:   PetscObjectGetComm((PetscObject)da,&comm);

    454:   if (bx == DM_BOUNDARY_PERIODIC && (m % 5)) SETERRQ(PetscObjectComm((PetscObject)da),PETSC_ERR_SUP,"For coloring efficiency ensure number of grid points in X is divisible by 5\n");
    455:   if (by == DM_BOUNDARY_PERIODIC && (n % 5)) SETERRQ(PetscObjectComm((PetscObject)da),PETSC_ERR_SUP,"For coloring efficiency ensure number of grid points in Y is divisible by 5\n");

    457:   /* create the coloring */
    458:   if (ctype == IS_COLORING_GLOBAL) {
    459:     if (!dd->localcoloring) {
    460:       PetscMalloc1(nc*nx*ny,&colors);
    461:       ii   = 0;
    462:       for (j=ys; j<ys+ny; j++) {
    463:         for (i=xs; i<xs+nx; i++) {
    464:           for (k=0; k<nc; k++) {
    465:             colors[ii++] = k + nc*((3*j+i) % 5);
    466:           }
    467:         }
    468:       }
    469:       ncolors = 5*nc;
    470:       ISColoringCreate(comm,ncolors,nc*nx*ny,colors,PETSC_OWN_POINTER,&dd->localcoloring);
    471:     }
    472:     *coloring = dd->localcoloring;
    473:   } else if (ctype == IS_COLORING_GHOSTED) {
    474:     if (!dd->ghostedcoloring) {
    475:       PetscMalloc1(nc*gnx*gny,&colors);
    476:       ii = 0;
    477:       for (j=gys; j<gys+gny; j++) {
    478:         for (i=gxs; i<gxs+gnx; i++) {
    479:           for (k=0; k<nc; k++) {
    480:             colors[ii++] = k + nc*((3*SetInRange(j,n) + SetInRange(i,m)) % 5);
    481:           }
    482:         }
    483:       }
    484:       ncolors = 5*nc;
    485:       ISColoringCreate(comm,ncolors,nc*gnx*gny,colors,PETSC_OWN_POINTER,&dd->ghostedcoloring);
    486:       ISColoringSetType(dd->ghostedcoloring,IS_COLORING_GHOSTED);
    487:     }
    488:     *coloring = dd->ghostedcoloring;
    489:   } else SETERRQ1(PetscObjectComm((PetscObject)da),PETSC_ERR_ARG_WRONG,"Unknown ISColoringType %d",(int)ctype);
    490:   return(0);
    491: }

    493: /* =========================================================================== */
    494: extern PetscErrorCode DMCreateMatrix_DA_1d_MPIAIJ(DM,Mat);
    495: extern PetscErrorCode DMCreateMatrix_DA_1d_MPIAIJ_Fill(DM,Mat);
    496: extern PetscErrorCode DMCreateMatrix_DA_2d_MPIAIJ(DM,Mat);
    497: extern PetscErrorCode DMCreateMatrix_DA_2d_MPIAIJ_Fill(DM,Mat);
    498: extern PetscErrorCode DMCreateMatrix_DA_3d_MPIAIJ(DM,Mat);
    499: extern PetscErrorCode DMCreateMatrix_DA_3d_MPIAIJ_Fill(DM,Mat);
    500: extern PetscErrorCode DMCreateMatrix_DA_2d_MPIBAIJ(DM,Mat);
    501: extern PetscErrorCode DMCreateMatrix_DA_3d_MPIBAIJ(DM,Mat);
    502: extern PetscErrorCode DMCreateMatrix_DA_2d_MPISBAIJ(DM,Mat);
    503: extern PetscErrorCode DMCreateMatrix_DA_3d_MPISBAIJ(DM,Mat);

    507: /*@C
    508:    MatSetupDM - Sets the DMDA that is to be used by the HYPRE_StructMatrix PETSc matrix

    510:    Logically Collective on Mat

    512:    Input Parameters:
    513: +  mat - the matrix
    514: -  da - the da

    516:    Level: intermediate

    518: @*/
    519: PetscErrorCode MatSetupDM(Mat mat,DM da)
    520: {

    526:   PetscTryMethod(mat,"MatSetupDM_C",(Mat,DM),(mat,da));
    527:   return(0);
    528: }

    532: PetscErrorCode  MatView_MPI_DA(Mat A,PetscViewer viewer)
    533: {
    534:   DM                da;
    535:   PetscErrorCode    ierr;
    536:   const char        *prefix;
    537:   Mat               Anatural;
    538:   AO                ao;
    539:   PetscInt          rstart,rend,*petsc,i;
    540:   IS                is;
    541:   MPI_Comm          comm;
    542:   PetscViewerFormat format;

    545:   /* Check whether we are just printing info, in which case MatView() already viewed everything we wanted to view */
    546:   PetscViewerGetFormat(viewer,&format);
    547:   if (format == PETSC_VIEWER_ASCII_INFO || format == PETSC_VIEWER_ASCII_INFO_DETAIL) return(0);

    549:   PetscObjectGetComm((PetscObject)A,&comm);
    550:   MatGetDM(A, &da);
    551:   if (!da) SETERRQ(PetscObjectComm((PetscObject)A),PETSC_ERR_ARG_WRONG,"Matrix not generated from a DMDA");

    553:   DMDAGetAO(da,&ao);
    554:   MatGetOwnershipRange(A,&rstart,&rend);
    555:   PetscMalloc1(rend-rstart,&petsc);
    556:   for (i=rstart; i<rend; i++) petsc[i-rstart] = i;
    557:   AOApplicationToPetsc(ao,rend-rstart,petsc);
    558:   ISCreateGeneral(comm,rend-rstart,petsc,PETSC_OWN_POINTER,&is);

    560:   /* call viewer on natural ordering */
    561:   MatGetSubMatrix(A,is,is,MAT_INITIAL_MATRIX,&Anatural);
    562:   ISDestroy(&is);
    563:   PetscObjectGetOptionsPrefix((PetscObject)A,&prefix);
    564:   PetscObjectSetOptionsPrefix((PetscObject)Anatural,prefix);
    565:   PetscObjectSetName((PetscObject)Anatural,((PetscObject)A)->name);
    566:   (Anatural->ops->view)(Anatural,viewer);
    567:   MatDestroy(&Anatural);
    568:   return(0);
    569: }

    573: PetscErrorCode  MatLoad_MPI_DA(Mat A,PetscViewer viewer)
    574: {
    575:   DM             da;
    577:   Mat            Anatural,Aapp;
    578:   AO             ao;
    579:   PetscInt       rstart,rend,*app,i;
    580:   IS             is;
    581:   MPI_Comm       comm;

    584:   PetscObjectGetComm((PetscObject)A,&comm);
    585:   MatGetDM(A, &da);
    586:   if (!da) SETERRQ(PetscObjectComm((PetscObject)A),PETSC_ERR_ARG_WRONG,"Matrix not generated from a DMDA");

    588:   /* Load the matrix in natural ordering */
    589:   MatCreate(PetscObjectComm((PetscObject)A),&Anatural);
    590:   MatSetType(Anatural,((PetscObject)A)->type_name);
    591:   MatSetSizes(Anatural,A->rmap->n,A->cmap->n,A->rmap->N,A->cmap->N);
    592:   MatLoad(Anatural,viewer);

    594:   /* Map natural ordering to application ordering and create IS */
    595:   DMDAGetAO(da,&ao);
    596:   MatGetOwnershipRange(Anatural,&rstart,&rend);
    597:   PetscMalloc1(rend-rstart,&app);
    598:   for (i=rstart; i<rend; i++) app[i-rstart] = i;
    599:   AOPetscToApplication(ao,rend-rstart,app);
    600:   ISCreateGeneral(comm,rend-rstart,app,PETSC_OWN_POINTER,&is);

    602:   /* Do permutation and replace header */
    603:   MatGetSubMatrix(Anatural,is,is,MAT_INITIAL_MATRIX,&Aapp);
    604:   MatHeaderReplace(A,Aapp);
    605:   ISDestroy(&is);
    606:   MatDestroy(&Anatural);
    607:   return(0);
    608: }

    612: PetscErrorCode DMCreateMatrix_DA(DM da, Mat *J)
    613: {
    615:   PetscInt       dim,dof,nx,ny,nz,dims[3],starts[3],M,N,P;
    616:   Mat            A;
    617:   MPI_Comm       comm;
    618:   MatType        Atype;
    619:   PetscSection   section, sectionGlobal;
    620:   void           (*aij)(void)=NULL,(*baij)(void)=NULL,(*sbaij)(void)=NULL;
    621:   MatType        mtype;
    622:   PetscMPIInt    size;
    623:   DM_DA          *dd = (DM_DA*)da->data;

    626:   MatInitializePackage();
    627:   mtype = da->mattype;

    629:   DMGetDefaultSection(da, &section);
    630:   if (section) {
    631:     PetscInt  bs = -1;
    632:     PetscInt  localSize;
    633:     PetscBool isShell, isBlock, isSeqBlock, isMPIBlock, isSymBlock, isSymSeqBlock, isSymMPIBlock, isSymmetric;

    635:     DMGetDefaultGlobalSection(da, &sectionGlobal);
    636:     PetscSectionGetConstrainedStorageSize(sectionGlobal, &localSize);
    637:     MatCreate(PetscObjectComm((PetscObject)da), J);
    638:     MatSetSizes(*J, localSize, localSize, PETSC_DETERMINE, PETSC_DETERMINE);
    639:     MatSetType(*J, mtype);
    640:     MatSetFromOptions(*J);
    641:     PetscStrcmp(mtype, MATSHELL, &isShell);
    642:     PetscStrcmp(mtype, MATBAIJ, &isBlock);
    643:     PetscStrcmp(mtype, MATSEQBAIJ, &isSeqBlock);
    644:     PetscStrcmp(mtype, MATMPIBAIJ, &isMPIBlock);
    645:     PetscStrcmp(mtype, MATSBAIJ, &isSymBlock);
    646:     PetscStrcmp(mtype, MATSEQSBAIJ, &isSymSeqBlock);
    647:     PetscStrcmp(mtype, MATMPISBAIJ, &isSymMPIBlock);
    648:     /* Check for symmetric storage */
    649:     isSymmetric = (PetscBool) (isSymBlock || isSymSeqBlock || isSymMPIBlock);
    650:     if (isSymmetric) {
    651:       MatSetOption(*J, MAT_IGNORE_LOWER_TRIANGULAR, PETSC_TRUE);
    652:     }
    653:     if (!isShell) {
    654:       PetscInt *dnz, *onz, *dnzu, *onzu, bsLocal;

    656:       if (bs < 0) {
    657:         if (isBlock || isSeqBlock || isMPIBlock || isSymBlock || isSymSeqBlock || isSymMPIBlock) {
    658:           PetscInt pStart, pEnd, p, dof;

    660:           PetscSectionGetChart(sectionGlobal, &pStart, &pEnd);
    661:           for (p = pStart; p < pEnd; ++p) {
    662:             PetscSectionGetDof(sectionGlobal, p, &dof);
    663:             if (dof) {
    664:               bs = dof;
    665:               break;
    666:             }
    667:           }
    668:         } else {
    669:           bs = 1;
    670:         }
    671:         /* Must have same blocksize on all procs (some might have no points) */
    672:         bsLocal = bs;
    673:         MPI_Allreduce(&bsLocal, &bs, 1, MPIU_INT, MPI_MAX, PetscObjectComm((PetscObject)da));
    674:       }
    675:       PetscCalloc4(localSize/bs, &dnz, localSize/bs, &onz, localSize/bs, &dnzu, localSize/bs, &onzu);
    676:       /* DMPlexPreallocateOperator(dm, bs, section, sectionGlobal, dnz, onz, dnzu, onzu, *J, fillMatrix); */
    677:       PetscFree4(dnz, onz, dnzu, onzu);
    678:     }
    679:   }
    680:   /*
    681:                                   m
    682:           ------------------------------------------------------
    683:          |                                                     |
    684:          |                                                     |
    685:          |               ----------------------                |
    686:          |               |                    |                |
    687:       n  |           ny  |                    |                |
    688:          |               |                    |                |
    689:          |               .---------------------                |
    690:          |             (xs,ys)     nx                          |
    691:          |            .                                        |
    692:          |         (gxs,gys)                                   |
    693:          |                                                     |
    694:           -----------------------------------------------------
    695:   */

    697:   /*
    698:          nc - number of components per grid point
    699:          col - number of colors needed in one direction for single component problem

    701:   */
    702:   M   = dd->M;
    703:   N   = dd->N;
    704:   P   = dd->P;
    705:   dim = da->dim;
    706:   dof = dd->w;
    707:   /* DMDAGetInfo(da,&dim,&M,&N,&P,0,0,0,&dof,0,0,0,0,0); */
    708:   DMDAGetCorners(da,0,0,0,&nx,&ny,&nz);
    709:   PetscObjectGetComm((PetscObject)da,&comm);
    710:   MatCreate(comm,&A);
    711:   MatSetSizes(A,dof*nx*ny*nz,dof*nx*ny*nz,dof*M*N*P,dof*M*N*P);
    712:   MatSetType(A,mtype);
    713:   MatSetDM(A,da);
    714:   MatSetFromOptions(A);
    715:   MatGetType(A,&Atype);
    716:   /*
    717:      We do not provide a getmatrix function in the DMDA operations because
    718:    the basic DMDA does not know about matrices. We think of DMDA as being more
    719:    more low-level than matrices. This is kind of cheating but, cause sometimes
    720:    we think of DMDA has higher level than matrices.

    722:      We could switch based on Atype (or mtype), but we do not since the
    723:    specialized setting routines depend only the particular preallocation
    724:    details of the matrix, not the type itself.
    725:   */
    726:   PetscObjectQueryFunction((PetscObject)A,"MatMPIAIJSetPreallocation_C",&aij);
    727:   if (!aij) {
    728:     PetscObjectQueryFunction((PetscObject)A,"MatSeqAIJSetPreallocation_C",&aij);
    729:   }
    730:   if (!aij) {
    731:     PetscObjectQueryFunction((PetscObject)A,"MatMPIBAIJSetPreallocation_C",&baij);
    732:     if (!baij) {
    733:       PetscObjectQueryFunction((PetscObject)A,"MatSeqBAIJSetPreallocation_C",&baij);
    734:     }
    735:     if (!baij) {
    736:       PetscObjectQueryFunction((PetscObject)A,"MatMPISBAIJSetPreallocation_C",&sbaij);
    737:       if (!sbaij) {
    738:         PetscObjectQueryFunction((PetscObject)A,"MatSeqSBAIJSetPreallocation_C",&sbaij);
    739:       }
    740:     }
    741:   }
    742:   if (aij) {
    743:     if (dim == 1) {
    744:       if (dd->ofill) {
    745:         DMCreateMatrix_DA_1d_MPIAIJ_Fill(da,A);
    746:       } else {
    747:         DMCreateMatrix_DA_1d_MPIAIJ(da,A);
    748:       }
    749:     } else if (dim == 2) {
    750:       if (dd->ofill) {
    751:         DMCreateMatrix_DA_2d_MPIAIJ_Fill(da,A);
    752:       } else {
    753:         DMCreateMatrix_DA_2d_MPIAIJ(da,A);
    754:       }
    755:     } else if (dim == 3) {
    756:       if (dd->ofill) {
    757:         DMCreateMatrix_DA_3d_MPIAIJ_Fill(da,A);
    758:       } else {
    759:         DMCreateMatrix_DA_3d_MPIAIJ(da,A);
    760:       }
    761:     }
    762:   } else if (baij) {
    763:     if (dim == 2) {
    764:       DMCreateMatrix_DA_2d_MPIBAIJ(da,A);
    765:     } else if (dim == 3) {
    766:       DMCreateMatrix_DA_3d_MPIBAIJ(da,A);
    767:     } else SETERRQ3(PetscObjectComm((PetscObject)da),PETSC_ERR_SUP,"Not implemented for %D dimension and Matrix Type: %s in %D dimension! Send mail to petsc-maint@mcs.anl.gov for code",dim,Atype,dim);
    768:   } else if (sbaij) {
    769:     if (dim == 2) {
    770:       DMCreateMatrix_DA_2d_MPISBAIJ(da,A);
    771:     } else if (dim == 3) {
    772:       DMCreateMatrix_DA_3d_MPISBAIJ(da,A);
    773:     } else SETERRQ3(PetscObjectComm((PetscObject)da),PETSC_ERR_SUP,"Not implemented for %D dimension and Matrix Type: %s in %D dimension! Send mail to petsc-maint@mcs.anl.gov for code",dim,Atype,dim);
    774:   } else {
    775:     ISLocalToGlobalMapping ltog;
    776:     DMGetLocalToGlobalMapping(da,&ltog);
    777:     MatSetUp(A);
    778:     MatSetLocalToGlobalMapping(A,ltog,ltog);
    779:   }
    780:   DMDAGetGhostCorners(da,&starts[0],&starts[1],&starts[2],&dims[0],&dims[1],&dims[2]);
    781:   MatSetStencil(A,dim,dims,starts,dof);
    782:   MatSetDM(A,da);
    783:   MPI_Comm_size(comm,&size);
    784:   if (size > 1) {
    785:     /* change viewer to display matrix in natural ordering */
    786:     MatShellSetOperation(A, MATOP_VIEW, (void (*)(void))MatView_MPI_DA);
    787:     MatShellSetOperation(A, MATOP_LOAD, (void (*)(void))MatLoad_MPI_DA);
    788:   }
    789:   *J = A;
    790:   return(0);
    791: }

    793: /* ---------------------------------------------------------------------------------*/
    796: PetscErrorCode DMCreateMatrix_DA_2d_MPIAIJ(DM da,Mat J)
    797: {
    798:   PetscErrorCode         ierr;
    799:   PetscInt               xs,ys,nx,ny,i,j,slot,gxs,gys,gnx,gny,m,n,dim,s,*cols = NULL,k,nc,*rows = NULL,col,cnt,l,p;
    800:   PetscInt               lstart,lend,pstart,pend,*dnz,*onz;
    801:   MPI_Comm               comm;
    802:   PetscScalar            *values;
    803:   DMBoundaryType         bx,by;
    804:   ISLocalToGlobalMapping ltog;
    805:   DMDAStencilType        st;

    808:   /*
    809:          nc - number of components per grid point
    810:          col - number of colors needed in one direction for single component problem

    812:   */
    813:   DMDAGetInfo(da,&dim,&m,&n,0,0,0,0,&nc,&s,&bx,&by,0,&st);
    814:   col  = 2*s + 1;
    815:   DMDAGetCorners(da,&xs,&ys,0,&nx,&ny,0);
    816:   DMDAGetGhostCorners(da,&gxs,&gys,0,&gnx,&gny,0);
    817:   PetscObjectGetComm((PetscObject)da,&comm);

    819:   PetscMalloc2(nc,&rows,col*col*nc*nc,&cols);
    820:   DMGetLocalToGlobalMapping(da,&ltog);

    822:   MatSetBlockSize(J,nc);
    823:   /* determine the matrix preallocation information */
    824:   MatPreallocateInitialize(comm,nc*nx*ny,nc*nx*ny,dnz,onz);
    825:   for (i=xs; i<xs+nx; i++) {

    827:     pstart = (bx == DM_BOUNDARY_PERIODIC) ? -s : (PetscMax(-s,-i));
    828:     pend   = (bx == DM_BOUNDARY_PERIODIC) ?  s : (PetscMin(s,m-i-1));

    830:     for (j=ys; j<ys+ny; j++) {
    831:       slot = i - gxs + gnx*(j - gys);

    833:       lstart = (by == DM_BOUNDARY_PERIODIC) ? -s : (PetscMax(-s,-j));
    834:       lend   = (by == DM_BOUNDARY_PERIODIC) ?  s : (PetscMin(s,n-j-1));

    836:       cnt = 0;
    837:       for (k=0; k<nc; k++) {
    838:         for (l=lstart; l<lend+1; l++) {
    839:           for (p=pstart; p<pend+1; p++) {
    840:             if ((st == DMDA_STENCIL_BOX) || (!l || !p)) {  /* entries on star have either l = 0 or p = 0 */
    841:               cols[cnt++] = k + nc*(slot + gnx*l + p);
    842:             }
    843:           }
    844:         }
    845:         rows[k] = k + nc*(slot);
    846:       }
    847:       MatPreallocateSetLocal(ltog,nc,rows,ltog,cnt,cols,dnz,onz);
    848:     }
    849:   }
    850:   MatSetBlockSize(J,nc);
    851:   MatSeqAIJSetPreallocation(J,0,dnz);
    852:   MatMPIAIJSetPreallocation(J,0,dnz,0,onz);
    853:   MatPreallocateFinalize(dnz,onz);

    855:   MatSetLocalToGlobalMapping(J,ltog,ltog);

    857:   /*
    858:     For each node in the grid: we get the neighbors in the local (on processor ordering
    859:     that includes the ghost points) then MatSetValuesLocal() maps those indices to the global
    860:     PETSc ordering.
    861:   */
    862:   if (!da->prealloc_only) {
    863:     PetscCalloc1(col*col*nc*nc,&values);
    864:     for (i=xs; i<xs+nx; i++) {

    866:       pstart = (bx == DM_BOUNDARY_PERIODIC) ? -s : (PetscMax(-s,-i));
    867:       pend   = (bx == DM_BOUNDARY_PERIODIC) ?  s : (PetscMin(s,m-i-1));

    869:       for (j=ys; j<ys+ny; j++) {
    870:         slot = i - gxs + gnx*(j - gys);

    872:         lstart = (by == DM_BOUNDARY_PERIODIC) ? -s : (PetscMax(-s,-j));
    873:         lend   = (by == DM_BOUNDARY_PERIODIC) ?  s : (PetscMin(s,n-j-1));

    875:         cnt = 0;
    876:         for (k=0; k<nc; k++) {
    877:           for (l=lstart; l<lend+1; l++) {
    878:             for (p=pstart; p<pend+1; p++) {
    879:               if ((st == DMDA_STENCIL_BOX) || (!l || !p)) {  /* entries on star have either l = 0 or p = 0 */
    880:                 cols[cnt++] = k + nc*(slot + gnx*l + p);
    881:               }
    882:             }
    883:           }
    884:           rows[k] = k + nc*(slot);
    885:         }
    886:         MatSetValuesLocal(J,nc,rows,cnt,cols,values,INSERT_VALUES);
    887:       }
    888:     }
    889:     PetscFree(values);
    890:     MatAssemblyBegin(J,MAT_FINAL_ASSEMBLY);
    891:     MatAssemblyEnd(J,MAT_FINAL_ASSEMBLY);
    892:     MatSetOption(J,MAT_NEW_NONZERO_LOCATION_ERR,PETSC_TRUE);
    893:   }
    894:   PetscFree2(rows,cols);
    895:   return(0);
    896: }

    900: PetscErrorCode DMCreateMatrix_DA_2d_MPIAIJ_Fill(DM da,Mat J)
    901: {
    902:   PetscErrorCode         ierr;
    903:   PetscInt               xs,ys,nx,ny,i,j,slot,gxs,gys,gnx,gny;
    904:   PetscInt               m,n,dim,s,*cols,k,nc,row,col,cnt,maxcnt = 0,l,p;
    905:   PetscInt               lstart,lend,pstart,pend,*dnz,*onz;
    906:   DM_DA                  *dd = (DM_DA*)da->data;
    907:   PetscInt               ifill_col,*ofill = dd->ofill, *dfill = dd->dfill;
    908:   MPI_Comm               comm;
    909:   PetscScalar            *values;
    910:   DMBoundaryType         bx,by;
    911:   ISLocalToGlobalMapping ltog;
    912:   DMDAStencilType        st;

    915:   /*
    916:          nc - number of components per grid point
    917:          col - number of colors needed in one direction for single component problem

    919:   */
    920:   DMDAGetInfo(da,&dim,&m,&n,0,0,0,0,&nc,&s,&bx,&by,0,&st);
    921:   col  = 2*s + 1;
    922:   DMDAGetCorners(da,&xs,&ys,0,&nx,&ny,0);
    923:   DMDAGetGhostCorners(da,&gxs,&gys,0,&gnx,&gny,0);
    924:   PetscObjectGetComm((PetscObject)da,&comm);

    926:   PetscMalloc1(col*col*nc,&cols);
    927:   DMGetLocalToGlobalMapping(da,&ltog);

    929:   MatSetBlockSize(J,nc);
    930:   /* determine the matrix preallocation information */
    931:   MatPreallocateInitialize(comm,nc*nx*ny,nc*nx*ny,dnz,onz);
    932:   for (i=xs; i<xs+nx; i++) {

    934:     pstart = (bx == DM_BOUNDARY_PERIODIC) ? -s : (PetscMax(-s,-i));
    935:     pend   = (bx == DM_BOUNDARY_PERIODIC) ?  s : (PetscMin(s,m-i-1));

    937:     for (j=ys; j<ys+ny; j++) {
    938:       slot = i - gxs + gnx*(j - gys);

    940:       lstart = (by == DM_BOUNDARY_PERIODIC) ? -s : (PetscMax(-s,-j));
    941:       lend   = (by == DM_BOUNDARY_PERIODIC) ?  s : (PetscMin(s,n-j-1));

    943:       for (k=0; k<nc; k++) {
    944:         cnt = 0;
    945:         for (l=lstart; l<lend+1; l++) {
    946:           for (p=pstart; p<pend+1; p++) {
    947:             if (l || p) {
    948:               if ((st == DMDA_STENCIL_BOX) || (!l || !p)) {  /* entries on star */
    949:                 for (ifill_col=ofill[k]; ifill_col<ofill[k+1]; ifill_col++) cols[cnt++] = ofill[ifill_col] + nc*(slot + gnx*l + p);
    950:               }
    951:             } else {
    952:               if (dfill) {
    953:                 for (ifill_col=dfill[k]; ifill_col<dfill[k+1]; ifill_col++) cols[cnt++] = dfill[ifill_col] + nc*(slot + gnx*l + p);
    954:               } else {
    955:                 for (ifill_col=0; ifill_col<nc; ifill_col++) cols[cnt++] = ifill_col + nc*(slot + gnx*l + p);
    956:               }
    957:             }
    958:           }
    959:         }
    960:         row    = k + nc*(slot);
    961:         maxcnt = PetscMax(maxcnt,cnt);
    962:         MatPreallocateSetLocal(ltog,1,&row,ltog,cnt,cols,dnz,onz);
    963:       }
    964:     }
    965:   }
    966:   MatSeqAIJSetPreallocation(J,0,dnz);
    967:   MatMPIAIJSetPreallocation(J,0,dnz,0,onz);
    968:   MatPreallocateFinalize(dnz,onz);
    969:   MatSetLocalToGlobalMapping(J,ltog,ltog);

    971:   /*
    972:     For each node in the grid: we get the neighbors in the local (on processor ordering
    973:     that includes the ghost points) then MatSetValuesLocal() maps those indices to the global
    974:     PETSc ordering.
    975:   */
    976:   if (!da->prealloc_only) {
    977:     PetscCalloc1(maxcnt,&values);
    978:     for (i=xs; i<xs+nx; i++) {

    980:       pstart = (bx == DM_BOUNDARY_PERIODIC) ? -s : (PetscMax(-s,-i));
    981:       pend   = (bx == DM_BOUNDARY_PERIODIC) ?  s : (PetscMin(s,m-i-1));

    983:       for (j=ys; j<ys+ny; j++) {
    984:         slot = i - gxs + gnx*(j - gys);

    986:         lstart = (by == DM_BOUNDARY_PERIODIC) ? -s : (PetscMax(-s,-j));
    987:         lend   = (by == DM_BOUNDARY_PERIODIC) ?  s : (PetscMin(s,n-j-1));

    989:         for (k=0; k<nc; k++) {
    990:           cnt = 0;
    991:           for (l=lstart; l<lend+1; l++) {
    992:             for (p=pstart; p<pend+1; p++) {
    993:               if (l || p) {
    994:                 if ((st == DMDA_STENCIL_BOX) || (!l || !p)) {  /* entries on star */
    995:                   for (ifill_col=ofill[k]; ifill_col<ofill[k+1]; ifill_col++) cols[cnt++] = ofill[ifill_col] + nc*(slot + gnx*l + p);
    996:                 }
    997:               } else {
    998:                 if (dfill) {
    999:                   for (ifill_col=dfill[k]; ifill_col<dfill[k+1]; ifill_col++) cols[cnt++] = dfill[ifill_col] + nc*(slot + gnx*l + p);
    1000:                 } else {
    1001:                   for (ifill_col=0; ifill_col<nc; ifill_col++) cols[cnt++] = ifill_col + nc*(slot + gnx*l + p);
    1002:                 }
    1003:               }
    1004:             }
    1005:           }
    1006:           row  = k + nc*(slot);
    1007:           MatSetValuesLocal(J,1,&row,cnt,cols,values,INSERT_VALUES);
    1008:         }
    1009:       }
    1010:     }
    1011:     PetscFree(values);
    1012:     MatAssemblyBegin(J,MAT_FINAL_ASSEMBLY);
    1013:     MatAssemblyEnd(J,MAT_FINAL_ASSEMBLY);
    1014:     MatSetOption(J,MAT_NEW_NONZERO_LOCATION_ERR,PETSC_TRUE);
    1015:   }
    1016:   PetscFree(cols);
    1017:   return(0);
    1018: }

    1020: /* ---------------------------------------------------------------------------------*/

    1024: PetscErrorCode DMCreateMatrix_DA_3d_MPIAIJ(DM da,Mat J)
    1025: {
    1026:   PetscErrorCode         ierr;
    1027:   PetscInt               xs,ys,nx,ny,i,j,slot,gxs,gys,gnx,gny;
    1028:   PetscInt               m,n,dim,s,*cols = NULL,k,nc,*rows = NULL,col,cnt,l,p,*dnz = NULL,*onz = NULL;
    1029:   PetscInt               istart,iend,jstart,jend,kstart,kend,zs,nz,gzs,gnz,ii,jj,kk;
    1030:   MPI_Comm               comm;
    1031:   PetscScalar            *values;
    1032:   DMBoundaryType         bx,by,bz;
    1033:   ISLocalToGlobalMapping ltog;
    1034:   DMDAStencilType        st;

    1037:   /*
    1038:          nc - number of components per grid point
    1039:          col - number of colors needed in one direction for single component problem

    1041:   */
    1042:   DMDAGetInfo(da,&dim,&m,&n,&p,0,0,0,&nc,&s,&bx,&by,&bz,&st);
    1043:   col  = 2*s + 1;

    1045:   DMDAGetCorners(da,&xs,&ys,&zs,&nx,&ny,&nz);
    1046:   DMDAGetGhostCorners(da,&gxs,&gys,&gzs,&gnx,&gny,&gnz);
    1047:   PetscObjectGetComm((PetscObject)da,&comm);

    1049:   PetscMalloc2(nc,&rows,col*col*col*nc*nc,&cols);
    1050:   DMGetLocalToGlobalMapping(da,&ltog);

    1052:   MatSetBlockSize(J,nc);
    1053:   /* determine the matrix preallocation information */
    1054:   MatPreallocateInitialize(comm,nc*nx*ny*nz,nc*nx*ny*nz,dnz,onz);
    1055:   for (i=xs; i<xs+nx; i++) {
    1056:     istart = (bx == DM_BOUNDARY_PERIODIC) ? -s : (PetscMax(-s,-i));
    1057:     iend   = (bx == DM_BOUNDARY_PERIODIC) ?  s : (PetscMin(s,m-i-1));
    1058:     for (j=ys; j<ys+ny; j++) {
    1059:       jstart = (by == DM_BOUNDARY_PERIODIC) ? -s : (PetscMax(-s,-j));
    1060:       jend   = (by == DM_BOUNDARY_PERIODIC) ?  s : (PetscMin(s,n-j-1));
    1061:       for (k=zs; k<zs+nz; k++) {
    1062:         kstart = (bz == DM_BOUNDARY_PERIODIC) ? -s : (PetscMax(-s,-k));
    1063:         kend   = (bz == DM_BOUNDARY_PERIODIC) ?  s : (PetscMin(s,p-k-1));

    1065:         slot = i - gxs + gnx*(j - gys) + gnx*gny*(k - gzs);

    1067:         cnt = 0;
    1068:         for (l=0; l<nc; l++) {
    1069:           for (ii=istart; ii<iend+1; ii++) {
    1070:             for (jj=jstart; jj<jend+1; jj++) {
    1071:               for (kk=kstart; kk<kend+1; kk++) {
    1072:                 if ((st == DMDA_STENCIL_BOX) || ((!ii && !jj) || (!jj && !kk) || (!ii && !kk))) {/* entries on star*/
    1073:                   cols[cnt++] = l + nc*(slot + ii + gnx*jj + gnx*gny*kk);
    1074:                 }
    1075:               }
    1076:             }
    1077:           }
    1078:           rows[l] = l + nc*(slot);
    1079:         }
    1080:         MatPreallocateSetLocal(ltog,nc,rows,ltog,cnt,cols,dnz,onz);
    1081:       }
    1082:     }
    1083:   }
    1084:   MatSetBlockSize(J,nc);
    1085:   MatSeqAIJSetPreallocation(J,0,dnz);
    1086:   MatMPIAIJSetPreallocation(J,0,dnz,0,onz);
    1087:   MatPreallocateFinalize(dnz,onz);
    1088:   MatSetLocalToGlobalMapping(J,ltog,ltog);

    1090:   /*
    1091:     For each node in the grid: we get the neighbors in the local (on processor ordering
    1092:     that includes the ghost points) then MatSetValuesLocal() maps those indices to the global
    1093:     PETSc ordering.
    1094:   */
    1095:   if (!da->prealloc_only) {
    1096:     PetscCalloc1(col*col*col*nc*nc*nc,&values);
    1097:     for (i=xs; i<xs+nx; i++) {
    1098:       istart = (bx == DM_BOUNDARY_PERIODIC) ? -s : (PetscMax(-s,-i));
    1099:       iend   = (bx == DM_BOUNDARY_PERIODIC) ?  s : (PetscMin(s,m-i-1));
    1100:       for (j=ys; j<ys+ny; j++) {
    1101:         jstart = (by == DM_BOUNDARY_PERIODIC) ? -s : (PetscMax(-s,-j));
    1102:         jend   = (by == DM_BOUNDARY_PERIODIC) ?  s : (PetscMin(s,n-j-1));
    1103:         for (k=zs; k<zs+nz; k++) {
    1104:           kstart = (bz == DM_BOUNDARY_PERIODIC) ? -s : (PetscMax(-s,-k));
    1105:           kend   = (bz == DM_BOUNDARY_PERIODIC) ?  s : (PetscMin(s,p-k-1));

    1107:           slot = i - gxs + gnx*(j - gys) + gnx*gny*(k - gzs);

    1109:           cnt = 0;
    1110:           for (l=0; l<nc; l++) {
    1111:             for (ii=istart; ii<iend+1; ii++) {
    1112:               for (jj=jstart; jj<jend+1; jj++) {
    1113:                 for (kk=kstart; kk<kend+1; kk++) {
    1114:                   if ((st == DMDA_STENCIL_BOX) || ((!ii && !jj) || (!jj && !kk) || (!ii && !kk))) {/* entries on star*/
    1115:                     cols[cnt++] = l + nc*(slot + ii + gnx*jj + gnx*gny*kk);
    1116:                   }
    1117:                 }
    1118:               }
    1119:             }
    1120:             rows[l] = l + nc*(slot);
    1121:           }
    1122:           MatSetValuesLocal(J,nc,rows,cnt,cols,values,INSERT_VALUES);
    1123:         }
    1124:       }
    1125:     }
    1126:     PetscFree(values);
    1127:     MatAssemblyBegin(J,MAT_FINAL_ASSEMBLY);
    1128:     MatAssemblyEnd(J,MAT_FINAL_ASSEMBLY);
    1129:     MatSetOption(J,MAT_NEW_NONZERO_LOCATION_ERR,PETSC_TRUE);
    1130:   }
    1131:   PetscFree2(rows,cols);
    1132:   return(0);
    1133: }

    1135: /* ---------------------------------------------------------------------------------*/

    1139: PetscErrorCode DMCreateMatrix_DA_1d_MPIAIJ_Fill(DM da,Mat J)
    1140: {
    1141:   PetscErrorCode         ierr;
    1142:   DM_DA                  *dd = (DM_DA*)da->data;
    1143:   PetscInt               xs,nx,i,j,gxs,gnx,row,k,l;
    1144:   PetscInt               m,dim,s,*cols = NULL,nc,cnt,maxcnt = 0,*ocols;
    1145:   PetscInt               *ofill = dd->ofill,*dfill = dd->dfill;
    1146:   PetscScalar            *values;
    1147:   DMBoundaryType         bx;
    1148:   ISLocalToGlobalMapping ltog;
    1149:   PetscMPIInt            rank,size;

    1152:   if (dd->bx == DM_BOUNDARY_PERIODIC) SETERRQ(PetscObjectComm((PetscObject)da),PETSC_ERR_SUP,"With fill provided not implemented with periodic boundary conditions");
    1153:   MPI_Comm_rank(PetscObjectComm((PetscObject)da),&rank);
    1154:   MPI_Comm_size(PetscObjectComm((PetscObject)da),&size);

    1156:   /*
    1157:          nc - number of components per grid point

    1159:   */
    1160:   DMDAGetInfo(da,&dim,&m,0,0,0,0,0,&nc,&s,&bx,0,0,0);
    1161:   DMDAGetCorners(da,&xs,0,0,&nx,0,0);
    1162:   DMDAGetGhostCorners(da,&gxs,0,0,&gnx,0,0);

    1164:   MatSetBlockSize(J,nc);
    1165:   PetscCalloc2(nx*nc,&cols,nx*nc,&ocols);

    1167:   if (nx < 2) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_SUP,"Need at least two grid points per process");
    1168:   /*
    1169:         note should be smaller for first and last process with no periodic
    1170:         does not handle dfill
    1171:   */
    1172:   cnt = 0;
    1173:   /* coupling with process to the left */
    1174:   for (i=0; i<s; i++) {
    1175:     for (j=0; j<nc; j++) {
    1176:       ocols[cnt] = ((!rank) ? 0 : (s - i)*(ofill[j+1] - ofill[j]));
    1177:       cols[cnt]  = dfill[j+1] - dfill[j] + (s + i)*(ofill[j+1] - ofill[j]);
    1178:       maxcnt = PetscMax(maxcnt,ocols[cnt]+cols[cnt]);
    1179:       cnt++;
    1180:     }
    1181:   }
    1182:   for (i=s; i<nx-s; i++) {
    1183:     for (j=0; j<nc; j++) {
    1184:       cols[cnt] = dfill[j+1] - dfill[j] + 2*s*(ofill[j+1] - ofill[j]);
    1185:       maxcnt = PetscMax(maxcnt,ocols[cnt]+cols[cnt]);
    1186:       cnt++;
    1187:     }
    1188:   }
    1189:   /* coupling with process to the right */
    1190:   for (i=nx-s; i<nx; i++) {
    1191:     for (j=0; j<nc; j++) {
    1192:       ocols[cnt] = ((rank == (size-1)) ? 0 : (i - nx + s + 1)*(ofill[j+1] - ofill[j]));
    1193:       cols[cnt]  = dfill[j+1] - dfill[j] + (s + nx - i - 1)*(ofill[j+1] - ofill[j]);
    1194:       maxcnt = PetscMax(maxcnt,ocols[cnt]+cols[cnt]);
    1195:       cnt++;
    1196:     }
    1197:   }

    1199:   MatSeqAIJSetPreallocation(J,0,cols);
    1200:   MatMPIAIJSetPreallocation(J,0,cols,0,ocols);
    1201:   PetscFree2(cols,ocols);

    1203:   DMGetLocalToGlobalMapping(da,&ltog);
    1204:   MatSetLocalToGlobalMapping(J,ltog,ltog);

    1206:   /*
    1207:     For each node in the grid: we get the neighbors in the local (on processor ordering
    1208:     that includes the ghost points) then MatSetValuesLocal() maps those indices to the global
    1209:     PETSc ordering.
    1210:   */
    1211:   if (!da->prealloc_only) {
    1212:     PetscCalloc2(maxcnt,&values,maxcnt,&cols);

    1214:     row = xs*nc;
    1215:     /* coupling with process to the left */
    1216:     for (i=xs; i<xs+s; i++) {
    1217:       for (j=0; j<nc; j++) {
    1218:         cnt = 0;
    1219:         if (rank) {
    1220:           for (l=0; l<s; l++) {
    1221:             for (k=ofill[j]; k<ofill[j+1]; k++) cols[cnt++] = (i - s + l)*nc + ofill[k];
    1222:           }
    1223:         }
    1224:         if (dfill) {
    1225:           for (k=dfill[j]; k<dfill[j+1]; k++) {
    1226:             cols[cnt++] = i*nc + dfill[k];
    1227:           }
    1228:         } else {
    1229:           for (k=0; k<nc; k++) {
    1230:             cols[cnt++] = i*nc + k;
    1231:           }
    1232:         }
    1233:         for (l=0; l<s; l++) {
    1234:           for (k=ofill[j]; k<ofill[j+1]; k++) cols[cnt++] = (i + s - l)*nc + ofill[k];
    1235:         }
    1236:         MatSetValues(J,1,&row,cnt,cols,values,INSERT_VALUES);
    1237:         row++;
    1238:       }
    1239:     }
    1240:     for (i=xs+s; i<xs+nx-s; i++) {
    1241:       for (j=0; j<nc; j++) {
    1242:         cnt = 0;
    1243:         for (l=0; l<s; l++) {
    1244:           for (k=ofill[j]; k<ofill[j+1]; k++) cols[cnt++] = (i - s + l)*nc + ofill[k];
    1245:         }
    1246:         if (dfill) {
    1247:           for (k=dfill[j]; k<dfill[j+1]; k++) {
    1248:             cols[cnt++] = i*nc + dfill[k];
    1249:           }
    1250:         } else {
    1251:           for (k=0; k<nc; k++) {
    1252:             cols[cnt++] = i*nc + k;
    1253:           }
    1254:         }
    1255:         for (l=0; l<s; l++) {
    1256:           for (k=ofill[j]; k<ofill[j+1]; k++) cols[cnt++] = (i + s - l)*nc + ofill[k];
    1257:         }
    1258:         MatSetValues(J,1,&row,cnt,cols,values,INSERT_VALUES);
    1259:         row++;
    1260:       }
    1261:     }
    1262:     /* coupling with process to the right */
    1263:     for (i=xs+nx-s; i<xs+nx; i++) {
    1264:       for (j=0; j<nc; j++) {
    1265:         cnt = 0;
    1266:         for (l=0; l<s; l++) {
    1267:           for (k=ofill[j]; k<ofill[j+1]; k++) cols[cnt++] = (i - s + l)*nc + ofill[k];
    1268:         }
    1269:         if (dfill) {
    1270:           for (k=dfill[j]; k<dfill[j+1]; k++) {
    1271:             cols[cnt++] = i*nc + dfill[k];
    1272:           }
    1273:         } else {
    1274:           for (k=0; k<nc; k++) {
    1275:             cols[cnt++] = i*nc + k;
    1276:           }
    1277:         }
    1278:         if (rank < size-1) {
    1279:           for (l=0; l<s; l++) {
    1280:             for (k=ofill[j]; k<ofill[j+1]; k++) cols[cnt++] = (i + s - l)*nc + ofill[k];
    1281:           }
    1282:         }
    1283:         MatSetValues(J,1,&row,cnt,cols,values,INSERT_VALUES);
    1284:         row++;
    1285:       }
    1286:     }
    1287:     PetscFree2(values,cols);
    1288:     MatAssemblyBegin(J,MAT_FINAL_ASSEMBLY);
    1289:     MatAssemblyEnd(J,MAT_FINAL_ASSEMBLY);
    1290:     MatSetOption(J,MAT_NEW_NONZERO_LOCATION_ERR,PETSC_TRUE);
    1291:   }
    1292:   return(0);
    1293: }

    1295: /* ---------------------------------------------------------------------------------*/

    1299: PetscErrorCode DMCreateMatrix_DA_1d_MPIAIJ(DM da,Mat J)
    1300: {
    1301:   PetscErrorCode         ierr;
    1302:   PetscInt               xs,nx,i,i1,slot,gxs,gnx;
    1303:   PetscInt               m,dim,s,*cols = NULL,nc,*rows = NULL,col,cnt,l;
    1304:   PetscInt               istart,iend;
    1305:   PetscScalar            *values;
    1306:   DMBoundaryType         bx;
    1307:   ISLocalToGlobalMapping ltog;

    1310:   /*
    1311:          nc - number of components per grid point
    1312:          col - number of colors needed in one direction for single component problem

    1314:   */
    1315:   DMDAGetInfo(da,&dim,&m,0,0,0,0,0,&nc,&s,&bx,0,0,0);
    1316:   col  = 2*s + 1;

    1318:   DMDAGetCorners(da,&xs,0,0,&nx,0,0);
    1319:   DMDAGetGhostCorners(da,&gxs,0,0,&gnx,0,0);

    1321:   MatSetBlockSize(J,nc);
    1322:   MatSeqAIJSetPreallocation(J,col*nc,0);
    1323:   MatMPIAIJSetPreallocation(J,col*nc,0,col*nc,0);

    1325:   DMGetLocalToGlobalMapping(da,&ltog);
    1326:   MatSetLocalToGlobalMapping(J,ltog,ltog);

    1328:   /*
    1329:     For each node in the grid: we get the neighbors in the local (on processor ordering
    1330:     that includes the ghost points) then MatSetValuesLocal() maps those indices to the global
    1331:     PETSc ordering.
    1332:   */
    1333:   if (!da->prealloc_only) {
    1334:     PetscMalloc2(nc,&rows,col*nc*nc,&cols);
    1335:     PetscCalloc1(col*nc*nc,&values);
    1336:     for (i=xs; i<xs+nx; i++) {
    1337:       istart = PetscMax(-s,gxs - i);
    1338:       iend   = PetscMin(s,gxs + gnx - i - 1);
    1339:       slot   = i - gxs;

    1341:       cnt = 0;
    1342:       for (l=0; l<nc; l++) {
    1343:         for (i1=istart; i1<iend+1; i1++) {
    1344:           cols[cnt++] = l + nc*(slot + i1);
    1345:         }
    1346:         rows[l] = l + nc*(slot);
    1347:       }
    1348:       MatSetValuesLocal(J,nc,rows,cnt,cols,values,INSERT_VALUES);
    1349:     }
    1350:     PetscFree(values);
    1351:     MatAssemblyBegin(J,MAT_FINAL_ASSEMBLY);
    1352:     MatAssemblyEnd(J,MAT_FINAL_ASSEMBLY);
    1353:     MatSetOption(J,MAT_NEW_NONZERO_LOCATION_ERR,PETSC_TRUE);
    1354:     PetscFree2(rows,cols);
    1355:   }
    1356:   return(0);
    1357: }

    1361: PetscErrorCode DMCreateMatrix_DA_2d_MPIBAIJ(DM da,Mat J)
    1362: {
    1363:   PetscErrorCode         ierr;
    1364:   PetscInt               xs,ys,nx,ny,i,j,slot,gxs,gys,gnx,gny;
    1365:   PetscInt               m,n,dim,s,*cols,nc,col,cnt,*dnz,*onz;
    1366:   PetscInt               istart,iend,jstart,jend,ii,jj;
    1367:   MPI_Comm               comm;
    1368:   PetscScalar            *values;
    1369:   DMBoundaryType         bx,by;
    1370:   DMDAStencilType        st;
    1371:   ISLocalToGlobalMapping ltog;

    1374:   /*
    1375:      nc - number of components per grid point
    1376:      col - number of colors needed in one direction for single component problem
    1377:   */
    1378:   DMDAGetInfo(da,&dim,&m,&n,0,0,0,0,&nc,&s,&bx,&by,0,&st);
    1379:   col  = 2*s + 1;

    1381:   DMDAGetCorners(da,&xs,&ys,0,&nx,&ny,0);
    1382:   DMDAGetGhostCorners(da,&gxs,&gys,0,&gnx,&gny,0);
    1383:   PetscObjectGetComm((PetscObject)da,&comm);

    1385:   PetscMalloc1(col*col*nc*nc,&cols);

    1387:   DMGetLocalToGlobalMapping(da,&ltog);

    1389:   /* determine the matrix preallocation information */
    1390:   MatPreallocateInitialize(comm,nx*ny,nx*ny,dnz,onz);
    1391:   for (i=xs; i<xs+nx; i++) {
    1392:     istart = (bx == DM_BOUNDARY_PERIODIC) ? -s : (PetscMax(-s,-i));
    1393:     iend   = (bx == DM_BOUNDARY_PERIODIC) ?  s : (PetscMin(s,m-i-1));
    1394:     for (j=ys; j<ys+ny; j++) {
    1395:       jstart = (by == DM_BOUNDARY_PERIODIC) ? -s : (PetscMax(-s,-j));
    1396:       jend   = (by == DM_BOUNDARY_PERIODIC) ?  s : (PetscMin(s,n-j-1));
    1397:       slot   = i - gxs + gnx*(j - gys);

    1399:       /* Find block columns in block row */
    1400:       cnt = 0;
    1401:       for (ii=istart; ii<iend+1; ii++) {
    1402:         for (jj=jstart; jj<jend+1; jj++) {
    1403:           if (st == DMDA_STENCIL_BOX || !ii || !jj) { /* BOX or on the STAR */
    1404:             cols[cnt++] = slot + ii + gnx*jj;
    1405:           }
    1406:         }
    1407:       }
    1408:       MatPreallocateSetLocalBlock(ltog,1,&slot,ltog,cnt,cols,dnz,onz);
    1409:     }
    1410:   }
    1411:   MatSeqBAIJSetPreallocation(J,nc,0,dnz);
    1412:   MatMPIBAIJSetPreallocation(J,nc,0,dnz,0,onz);
    1413:   MatPreallocateFinalize(dnz,onz);

    1415:   MatSetLocalToGlobalMapping(J,ltog,ltog);

    1417:   /*
    1418:     For each node in the grid: we get the neighbors in the local (on processor ordering
    1419:     that includes the ghost points) then MatSetValuesLocal() maps those indices to the global
    1420:     PETSc ordering.
    1421:   */
    1422:   if (!da->prealloc_only) {
    1423:     PetscCalloc1(col*col*nc*nc,&values);
    1424:     for (i=xs; i<xs+nx; i++) {
    1425:       istart = (bx == DM_BOUNDARY_PERIODIC) ? -s : (PetscMax(-s,-i));
    1426:       iend   = (bx == DM_BOUNDARY_PERIODIC) ?  s : (PetscMin(s,m-i-1));
    1427:       for (j=ys; j<ys+ny; j++) {
    1428:         jstart = (by == DM_BOUNDARY_PERIODIC) ? -s : (PetscMax(-s,-j));
    1429:         jend   = (by == DM_BOUNDARY_PERIODIC) ?  s : (PetscMin(s,n-j-1));
    1430:         slot = i - gxs + gnx*(j - gys);
    1431:         cnt  = 0;
    1432:         for (ii=istart; ii<iend+1; ii++) {
    1433:           for (jj=jstart; jj<jend+1; jj++) {
    1434:             if (st == DMDA_STENCIL_BOX || !ii || !jj) { /* BOX or on the STAR */
    1435:               cols[cnt++] = slot + ii + gnx*jj;
    1436:             }
    1437:           }
    1438:         }
    1439:         MatSetValuesBlockedLocal(J,1,&slot,cnt,cols,values,INSERT_VALUES);
    1440:       }
    1441:     }
    1442:     PetscFree(values);
    1443:     MatAssemblyBegin(J,MAT_FINAL_ASSEMBLY);
    1444:     MatAssemblyEnd(J,MAT_FINAL_ASSEMBLY);
    1445:     MatSetOption(J,MAT_NEW_NONZERO_LOCATION_ERR,PETSC_TRUE);
    1446:   }
    1447:   PetscFree(cols);
    1448:   return(0);
    1449: }

    1453: PetscErrorCode DMCreateMatrix_DA_3d_MPIBAIJ(DM da,Mat J)
    1454: {
    1455:   PetscErrorCode         ierr;
    1456:   PetscInt               xs,ys,nx,ny,i,j,slot,gxs,gys,gnx,gny;
    1457:   PetscInt               m,n,dim,s,*cols,k,nc,col,cnt,p,*dnz,*onz;
    1458:   PetscInt               istart,iend,jstart,jend,kstart,kend,zs,nz,gzs,gnz,ii,jj,kk;
    1459:   MPI_Comm               comm;
    1460:   PetscScalar            *values;
    1461:   DMBoundaryType         bx,by,bz;
    1462:   DMDAStencilType        st;
    1463:   ISLocalToGlobalMapping ltog;

    1466:   /*
    1467:          nc - number of components per grid point
    1468:          col - number of colors needed in one direction for single component problem

    1470:   */
    1471:   DMDAGetInfo(da,&dim,&m,&n,&p,0,0,0,&nc,&s,&bx,&by,&bz,&st);
    1472:   col  = 2*s + 1;

    1474:   DMDAGetCorners(da,&xs,&ys,&zs,&nx,&ny,&nz);
    1475:   DMDAGetGhostCorners(da,&gxs,&gys,&gzs,&gnx,&gny,&gnz);
    1476:   PetscObjectGetComm((PetscObject)da,&comm);

    1478:   PetscMalloc1(col*col*col,&cols);

    1480:   DMGetLocalToGlobalMapping(da,&ltog);

    1482:   /* determine the matrix preallocation information */
    1483:   MatPreallocateInitialize(comm,nx*ny*nz,nx*ny*nz,dnz,onz);
    1484:   for (i=xs; i<xs+nx; i++) {
    1485:     istart = (bx == DM_BOUNDARY_PERIODIC) ? -s : (PetscMax(-s,-i));
    1486:     iend   = (bx == DM_BOUNDARY_PERIODIC) ?  s : (PetscMin(s,m-i-1));
    1487:     for (j=ys; j<ys+ny; j++) {
    1488:       jstart = (by == DM_BOUNDARY_PERIODIC) ? -s : (PetscMax(-s,-j));
    1489:       jend   = (by == DM_BOUNDARY_PERIODIC) ?  s : (PetscMin(s,n-j-1));
    1490:       for (k=zs; k<zs+nz; k++) {
    1491:         kstart = (bz == DM_BOUNDARY_PERIODIC) ? -s : (PetscMax(-s,-k));
    1492:         kend   = (bz == DM_BOUNDARY_PERIODIC) ?  s : (PetscMin(s,p-k-1));

    1494:         slot = i - gxs + gnx*(j - gys) + gnx*gny*(k - gzs);

    1496:         /* Find block columns in block row */
    1497:         cnt = 0;
    1498:         for (ii=istart; ii<iend+1; ii++) {
    1499:           for (jj=jstart; jj<jend+1; jj++) {
    1500:             for (kk=kstart; kk<kend+1; kk++) {
    1501:               if ((st == DMDA_STENCIL_BOX) || ((!ii && !jj) || (!jj && !kk) || (!ii && !kk))) {/* entries on star*/
    1502:                 cols[cnt++] = slot + ii + gnx*jj + gnx*gny*kk;
    1503:               }
    1504:             }
    1505:           }
    1506:         }
    1507:         MatPreallocateSetLocalBlock(ltog,1,&slot,ltog,cnt,cols,dnz,onz);
    1508:       }
    1509:     }
    1510:   }
    1511:   MatSeqBAIJSetPreallocation(J,nc,0,dnz);
    1512:   MatMPIBAIJSetPreallocation(J,nc,0,dnz,0,onz);
    1513:   MatPreallocateFinalize(dnz,onz);

    1515:   MatSetLocalToGlobalMapping(J,ltog,ltog);

    1517:   /*
    1518:     For each node in the grid: we get the neighbors in the local (on processor ordering
    1519:     that includes the ghost points) then MatSetValuesLocal() maps those indices to the global
    1520:     PETSc ordering.
    1521:   */
    1522:   if (!da->prealloc_only) {
    1523:     PetscCalloc1(col*col*col*nc*nc,&values);
    1524:     for (i=xs; i<xs+nx; i++) {
    1525:       istart = (bx == DM_BOUNDARY_PERIODIC) ? -s : (PetscMax(-s,-i));
    1526:       iend   = (bx == DM_BOUNDARY_PERIODIC) ?  s : (PetscMin(s,m-i-1));
    1527:       for (j=ys; j<ys+ny; j++) {
    1528:         jstart = (by == DM_BOUNDARY_PERIODIC) ? -s : (PetscMax(-s,-j));
    1529:         jend   = (by == DM_BOUNDARY_PERIODIC) ?  s : (PetscMin(s,n-j-1));
    1530:         for (k=zs; k<zs+nz; k++) {
    1531:           kstart = (bz == DM_BOUNDARY_PERIODIC) ? -s : (PetscMax(-s,-k));
    1532:           kend   = (bz == DM_BOUNDARY_PERIODIC) ?  s : (PetscMin(s,p-k-1));

    1534:           slot = i - gxs + gnx*(j - gys) + gnx*gny*(k - gzs);

    1536:           cnt = 0;
    1537:           for (ii=istart; ii<iend+1; ii++) {
    1538:             for (jj=jstart; jj<jend+1; jj++) {
    1539:               for (kk=kstart; kk<kend+1; kk++) {
    1540:                 if ((st == DMDA_STENCIL_BOX) || ((!ii && !jj) || (!jj && !kk) || (!ii && !kk))) {/* entries on star*/
    1541:                   cols[cnt++] = slot + ii + gnx*jj + gnx*gny*kk;
    1542:                 }
    1543:               }
    1544:             }
    1545:           }
    1546:           MatSetValuesBlockedLocal(J,1,&slot,cnt,cols,values,INSERT_VALUES);
    1547:         }
    1548:       }
    1549:     }
    1550:     PetscFree(values);
    1551:     MatAssemblyBegin(J,MAT_FINAL_ASSEMBLY);
    1552:     MatAssemblyEnd(J,MAT_FINAL_ASSEMBLY);
    1553:     MatSetOption(J,MAT_NEW_NONZERO_LOCATION_ERR,PETSC_TRUE);
    1554:   }
    1555:   PetscFree(cols);
    1556:   return(0);
    1557: }

    1561: /*
    1562:   This helper is for of SBAIJ preallocation, to discard the lower-triangular values which are difficult to
    1563:   identify in the local ordering with periodic domain.
    1564: */
    1565: static PetscErrorCode L2GFilterUpperTriangular(ISLocalToGlobalMapping ltog,PetscInt *row,PetscInt *cnt,PetscInt col[])
    1566: {
    1568:   PetscInt       i,n;

    1571:   ISLocalToGlobalMappingApplyBlock(ltog,1,row,row);
    1572:   ISLocalToGlobalMappingApplyBlock(ltog,*cnt,col,col);
    1573:   for (i=0,n=0; i<*cnt; i++) {
    1574:     if (col[i] >= *row) col[n++] = col[i];
    1575:   }
    1576:   *cnt = n;
    1577:   return(0);
    1578: }

    1582: PetscErrorCode DMCreateMatrix_DA_2d_MPISBAIJ(DM da,Mat J)
    1583: {
    1584:   PetscErrorCode         ierr;
    1585:   PetscInt               xs,ys,nx,ny,i,j,slot,gxs,gys,gnx,gny;
    1586:   PetscInt               m,n,dim,s,*cols,nc,col,cnt,*dnz,*onz;
    1587:   PetscInt               istart,iend,jstart,jend,ii,jj;
    1588:   MPI_Comm               comm;
    1589:   PetscScalar            *values;
    1590:   DMBoundaryType         bx,by;
    1591:   DMDAStencilType        st;
    1592:   ISLocalToGlobalMapping ltog;

    1595:   /*
    1596:      nc - number of components per grid point
    1597:      col - number of colors needed in one direction for single component problem
    1598:   */
    1599:   DMDAGetInfo(da,&dim,&m,&n,0,0,0,0,&nc,&s,&bx,&by,0,&st);
    1600:   col  = 2*s + 1;

    1602:   DMDAGetCorners(da,&xs,&ys,0,&nx,&ny,0);
    1603:   DMDAGetGhostCorners(da,&gxs,&gys,0,&gnx,&gny,0);
    1604:   PetscObjectGetComm((PetscObject)da,&comm);

    1606:   PetscMalloc1(col*col*nc*nc,&cols);

    1608:   DMGetLocalToGlobalMapping(da,&ltog);

    1610:   /* determine the matrix preallocation information */
    1611:   MatPreallocateInitialize(comm,nx*ny,nx*ny,dnz,onz);
    1612:   for (i=xs; i<xs+nx; i++) {
    1613:     istart = (bx == DM_BOUNDARY_PERIODIC) ? -s : (PetscMax(-s,-i));
    1614:     iend   = (bx == DM_BOUNDARY_PERIODIC) ?  s : (PetscMin(s,m-i-1));
    1615:     for (j=ys; j<ys+ny; j++) {
    1616:       jstart = (by == DM_BOUNDARY_PERIODIC) ? -s : (PetscMax(-s,-j));
    1617:       jend   = (by == DM_BOUNDARY_PERIODIC) ?  s : (PetscMin(s,n-j-1));
    1618:       slot   = i - gxs + gnx*(j - gys);

    1620:       /* Find block columns in block row */
    1621:       cnt = 0;
    1622:       for (ii=istart; ii<iend+1; ii++) {
    1623:         for (jj=jstart; jj<jend+1; jj++) {
    1624:           if (st == DMDA_STENCIL_BOX || !ii || !jj) {
    1625:             cols[cnt++] = slot + ii + gnx*jj;
    1626:           }
    1627:         }
    1628:       }
    1629:       L2GFilterUpperTriangular(ltog,&slot,&cnt,cols);
    1630:       MatPreallocateSymmetricSetBlock(slot,cnt,cols,dnz,onz);
    1631:     }
    1632:   }
    1633:   MatSeqSBAIJSetPreallocation(J,nc,0,dnz);
    1634:   MatMPISBAIJSetPreallocation(J,nc,0,dnz,0,onz);
    1635:   MatPreallocateFinalize(dnz,onz);

    1637:   MatSetLocalToGlobalMapping(J,ltog,ltog);

    1639:   /*
    1640:     For each node in the grid: we get the neighbors in the local (on processor ordering
    1641:     that includes the ghost points) then MatSetValuesLocal() maps those indices to the global
    1642:     PETSc ordering.
    1643:   */
    1644:   if (!da->prealloc_only) {
    1645:     PetscCalloc1(col*col*nc*nc,&values);
    1646:     for (i=xs; i<xs+nx; i++) {
    1647:       istart = (bx == DM_BOUNDARY_PERIODIC) ? -s : (PetscMax(-s,-i));
    1648:       iend   = (bx == DM_BOUNDARY_PERIODIC) ?  s : (PetscMin(s,m-i-1));
    1649:       for (j=ys; j<ys+ny; j++) {
    1650:         jstart = (by == DM_BOUNDARY_PERIODIC) ? -s : (PetscMax(-s,-j));
    1651:         jend   = (by == DM_BOUNDARY_PERIODIC) ?  s : (PetscMin(s,n-j-1));
    1652:         slot   = i - gxs + gnx*(j - gys);

    1654:         /* Find block columns in block row */
    1655:         cnt = 0;
    1656:         for (ii=istart; ii<iend+1; ii++) {
    1657:           for (jj=jstart; jj<jend+1; jj++) {
    1658:             if (st == DMDA_STENCIL_BOX || !ii || !jj) {
    1659:               cols[cnt++] = slot + ii + gnx*jj;
    1660:             }
    1661:           }
    1662:         }
    1663:         L2GFilterUpperTriangular(ltog,&slot,&cnt,cols);
    1664:         MatSetValuesBlocked(J,1,&slot,cnt,cols,values,INSERT_VALUES);
    1665:       }
    1666:     }
    1667:     PetscFree(values);
    1668:     MatAssemblyBegin(J,MAT_FINAL_ASSEMBLY);
    1669:     MatAssemblyEnd(J,MAT_FINAL_ASSEMBLY);
    1670:     MatSetOption(J,MAT_NEW_NONZERO_LOCATION_ERR,PETSC_TRUE);
    1671:   }
    1672:   PetscFree(cols);
    1673:   return(0);
    1674: }

    1678: PetscErrorCode DMCreateMatrix_DA_3d_MPISBAIJ(DM da,Mat J)
    1679: {
    1680:   PetscErrorCode         ierr;
    1681:   PetscInt               xs,ys,nx,ny,i,j,slot,gxs,gys,gnx,gny;
    1682:   PetscInt               m,n,dim,s,*cols,k,nc,col,cnt,p,*dnz,*onz;
    1683:   PetscInt               istart,iend,jstart,jend,kstart,kend,zs,nz,gzs,gnz,ii,jj,kk;
    1684:   MPI_Comm               comm;
    1685:   PetscScalar            *values;
    1686:   DMBoundaryType         bx,by,bz;
    1687:   DMDAStencilType        st;
    1688:   ISLocalToGlobalMapping ltog;

    1691:   /*
    1692:      nc - number of components per grid point
    1693:      col - number of colors needed in one direction for single component problem
    1694:   */
    1695:   DMDAGetInfo(da,&dim,&m,&n,&p,0,0,0,&nc,&s,&bx,&by,&bz,&st);
    1696:   col  = 2*s + 1;

    1698:   DMDAGetCorners(da,&xs,&ys,&zs,&nx,&ny,&nz);
    1699:   DMDAGetGhostCorners(da,&gxs,&gys,&gzs,&gnx,&gny,&gnz);
    1700:   PetscObjectGetComm((PetscObject)da,&comm);

    1702:   /* create the matrix */
    1703:   PetscMalloc1(col*col*col,&cols);

    1705:   DMGetLocalToGlobalMapping(da,&ltog);

    1707:   /* determine the matrix preallocation information */
    1708:   MatPreallocateInitialize(comm,nx*ny*nz,nx*ny*nz,dnz,onz);
    1709:   for (i=xs; i<xs+nx; i++) {
    1710:     istart = (bx == DM_BOUNDARY_PERIODIC) ? -s : (PetscMax(-s,-i));
    1711:     iend   = (bx == DM_BOUNDARY_PERIODIC) ?  s : (PetscMin(s,m-i-1));
    1712:     for (j=ys; j<ys+ny; j++) {
    1713:       jstart = (by == DM_BOUNDARY_PERIODIC) ? -s : (PetscMax(-s,-j));
    1714:       jend   = (by == DM_BOUNDARY_PERIODIC) ?  s : (PetscMin(s,n-j-1));
    1715:       for (k=zs; k<zs+nz; k++) {
    1716:         kstart = (bz == DM_BOUNDARY_PERIODIC) ? -s : (PetscMax(-s,-k));
    1717:         kend   = (bz == DM_BOUNDARY_PERIODIC) ?  s : (PetscMin(s,p-k-1));

    1719:         slot = i - gxs + gnx*(j - gys) + gnx*gny*(k - gzs);

    1721:         /* Find block columns in block row */
    1722:         cnt = 0;
    1723:         for (ii=istart; ii<iend+1; ii++) {
    1724:           for (jj=jstart; jj<jend+1; jj++) {
    1725:             for (kk=kstart; kk<kend+1; kk++) {
    1726:               if ((st == DMDA_STENCIL_BOX) || (!ii && !jj) || (!jj && !kk) || (!ii && !kk)) {
    1727:                 cols[cnt++] = slot + ii + gnx*jj + gnx*gny*kk;
    1728:               }
    1729:             }
    1730:           }
    1731:         }
    1732:         L2GFilterUpperTriangular(ltog,&slot,&cnt,cols);
    1733:         MatPreallocateSymmetricSetBlock(slot,cnt,cols,dnz,onz);
    1734:       }
    1735:     }
    1736:   }
    1737:   MatSeqSBAIJSetPreallocation(J,nc,0,dnz);
    1738:   MatMPISBAIJSetPreallocation(J,nc,0,dnz,0,onz);
    1739:   MatPreallocateFinalize(dnz,onz);

    1741:   MatSetLocalToGlobalMapping(J,ltog,ltog);

    1743:   /*
    1744:     For each node in the grid: we get the neighbors in the local (on processor ordering
    1745:     that includes the ghost points) then MatSetValuesLocal() maps those indices to the global
    1746:     PETSc ordering.
    1747:   */
    1748:   if (!da->prealloc_only) {
    1749:     PetscCalloc1(col*col*col*nc*nc,&values);
    1750:     for (i=xs; i<xs+nx; i++) {
    1751:       istart = (bx == DM_BOUNDARY_PERIODIC) ? -s : (PetscMax(-s,-i));
    1752:       iend   = (bx == DM_BOUNDARY_PERIODIC) ?  s : (PetscMin(s,m-i-1));
    1753:       for (j=ys; j<ys+ny; j++) {
    1754:         jstart = (by == DM_BOUNDARY_PERIODIC) ? -s : (PetscMax(-s,-j));
    1755:         jend   = (by == DM_BOUNDARY_PERIODIC) ?  s : (PetscMin(s,n-j-1));
    1756:         for (k=zs; k<zs+nz; k++) {
    1757:           kstart = (bz == DM_BOUNDARY_PERIODIC) ? -s : (PetscMax(-s,-k));
    1758:           kend   = (bz == DM_BOUNDARY_PERIODIC) ?  s : (PetscMin(s,p-k-1));

    1760:           slot = i - gxs + gnx*(j - gys) + gnx*gny*(k - gzs);

    1762:           cnt = 0;
    1763:           for (ii=istart; ii<iend+1; ii++) {
    1764:             for (jj=jstart; jj<jend+1; jj++) {
    1765:               for (kk=kstart; kk<kend+1; kk++) {
    1766:                 if ((st == DMDA_STENCIL_BOX) || (!ii && !jj) || (!jj && !kk) || (!ii && !kk)) {
    1767:                   cols[cnt++] = slot + ii + gnx*jj + gnx*gny*kk;
    1768:                 }
    1769:               }
    1770:             }
    1771:           }
    1772:           L2GFilterUpperTriangular(ltog,&slot,&cnt,cols);
    1773:           MatSetValuesBlocked(J,1,&slot,cnt,cols,values,INSERT_VALUES);
    1774:         }
    1775:       }
    1776:     }
    1777:     PetscFree(values);
    1778:     MatAssemblyBegin(J,MAT_FINAL_ASSEMBLY);
    1779:     MatAssemblyEnd(J,MAT_FINAL_ASSEMBLY);
    1780:     MatSetOption(J,MAT_NEW_NONZERO_LOCATION_ERR,PETSC_TRUE);
    1781:   }
    1782:   PetscFree(cols);
    1783:   return(0);
    1784: }

    1786: /* ---------------------------------------------------------------------------------*/

    1790: PetscErrorCode DMCreateMatrix_DA_3d_MPIAIJ_Fill(DM da,Mat J)
    1791: {
    1792:   PetscErrorCode         ierr;
    1793:   PetscInt               xs,ys,nx,ny,i,j,slot,gxs,gys,gnx,gny;
    1794:   PetscInt               m,n,dim,s,*cols,k,nc,row,col,cnt, maxcnt = 0,l,p,*dnz,*onz;
    1795:   PetscInt               istart,iend,jstart,jend,kstart,kend,zs,nz,gzs,gnz,ii,jj,kk;
    1796:   DM_DA                  *dd = (DM_DA*)da->data;
    1797:   PetscInt               ifill_col,*dfill = dd->dfill,*ofill = dd->ofill;
    1798:   MPI_Comm               comm;
    1799:   PetscScalar            *values;
    1800:   DMBoundaryType         bx,by,bz;
    1801:   ISLocalToGlobalMapping ltog;
    1802:   DMDAStencilType        st;

    1805:   /*
    1806:          nc - number of components per grid point
    1807:          col - number of colors needed in one direction for single component problem

    1809:   */
    1810:   DMDAGetInfo(da,&dim,&m,&n,&p,0,0,0,&nc,&s,&bx,&by,&bz,&st);
    1811:   col  = 2*s + 1;
    1812:   if (bx == DM_BOUNDARY_PERIODIC && (m % col)) SETERRQ(PetscObjectComm((PetscObject)da),PETSC_ERR_SUP,"For coloring efficiency ensure number of grid points in X is divisible\n\
    1813:                  by 2*stencil_width + 1\n");
    1814:   if (by == DM_BOUNDARY_PERIODIC && (n % col)) SETERRQ(PetscObjectComm((PetscObject)da),PETSC_ERR_SUP,"For coloring efficiency ensure number of grid points in Y is divisible\n\
    1815:                  by 2*stencil_width + 1\n");
    1816:   if (bz == DM_BOUNDARY_PERIODIC && (p % col)) SETERRQ(PetscObjectComm((PetscObject)da),PETSC_ERR_SUP,"For coloring efficiency ensure number of grid points in Z is divisible\n\
    1817:                  by 2*stencil_width + 1\n");

    1819:   DMDAGetCorners(da,&xs,&ys,&zs,&nx,&ny,&nz);
    1820:   DMDAGetGhostCorners(da,&gxs,&gys,&gzs,&gnx,&gny,&gnz);
    1821:   PetscObjectGetComm((PetscObject)da,&comm);

    1823:   PetscMalloc1(col*col*col*nc,&cols);
    1824:   DMGetLocalToGlobalMapping(da,&ltog);

    1826:   /* determine the matrix preallocation information */
    1827:   MatPreallocateInitialize(comm,nc*nx*ny*nz,nc*nx*ny*nz,dnz,onz);

    1829:   MatSetBlockSize(J,nc);
    1830:   for (i=xs; i<xs+nx; i++) {
    1831:     istart = (bx == DM_BOUNDARY_PERIODIC) ? -s : (PetscMax(-s,-i));
    1832:     iend   = (bx == DM_BOUNDARY_PERIODIC) ?  s : (PetscMin(s,m-i-1));
    1833:     for (j=ys; j<ys+ny; j++) {
    1834:       jstart = (by == DM_BOUNDARY_PERIODIC) ? -s : (PetscMax(-s,-j));
    1835:       jend   = (by == DM_BOUNDARY_PERIODIC) ?  s : (PetscMin(s,n-j-1));
    1836:       for (k=zs; k<zs+nz; k++) {
    1837:         kstart = (bz == DM_BOUNDARY_PERIODIC) ? -s : (PetscMax(-s,-k));
    1838:         kend   = (bz == DM_BOUNDARY_PERIODIC) ?  s : (PetscMin(s,p-k-1));

    1840:         slot = i - gxs + gnx*(j - gys) + gnx*gny*(k - gzs);

    1842:         for (l=0; l<nc; l++) {
    1843:           cnt = 0;
    1844:           for (ii=istart; ii<iend+1; ii++) {
    1845:             for (jj=jstart; jj<jend+1; jj++) {
    1846:               for (kk=kstart; kk<kend+1; kk++) {
    1847:                 if (ii || jj || kk) {
    1848:                   if ((st == DMDA_STENCIL_BOX) || ((!ii && !jj) || (!jj && !kk) || (!ii && !kk))) {/* entries on star*/
    1849:                     for (ifill_col=ofill[l]; ifill_col<ofill[l+1]; ifill_col++) cols[cnt++] = ofill[ifill_col] + nc*(slot + ii + gnx*jj + gnx*gny*kk);
    1850:                   }
    1851:                 } else {
    1852:                   if (dfill) {
    1853:                     for (ifill_col=dfill[l]; ifill_col<dfill[l+1]; ifill_col++) cols[cnt++] = dfill[ifill_col] + nc*(slot + ii + gnx*jj + gnx*gny*kk);
    1854:                   } else {
    1855:                     for (ifill_col=0; ifill_col<nc; ifill_col++) cols[cnt++] = ifill_col + nc*(slot + ii + gnx*jj + gnx*gny*kk);
    1856:                   }
    1857:                 }
    1858:               }
    1859:             }
    1860:           }
    1861:           row  = l + nc*(slot);
    1862:           maxcnt = PetscMax(maxcnt,cnt);
    1863:           MatPreallocateSetLocal(ltog,1,&row,ltog,cnt,cols,dnz,onz);
    1864:         }
    1865:       }
    1866:     }
    1867:   }
    1868:   MatSeqAIJSetPreallocation(J,0,dnz);
    1869:   MatMPIAIJSetPreallocation(J,0,dnz,0,onz);
    1870:   MatPreallocateFinalize(dnz,onz);
    1871:   MatSetLocalToGlobalMapping(J,ltog,ltog);

    1873:   /*
    1874:     For each node in the grid: we get the neighbors in the local (on processor ordering
    1875:     that includes the ghost points) then MatSetValuesLocal() maps those indices to the global
    1876:     PETSc ordering.
    1877:   */
    1878:   if (!da->prealloc_only) {
    1879:     PetscCalloc1(maxcnt,&values);
    1880:     for (i=xs; i<xs+nx; i++) {
    1881:       istart = (bx == DM_BOUNDARY_PERIODIC) ? -s : (PetscMax(-s,-i));
    1882:       iend   = (bx == DM_BOUNDARY_PERIODIC) ?  s : (PetscMin(s,m-i-1));
    1883:       for (j=ys; j<ys+ny; j++) {
    1884:         jstart = (by == DM_BOUNDARY_PERIODIC) ? -s : (PetscMax(-s,-j));
    1885:         jend   = (by == DM_BOUNDARY_PERIODIC) ?  s : (PetscMin(s,n-j-1));
    1886:         for (k=zs; k<zs+nz; k++) {
    1887:           kstart = (bz == DM_BOUNDARY_PERIODIC) ? -s : (PetscMax(-s,-k));
    1888:           kend   = (bz == DM_BOUNDARY_PERIODIC) ?  s : (PetscMin(s,p-k-1));

    1890:           slot = i - gxs + gnx*(j - gys) + gnx*gny*(k - gzs);

    1892:           for (l=0; l<nc; l++) {
    1893:             cnt = 0;
    1894:             for (ii=istart; ii<iend+1; ii++) {
    1895:               for (jj=jstart; jj<jend+1; jj++) {
    1896:                 for (kk=kstart; kk<kend+1; kk++) {
    1897:                   if (ii || jj || kk) {
    1898:                     if ((st == DMDA_STENCIL_BOX) || ((!ii && !jj) || (!jj && !kk) || (!ii && !kk))) {/* entries on star*/
    1899:                       for (ifill_col=ofill[l]; ifill_col<ofill[l+1]; ifill_col++) cols[cnt++] = ofill[ifill_col] + nc*(slot + ii + gnx*jj + gnx*gny*kk);
    1900:                     }
    1901:                   } else {
    1902:                     if (dfill) {
    1903:                       for (ifill_col=dfill[l]; ifill_col<dfill[l+1]; ifill_col++) cols[cnt++] = dfill[ifill_col] + nc*(slot + ii + gnx*jj + gnx*gny*kk);
    1904:                     } else {
    1905:                       for (ifill_col=0; ifill_col<nc; ifill_col++) cols[cnt++] = ifill_col + nc*(slot + ii + gnx*jj + gnx*gny*kk);
    1906:                     }
    1907:                   }
    1908:                 }
    1909:               }
    1910:             }
    1911:             row  = l + nc*(slot);
    1912:             MatSetValuesLocal(J,1,&row,cnt,cols,values,INSERT_VALUES);
    1913:           }
    1914:         }
    1915:       }
    1916:     }
    1917:     PetscFree(values);
    1918:     MatAssemblyBegin(J,MAT_FINAL_ASSEMBLY);
    1919:     MatAssemblyEnd(J,MAT_FINAL_ASSEMBLY);
    1920:     MatSetOption(J,MAT_NEW_NONZERO_LOCATION_ERR,PETSC_TRUE);
    1921:   }
    1922:   PetscFree(cols);
    1923:   return(0);
    1924: }