Actual source code: sbaij.c

  1: /*$Id: sbaij.c,v 1.62 2001/08/07 03:03:01 balay Exp $*/

  3: /*
  4:     Defines the basic matrix operations for the SBAIJ (compressed row)
  5:   matrix storage format.
  6: */
 7:  #include src/mat/impls/baij/seq/baij.h
 8:  #include src/vec/vecimpl.h
 9:  #include src/inline/spops.h
 10:  #include src/mat/impls/sbaij/seq/sbaij.h

 12: #define CHUNKSIZE  10

 14: /*
 15:      Checks for missing diagonals
 16: */
 19: int MatMissingDiagonal_SeqSBAIJ(Mat A)
 20: {
 21:   Mat_SeqSBAIJ *a = (Mat_SeqSBAIJ*)A->data;
 22:   int         *diag,*jj = a->j,i,ierr;

 25:   MatMarkDiagonal_SeqSBAIJ(A);
 26:   diag = a->diag;
 27:   for (i=0; i<a->mbs; i++) {
 28:     if (jj[diag[i]] != i) SETERRQ1(1,"Matrix is missing diagonal number %d",i);
 29:   }
 30:   return(0);
 31: }

 35: int MatMarkDiagonal_SeqSBAIJ(Mat A)
 36: {
 37:   Mat_SeqSBAIJ *a = (Mat_SeqSBAIJ*)A->data;
 38:   int          i,mbs = a->mbs,ierr;

 41:   if (a->diag) return(0);

 43:   PetscMalloc((mbs+1)*sizeof(int),&a->diag);
 44:   PetscLogObjectMemory(A,(mbs+1)*sizeof(int));
 45:   for (i=0; i<mbs; i++) a->diag[i] = a->i[i];
 46:   return(0);
 47: }

 51: static int MatGetRowIJ_SeqSBAIJ(Mat A,int oshift,PetscTruth symmetric,int *nn,int *ia[],int *ja[],PetscTruth *done)
 52: {
 53:   Mat_SeqSBAIJ *a = (Mat_SeqSBAIJ*)A->data;
 54:   int         n = a->mbs,i;

 57:   *nn = n;
 58:   if (!ia) return(0);

 60:   if (oshift == 1) {
 61:     /* temporarily add 1 to i and j indices */
 62:     int s_nz = a->i[n];
 63:     for (i=0; i<s_nz; i++) a->j[i]++;
 64:     for (i=0; i<n+1; i++) a->i[i]++;
 65:     *ia = a->i; *ja = a->j;
 66:   } else {
 67:     *ia = a->i; *ja = a->j;
 68:   }
 69:   return(0);
 70: }

 74: static int MatRestoreRowIJ_SeqSBAIJ(Mat A,int oshift,PetscTruth symmetric,int *nn,int *ia[],int *ja[],PetscTruth *done)
 75: {
 76:   Mat_SeqSBAIJ *a = (Mat_SeqSBAIJ*)A->data;
 77:   int         i,n = a->mbs;

 80:   if (!ia) return(0);

 82:   if (oshift == 1) {
 83:     int s_nz = a->i[n]-1;
 84:     for (i=0; i<s_nz; i++) a->j[i]--;
 85:     for (i=0; i<n+1; i++) a->i[i]--;
 86:   }
 87:   return(0);
 88: }

 92: int MatGetBlockSize_SeqSBAIJ(Mat mat,int *bs)
 93: {
 94:   Mat_SeqSBAIJ *sbaij = (Mat_SeqSBAIJ*)mat->data;

 97:   *bs = sbaij->bs;
 98:   return(0);
 99: }

103: int MatDestroy_SeqSBAIJ(Mat A)
104: {
105:   Mat_SeqSBAIJ *a = (Mat_SeqSBAIJ*)A->data;
106:   int         ierr;

109: #if defined(PETSC_USE_LOG)
110:   PetscLogObjectState((PetscObject)A,"Rows=%d, s_NZ=%d",A->m,a->s_nz);
111: #endif
112:   PetscFree(a->a);
113:   if (!a->singlemalloc) {
114:     PetscFree(a->i);
115:     PetscFree(a->j);
116:   }
117:   if (a->row) {
118:     ISDestroy(a->row);
119:   }
120:   if (a->diag) {PetscFree(a->diag);}
121:   if (a->ilen) {PetscFree(a->ilen);}
122:   if (a->imax) {PetscFree(a->imax);}
123:   if (a->icol) {ISDestroy(a->icol);}
124:   if (a->solve_work)  {PetscFree(a->solve_work);}
125:   if (a->solves_work) {PetscFree(a->solves_work);}
126:   if (a->mult_work)   {PetscFree(a->mult_work);}
127:   if (a->saved_values) {PetscFree(a->saved_values);}
128:   if (a->xtoy) {PetscFree(a->xtoy);}

130:   if (a->inew){
131:     PetscFree(a->inew);
132:     a->inew = 0;
133:   }
134:   PetscFree(a);
135:   return(0);
136: }

140: int MatSetOption_SeqSBAIJ(Mat A,MatOption op)
141: {
142:   Mat_SeqSBAIJ *a = (Mat_SeqSBAIJ*)A->data;

145:   switch (op) {
146:   case MAT_ROW_ORIENTED:
147:     a->roworiented    = PETSC_TRUE;
148:     break;
149:   case MAT_COLUMN_ORIENTED:
150:     a->roworiented    = PETSC_FALSE;
151:     break;
152:   case MAT_COLUMNS_SORTED:
153:     a->sorted         = PETSC_TRUE;
154:     break;
155:   case MAT_COLUMNS_UNSORTED:
156:     a->sorted         = PETSC_FALSE;
157:     break;
158:   case MAT_KEEP_ZEROED_ROWS:
159:     a->keepzeroedrows = PETSC_TRUE;
160:     break;
161:   case MAT_NO_NEW_NONZERO_LOCATIONS:
162:     a->nonew          = 1;
163:     break;
164:   case MAT_NEW_NONZERO_LOCATION_ERR:
165:     a->nonew          = -1;
166:     break;
167:   case MAT_NEW_NONZERO_ALLOCATION_ERR:
168:     a->nonew          = -2;
169:     break;
170:   case MAT_YES_NEW_NONZERO_LOCATIONS:
171:     a->nonew          = 0;
172:     break;
173:   case MAT_ROWS_SORTED:
174:   case MAT_ROWS_UNSORTED:
175:   case MAT_YES_NEW_DIAGONALS:
176:   case MAT_IGNORE_OFF_PROC_ENTRIES:
177:   case MAT_USE_HASH_TABLE:
178:     PetscLogInfo(A,"MatSetOption_SeqSBAIJ:Option ignored\n");
179:     break;
180:   case MAT_NO_NEW_DIAGONALS:
181:     SETERRQ(PETSC_ERR_SUP,"MAT_NO_NEW_DIAGONALS");
182:   default:
183:     SETERRQ(PETSC_ERR_SUP,"unknown option");
184:   }
185:   return(0);
186: }

190: int MatGetRow_SeqSBAIJ(Mat A,int row,int *ncols,int **cols,PetscScalar **v)
191: {
192:   Mat_SeqSBAIJ  *a = (Mat_SeqSBAIJ*)A->data;
193:   int          itmp,i,j,k,M,*ai,*aj,bs,bn,bp,*cols_i,bs2,ierr;
194:   MatScalar    *aa,*aa_i;
195:   PetscScalar  *v_i;

198:   bs  = a->bs;
199:   ai  = a->i;
200:   aj  = a->j;
201:   aa  = a->a;
202:   bs2 = a->bs2;
203: 
204:   if (row < 0 || row >= A->m) SETERRQ1(PETSC_ERR_ARG_OUTOFRANGE, "Row %d out of range", row);
205: 
206:   bn  = row/bs;   /* Block number */
207:   bp  = row % bs; /* Block position */
208:   M   = ai[bn+1] - ai[bn];
209:   *ncols = bs*M;
210: 
211:   if (v) {
212:     *v = 0;
213:     if (*ncols) {
214:       PetscMalloc((*ncols+row)*sizeof(PetscScalar),v);
215:       for (i=0; i<M; i++) { /* for each block in the block row */
216:         v_i  = *v + i*bs;
217:         aa_i = aa + bs2*(ai[bn] + i);
218:         for (j=bp,k=0; j<bs2; j+=bs,k++) {v_i[k] = aa_i[j];}
219:       }
220:     }
221:   }

223:   if (cols) {
224:     *cols = 0;
225:     if (*ncols) {
226:       PetscMalloc((*ncols+row)*sizeof(int),cols);
227:       for (i=0; i<M; i++) { /* for each block in the block row */
228:         cols_i = *cols + i*bs;
229:         itmp  = bs*aj[ai[bn] + i];
230:         for (j=0; j<bs; j++) {cols_i[j] = itmp++;}
231:       }
232:     }
233:   }

235:   /*search column A(0:row-1,row) (=A(row,0:row-1)). Could be expensive! */
236:   /* this segment is currently removed, so only entries in the upper triangle are obtained */
237: #ifdef column_search
238:   v_i    = *v    + M*bs;
239:   cols_i = *cols + M*bs;
240:   for (i=0; i<bn; i++){ /* for each block row */
241:     M = ai[i+1] - ai[i];
242:     for (j=0; j<M; j++){
243:       itmp = aj[ai[i] + j];    /* block column value */
244:       if (itmp == bn){
245:         aa_i   = aa    + bs2*(ai[i] + j) + bs*bp;
246:         for (k=0; k<bs; k++) {
247:           *cols_i++ = i*bs+k;
248:           *v_i++    = aa_i[k];
249:         }
250:         *ncols += bs;
251:         break;
252:       }
253:     }
254:   }
255: #endif

257:   return(0);
258: }

262: int MatRestoreRow_SeqSBAIJ(Mat A,int row,int *nz,int **idx,PetscScalar **v)
263: {

267:   if (idx) {if (*idx) {PetscFree(*idx);}}
268:   if (v)   {if (*v)   {PetscFree(*v);}}
269:   return(0);
270: }

274: int MatTranspose_SeqSBAIJ(Mat A,Mat *B)
275: {
278:   MatDuplicate(A,MAT_COPY_VALUES,B);
279:   return(0);
280: }

284: static int MatView_SeqSBAIJ_Binary(Mat A,PetscViewer viewer)
285: {
286:   Mat_SeqSBAIJ *a = (Mat_SeqSBAIJ*)A->data;
287:   int          i,fd,*col_lens,ierr,bs = a->bs,count,*jj,j,k,l,bs2=a->bs2;
288:   PetscScalar  *aa;
289:   FILE         *file;

292:   PetscViewerBinaryGetDescriptor(viewer,&fd);
293:   PetscMalloc((4+A->m)*sizeof(int),&col_lens);
294:   col_lens[0] = MAT_FILE_COOKIE;

296:   col_lens[1] = A->m;
297:   col_lens[2] = A->m;
298:   col_lens[3] = a->s_nz*bs2;

300:   /* store lengths of each row and write (including header) to file */
301:   count = 0;
302:   for (i=0; i<a->mbs; i++) {
303:     for (j=0; j<bs; j++) {
304:       col_lens[4+count++] = bs*(a->i[i+1] - a->i[i]);
305:     }
306:   }
307:   PetscBinaryWrite(fd,col_lens,4+A->m,PETSC_INT,1);
308:   PetscFree(col_lens);

310:   /* store column indices (zero start index) */
311:   PetscMalloc((a->s_nz+1)*bs2*sizeof(int),&jj);
312:   count = 0;
313:   for (i=0; i<a->mbs; i++) {
314:     for (j=0; j<bs; j++) {
315:       for (k=a->i[i]; k<a->i[i+1]; k++) {
316:         for (l=0; l<bs; l++) {
317:           jj[count++] = bs*a->j[k] + l;
318:         }
319:       }
320:     }
321:   }
322:   PetscBinaryWrite(fd,jj,bs2*a->s_nz,PETSC_INT,0);
323:   PetscFree(jj);

325:   /* store nonzero values */
326:   PetscMalloc((a->s_nz+1)*bs2*sizeof(PetscScalar),&aa);
327:   count = 0;
328:   for (i=0; i<a->mbs; i++) {
329:     for (j=0; j<bs; j++) {
330:       for (k=a->i[i]; k<a->i[i+1]; k++) {
331:         for (l=0; l<bs; l++) {
332:           aa[count++] = a->a[bs2*k + l*bs + j];
333:         }
334:       }
335:     }
336:   }
337:   PetscBinaryWrite(fd,aa,bs2*a->s_nz,PETSC_SCALAR,0);
338:   PetscFree(aa);

340:   PetscViewerBinaryGetInfoPointer(viewer,&file);
341:   if (file) {
342:     fprintf(file,"-matload_block_size %d\n",a->bs);
343:   }
344:   return(0);
345: }

349: static int MatView_SeqSBAIJ_ASCII(Mat A,PetscViewer viewer)
350: {
351:   Mat_SeqSBAIJ      *a = (Mat_SeqSBAIJ*)A->data;
352:   int               ierr,i,j,bs = a->bs,k,l,bs2=a->bs2;
353:   char              *name;
354:   PetscViewerFormat format;

357:   PetscObjectGetName((PetscObject)A,&name);
358:   PetscViewerGetFormat(viewer,&format);
359:   if (format == PETSC_VIEWER_ASCII_INFO || format == PETSC_VIEWER_ASCII_INFO_DETAIL) {
360:     PetscViewerASCIIPrintf(viewer,"  block size is %d\n",bs);
361:   } else if (format == PETSC_VIEWER_ASCII_MATLAB) {
362:     SETERRQ(PETSC_ERR_SUP,"Matlab format not supported");
363:   } else if (format == PETSC_VIEWER_ASCII_COMMON) {
364:     PetscViewerASCIIUseTabs(viewer,PETSC_NO);
365:     for (i=0; i<a->mbs; i++) {
366:       for (j=0; j<bs; j++) {
367:         PetscViewerASCIIPrintf(viewer,"row %d:",i*bs+j);
368:         for (k=a->i[i]; k<a->i[i+1]; k++) {
369:           for (l=0; l<bs; l++) {
370: #if defined(PETSC_USE_COMPLEX)
371:             if (PetscImaginaryPart(a->a[bs2*k + l*bs + j]) > 0.0 && PetscRealPart(a->a[bs2*k + l*bs + j]) != 0.0) {
372:               PetscViewerASCIIPrintf(viewer," (%d, %g + %g i) ",bs*a->j[k]+l,
373:                       PetscRealPart(a->a[bs2*k + l*bs + j]),PetscImaginaryPart(a->a[bs2*k + l*bs + j]));
374:             } else if (PetscImaginaryPart(a->a[bs2*k + l*bs + j]) < 0.0 && PetscRealPart(a->a[bs2*k + l*bs + j]) != 0.0) {
375:               PetscViewerASCIIPrintf(viewer," (%d, %g - %g i) ",bs*a->j[k]+l,
376:                       PetscRealPart(a->a[bs2*k + l*bs + j]),-PetscImaginaryPart(a->a[bs2*k + l*bs + j]));
377:             } else if (PetscRealPart(a->a[bs2*k + l*bs + j]) != 0.0) {
378:               PetscViewerASCIIPrintf(viewer," (%d, %g) ",bs*a->j[k]+l,PetscRealPart(a->a[bs2*k + l*bs + j]));
379:             }
380: #else
381:             if (a->a[bs2*k + l*bs + j] != 0.0) {
382:               PetscViewerASCIIPrintf(viewer," (%d, %g) ",bs*a->j[k]+l,a->a[bs2*k + l*bs + j]);
383:             }
384: #endif
385:           }
386:         }
387:         PetscViewerASCIIPrintf(viewer,"\n");
388:       }
389:     }
390:     PetscViewerASCIIUseTabs(viewer,PETSC_YES);
391:   } else {
392:     PetscViewerASCIIUseTabs(viewer,PETSC_NO);
393:     for (i=0; i<a->mbs; i++) {
394:       for (j=0; j<bs; j++) {
395:         PetscViewerASCIIPrintf(viewer,"row %d:",i*bs+j);
396:         for (k=a->i[i]; k<a->i[i+1]; k++) {
397:           for (l=0; l<bs; l++) {
398: #if defined(PETSC_USE_COMPLEX)
399:             if (PetscImaginaryPart(a->a[bs2*k + l*bs + j]) > 0.0) {
400:               PetscViewerASCIIPrintf(viewer," (%d, %g + %g i) ",bs*a->j[k]+l,
401:                 PetscRealPart(a->a[bs2*k + l*bs + j]),PetscImaginaryPart(a->a[bs2*k + l*bs + j]));
402:             } else if (PetscImaginaryPart(a->a[bs2*k + l*bs + j]) < 0.0) {
403:               PetscViewerASCIIPrintf(viewer," (%d, %g - %g i) ",bs*a->j[k]+l,
404:                 PetscRealPart(a->a[bs2*k + l*bs + j]),-PetscImaginaryPart(a->a[bs2*k + l*bs + j]));
405:             } else {
406:               PetscViewerASCIIPrintf(viewer," (%d, %g) ",bs*a->j[k]+l,PetscRealPart(a->a[bs2*k + l*bs + j]));
407:             }
408: #else
409:             PetscViewerASCIIPrintf(viewer," %d %g ",bs*a->j[k]+l,a->a[bs2*k + l*bs + j]);
410: #endif
411:           }
412:         }
413:         PetscViewerASCIIPrintf(viewer,"\n");
414:       }
415:     }
416:     PetscViewerASCIIUseTabs(viewer,PETSC_YES);
417:   }
418:   PetscViewerFlush(viewer);
419:   return(0);
420: }

424: static int MatView_SeqSBAIJ_Draw_Zoom(PetscDraw draw,void *Aa)
425: {
426:   Mat          A = (Mat) Aa;
427:   Mat_SeqSBAIJ *a=(Mat_SeqSBAIJ*)A->data;
428:   int          row,ierr,i,j,k,l,mbs=a->mbs,color,bs=a->bs,bs2=a->bs2,rank;
429:   PetscReal    xl,yl,xr,yr,x_l,x_r,y_l,y_r;
430:   MatScalar    *aa;
431:   MPI_Comm     comm;
432:   PetscViewer  viewer;

435:   /*
436:       This is nasty. If this is called from an originally parallel matrix
437:    then all processes call this,but only the first has the matrix so the
438:    rest should return immediately.
439:   */
440:   PetscObjectGetComm((PetscObject)draw,&comm);
441:   MPI_Comm_rank(comm,&rank);
442:   if (rank) return(0);

444:   PetscObjectQuery((PetscObject)A,"Zoomviewer",(PetscObject*)&viewer);

446:   PetscDrawGetCoordinates(draw,&xl,&yl,&xr,&yr);
447:   PetscDrawString(draw, .3*(xl+xr), .3*(yl+yr), PETSC_DRAW_BLACK, "symmetric");

449:   /* loop over matrix elements drawing boxes */
450:   color = PETSC_DRAW_BLUE;
451:   for (i=0,row=0; i<mbs; i++,row+=bs) {
452:     for (j=a->i[i]; j<a->i[i+1]; j++) {
453:       y_l = A->m - row - 1.0; y_r = y_l + 1.0;
454:       x_l = a->j[j]*bs; x_r = x_l + 1.0;
455:       aa = a->a + j*bs2;
456:       for (k=0; k<bs; k++) {
457:         for (l=0; l<bs; l++) {
458:           if (PetscRealPart(*aa++) >=  0.) continue;
459:           PetscDrawRectangle(draw,x_l+k,y_l-l,x_r+k,y_r-l,color,color,color,color);
460:         }
461:       }
462:     }
463:   }
464:   color = PETSC_DRAW_CYAN;
465:   for (i=0,row=0; i<mbs; i++,row+=bs) {
466:     for (j=a->i[i]; j<a->i[i+1]; j++) {
467:       y_l = A->m - row - 1.0; y_r = y_l + 1.0;
468:       x_l = a->j[j]*bs; x_r = x_l + 1.0;
469:       aa = a->a + j*bs2;
470:       for (k=0; k<bs; k++) {
471:         for (l=0; l<bs; l++) {
472:           if (PetscRealPart(*aa++) != 0.) continue;
473:           PetscDrawRectangle(draw,x_l+k,y_l-l,x_r+k,y_r-l,color,color,color,color);
474:         }
475:       }
476:     }
477:   }

479:   color = PETSC_DRAW_RED;
480:   for (i=0,row=0; i<mbs; i++,row+=bs) {
481:     for (j=a->i[i]; j<a->i[i+1]; j++) {
482:       y_l = A->m - row - 1.0; y_r = y_l + 1.0;
483:       x_l = a->j[j]*bs; x_r = x_l + 1.0;
484:       aa = a->a + j*bs2;
485:       for (k=0; k<bs; k++) {
486:         for (l=0; l<bs; l++) {
487:           if (PetscRealPart(*aa++) <= 0.) continue;
488:           PetscDrawRectangle(draw,x_l+k,y_l-l,x_r+k,y_r-l,color,color,color,color);
489:         }
490:       }
491:     }
492:   }
493:   return(0);
494: }

498: static int MatView_SeqSBAIJ_Draw(Mat A,PetscViewer viewer)
499: {
500:   int          ierr;
501:   PetscReal    xl,yl,xr,yr,w,h;
502:   PetscDraw    draw;
503:   PetscTruth   isnull;


507:   PetscViewerDrawGetDraw(viewer,0,&draw);
508:   PetscDrawIsNull(draw,&isnull); if (isnull) return(0);

510:   PetscObjectCompose((PetscObject)A,"Zoomviewer",(PetscObject)viewer);
511:   xr  = A->m; yr = A->m; h = yr/10.0; w = xr/10.0;
512:   xr += w;    yr += h;  xl = -w;     yl = -h;
513:   PetscDrawSetCoordinates(draw,xl,yl,xr,yr);
514:   PetscDrawZoom(draw,MatView_SeqSBAIJ_Draw_Zoom,A);
515:   PetscObjectCompose((PetscObject)A,"Zoomviewer",PETSC_NULL);
516:   return(0);
517: }

521: int MatView_SeqSBAIJ(Mat A,PetscViewer viewer)
522: {
523:   int        ierr;
524:   PetscTruth issocket,isascii,isbinary,isdraw;

527:   PetscTypeCompare((PetscObject)viewer,PETSC_VIEWER_SOCKET,&issocket);
528:   PetscTypeCompare((PetscObject)viewer,PETSC_VIEWER_ASCII,&isascii);
529:   PetscTypeCompare((PetscObject)viewer,PETSC_VIEWER_BINARY,&isbinary);
530:   PetscTypeCompare((PetscObject)viewer,PETSC_VIEWER_DRAW,&isdraw);
531:   if (issocket) {
532:     SETERRQ(PETSC_ERR_SUP,"Socket viewer not supported");
533:   } else if (isascii){
534:     MatView_SeqSBAIJ_ASCII(A,viewer);
535:   } else if (isbinary) {
536:     MatView_SeqSBAIJ_Binary(A,viewer);
537:   } else if (isdraw) {
538:     MatView_SeqSBAIJ_Draw(A,viewer);
539:   } else {
540:     SETERRQ1(1,"Viewer type %s not supported by SeqSBAIJ matrices",((PetscObject)viewer)->type_name);
541:   }
542:   return(0);
543: }


548: int MatGetValues_SeqSBAIJ(Mat A,int m,const int im[],int n,const int in[],PetscScalar v[])
549: {
550:   Mat_SeqSBAIJ *a = (Mat_SeqSBAIJ*)A->data;
551:   int        *rp,k,low,high,t,row,nrow,i,col,l,*aj = a->j;
552:   int        *ai = a->i,*ailen = a->ilen;
553:   int        brow,bcol,ridx,cidx,bs=a->bs,bs2=a->bs2;
554:   MatScalar  *ap,*aa = a->a,zero = 0.0;

557:   for (k=0; k<m; k++) { /* loop over rows */
558:     row  = im[k]; brow = row/bs;
559:     if (row < 0) SETERRQ1(PETSC_ERR_ARG_OUTOFRANGE,"Negative row: %d",row);
560:     if (row >= A->m) SETERRQ2(PETSC_ERR_ARG_OUTOFRANGE,"Row too large: row %d max %d",row,A->m-1);
561:     rp   = aj + ai[brow] ; ap = aa + bs2*ai[brow] ;
562:     nrow = ailen[brow];
563:     for (l=0; l<n; l++) { /* loop over columns */
564:       if (in[l] < 0) SETERRQ1(PETSC_ERR_ARG_OUTOFRANGE,"Negative column: %d",in[l]);
565:       if (in[l] >= A->n) SETERRQ2(PETSC_ERR_ARG_OUTOFRANGE,"Column too large: col %d max %d",in[l],A->n-1);
566:       col  = in[l] ;
567:       bcol = col/bs;
568:       cidx = col%bs;
569:       ridx = row%bs;
570:       high = nrow;
571:       low  = 0; /* assume unsorted */
572:       while (high-low > 5) {
573:         t = (low+high)/2;
574:         if (rp[t] > bcol) high = t;
575:         else             low  = t;
576:       }
577:       for (i=low; i<high; i++) {
578:         if (rp[i] > bcol) break;
579:         if (rp[i] == bcol) {
580:           *v++ = ap[bs2*i+bs*cidx+ridx];
581:           goto finished;
582:         }
583:       }
584:       *v++ = zero;
585:       finished:;
586:     }
587:   }
588:   return(0);
589: }


594: int MatSetValuesBlocked_SeqSBAIJ(Mat A,int m,const int im[],int n,const int in[],const PetscScalar v[],InsertMode is)
595: {
596:   Mat_SeqSBAIJ    *a = (Mat_SeqSBAIJ*)A->data;
597:   int             *rp,k,low,high,t,ii,jj,row,nrow,i,col,l,rmax,N,sorted=a->sorted;
598:   int             *imax=a->imax,*ai=a->i,*ailen=a->ilen;
599:   int             *aj=a->j,nonew=a->nonew,bs2=a->bs2,bs=a->bs,stepval,ierr;
600:   PetscTruth      roworiented=a->roworiented;
601:   const MatScalar *value = v;
602:   MatScalar       *ap,*aa = a->a,*bap;
603: 
605:   if (roworiented) {
606:     stepval = (n-1)*bs;
607:   } else {
608:     stepval = (m-1)*bs;
609:   }
610:   for (k=0; k<m; k++) { /* loop over added rows */
611:     row  = im[k];
612:     if (row < 0) continue;
613: #if defined(PETSC_USE_BOPT_g)  
614:     if (row >= a->mbs) SETERRQ2(PETSC_ERR_ARG_OUTOFRANGE,"Row too large: row %d max %d",row,a->mbs-1);
615: #endif
616:     rp   = aj + ai[row];
617:     ap   = aa + bs2*ai[row];
618:     rmax = imax[row];
619:     nrow = ailen[row];
620:     low  = 0;
621:     for (l=0; l<n; l++) { /* loop over added columns */
622:       if (in[l] < 0) continue;
623:       col = in[l];
624: #if defined(PETSC_USE_BOPT_g)  
625:       if (col >= a->nbs) SETERRQ2(PETSC_ERR_ARG_OUTOFRANGE,"Column too large: col %d max %d",col,a->nbs-1);
626: #endif
627:       if (col < row) continue; /* ignore lower triangular block */
628:       if (roworiented) {
629:         value = v + k*(stepval+bs)*bs + l*bs;
630:       } else {
631:         value = v + l*(stepval+bs)*bs + k*bs;
632:       }
633:       if (!sorted) low = 0; high = nrow;
634:       while (high-low > 7) {
635:         t = (low+high)/2;
636:         if (rp[t] > col) high = t;
637:         else             low  = t;
638:       }
639:       for (i=low; i<high; i++) {
640:         if (rp[i] > col) break;
641:         if (rp[i] == col) {
642:           bap  = ap +  bs2*i;
643:           if (roworiented) {
644:             if (is == ADD_VALUES) {
645:               for (ii=0; ii<bs; ii++,value+=stepval) {
646:                 for (jj=ii; jj<bs2; jj+=bs) {
647:                   bap[jj] += *value++;
648:                 }
649:               }
650:             } else {
651:               for (ii=0; ii<bs; ii++,value+=stepval) {
652:                 for (jj=ii; jj<bs2; jj+=bs) {
653:                   bap[jj] = *value++;
654:                 }
655:               }
656:             }
657:           } else {
658:             if (is == ADD_VALUES) {
659:               for (ii=0; ii<bs; ii++,value+=stepval) {
660:                 for (jj=0; jj<bs; jj++) {
661:                   *bap++ += *value++;
662:                 }
663:               }
664:             } else {
665:               for (ii=0; ii<bs; ii++,value+=stepval) {
666:                 for (jj=0; jj<bs; jj++) {
667:                   *bap++  = *value++;
668:                 }
669:               }
670:             }
671:           }
672:           goto noinsert2;
673:         }
674:       }
675:       if (nonew == 1) goto noinsert2;
676:       else if (nonew == -1) SETERRQ2(PETSC_ERR_ARG_OUTOFRANGE,"Inserting a new nonzero (%d, %d) in the matrix", row, col);
677:       if (nrow >= rmax) {
678:         /* there is no extra room in row, therefore enlarge */
679:         int       new_nz = ai[a->mbs] + CHUNKSIZE,len,*new_i,*new_j;
680:         MatScalar *new_a;

682:         if (nonew == -2) SETERRQ2(PETSC_ERR_ARG_OUTOFRANGE,"Inserting a new nonzero (%d, %d) in the matrix", row, col);

684:         /* malloc new storage space */
685:         len     = new_nz*(sizeof(int)+bs2*sizeof(MatScalar))+(a->mbs+1)*sizeof(int);
686:         PetscMalloc(len,&new_a);
687:         new_j   = (int*)(new_a + bs2*new_nz);
688:         new_i   = new_j + new_nz;

690:         /* copy over old data into new slots */
691:         for (ii=0; ii<row+1; ii++) {new_i[ii] = ai[ii];}
692:         for (ii=row+1; ii<a->mbs+1; ii++) {new_i[ii] = ai[ii]+CHUNKSIZE;}
693:         PetscMemcpy(new_j,aj,(ai[row]+nrow)*sizeof(int));
694:         len  = (new_nz - CHUNKSIZE - ai[row] - nrow);
695:         PetscMemcpy(new_j+ai[row]+nrow+CHUNKSIZE,aj+ai[row]+nrow,len*sizeof(int));
696:         PetscMemcpy(new_a,aa,(ai[row]+nrow)*bs2*sizeof(MatScalar));
697:         PetscMemzero(new_a+bs2*(ai[row]+nrow),bs2*CHUNKSIZE*sizeof(MatScalar));
698:         PetscMemcpy(new_a+bs2*(ai[row]+nrow+CHUNKSIZE),aa+bs2*(ai[row]+nrow),bs2*len*sizeof(MatScalar));
699:         /* free up old matrix storage */
700:         PetscFree(a->a);
701:         if (!a->singlemalloc) {
702:           PetscFree(a->i);
703:           PetscFree(a->j);
704:         }
705:         aa = a->a = new_a; ai = a->i = new_i; aj = a->j = new_j;
706:         a->singlemalloc = PETSC_TRUE;

708:         rp   = aj + ai[row]; ap = aa + bs2*ai[row];
709:         rmax = imax[row] = imax[row] + CHUNKSIZE;
710:         PetscLogObjectMemory(A,CHUNKSIZE*(sizeof(int) + bs2*sizeof(MatScalar)));
711:         a->s_maxnz += bs2*CHUNKSIZE;
712:         a->reallocs++;
713:         a->s_nz++;
714:       }
715:       N = nrow++ - 1;
716:       /* shift up all the later entries in this row */
717:       for (ii=N; ii>=i; ii--) {
718:         rp[ii+1] = rp[ii];
719:         PetscMemcpy(ap+bs2*(ii+1),ap+bs2*(ii),bs2*sizeof(MatScalar));
720:       }
721:       if (N >= i) {
722:         PetscMemzero(ap+bs2*i,bs2*sizeof(MatScalar));
723:       }
724:       rp[i] = col;
725:       bap   = ap +  bs2*i;
726:       if (roworiented) {
727:         for (ii=0; ii<bs; ii++,value+=stepval) {
728:           for (jj=ii; jj<bs2; jj+=bs) {
729:             bap[jj] = *value++;
730:           }
731:         }
732:       } else {
733:         for (ii=0; ii<bs; ii++,value+=stepval) {
734:           for (jj=0; jj<bs; jj++) {
735:             *bap++  = *value++;
736:           }
737:         }
738:       }
739:       noinsert2:;
740:       low = i;
741:     }
742:     ailen[row] = nrow;
743:   }
744:   return(0);
745: }

749: int MatAssemblyEnd_SeqSBAIJ(Mat A,MatAssemblyType mode)
750: {
751:   Mat_SeqSBAIJ *a = (Mat_SeqSBAIJ*)A->data;
752:   int        fshift = 0,i,j,*ai = a->i,*aj = a->j,*imax = a->imax;
753:   int        m = A->m,*ip,N,*ailen = a->ilen;
754:   int        mbs = a->mbs,bs2 = a->bs2,rmax = 0,ierr;
755:   MatScalar  *aa = a->a,*ap;

758:   if (mode == MAT_FLUSH_ASSEMBLY) return(0);

760:   if (m) rmax = ailen[0];
761:   for (i=1; i<mbs; i++) {
762:     /* move each row back by the amount of empty slots (fshift) before it*/
763:     fshift += imax[i-1] - ailen[i-1];
764:     rmax   = PetscMax(rmax,ailen[i]);
765:     if (fshift) {
766:       ip = aj + ai[i]; ap = aa + bs2*ai[i];
767:       N = ailen[i];
768:       for (j=0; j<N; j++) {
769:         ip[j-fshift] = ip[j];
770:         PetscMemcpy(ap+(j-fshift)*bs2,ap+j*bs2,bs2*sizeof(MatScalar));
771:       }
772:     }
773:     ai[i] = ai[i-1] + ailen[i-1];
774:   }
775:   if (mbs) {
776:     fshift += imax[mbs-1] - ailen[mbs-1];
777:     ai[mbs] = ai[mbs-1] + ailen[mbs-1];
778:   }
779:   /* reset ilen and imax for each row */
780:   for (i=0; i<mbs; i++) {
781:     ailen[i] = imax[i] = ai[i+1] - ai[i];
782:   }
783:   a->s_nz = ai[mbs];

785:   /* diagonals may have moved, reset it */
786:   if (a->diag) {
787:     PetscMemcpy(a->diag,ai,(mbs+1)*sizeof(int));
788:   }
789:   PetscLogInfo(A,"MatAssemblyEnd_SeqSBAIJ:Matrix size: %d X %d, block size %d; storage space: %d unneeded, %d used\n",
790:            m,A->m,a->bs,fshift*bs2,a->s_nz*bs2);
791:   PetscLogInfo(A,"MatAssemblyEnd_SeqSBAIJ:Number of mallocs during MatSetValues is %d\n",
792:            a->reallocs);
793:   PetscLogInfo(A,"MatAssemblyEnd_SeqSBAIJ:Most nonzeros blocks in any row is %d\n",rmax);
794:   a->reallocs          = 0;
795:   A->info.nz_unneeded  = (PetscReal)fshift*bs2;
796: 
797:   return(0);
798: }

800: /* 
801:    This function returns an array of flags which indicate the locations of contiguous
802:    blocks that should be zeroed. for eg: if bs = 3  and is = [0,1,2,3,5,6,7,8,9]
803:    then the resulting sizes = [3,1,1,3,1] correspondig to sets [(0,1,2),(3),(5),(6,7,8),(9)]
804:    Assume: sizes should be long enough to hold all the values.
805: */
808: int MatZeroRows_SeqSBAIJ_Check_Blocks(int idx[],int n,int bs,int sizes[], int *bs_max)
809: {
810:   int        i,j,k,row;
811:   PetscTruth flg;

814:   for (i=0,j=0; i<n; j++) {
815:     row = idx[i];
816:     if (row%bs!=0) { /* Not the begining of a block */
817:       sizes[j] = 1;
818:       i++;
819:     } else if (i+bs > n) { /* Beginning of a block, but complete block doesn't exist (at idx end) */
820:       sizes[j] = 1;         /* Also makes sure atleast 'bs' values exist for next else */
821:       i++;
822:     } else { /* Begining of the block, so check if the complete block exists */
823:       flg = PETSC_TRUE;
824:       for (k=1; k<bs; k++) {
825:         if (row+k != idx[i+k]) { /* break in the block */
826:           flg = PETSC_FALSE;
827:           break;
828:         }
829:       }
830:       if (flg == PETSC_TRUE) { /* No break in the bs */
831:         sizes[j] = bs;
832:         i+= bs;
833:       } else {
834:         sizes[j] = 1;
835:         i++;
836:       }
837:     }
838:   }
839:   *bs_max = j;
840:   return(0);
841: }
842: 
845: int MatZeroRows_SeqSBAIJ(Mat A,IS is,const PetscScalar *diag)
846: {
848:   SETERRQ(PETSC_ERR_SUP,"No support for this function yet");
849: }

851: /* Only add/insert a(i,j) with i<=j (blocks). 
852:    Any a(i,j) with i>j input by user is ingored. 
853: */

857: int MatSetValues_SeqSBAIJ(Mat A,int m,const int im[],int n,const int in[],const PetscScalar v[],InsertMode is)
858: {
859:   Mat_SeqSBAIJ *a = (Mat_SeqSBAIJ*)A->data;
860:   int         *rp,k,low,high,t,ii,row,nrow,i,col,l,rmax,N,sorted=a->sorted;
861:   int         *imax=a->imax,*ai=a->i,*ailen=a->ilen,roworiented=a->roworiented;
862:   int         *aj=a->j,nonew=a->nonew,bs=a->bs,brow,bcol;
863:   int         ridx,cidx,bs2=a->bs2,ierr;
864:   MatScalar   *ap,value,*aa=a->a,*bap;


868:   for (k=0; k<m; k++) { /* loop over added rows */
869:     row  = im[k];       /* row number */
870:     brow = row/bs;      /* block row number */
871:     if (row < 0) continue;
872: #if defined(PETSC_USE_BOPT_g)  
873:     if (row >= A->m) SETERRQ2(PETSC_ERR_ARG_OUTOFRANGE,"Row too large: row %d max %d",row,A->m-1);
874: #endif
875:     rp   = aj + ai[brow]; /*ptr to beginning of column value of the row block*/
876:     ap   = aa + bs2*ai[brow]; /*ptr to beginning of element value of the row block*/
877:     rmax = imax[brow];  /* maximum space allocated for this row */
878:     nrow = ailen[brow]; /* actual length of this row */
879:     low  = 0;

881:     for (l=0; l<n; l++) { /* loop over added columns */
882:       if (in[l] < 0) continue;
883: #if defined(PETSC_USE_BOPT_g)  
884:       if (in[l] >= A->m) SETERRQ2(PETSC_ERR_ARG_OUTOFRANGE,"Column too large: col %d max %d",in[l],A->m-1);
885: #endif
886:       col = in[l];
887:       bcol = col/bs;              /* block col number */

889:       if (brow <= bcol){
890:         ridx = row % bs; cidx = col % bs; /*row and col index inside the block */
891:         if ((brow==bcol && ridx<=cidx) || (brow<bcol)){
892:           /* element value a(k,l) */
893:           if (roworiented) {
894:             value = v[l + k*n];
895:           } else {
896:             value = v[k + l*m];
897:           }

899:           /* move pointer bap to a(k,l) quickly and add/insert value */
900:           if (!sorted) low = 0; high = nrow;
901:           while (high-low > 7) {
902:             t = (low+high)/2;
903:             if (rp[t] > bcol) high = t;
904:             else              low  = t;
905:           }
906:           for (i=low; i<high; i++) {
907:             /* printf("The loop of i=low.., rp[%d]=%d\n",i,rp[i]); */
908:             if (rp[i] > bcol) break;
909:             if (rp[i] == bcol) {
910:               bap  = ap +  bs2*i + bs*cidx + ridx;
911:               if (is == ADD_VALUES) *bap += value;
912:               else                  *bap  = value;
913:               /* for diag block, add/insert its symmetric element a(cidx,ridx) */
914:               if (brow == bcol && ridx < cidx){
915:                 bap  = ap +  bs2*i + bs*ridx + cidx;
916:                 if (is == ADD_VALUES) *bap += value;
917:                 else                  *bap  = value;
918:               }
919:               goto noinsert1;
920:             }
921:           }
922: 
923:       if (nonew == 1) goto noinsert1;
924:       else if (nonew == -1) SETERRQ2(PETSC_ERR_ARG_OUTOFRANGE,"Inserting a new nonzero (%d, %d) in the matrix", row, col);
925:       if (nrow >= rmax) {
926:         /* there is no extra room in row, therefore enlarge */
927:         int       new_nz = ai[a->mbs] + CHUNKSIZE,len,*new_i,*new_j;
928:         MatScalar *new_a;

930:         if (nonew == -2) SETERRQ2(PETSC_ERR_ARG_OUTOFRANGE,"Inserting a new nonzero (%d, %d) in the matrix", row, col);

932:         /* Malloc new storage space */
933:         len   = new_nz*(sizeof(int)+bs2*sizeof(MatScalar))+(a->mbs+1)*sizeof(int);
934:         PetscMalloc(len,&new_a);
935:         new_j = (int*)(new_a + bs2*new_nz);
936:         new_i = new_j + new_nz;

938:         /* copy over old data into new slots */
939:         for (ii=0; ii<brow+1; ii++) {new_i[ii] = ai[ii];}
940:         for (ii=brow+1; ii<a->mbs+1; ii++) {new_i[ii] = ai[ii]+CHUNKSIZE;}
941:         PetscMemcpy(new_j,aj,(ai[brow]+nrow)*sizeof(int));
942:         len  = (new_nz - CHUNKSIZE - ai[brow] - nrow);
943:         PetscMemcpy(new_j+ai[brow]+nrow+CHUNKSIZE,aj+ai[brow]+nrow,len*sizeof(int));
944:         PetscMemcpy(new_a,aa,(ai[brow]+nrow)*bs2*sizeof(MatScalar));
945:         PetscMemzero(new_a+bs2*(ai[brow]+nrow),bs2*CHUNKSIZE*sizeof(MatScalar));
946:         PetscMemcpy(new_a+bs2*(ai[brow]+nrow+CHUNKSIZE),aa+bs2*(ai[brow]+nrow),bs2*len*sizeof(MatScalar));
947:         /* free up old matrix storage */
948:         PetscFree(a->a);
949:         if (!a->singlemalloc) {
950:           PetscFree(a->i);
951:           PetscFree(a->j);
952:         }
953:         aa = a->a = new_a; ai = a->i = new_i; aj = a->j = new_j;
954:         a->singlemalloc = PETSC_TRUE;

956:         rp   = aj + ai[brow]; ap = aa + bs2*ai[brow];
957:         rmax = imax[brow] = imax[brow] + CHUNKSIZE;
958:         PetscLogObjectMemory(A,CHUNKSIZE*(sizeof(int) + bs2*sizeof(MatScalar)));
959:         a->s_maxnz += bs2*CHUNKSIZE;
960:         a->reallocs++;
961:         a->s_nz++;
962:       }

964:       N = nrow++ - 1;
965:       /* shift up all the later entries in this row */
966:       for (ii=N; ii>=i; ii--) {
967:         rp[ii+1] = rp[ii];
968:         PetscMemcpy(ap+bs2*(ii+1),ap+bs2*(ii),bs2*sizeof(MatScalar));
969:       }
970:       if (N>=i) {
971:         PetscMemzero(ap+bs2*i,bs2*sizeof(MatScalar));
972:       }
973:       rp[i]                      = bcol;
974:       ap[bs2*i + bs*cidx + ridx] = value;
975:       noinsert1:;
976:       low = i;
977:       /* } */
978:         }
979:       } /* end of if .. if..  */
980:     }                     /* end of loop over added columns */
981:     ailen[brow] = nrow;
982:   }                       /* end of loop over added rows */

984:   return(0);
985: }

987: extern int MatCholeskyFactorSymbolic_SeqSBAIJ(Mat,IS,MatFactorInfo*,Mat*);
988: extern int MatCholeskyFactor_SeqSBAIJ(Mat,IS,MatFactorInfo*);
989: extern int MatIncreaseOverlap_SeqSBAIJ(Mat,int,IS[],int);
990: extern int MatGetSubMatrix_SeqSBAIJ(Mat,IS,IS,int,MatReuse,Mat*);
991: extern int MatGetSubMatrices_SeqSBAIJ(Mat,int,const IS[],const IS[],MatReuse,Mat*[]);
992: extern int MatMultTranspose_SeqSBAIJ(Mat,Vec,Vec);
993: extern int MatMultTransposeAdd_SeqSBAIJ(Mat,Vec,Vec,Vec);
994: extern int MatScale_SeqSBAIJ(const PetscScalar*,Mat);
995: extern int MatNorm_SeqSBAIJ(Mat,NormType,PetscReal *);
996: extern int MatEqual_SeqSBAIJ(Mat,Mat,PetscTruth*);
997: extern int MatGetDiagonal_SeqSBAIJ(Mat,Vec);
998: extern int MatDiagonalScale_SeqSBAIJ(Mat,Vec,Vec);
999: extern int MatGetInfo_SeqSBAIJ(Mat,MatInfoType,MatInfo *);
1000: extern int MatZeroEntries_SeqSBAIJ(Mat);
1001: extern int MatGetRowMax_SeqSBAIJ(Mat,Vec);

1003: extern int MatSolve_SeqSBAIJ_N(Mat,Vec,Vec);
1004: extern int MatSolve_SeqSBAIJ_1(Mat,Vec,Vec);
1005: extern int MatSolve_SeqSBAIJ_2(Mat,Vec,Vec);
1006: extern int MatSolve_SeqSBAIJ_3(Mat,Vec,Vec);
1007: extern int MatSolve_SeqSBAIJ_4(Mat,Vec,Vec);
1008: extern int MatSolve_SeqSBAIJ_5(Mat,Vec,Vec);
1009: extern int MatSolve_SeqSBAIJ_6(Mat,Vec,Vec);
1010: extern int MatSolve_SeqSBAIJ_7(Mat,Vec,Vec);
1011: extern int MatSolveTranspose_SeqSBAIJ_7(Mat,Vec,Vec);
1012: extern int MatSolveTranspose_SeqSBAIJ_6(Mat,Vec,Vec);
1013: extern int MatSolveTranspose_SeqSBAIJ_5(Mat,Vec,Vec);
1014: extern int MatSolveTranspose_SeqSBAIJ_4(Mat,Vec,Vec);
1015: extern int MatSolveTranspose_SeqSBAIJ_3(Mat,Vec,Vec);
1016: extern int MatSolveTranspose_SeqSBAIJ_2(Mat,Vec,Vec);
1017: extern int MatSolveTranspose_SeqSBAIJ_1(Mat,Vec,Vec);

1019: extern int MatSolves_SeqSBAIJ_1(Mat,Vecs,Vecs);

1021: extern int MatSolve_SeqSBAIJ_1_NaturalOrdering(Mat,Vec,Vec);
1022: extern int MatSolve_SeqSBAIJ_2_NaturalOrdering(Mat,Vec,Vec);
1023: extern int MatSolve_SeqSBAIJ_3_NaturalOrdering(Mat,Vec,Vec);
1024: extern int MatSolve_SeqSBAIJ_4_NaturalOrdering(Mat,Vec,Vec);
1025: extern int MatSolve_SeqSBAIJ_5_NaturalOrdering(Mat,Vec,Vec);
1026: extern int MatSolve_SeqSBAIJ_6_NaturalOrdering(Mat,Vec,Vec);
1027: extern int MatSolve_SeqSBAIJ_7_NaturalOrdering(Mat,Vec,Vec);
1028: extern int MatSolve_SeqSBAIJ_N_NaturalOrdering(Mat,Vec,Vec);

1030: extern int MatCholeskyFactorNumeric_SeqSBAIJ_N(Mat,Mat*);
1031: extern int MatCholeskyFactorNumeric_SeqSBAIJ_1(Mat,Mat*);
1032: extern int MatCholeskyFactorNumeric_SeqSBAIJ_2(Mat,Mat*);
1033: extern int MatCholeskyFactorNumeric_SeqSBAIJ_3(Mat,Mat*);
1034: extern int MatCholeskyFactorNumeric_SeqSBAIJ_4(Mat,Mat*);
1035: extern int MatCholeskyFactorNumeric_SeqSBAIJ_5(Mat,Mat*);
1036: extern int MatCholeskyFactorNumeric_SeqSBAIJ_6(Mat,Mat*);
1037: extern int MatCholeskyFactorNumeric_SeqSBAIJ_7(Mat,Mat*);
1038: extern int MatGetInertia_SeqSBAIJ(Mat,int*,int*,int*);

1040: extern int MatMult_SeqSBAIJ_1(Mat,Vec,Vec);
1041: extern int MatMult_SeqSBAIJ_2(Mat,Vec,Vec);
1042: extern int MatMult_SeqSBAIJ_3(Mat,Vec,Vec);
1043: extern int MatMult_SeqSBAIJ_4(Mat,Vec,Vec);
1044: extern int MatMult_SeqSBAIJ_5(Mat,Vec,Vec);
1045: extern int MatMult_SeqSBAIJ_6(Mat,Vec,Vec);
1046: extern int MatMult_SeqSBAIJ_7(Mat,Vec,Vec);
1047: extern int MatMult_SeqSBAIJ_N(Mat,Vec,Vec);

1049: extern int MatMultAdd_SeqSBAIJ_1(Mat,Vec,Vec,Vec);
1050: extern int MatMultAdd_SeqSBAIJ_2(Mat,Vec,Vec,Vec);
1051: extern int MatMultAdd_SeqSBAIJ_3(Mat,Vec,Vec,Vec);
1052: extern int MatMultAdd_SeqSBAIJ_4(Mat,Vec,Vec,Vec);
1053: extern int MatMultAdd_SeqSBAIJ_5(Mat,Vec,Vec,Vec);
1054: extern int MatMultAdd_SeqSBAIJ_6(Mat,Vec,Vec,Vec);
1055: extern int MatMultAdd_SeqSBAIJ_7(Mat,Vec,Vec,Vec);
1056: extern int MatMultAdd_SeqSBAIJ_N(Mat,Vec,Vec,Vec);

1058: #ifdef HAVE_MatICCFactor
1059: /* modefied from MatILUFactor_SeqSBAIJ, needs further work!  */
1062: int MatICCFactor_SeqSBAIJ(Mat inA,IS row,MatFactorInfo *info)
1063: {
1064:   Mat_SeqSBAIJ *a = (Mat_SeqSBAIJ*)inA->data;
1065:   Mat         outA;
1066:   int         ierr;
1067:   PetscTruth  row_identity,col_identity;

1070:   /*
1071:   if (level != 0) SETERRQ(PETSC_ERR_SUP,"Only levels = 0 supported for in-place ILU"); 
1072:   ISIdentity(row,&row_identity);
1073:   ISIdentity(col,&col_identity);
1074:   if (!row_identity || !col_identity) {
1075:     SETERRQ(1,"Row and column permutations must be identity for in-place ICC");
1076:   }
1077:   */

1079:   outA          = inA;
1080:   inA->factor   = FACTOR_CHOLESKY;

1082:   if (!a->diag) {
1083:     MatMarkDiagonal_SeqSBAIJ(inA);
1084:   }
1085:   /*
1086:       Blocksize 2, 3, 4, 5, 6 and 7 have a special faster factorization/solver 
1087:       for ILU(0) factorization with natural ordering
1088:   */
1089:   switch (a->bs) {
1090:   case 1:
1091:     inA->ops->solve            = MatSolve_SeqSBAIJ_1_NaturalOrdering;
1092:     inA->ops->solvetranspose   = MatSolve_SeqSBAIJ_1_NaturalOrdering;
1093:     inA->ops->solves           = MatSolves_SeqSBAIJ_1;
1094:     PetscLoginfo(inA,"MatICCFactor_SeqSBAIJ:Using special in-place natural ordering solvetrans BS=1\n");
1095:   case 2:
1096:     inA->ops->lufactornumeric = MatCholeskyFactorNumeric_SeqSBAIJ_2_NaturalOrdering;
1097:     inA->ops->solve           = MatSolve_SeqSBAIJ_2_NaturalOrdering;
1098:     inA->ops->solvetranspose  = MatSolve_SeqSBAIJ_2_NaturalOrdering;
1099:     PetscLogInfo(inA,"MatICCFactor_SeqSBAIJ:Using special in-place natural ordering factor and solve BS=2\n");
1100:     break;
1101:   case 3:
1102:     inA->ops->lufactornumeric = MatCholeskyFactorNumeric_SeqSBAIJ_3_NaturalOrdering;
1103:     inA->ops->solve           = MatSolve_SeqSBAIJ_3_NaturalOrdering;
1104:     inA->ops->solvetranspose  = MatSolve_SeqSBAIJ_3_NaturalOrdering;
1105:     PetscLogInfo(inA,"MatICCFactor_SeqSBAIJ:Using special in-place natural ordering factor and solve BS=3\n");
1106:     break;
1107:   case 4:
1108:     inA->ops->lufactornumeric = MatCholeskyFactorNumeric_SeqSBAIJ_4_NaturalOrdering;
1109:     inA->ops->solve           = MatSolve_SeqSBAIJ_4_NaturalOrdering;
1110:     inA->ops->solvetranspose  = MatSolve_SeqSBAIJ_4_NaturalOrdering;
1111:     PetscLogInfo(inA,"MatICCFactor_SeqSBAIJ:Using special in-place natural ordering factor and solve BS=4\n");
1112:     break;
1113:   case 5:
1114:     inA->ops->lufactornumeric = MatCholeskyFactorNumeric_SeqSBAIJ_5_NaturalOrdering;
1115:     inA->ops->solve           = MatSolve_SeqSBAIJ_5_NaturalOrdering;
1116:     inA->ops->solvetranspose  = MatSolve_SeqSBAIJ_5_NaturalOrdering;
1117:     PetscLogInfo(inA,"MatICCFactor_SeqSBAIJ:Using special in-place natural ordering factor and solve BS=5\n");
1118:     break;
1119:   case 6:
1120:     inA->ops->lufactornumeric = MatCholeskyFactorNumeric_SeqSBAIJ_6_NaturalOrdering;
1121:     inA->ops->solve           = MatSolve_SeqSBAIJ_6_NaturalOrdering;
1122:     inA->ops->solvetranspose  = MatSolve_SeqSBAIJ_6_NaturalOrdering;
1123:     PetscLogInfo(inA,"MatICCFactor_SeqSBAIJ:Using special in-place natural ordering factor and solve BS=6\n");
1124:     break;
1125:   case 7:
1126:     inA->ops->lufactornumeric = MatCholeskyFactorNumeric_SeqSBAIJ_7_NaturalOrdering;
1127:     inA->ops->solvetranspose  = MatSolve_SeqSBAIJ_7_NaturalOrdering;
1128:     inA->ops->solve           = MatSolve_SeqSBAIJ_7_NaturalOrdering;
1129:     PetscLogInfo(inA,"MatICCFactor_SeqSBAIJ:Using special in-place natural ordering factor and solve BS=7\n");
1130:     break;
1131:   default:
1132:     a->row        = row;
1133:     a->icol       = col;
1134:     PetscObjectReference((PetscObject)row);
1135:     PetscObjectReference((PetscObject)col);

1137:     /* Create the invert permutation so that it can be used in MatLUFactorNumeric() */
1138:     ISInvertPermutation(col,PETSC_DECIDE, &(a->icol));
1139:     PetscLogObjectParent(inA,a->icol);

1141:     if (!a->solve_work) {
1142:       PetscMalloc((A->m+a->bs)*sizeof(PetscScalar),&a->solve_work);
1143:       PetscLogObjectMemory(inA,(A->m+a->bs)*sizeof(PetscScalar));
1144:     }
1145:   }

1147:   MatCholeskyFactorNumeric(inA,&outA);

1149:   return(0);
1150: }
1151: #endif

1155: int MatPrintHelp_SeqSBAIJ(Mat A)
1156: {
1157:   static PetscTruth called = PETSC_FALSE;
1158:   MPI_Comm          comm = A->comm;
1159:   int               ierr;

1162:   if (called) {return(0);} else called = PETSC_TRUE;
1163:   (*PetscHelpPrintf)(comm," Options for MATSEQSBAIJ and MATMPISBAIJ matrix formats (the defaults):\n");
1164:   (*PetscHelpPrintf)(comm,"  -mat_block_size <block_size>\n");
1165:   return(0);
1166: }

1168: EXTERN_C_BEGIN
1171: int MatSeqSBAIJSetColumnIndices_SeqSBAIJ(Mat mat,int *indices)
1172: {
1173:   Mat_SeqSBAIJ *baij = (Mat_SeqSBAIJ *)mat->data;
1174:   int         i,nz,n;

1177:   nz = baij->s_maxnz;
1178:   n  = mat->n;
1179:   for (i=0; i<nz; i++) {
1180:     baij->j[i] = indices[i];
1181:   }
1182:   baij->s_nz = nz;
1183:   for (i=0; i<n; i++) {
1184:     baij->ilen[i] = baij->imax[i];
1185:   }

1187:   return(0);
1188: }
1189: EXTERN_C_END

1193: /*@
1194:     MatSeqSBAIJSetColumnIndices - Set the column indices for all the rows
1195:        in the matrix.

1197:   Input Parameters:
1198: +  mat     - the SeqSBAIJ matrix
1199: -  indices - the column indices

1201:   Level: advanced

1203:   Notes:
1204:     This can be called if you have precomputed the nonzero structure of the 
1205:   matrix and want to provide it to the matrix object to improve the performance
1206:   of the MatSetValues() operation.

1208:     You MUST have set the correct numbers of nonzeros per row in the call to 
1209:   MatCreateSeqSBAIJ().

1211:     MUST be called before any calls to MatSetValues()

1213: .seealso: MatCreateSeqSBAIJ
1214: @*/
1215: int MatSeqSBAIJSetColumnIndices(Mat mat,int *indices)
1216: {
1217:   int ierr,(*f)(Mat,int *);

1221:   PetscObjectQueryFunction((PetscObject)mat,"MatSeqSBAIJSetColumnIndices_C",(void (**)(void))&f);
1222:   if (f) {
1223:     (*f)(mat,indices);
1224:   } else {
1225:     SETERRQ(1,"Wrong type of matrix to set column indices");
1226:   }
1227:   return(0);
1228: }

1232: int MatSetUpPreallocation_SeqSBAIJ(Mat A)
1233: {
1234:   int        ierr;

1237:    MatSeqSBAIJSetPreallocation(A,1,PETSC_DEFAULT,0);
1238:   return(0);
1239: }

1243: int MatGetArray_SeqSBAIJ(Mat A,PetscScalar *array[])
1244: {
1245:   Mat_SeqSBAIJ *a = (Mat_SeqSBAIJ*)A->data;
1247:   *array = a->a;
1248:   return(0);
1249: }

1253: int MatRestoreArray_SeqSBAIJ(Mat A,PetscScalar *array[])
1254: {
1256:   return(0);
1257: }

1259:  #include petscblaslapack.h
1262: int MatAXPY_SeqSBAIJ(const PetscScalar *a,Mat X,Mat Y,MatStructure str)
1263: {
1264:   Mat_SeqSBAIJ *x=(Mat_SeqSBAIJ *)X->data, *y=(Mat_SeqSBAIJ *)Y->data;
1265:   int          ierr,one=1,i,bs=y->bs,bs2,j;

1268:   if (str == SAME_NONZERO_PATTERN) {
1269:     BLaxpy_(&x->s_nz,(PetscScalar*)a,x->a,&one,y->a,&one);
1270:   } else if (str == SUBSET_NONZERO_PATTERN) { /* nonzeros of X is a subset of Y's */
1271:     if (y->xtoy && y->XtoY != X) {
1272:       PetscFree(y->xtoy);
1273:       MatDestroy(y->XtoY);
1274:     }
1275:     if (!y->xtoy) { /* get xtoy */
1276:       MatAXPYGetxtoy_Private(x->mbs,x->i,x->j,PETSC_NULL, y->i,y->j,PETSC_NULL, &y->xtoy);
1277:       y->XtoY = X;
1278:     }
1279:     bs2 = bs*bs;
1280:     for (i=0; i<x->s_nz; i++) {
1281:       j = 0;
1282:       while (j < bs2){
1283:         y->a[bs2*y->xtoy[i]+j] += (*a)*(x->a[bs2*i+j]);
1284:         j++;
1285:       }
1286:     }
1287:     PetscLogInfo(0,"MatAXPY_SeqSBAIJ: ratio of nnz_s(X)/nnz_s(Y): %d/%d = %g\n",bs2*x->s_nz,bs2*y->s_nz,(PetscReal)(bs2*x->s_nz)/(bs2*y->s_nz));
1288:   } else {
1289:     MatAXPY_Basic(a,X,Y,str);
1290:   }
1291:   return(0);
1292: }

1294: /* -------------------------------------------------------------------*/
1295: static struct _MatOps MatOps_Values = {MatSetValues_SeqSBAIJ,
1296:        MatGetRow_SeqSBAIJ,
1297:        MatRestoreRow_SeqSBAIJ,
1298:        MatMult_SeqSBAIJ_N,
1299: /* 4*/ MatMultAdd_SeqSBAIJ_N,
1300:        MatMultTranspose_SeqSBAIJ,
1301:        MatMultTransposeAdd_SeqSBAIJ,
1302:        MatSolve_SeqSBAIJ_N,
1303:        0,
1304:        0,
1305: /*10*/ 0,
1306:        0,
1307:        MatCholeskyFactor_SeqSBAIJ,
1308:        MatRelax_SeqSBAIJ,
1309:        MatTranspose_SeqSBAIJ,
1310: /*15*/ MatGetInfo_SeqSBAIJ,
1311:        MatEqual_SeqSBAIJ,
1312:        MatGetDiagonal_SeqSBAIJ,
1313:        MatDiagonalScale_SeqSBAIJ,
1314:        MatNorm_SeqSBAIJ,
1315: /*20*/ 0,
1316:        MatAssemblyEnd_SeqSBAIJ,
1317:        0,
1318:        MatSetOption_SeqSBAIJ,
1319:        MatZeroEntries_SeqSBAIJ,
1320: /*25*/ MatZeroRows_SeqSBAIJ,
1321:        0,
1322:        0,
1323:        MatCholeskyFactorSymbolic_SeqSBAIJ,
1324:        MatCholeskyFactorNumeric_SeqSBAIJ_N,
1325: /*30*/ MatSetUpPreallocation_SeqSBAIJ,
1326:        0,
1327:        MatICCFactorSymbolic_SeqSBAIJ,
1328:        MatGetArray_SeqSBAIJ,
1329:        MatRestoreArray_SeqSBAIJ,
1330: /*35*/ MatDuplicate_SeqSBAIJ,
1331:        0,
1332:        0,
1333:        0,
1334:        0,
1335: /*40*/ MatAXPY_SeqSBAIJ,
1336:        MatGetSubMatrices_SeqSBAIJ,
1337:        MatIncreaseOverlap_SeqSBAIJ,
1338:        MatGetValues_SeqSBAIJ,
1339:        0,
1340: /*45*/ MatPrintHelp_SeqSBAIJ,
1341:        MatScale_SeqSBAIJ,
1342:        0,
1343:        0,
1344:        0,
1345: /*50*/ MatGetBlockSize_SeqSBAIJ,
1346:        MatGetRowIJ_SeqSBAIJ,
1347:        MatRestoreRowIJ_SeqSBAIJ,
1348:        0,
1349:        0,
1350: /*55*/ 0,
1351:        0,
1352:        0,
1353:        0,
1354:        MatSetValuesBlocked_SeqSBAIJ,
1355: /*60*/ MatGetSubMatrix_SeqSBAIJ,
1356:        0,
1357:        0,
1358:        MatGetPetscMaps_Petsc,
1359:        0,
1360: /*65*/ 0,
1361:        0,
1362:        0,
1363:        0,
1364:        0,
1365: /*70*/ MatGetRowMax_SeqSBAIJ,
1366:        0,
1367:        0,
1368:        0,
1369:        0,
1370: /*75*/ 0,
1371:        0,
1372:        0,
1373:        0,
1374:        0,
1375: /*80*/ 0,
1376:        0,
1377:        0,
1378:        0,
1379: #if !defined(PETSC_USE_COMPLEX)
1380:        MatGetInertia_SeqSBAIJ,
1381: #else
1382:        0,
1383: #endif
1384: /*85*/ MatLoad_SeqSBAIJ
1385: };

1387: EXTERN_C_BEGIN
1390: int MatStoreValues_SeqSBAIJ(Mat mat)
1391: {
1392:   Mat_SeqSBAIJ *aij = (Mat_SeqSBAIJ *)mat->data;
1393:   int         nz = aij->i[mat->m]*aij->bs*aij->bs2;
1394:   int         ierr;

1397:   if (aij->nonew != 1) {
1398:     SETERRQ(1,"Must call MatSetOption(A,MAT_NO_NEW_NONZERO_LOCATIONS);first");
1399:   }

1401:   /* allocate space for values if not already there */
1402:   if (!aij->saved_values) {
1403:     PetscMalloc((nz+1)*sizeof(PetscScalar),&aij->saved_values);
1404:   }

1406:   /* copy values over */
1407:   PetscMemcpy(aij->saved_values,aij->a,nz*sizeof(PetscScalar));
1408:   return(0);
1409: }
1410: EXTERN_C_END

1412: EXTERN_C_BEGIN
1415: int MatRetrieveValues_SeqSBAIJ(Mat mat)
1416: {
1417:   Mat_SeqSBAIJ *aij = (Mat_SeqSBAIJ *)mat->data;
1418:   int         nz = aij->i[mat->m]*aij->bs*aij->bs2,ierr;

1421:   if (aij->nonew != 1) {
1422:     SETERRQ(1,"Must call MatSetOption(A,MAT_NO_NEW_NONZERO_LOCATIONS);first");
1423:   }
1424:   if (!aij->saved_values) {
1425:     SETERRQ(1,"Must call MatStoreValues(A);first");
1426:   }

1428:   /* copy values over */
1429:   PetscMemcpy(aij->a,aij->saved_values,nz*sizeof(PetscScalar));
1430:   return(0);
1431: }
1432: EXTERN_C_END

1434: EXTERN_C_BEGIN
1437: int MatSeqSBAIJSetPreallocation_SeqSBAIJ(Mat B,int bs,int nz,int *nnz)
1438: {
1439:   Mat_SeqSBAIJ *b = (Mat_SeqSBAIJ*)B->data;
1440:   int          i,len,ierr,mbs,bs2;
1441:   PetscTruth   flg;
1442:   int          s_nz;

1445:   B->preallocated = PETSC_TRUE;
1446:   PetscOptionsGetInt(B->prefix,"-mat_block_size",&bs,PETSC_NULL);
1447:   mbs  = B->m/bs;
1448:   bs2  = bs*bs;

1450:   if (mbs*bs != B->m) {
1451:     SETERRQ(PETSC_ERR_ARG_SIZ,"Number rows, cols must be divisible by blocksize");
1452:   }

1454:   if (nz == PETSC_DEFAULT || nz == PETSC_DECIDE) nz = 3;
1455:   if (nz < 0) SETERRQ1(PETSC_ERR_ARG_OUTOFRANGE,"nz cannot be less than 0: value %d",nz);
1456:   if (nnz) {
1457:     for (i=0; i<mbs; i++) {
1458:       if (nnz[i] < 0) SETERRQ2(PETSC_ERR_ARG_OUTOFRANGE,"nnz cannot be less than 0: local row %d value %d",i,nnz[i]);
1459:       if (nnz[i] > mbs) SETERRQ3(PETSC_ERR_ARG_OUTOFRANGE,"nnz cannot be greater than block row length: local row %d value %d rowlength %d",i,nnz[i],mbs);
1460:     }
1461:   }

1463:   PetscOptionsHasName(B->prefix,"-mat_no_unroll",&flg);
1464:   if (!flg) {
1465:     switch (bs) {
1466:     case 1:
1467:       B->ops->choleskyfactornumeric = MatCholeskyFactorNumeric_SeqSBAIJ_1;
1468:       B->ops->solve           = MatSolve_SeqSBAIJ_1;
1469:       B->ops->solves          = MatSolves_SeqSBAIJ_1;
1470:       B->ops->solvetranspose  = MatSolveTranspose_SeqSBAIJ_1;
1471:       B->ops->mult            = MatMult_SeqSBAIJ_1;
1472:       B->ops->multadd         = MatMultAdd_SeqSBAIJ_1;
1473:       break;
1474:     case 2:
1475:       B->ops->choleskyfactornumeric = MatCholeskyFactorNumeric_SeqSBAIJ_2;
1476:       B->ops->solve           = MatSolve_SeqSBAIJ_2;
1477:       B->ops->solvetranspose  = MatSolveTranspose_SeqSBAIJ_2;
1478:       B->ops->mult            = MatMult_SeqSBAIJ_2;
1479:       B->ops->multadd         = MatMultAdd_SeqSBAIJ_2;
1480:       break;
1481:     case 3:
1482:       B->ops->choleskyfactornumeric = MatCholeskyFactorNumeric_SeqSBAIJ_3;
1483:       B->ops->solve           = MatSolve_SeqSBAIJ_3;
1484:       B->ops->solvetranspose  = MatSolveTranspose_SeqSBAIJ_3;
1485:       B->ops->mult            = MatMult_SeqSBAIJ_3;
1486:       B->ops->multadd         = MatMultAdd_SeqSBAIJ_3;
1487:       break;
1488:     case 4:
1489:       B->ops->choleskyfactornumeric = MatCholeskyFactorNumeric_SeqSBAIJ_4;
1490:       B->ops->solve           = MatSolve_SeqSBAIJ_4;
1491:       B->ops->solvetranspose  = MatSolveTranspose_SeqSBAIJ_4;
1492:       B->ops->mult            = MatMult_SeqSBAIJ_4;
1493:       B->ops->multadd         = MatMultAdd_SeqSBAIJ_4;
1494:       break;
1495:     case 5:
1496:       B->ops->choleskyfactornumeric = MatCholeskyFactorNumeric_SeqSBAIJ_5;
1497:       B->ops->solve           = MatSolve_SeqSBAIJ_5;
1498:       B->ops->solvetranspose  = MatSolveTranspose_SeqSBAIJ_5;
1499:       B->ops->mult            = MatMult_SeqSBAIJ_5;
1500:       B->ops->multadd         = MatMultAdd_SeqSBAIJ_5;
1501:       break;
1502:     case 6:
1503:       B->ops->choleskyfactornumeric = MatCholeskyFactorNumeric_SeqSBAIJ_6;
1504:       B->ops->solve           = MatSolve_SeqSBAIJ_6;
1505:       B->ops->solvetranspose  = MatSolveTranspose_SeqSBAIJ_6;
1506:       B->ops->mult            = MatMult_SeqSBAIJ_6;
1507:       B->ops->multadd         = MatMultAdd_SeqSBAIJ_6;
1508:       break;
1509:     case 7:
1510:       B->ops->choleskyfactornumeric = MatCholeskyFactorNumeric_SeqSBAIJ_7;
1511:       B->ops->solve           = MatSolve_SeqSBAIJ_7;
1512:       B->ops->solvetranspose  = MatSolveTranspose_SeqSBAIJ_7;
1513:       B->ops->mult            = MatMult_SeqSBAIJ_7;
1514:       B->ops->multadd         = MatMultAdd_SeqSBAIJ_7;
1515:       break;
1516:     }
1517:   }

1519:   b->mbs = mbs;
1520:   b->nbs = mbs;
1521:   PetscMalloc((mbs+1)*sizeof(int),&b->imax);
1522:   if (!nnz) {
1523:     if (nz == PETSC_DEFAULT || nz == PETSC_DECIDE) nz = 5;
1524:     else if (nz <= 0)        nz = 1;
1525:     for (i=0; i<mbs; i++) {
1526:       b->imax[i] = nz;
1527:     }
1528:     nz = nz*mbs; /* total nz */
1529:   } else {
1530:     nz = 0;
1531:     for (i=0; i<mbs; i++) {b->imax[i] = nnz[i]; nz += nnz[i];}
1532:   }
1533:   /* s_nz=(nz+mbs)/2; */ /* total diagonal and superdiagonal nonzero blocks */
1534:   s_nz = nz;

1536:   /* allocate the matrix space */
1537:   len  = s_nz*sizeof(int) + s_nz*bs2*sizeof(MatScalar) + (B->m+1)*sizeof(int);
1538:   PetscMalloc(len,&b->a);
1539:   PetscMemzero(b->a,s_nz*bs2*sizeof(MatScalar));
1540:   b->j = (int*)(b->a + s_nz*bs2);
1541:   PetscMemzero(b->j,s_nz*sizeof(int));
1542:   b->i = b->j + s_nz;
1543:   b->singlemalloc = PETSC_TRUE;

1545:   /* pointer to beginning of each row */
1546:   b->i[0] = 0;
1547:   for (i=1; i<mbs+1; i++) {
1548:     b->i[i] = b->i[i-1] + b->imax[i-1];
1549:   }

1551:   /* b->ilen will count nonzeros in each block row so far. */
1552:   PetscMalloc((mbs+1)*sizeof(int),&b->ilen);
1553:   PetscLogObjectMemory(B,len+2*(mbs+1)*sizeof(int)+sizeof(struct _p_Mat)+sizeof(Mat_SeqSBAIJ));
1554:   for (i=0; i<mbs; i++) { b->ilen[i] = 0;}
1555: 
1556:   b->bs               = bs;
1557:   b->bs2              = bs2;
1558:   b->s_nz             = 0;
1559:   b->s_maxnz          = s_nz*bs2;
1560: 
1561:   b->inew             = 0;
1562:   b->jnew             = 0;
1563:   b->anew             = 0;
1564:   b->a2anew           = 0;
1565:   b->permute          = PETSC_FALSE;
1566:   return(0);
1567: }
1568: EXTERN_C_END

1570: /*MC
1571:    MATSEQSBAIJ - MATSEQSBAIJ = "seqsbaij" - A matrix type to be used for sequential symmetric block sparse matrices, 
1572:    based on block compressed sparse row format.  Only the upper triangular portion of the matrix is stored.

1574:    Options Database Keys:
1575: . -mat_type seqsbaij - sets the matrix type to "seqsbaij" during a call to MatSetFromOptions()

1577:   Level: beginner

1579: .seealso: MatCreateSeqSBAIJ
1580: M*/

1582: EXTERN_C_BEGIN
1585: int MatCreate_SeqSBAIJ(Mat B)
1586: {
1587:   Mat_SeqSBAIJ *b;
1588:   int          ierr,size;

1591:   MPI_Comm_size(B->comm,&size);
1592:   if (size > 1) SETERRQ(PETSC_ERR_ARG_WRONG,"Comm must be of size 1");
1593:   B->m = B->M = PetscMax(B->m,B->M);
1594:   B->n = B->N = PetscMax(B->n,B->N);

1596:   PetscNew(Mat_SeqSBAIJ,&b);
1597:   B->data = (void*)b;
1598:   PetscMemzero(b,sizeof(Mat_SeqSBAIJ));
1599:   PetscMemcpy(B->ops,&MatOps_Values,sizeof(struct _MatOps));
1600:   B->ops->destroy     = MatDestroy_SeqSBAIJ;
1601:   B->ops->view        = MatView_SeqSBAIJ;
1602:   B->factor           = 0;
1603:   B->lupivotthreshold = 1.0;
1604:   B->mapping          = 0;
1605:   b->row              = 0;
1606:   b->icol             = 0;
1607:   b->reallocs         = 0;
1608:   b->saved_values     = 0;
1609: 
1610:   PetscMapCreateMPI(B->comm,B->m,B->M,&B->rmap);
1611:   PetscMapCreateMPI(B->comm,B->n,B->N,&B->cmap);

1613:   b->sorted           = PETSC_FALSE;
1614:   b->roworiented      = PETSC_TRUE;
1615:   b->nonew            = 0;
1616:   b->diag             = 0;
1617:   b->solve_work       = 0;
1618:   b->mult_work        = 0;
1619:   B->spptr            = 0;
1620:   b->keepzeroedrows   = PETSC_FALSE;
1621:   b->xtoy             = 0;
1622:   b->XtoY             = 0;
1623: 
1624:   b->inew             = 0;
1625:   b->jnew             = 0;
1626:   b->anew             = 0;
1627:   b->a2anew           = 0;
1628:   b->permute          = PETSC_FALSE;

1630:   PetscObjectComposeFunctionDynamic((PetscObject)B,"MatStoreValues_C",
1631:                                      "MatStoreValues_SeqSBAIJ",
1632:                                      MatStoreValues_SeqSBAIJ);
1633:   PetscObjectComposeFunctionDynamic((PetscObject)B,"MatRetrieveValues_C",
1634:                                      "MatRetrieveValues_SeqSBAIJ",
1635:                                      (void*)MatRetrieveValues_SeqSBAIJ);
1636:   PetscObjectComposeFunctionDynamic((PetscObject)B,"MatSeqSBAIJSetColumnIndices_C",
1637:                                      "MatSeqSBAIJSetColumnIndices_SeqSBAIJ",
1638:                                      MatSeqSBAIJSetColumnIndices_SeqSBAIJ);
1639:   PetscObjectComposeFunctionDynamic((PetscObject)B,"MatSeqSBAIJSetPreallocation_C",
1640:                                      "MatSeqSBAIJSetPreallocation_SeqSBAIJ",
1641:                                      MatSeqSBAIJSetPreallocation_SeqSBAIJ);
1642:   return(0);
1643: }
1644: EXTERN_C_END

1648: /*@C
1649:    MatSeqSBAIJSetPreallocation - Creates a sparse symmetric matrix in block AIJ (block
1650:    compressed row) format.  For good matrix assembly performance the
1651:    user should preallocate the matrix storage by setting the parameter nz
1652:    (or the array nnz).  By setting these parameters accurately, performance
1653:    during matrix assembly can be increased by more than a factor of 50.

1655:    Collective on Mat

1657:    Input Parameters:
1658: +  A - the symmetric matrix 
1659: .  bs - size of block
1660: .  nz - number of block nonzeros per block row (same for all rows)
1661: -  nnz - array containing the number of block nonzeros in the upper triangular plus
1662:          diagonal portion of each block (possibly different for each block row) or PETSC_NULL

1664:    Options Database Keys:
1665: .   -mat_no_unroll - uses code that does not unroll the loops in the 
1666:                      block calculations (much slower)
1667: .    -mat_block_size - size of the blocks to use

1669:    Level: intermediate

1671:    Notes:
1672:    Specify the preallocated storage with either nz or nnz (not both).
1673:    Set nz=PETSC_DEFAULT and nnz=PETSC_NULL for PETSc to control dynamic memory 
1674:    allocation.  For additional details, see the users manual chapter on
1675:    matrices.

1677: .seealso: MatCreate(), MatCreateSeqAIJ(), MatSetValues(), MatCreateMPISBAIJ()
1678: @*/
1679: int MatSeqSBAIJSetPreallocation(Mat B,int bs,int nz,const int nnz[]) {
1680:   int ierr,(*f)(Mat,int,int,const int[]);

1683:   PetscObjectQueryFunction((PetscObject)B,"MatSeqSBAIJSetPreallocation_C",(void (**)(void))&f);
1684:   if (f) {
1685:     (*f)(B,bs,nz,nnz);
1686:   }
1687:   return(0);
1688: }

1692: /*@C
1693:    MatCreateSeqSBAIJ - Creates a sparse symmetric matrix in block AIJ (block
1694:    compressed row) format.  For good matrix assembly performance the
1695:    user should preallocate the matrix storage by setting the parameter nz
1696:    (or the array nnz).  By setting these parameters accurately, performance
1697:    during matrix assembly can be increased by more than a factor of 50.

1699:    Collective on MPI_Comm

1701:    Input Parameters:
1702: +  comm - MPI communicator, set to PETSC_COMM_SELF
1703: .  bs - size of block
1704: .  m - number of rows, or number of columns
1705: .  nz - number of block nonzeros per block row (same for all rows)
1706: -  nnz - array containing the number of block nonzeros in the upper triangular plus
1707:          diagonal portion of each block (possibly different for each block row) or PETSC_NULL

1709:    Output Parameter:
1710: .  A - the symmetric matrix 

1712:    Options Database Keys:
1713: .   -mat_no_unroll - uses code that does not unroll the loops in the 
1714:                      block calculations (much slower)
1715: .    -mat_block_size - size of the blocks to use

1717:    Level: intermediate

1719:    Notes:

1721:    Specify the preallocated storage with either nz or nnz (not both).
1722:    Set nz=PETSC_DEFAULT and nnz=PETSC_NULL for PETSc to control dynamic memory 
1723:    allocation.  For additional details, see the users manual chapter on
1724:    matrices.

1726: .seealso: MatCreate(), MatCreateSeqAIJ(), MatSetValues(), MatCreateMPISBAIJ()
1727: @*/
1728: int MatCreateSeqSBAIJ(MPI_Comm comm,int bs,int m,int n,int nz,const int nnz[],Mat *A)
1729: {
1731: 
1733:   MatCreate(comm,m,n,m,n,A);
1734:   MatSetType(*A,MATSEQSBAIJ);
1735:   MatSeqSBAIJSetPreallocation(*A,bs,nz,nnz);
1736:   return(0);
1737: }

1741: int MatDuplicate_SeqSBAIJ(Mat A,MatDuplicateOption cpvalues,Mat *B)
1742: {
1743:   Mat         C;
1744:   Mat_SeqSBAIJ *c,*a = (Mat_SeqSBAIJ*)A->data;
1745:   int         i,len,mbs = a->mbs,nz = a->s_nz,bs2 =a->bs2,ierr;

1748:   if (a->i[mbs] != nz) SETERRQ(PETSC_ERR_PLIB,"Corrupt matrix");

1750:   *B = 0;
1751:   MatCreate(A->comm,A->m,A->n,A->m,A->n,&C);
1752:   MatSetType(C,MATSEQSBAIJ);
1753:   c    = (Mat_SeqSBAIJ*)C->data;

1755:   PetscMemcpy(C->ops,A->ops,sizeof(struct _MatOps));
1756:   C->preallocated   = PETSC_TRUE;
1757:   C->factor         = A->factor;
1758:   c->row            = 0;
1759:   c->icol           = 0;
1760:   c->saved_values   = 0;
1761:   c->keepzeroedrows = a->keepzeroedrows;
1762:   C->assembled      = PETSC_TRUE;

1764:   c->bs         = a->bs;
1765:   c->bs2        = a->bs2;
1766:   c->mbs        = a->mbs;
1767:   c->nbs        = a->nbs;

1769:   PetscMalloc((mbs+1)*sizeof(int),&c->imax);
1770:   PetscMalloc((mbs+1)*sizeof(int),&c->ilen);
1771:   for (i=0; i<mbs; i++) {
1772:     c->imax[i] = a->imax[i];
1773:     c->ilen[i] = a->ilen[i];
1774:   }

1776:   /* allocate the matrix space */
1777:   c->singlemalloc = PETSC_TRUE;
1778:   len  = (mbs+1)*sizeof(int) + nz*(bs2*sizeof(MatScalar) + sizeof(int));
1779:   PetscMalloc(len,&c->a);
1780:   c->j = (int*)(c->a + nz*bs2);
1781:   c->i = c->j + nz;
1782:   PetscMemcpy(c->i,a->i,(mbs+1)*sizeof(int));
1783:   if (mbs > 0) {
1784:     PetscMemcpy(c->j,a->j,nz*sizeof(int));
1785:     if (cpvalues == MAT_COPY_VALUES) {
1786:       PetscMemcpy(c->a,a->a,bs2*nz*sizeof(MatScalar));
1787:     } else {
1788:       PetscMemzero(c->a,bs2*nz*sizeof(MatScalar));
1789:     }
1790:   }

1792:   PetscLogObjectMemory(C,len+2*(mbs+1)*sizeof(int)+sizeof(struct _p_Mat)+sizeof(Mat_SeqSBAIJ));
1793:   c->sorted      = a->sorted;
1794:   c->roworiented = a->roworiented;
1795:   c->nonew       = a->nonew;

1797:   if (a->diag) {
1798:     PetscMalloc((mbs+1)*sizeof(int),&c->diag);
1799:     PetscLogObjectMemory(C,(mbs+1)*sizeof(int));
1800:     for (i=0; i<mbs; i++) {
1801:       c->diag[i] = a->diag[i];
1802:     }
1803:   } else c->diag        = 0;
1804:   c->s_nz               = a->s_nz;
1805:   c->s_maxnz            = a->s_maxnz;
1806:   c->solve_work         = 0;
1807:   C->spptr              = 0;      /* Dangerous -I'm throwing away a->spptr */
1808:   c->mult_work          = 0;
1809:   *B = C;
1810:   PetscFListDuplicate(A->qlist,&C->qlist);
1811:   return(0);
1812: }

1816: int MatLoad_SeqSBAIJ(PetscViewer viewer,MatType type,Mat *A)
1817: {
1818:   Mat_SeqSBAIJ *a;
1819:   Mat          B;
1820:   int          i,nz,ierr,fd,header[4],size,*rowlengths=0,M,N,bs=1;
1821:   int          *mask,mbs,*jj,j,rowcount,nzcount,k,*s_browlengths,maskcount;
1822:   int          kmax,jcount,block,idx,point,nzcountb,extra_rows;
1823:   int          *masked,nmask,tmp,bs2,ishift;
1824:   PetscScalar  *aa;
1825:   MPI_Comm     comm = ((PetscObject)viewer)->comm;

1828:   PetscOptionsGetInt(PETSC_NULL,"-matload_block_size",&bs,PETSC_NULL);
1829:   bs2  = bs*bs;

1831:   MPI_Comm_size(comm,&size);
1832:   if (size > 1) SETERRQ(PETSC_ERR_ARG_WRONG,"view must have one processor");
1833:   PetscViewerBinaryGetDescriptor(viewer,&fd);
1834:   PetscBinaryRead(fd,header,4,PETSC_INT);
1835:   if (header[0] != MAT_FILE_COOKIE) SETERRQ(PETSC_ERR_FILE_UNEXPECTED,"not Mat object");
1836:   M = header[1]; N = header[2]; nz = header[3];

1838:   if (header[3] < 0) {
1839:     SETERRQ(PETSC_ERR_FILE_UNEXPECTED,"Matrix stored in special format, cannot load as SeqSBAIJ");
1840:   }

1842:   if (M != N) SETERRQ(PETSC_ERR_SUP,"Can only do square matrices");

1844:   /* 
1845:      This code adds extra rows to make sure the number of rows is 
1846:     divisible by the blocksize
1847:   */
1848:   mbs        = M/bs;
1849:   extra_rows = bs - M + bs*(mbs);
1850:   if (extra_rows == bs) extra_rows = 0;
1851:   else                  mbs++;
1852:   if (extra_rows) {
1853:     PetscLogInfo(0,"MatLoad_SeqSBAIJ:Padding loaded matrix to match blocksize\n");
1854:   }

1856:   /* read in row lengths */
1857:   PetscMalloc((M+extra_rows)*sizeof(int),&rowlengths);
1858:   PetscBinaryRead(fd,rowlengths,M,PETSC_INT);
1859:   for (i=0; i<extra_rows; i++) rowlengths[M+i] = 1;

1861:   /* read in column indices */
1862:   PetscMalloc((nz+extra_rows)*sizeof(int),&jj);
1863:   PetscBinaryRead(fd,jj,nz,PETSC_INT);
1864:   for (i=0; i<extra_rows; i++) jj[nz+i] = M+i;

1866:   /* loop over row lengths determining block row lengths */
1867:   PetscMalloc(mbs*sizeof(int),&s_browlengths);
1868:   PetscMemzero(s_browlengths,mbs*sizeof(int));
1869:   PetscMalloc(2*mbs*sizeof(int),&mask);
1870:   PetscMemzero(mask,mbs*sizeof(int));
1871:   masked   = mask + mbs;
1872:   rowcount = 0; nzcount = 0;
1873:   for (i=0; i<mbs; i++) {
1874:     nmask = 0;
1875:     for (j=0; j<bs; j++) {
1876:       kmax = rowlengths[rowcount];
1877:       for (k=0; k<kmax; k++) {
1878:         tmp = jj[nzcount++]/bs;   /* block col. index */
1879:         if (!mask[tmp] && tmp >= i) {masked[nmask++] = tmp; mask[tmp] = 1;}
1880:       }
1881:       rowcount++;
1882:     }
1883:     s_browlengths[i] += nmask;
1884: 
1885:     /* zero out the mask elements we set */
1886:     for (j=0; j<nmask; j++) mask[masked[j]] = 0;
1887:   }

1889:   /* create our matrix */
1890:   MatCreate(comm,M+extra_rows,N+extra_rows,M+extra_rows,N+extra_rows,&B);
1891:   MatSetType(B,type);
1892:   MatSeqSBAIJSetPreallocation(B,bs,0,s_browlengths);
1893:   a = (Mat_SeqSBAIJ*)B->data;

1895:   /* set matrix "i" values */
1896:   a->i[0] = 0;
1897:   for (i=1; i<= mbs; i++) {
1898:     a->i[i]      = a->i[i-1] + s_browlengths[i-1];
1899:     a->ilen[i-1] = s_browlengths[i-1];
1900:   }
1901:   a->s_nz = a->i[mbs];

1903:   /* read in nonzero values */
1904:   PetscMalloc((nz+extra_rows)*sizeof(PetscScalar),&aa);
1905:   PetscBinaryRead(fd,aa,nz,PETSC_SCALAR);
1906:   for (i=0; i<extra_rows; i++) aa[nz+i] = 1.0;

1908:   /* set "a" and "j" values into matrix */
1909:   nzcount = 0; jcount = 0;
1910:   for (i=0; i<mbs; i++) {
1911:     nzcountb = nzcount;
1912:     nmask    = 0;
1913:     for (j=0; j<bs; j++) {
1914:       kmax = rowlengths[i*bs+j];
1915:       for (k=0; k<kmax; k++) {
1916:         tmp = jj[nzcount++]/bs; /* block col. index */
1917:         if (!mask[tmp] && tmp >= i) { masked[nmask++] = tmp; mask[tmp] = 1;}
1918:       }
1919:     }
1920:     /* sort the masked values */
1921:     PetscSortInt(nmask,masked);

1923:     /* set "j" values into matrix */
1924:     maskcount = 1;
1925:     for (j=0; j<nmask; j++) {
1926:       a->j[jcount++]  = masked[j];
1927:       mask[masked[j]] = maskcount++;
1928:     }

1930:     /* set "a" values into matrix */
1931:     ishift = bs2*a->i[i];
1932:     for (j=0; j<bs; j++) {
1933:       kmax = rowlengths[i*bs+j];
1934:       for (k=0; k<kmax; k++) {
1935:         tmp       = jj[nzcountb]/bs ; /* block col. index */
1936:         if (tmp >= i){
1937:           block     = mask[tmp] - 1;
1938:           point     = jj[nzcountb] - bs*tmp;
1939:           idx       = ishift + bs2*block + j + bs*point;
1940:           a->a[idx] = aa[nzcountb];
1941:         }
1942:         nzcountb++;
1943:       }
1944:     }
1945:     /* zero out the mask elements we set */
1946:     for (j=0; j<nmask; j++) mask[masked[j]] = 0;
1947:   }
1948:   if (jcount != a->s_nz) SETERRQ(PETSC_ERR_FILE_UNEXPECTED,"Bad binary matrix");

1950:   PetscFree(rowlengths);
1951:   PetscFree(s_browlengths);
1952:   PetscFree(aa);
1953:   PetscFree(jj);
1954:   PetscFree(mask);

1956:   MatAssemblyBegin(B,MAT_FINAL_ASSEMBLY);
1957:   MatAssemblyEnd(B,MAT_FINAL_ASSEMBLY);
1958:   MatView_Private(B);
1959:   *A = B;
1960:   return(0);
1961: }

1965: int MatRelax_SeqSBAIJ(Mat A,Vec bb,PetscReal omega,MatSORType flag,PetscReal fshift,int its,int lits,Vec xx)
1966: {
1967:   Mat_SeqSBAIJ *a = (Mat_SeqSBAIJ*)A->data;
1968:   MatScalar    *aa=a->a,*v,*v1;
1969:   PetscScalar  *x,*b,*t,sum,d;
1970:   int          m=a->mbs,bs=a->bs,*ai=a->i,*aj=a->j,ierr;
1971:   int          nz,nz1,*vj,*vj1,i;

1974:   its = its*lits;
1975:   if (its <= 0) SETERRQ2(PETSC_ERR_ARG_WRONG,"Relaxation requires global its %d and local its %d both positive",its,lits);

1977:   if (bs > 1)
1978:     SETERRQ(PETSC_ERR_SUP,"SSOR for block size > 1 is not yet implemented");

1980:   VecGetArray(xx,&x);
1981:   if (xx != bb) {
1982:     VecGetArray(bb,&b);
1983:   } else {
1984:     b = x;
1985:   }

1987:   PetscMalloc(m*sizeof(PetscScalar),&t);
1988: 
1989:   if (flag & SOR_ZERO_INITIAL_GUESS) {
1990:     if (flag & SOR_FORWARD_SWEEP || flag & SOR_LOCAL_FORWARD_SWEEP){
1991:       for (i=0; i<m; i++)
1992:         t[i] = b[i];

1994:       for (i=0; i<m; i++){
1995:         d  = *(aa + ai[i]);  /* diag[i] */
1996:         v  = aa + ai[i] + 1;
1997:         vj = aj + ai[i] + 1;
1998:         nz = ai[i+1] - ai[i] - 1;
1999:         x[i] = omega*t[i]/d;
2000:         while (nz--) t[*vj++] -= x[i]*(*v++); /* update rhs */
2001:         PetscLogFlops(2*nz-1);
2002:       }
2003:     }

2005:     if (flag & SOR_BACKWARD_SWEEP || flag & SOR_LOCAL_BACKWARD_SWEEP){
2006:       for (i=0; i<m; i++)
2007:         t[i] = b[i];
2008: 
2009:       for (i=0; i<m-1; i++){  /* update rhs */
2010:         v  = aa + ai[i] + 1;
2011:         vj = aj + ai[i] + 1;
2012:         nz = ai[i+1] - ai[i] - 1;
2013:         while (nz--) t[*vj++] -= x[i]*(*v++);
2014:         PetscLogFlops(2*nz-1);
2015:       }
2016:       for (i=m-1; i>=0; i--){
2017:         d  = *(aa + ai[i]);
2018:         v  = aa + ai[i] + 1;
2019:         vj = aj + ai[i] + 1;
2020:         nz = ai[i+1] - ai[i] - 1;
2021:         sum = t[i];
2022:         while (nz--) sum -= x[*vj++]*(*v++);
2023:         PetscLogFlops(2*nz-1);
2024:         x[i] =   (1-omega)*x[i] + omega*sum/d;
2025:       }
2026:     }
2027:     its--;
2028:   }

2030:   while (its--) {
2031:     /* 
2032:        forward sweep:
2033:        for i=0,...,m-1:
2034:          sum[i] = (b[i] - U(i,:)x )/d[i];
2035:          x[i]   = (1-omega)x[i] + omega*sum[i];
2036:          b      = b - x[i]*U^T(i,:);
2037:          
2038:     */
2039:     if (flag & SOR_FORWARD_SWEEP || flag & SOR_LOCAL_FORWARD_SWEEP){
2040:       for (i=0; i<m; i++)
2041:         t[i] = b[i];

2043:       for (i=0; i<m; i++){
2044:         d  = *(aa + ai[i]);  /* diag[i] */
2045:         v  = aa + ai[i] + 1; v1=v;
2046:         vj = aj + ai[i] + 1; vj1=vj;
2047:         nz = ai[i+1] - ai[i] - 1; nz1=nz;
2048:         sum = t[i];
2049:         while (nz1--) sum -= (*v1++)*x[*vj1++];
2050:         x[i] = (1-omega)*x[i] + omega*sum/d;
2051:         while (nz--) t[*vj++] -= x[i]*(*v++);
2052:         PetscLogFlops(4*nz-2);
2053:       }
2054:     }
2055: 
2056:   if (flag & SOR_BACKWARD_SWEEP || flag & SOR_LOCAL_BACKWARD_SWEEP){
2057:       /* 
2058:        backward sweep:
2059:        b = b - x[i]*U^T(i,:), i=0,...,n-2
2060:        for i=m-1,...,0:
2061:          sum[i] = (b[i] - U(i,:)x )/d[i];
2062:          x[i]   = (1-omega)x[i] + omega*sum[i];
2063:       */
2064:       for (i=0; i<m; i++)
2065:         t[i] = b[i];
2066: 
2067:       for (i=0; i<m-1; i++){  /* update rhs */
2068:         v  = aa + ai[i] + 1;
2069:         vj = aj + ai[i] + 1;
2070:         nz = ai[i+1] - ai[i] - 1;
2071:         while (nz--) t[*vj++] -= x[i]*(*v++);
2072:         PetscLogFlops(2*nz-1);
2073:       }
2074:       for (i=m-1; i>=0; i--){
2075:         d  = *(aa + ai[i]);
2076:         v  = aa + ai[i] + 1;
2077:         vj = aj + ai[i] + 1;
2078:         nz = ai[i+1] - ai[i] - 1;
2079:         sum = t[i];
2080:         while (nz--) sum -= x[*vj++]*(*v++);
2081:         PetscLogFlops(2*nz-1);
2082:         x[i] =   (1-omega)*x[i] + omega*sum/d;
2083:       }
2084:     }
2085:   }

2087:   PetscFree(t);
2088:   VecRestoreArray(xx,&x);
2089:   if (bb != xx) {
2090:     VecRestoreArray(bb,&b);
2091:   }

2093:   return(0);
2094: }