Actual source code: sbaij.c
1: #define PETSCMAT_DLL
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/inline/spops.h
9: #include src/mat/impls/sbaij/seq/sbaij.h
11: #define CHUNKSIZE 10
13: /*
14: Checks for missing diagonals
15: */
18: PetscErrorCode MatMissingDiagonal_SeqSBAIJ(Mat A)
19: {
20: Mat_SeqSBAIJ *a = (Mat_SeqSBAIJ*)A->data;
22: PetscInt *diag,*jj = a->j,i;
25: MatMarkDiagonal_SeqSBAIJ(A);
26: diag = a->diag;
27: for (i=0; i<a->mbs; i++) {
28: if (jj[diag[i]] != i) SETERRQ1(PETSC_ERR_ARG_CORRUPT,"Matrix is missing diagonal number %D",i);
29: }
30: return(0);
31: }
35: PetscErrorCode MatMarkDiagonal_SeqSBAIJ(Mat A)
36: {
37: Mat_SeqSBAIJ *a = (Mat_SeqSBAIJ*)A->data;
39: PetscInt i,mbs = a->mbs;
42: if (a->diag) return(0);
44: PetscMalloc((mbs+1)*sizeof(PetscInt),&a->diag);
45: PetscLogObjectMemory(A,(mbs+1)*sizeof(PetscInt));
46: for (i=0; i<mbs; i++) a->diag[i] = a->i[i];
47: return(0);
48: }
52: static PetscErrorCode MatGetRowIJ_SeqSBAIJ(Mat A,PetscInt oshift,PetscTruth symmetric,PetscInt *nn,PetscInt *ia[],PetscInt *ja[],PetscTruth *done)
53: {
54: Mat_SeqSBAIJ *a = (Mat_SeqSBAIJ*)A->data;
55: PetscInt n = a->mbs,i;
58: *nn = n;
59: if (!ia) return(0);
61: if (oshift == 1) {
62: /* temporarily add 1 to i and j indices */
63: PetscInt nz = a->i[n];
64: for (i=0; i<nz; i++) a->j[i]++;
65: for (i=0; i<n+1; i++) a->i[i]++;
66: *ia = a->i; *ja = a->j;
67: } else {
68: *ia = a->i; *ja = a->j;
69: }
70: return(0);
71: }
75: static PetscErrorCode MatRestoreRowIJ_SeqSBAIJ(Mat A,PetscInt oshift,PetscTruth symmetric,PetscInt *nn,PetscInt *ia[],PetscInt *ja[],PetscTruth *done)
76: {
77: Mat_SeqSBAIJ *a = (Mat_SeqSBAIJ*)A->data;
78: PetscInt i,n = a->mbs;
81: if (!ia) return(0);
83: if (oshift == 1) {
84: PetscInt nz = a->i[n]-1;
85: for (i=0; i<nz; i++) a->j[i]--;
86: for (i=0; i<n+1; i++) a->i[i]--;
87: }
88: return(0);
89: }
93: PetscErrorCode MatDestroy_SeqSBAIJ(Mat A)
94: {
95: Mat_SeqSBAIJ *a = (Mat_SeqSBAIJ*)A->data;
99: #if defined(PETSC_USE_LOG)
100: PetscLogObjectState((PetscObject)A,"Rows=%D, NZ=%D",A->rmap.N,a->nz);
101: #endif
102: MatSeqXAIJFreeAIJ(a->singlemalloc,&a->a,&a->j,&a->i);
103: if (a->row) {
104: ISDestroy(a->row);
105: }
106: PetscFree(a->diag);
107: PetscFree2(a->imax,a->ilen);
108: if (a->icol) {ISDestroy(a->icol);}
109: PetscFree(a->solve_work);
110: PetscFree(a->solves_work);
111: PetscFree(a->mult_work);
112: PetscFree(a->saved_values);
113: PetscFree(a->xtoy);
115: PetscFree(a->inew);
116: PetscFree(a);
118: PetscObjectComposeFunction((PetscObject)A,"MatStoreValues_C","",PETSC_NULL);
119: PetscObjectComposeFunction((PetscObject)A,"MatRetrieveValues_C","",PETSC_NULL);
120: PetscObjectComposeFunction((PetscObject)A,"MatSeqSBAIJSetColumnIndices_C","",PETSC_NULL);
121: PetscObjectComposeFunction((PetscObject)A,"MatConvert_seqsbaij_seqaij_C","",PETSC_NULL);
122: PetscObjectComposeFunction((PetscObject)A,"MatConvert_seqsbaij_seqbaij_C","",PETSC_NULL);
123: PetscObjectComposeFunction((PetscObject)A,"MatSeqSBAIJSetPreallocation_C","",PETSC_NULL);
124: return(0);
125: }
129: PetscErrorCode MatSetOption_SeqSBAIJ(Mat A,MatOption op)
130: {
131: Mat_SeqSBAIJ *a = (Mat_SeqSBAIJ*)A->data;
135: switch (op) {
136: case MAT_ROW_ORIENTED:
137: a->roworiented = PETSC_TRUE;
138: break;
139: case MAT_COLUMN_ORIENTED:
140: a->roworiented = PETSC_FALSE;
141: break;
142: case MAT_COLUMNS_SORTED:
143: a->sorted = PETSC_TRUE;
144: break;
145: case MAT_COLUMNS_UNSORTED:
146: a->sorted = PETSC_FALSE;
147: break;
148: case MAT_KEEP_ZEROED_ROWS:
149: a->keepzeroedrows = PETSC_TRUE;
150: break;
151: case MAT_NO_NEW_NONZERO_LOCATIONS:
152: a->nonew = 1;
153: break;
154: case MAT_NEW_NONZERO_LOCATION_ERR:
155: a->nonew = -1;
156: break;
157: case MAT_NEW_NONZERO_ALLOCATION_ERR:
158: a->nonew = -2;
159: break;
160: case MAT_YES_NEW_NONZERO_LOCATIONS:
161: a->nonew = 0;
162: break;
163: case MAT_ROWS_SORTED:
164: case MAT_ROWS_UNSORTED:
165: case MAT_YES_NEW_DIAGONALS:
166: case MAT_IGNORE_OFF_PROC_ENTRIES:
167: case MAT_USE_HASH_TABLE:
168: PetscInfo(A,"Option ignored\n");
169: break;
170: case MAT_NO_NEW_DIAGONALS:
171: SETERRQ(PETSC_ERR_SUP,"MAT_NO_NEW_DIAGONALS");
172: case MAT_NOT_SYMMETRIC:
173: case MAT_NOT_STRUCTURALLY_SYMMETRIC:
174: case MAT_HERMITIAN:
175: SETERRQ(PETSC_ERR_SUP,"Matrix must be symmetric");
176: case MAT_SYMMETRIC:
177: case MAT_STRUCTURALLY_SYMMETRIC:
178: case MAT_NOT_HERMITIAN:
179: case MAT_SYMMETRY_ETERNAL:
180: case MAT_NOT_SYMMETRY_ETERNAL:
181: case MAT_IGNORE_LOWER_TRIANGULAR:
182: a->ignore_ltriangular = PETSC_TRUE;
183: break;
184: case MAT_ERROR_LOWER_TRIANGULAR:
185: a->ignore_ltriangular = PETSC_FALSE;
186: break;
187: case MAT_GETROW_UPPERTRIANGULAR:
188: a->getrow_utriangular = PETSC_TRUE;
189: break;
190: default:
191: SETERRQ(PETSC_ERR_SUP,"unknown option");
192: }
193: return(0);
194: }
198: PetscErrorCode MatGetRow_SeqSBAIJ(Mat A,PetscInt row,PetscInt *ncols,PetscInt **cols,PetscScalar **v)
199: {
200: Mat_SeqSBAIJ *a = (Mat_SeqSBAIJ*)A->data;
202: PetscInt itmp,i,j,k,M,*ai,*aj,bs,bn,bp,*cols_i,bs2;
203: MatScalar *aa,*aa_i;
204: PetscScalar *v_i;
207: if (A && !a->getrow_utriangular) SETERRQ(PETSC_ERR_SUP,"MatGetRow is not supported for SBAIJ matrix format. Getting the upper triangular part of row, run with -mat_getrow_uppertriangular, call MatSetOption(mat,MAT_GETROW_UPPERTRIANGULAR) or MatGetRowUpperTriangular()");
208: /* Get the upper triangular part of the row */
209: bs = A->rmap.bs;
210: ai = a->i;
211: aj = a->j;
212: aa = a->a;
213: bs2 = a->bs2;
214:
215: if (row < 0 || row >= A->rmap.N) SETERRQ1(PETSC_ERR_ARG_OUTOFRANGE, "Row %D out of range", row);
216:
217: bn = row/bs; /* Block number */
218: bp = row % bs; /* Block position */
219: M = ai[bn+1] - ai[bn];
220: *ncols = bs*M;
221:
222: if (v) {
223: *v = 0;
224: if (*ncols) {
225: PetscMalloc((*ncols+row)*sizeof(PetscScalar),v);
226: for (i=0; i<M; i++) { /* for each block in the block row */
227: v_i = *v + i*bs;
228: aa_i = aa + bs2*(ai[bn] + i);
229: for (j=bp,k=0; j<bs2; j+=bs,k++) {v_i[k] = aa_i[j];}
230: }
231: }
232: }
233:
234: if (cols) {
235: *cols = 0;
236: if (*ncols) {
237: PetscMalloc((*ncols+row)*sizeof(PetscInt),cols);
238: for (i=0; i<M; i++) { /* for each block in the block row */
239: cols_i = *cols + i*bs;
240: itmp = bs*aj[ai[bn] + i];
241: for (j=0; j<bs; j++) {cols_i[j] = itmp++;}
242: }
243: }
244: }
245:
246: /*search column A(0:row-1,row) (=A(row,0:row-1)). Could be expensive! */
247: /* this segment is currently removed, so only entries in the upper triangle are obtained */
248: #ifdef column_search
249: v_i = *v + M*bs;
250: cols_i = *cols + M*bs;
251: for (i=0; i<bn; i++){ /* for each block row */
252: M = ai[i+1] - ai[i];
253: for (j=0; j<M; j++){
254: itmp = aj[ai[i] + j]; /* block column value */
255: if (itmp == bn){
256: aa_i = aa + bs2*(ai[i] + j) + bs*bp;
257: for (k=0; k<bs; k++) {
258: *cols_i++ = i*bs+k;
259: *v_i++ = aa_i[k];
260: }
261: *ncols += bs;
262: break;
263: }
264: }
265: }
266: #endif
267: return(0);
268: }
272: PetscErrorCode MatRestoreRow_SeqSBAIJ(Mat A,PetscInt row,PetscInt *nz,PetscInt **idx,PetscScalar **v)
273: {
275:
277: if (idx) {PetscFree(*idx);}
278: if (v) {PetscFree(*v);}
279: return(0);
280: }
284: PetscErrorCode MatGetRowUpperTriangular_SeqSBAIJ(Mat A)
285: {
286: Mat_SeqSBAIJ *a = (Mat_SeqSBAIJ*)A->data;
289: a->getrow_utriangular = PETSC_TRUE;
290: return(0);
291: }
294: PetscErrorCode MatRestoreRowUpperTriangular_SeqSBAIJ(Mat A)
295: {
296: Mat_SeqSBAIJ *a = (Mat_SeqSBAIJ*)A->data;
299: a->getrow_utriangular = PETSC_FALSE;
300: return(0);
301: }
305: PetscErrorCode MatTranspose_SeqSBAIJ(Mat A,Mat *B)
306: {
309: MatDuplicate(A,MAT_COPY_VALUES,B);
310: return(0);
311: }
315: static PetscErrorCode MatView_SeqSBAIJ_ASCII(Mat A,PetscViewer viewer)
316: {
317: Mat_SeqSBAIJ *a = (Mat_SeqSBAIJ*)A->data;
318: PetscErrorCode ierr;
319: PetscInt i,j,bs = A->rmap.bs,k,l,bs2=a->bs2;
320: const char *name;
321: PetscViewerFormat format;
322:
324: PetscObjectGetName((PetscObject)A,&name);
325: PetscViewerGetFormat(viewer,&format);
326: if (format == PETSC_VIEWER_ASCII_INFO || format == PETSC_VIEWER_ASCII_INFO_DETAIL) {
327: PetscViewerASCIIPrintf(viewer," block size is %D\n",bs);
328: } else if (format == PETSC_VIEWER_ASCII_MATLAB) {
329: SETERRQ(PETSC_ERR_SUP,"Matlab format not supported");
330: } else if (format == PETSC_VIEWER_ASCII_COMMON) {
331: PetscViewerASCIIUseTabs(viewer,PETSC_NO);
332: for (i=0; i<a->mbs; i++) {
333: for (j=0; j<bs; j++) {
334: PetscViewerASCIIPrintf(viewer,"row %D:",i*bs+j);
335: for (k=a->i[i]; k<a->i[i+1]; k++) {
336: for (l=0; l<bs; l++) {
337: #if defined(PETSC_USE_COMPLEX)
338: if (PetscImaginaryPart(a->a[bs2*k + l*bs + j]) > 0.0 && PetscRealPart(a->a[bs2*k + l*bs + j]) != 0.0) {
339: PetscViewerASCIIPrintf(viewer," (%D, %G + %G i) ",bs*a->j[k]+l,
340: PetscRealPart(a->a[bs2*k + l*bs + j]),PetscImaginaryPart(a->a[bs2*k + l*bs + j]));
341: } else if (PetscImaginaryPart(a->a[bs2*k + l*bs + j]) < 0.0 && PetscRealPart(a->a[bs2*k + l*bs + j]) != 0.0) {
342: PetscViewerASCIIPrintf(viewer," (%D, %G - %G i) ",bs*a->j[k]+l,
343: PetscRealPart(a->a[bs2*k + l*bs + j]),-PetscImaginaryPart(a->a[bs2*k + l*bs + j]));
344: } else if (PetscRealPart(a->a[bs2*k + l*bs + j]) != 0.0) {
345: PetscViewerASCIIPrintf(viewer," (%D, %G) ",bs*a->j[k]+l,PetscRealPart(a->a[bs2*k + l*bs + j]));
346: }
347: #else
348: if (a->a[bs2*k + l*bs + j] != 0.0) {
349: PetscViewerASCIIPrintf(viewer," (%D, %G) ",bs*a->j[k]+l,a->a[bs2*k + l*bs + j]);
350: }
351: #endif
352: }
353: }
354: PetscViewerASCIIPrintf(viewer,"\n");
355: }
356: }
357: PetscViewerASCIIUseTabs(viewer,PETSC_YES);
358: } else if (format == PETSC_VIEWER_ASCII_FACTOR_INFO) {
359: return(0);
360: } else {
361: PetscViewerASCIIUseTabs(viewer,PETSC_NO);
362: for (i=0; i<a->mbs; i++) {
363: for (j=0; j<bs; j++) {
364: PetscViewerASCIIPrintf(viewer,"row %D:",i*bs+j);
365: for (k=a->i[i]; k<a->i[i+1]; k++) {
366: for (l=0; l<bs; l++) {
367: #if defined(PETSC_USE_COMPLEX)
368: if (PetscImaginaryPart(a->a[bs2*k + l*bs + j]) > 0.0) {
369: PetscViewerASCIIPrintf(viewer," (%D, %G + %G i) ",bs*a->j[k]+l,
370: PetscRealPart(a->a[bs2*k + l*bs + j]),PetscImaginaryPart(a->a[bs2*k + l*bs + j]));
371: } else if (PetscImaginaryPart(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 {
375: PetscViewerASCIIPrintf(viewer," (%D, %G) ",bs*a->j[k]+l,PetscRealPart(a->a[bs2*k + l*bs + j]));
376: }
377: #else
378: PetscViewerASCIIPrintf(viewer," %D %G ",bs*a->j[k]+l,a->a[bs2*k + l*bs + j]);
379: #endif
380: }
381: }
382: PetscViewerASCIIPrintf(viewer,"\n");
383: }
384: }
385: PetscViewerASCIIUseTabs(viewer,PETSC_YES);
386: }
387: PetscViewerFlush(viewer);
388: return(0);
389: }
393: static PetscErrorCode MatView_SeqSBAIJ_Draw_Zoom(PetscDraw draw,void *Aa)
394: {
395: Mat A = (Mat) Aa;
396: Mat_SeqSBAIJ *a=(Mat_SeqSBAIJ*)A->data;
398: PetscInt row,i,j,k,l,mbs=a->mbs,color,bs=A->rmap.bs,bs2=a->bs2;
399: PetscMPIInt rank;
400: PetscReal xl,yl,xr,yr,x_l,x_r,y_l,y_r;
401: MatScalar *aa;
402: MPI_Comm comm;
403: PetscViewer viewer;
404:
406: /*
407: This is nasty. If this is called from an originally parallel matrix
408: then all processes call this,but only the first has the matrix so the
409: rest should return immediately.
410: */
411: PetscObjectGetComm((PetscObject)draw,&comm);
412: MPI_Comm_rank(comm,&rank);
413: if (rank) return(0);
414:
415: PetscObjectQuery((PetscObject)A,"Zoomviewer",(PetscObject*)&viewer);
416:
417: PetscDrawGetCoordinates(draw,&xl,&yl,&xr,&yr);
418: PetscDrawString(draw, .3*(xl+xr), .3*(yl+yr), PETSC_DRAW_BLACK, "symmetric");
419:
420: /* loop over matrix elements drawing boxes */
421: color = PETSC_DRAW_BLUE;
422: for (i=0,row=0; i<mbs; i++,row+=bs) {
423: for (j=a->i[i]; j<a->i[i+1]; j++) {
424: y_l = A->rmap.N - row - 1.0; y_r = y_l + 1.0;
425: x_l = a->j[j]*bs; x_r = x_l + 1.0;
426: aa = a->a + j*bs2;
427: for (k=0; k<bs; k++) {
428: for (l=0; l<bs; l++) {
429: if (PetscRealPart(*aa++) >= 0.) continue;
430: PetscDrawRectangle(draw,x_l+k,y_l-l,x_r+k,y_r-l,color,color,color,color);
431: }
432: }
433: }
434: }
435: color = PETSC_DRAW_CYAN;
436: for (i=0,row=0; i<mbs; i++,row+=bs) {
437: for (j=a->i[i]; j<a->i[i+1]; j++) {
438: y_l = A->rmap.N - row - 1.0; y_r = y_l + 1.0;
439: x_l = a->j[j]*bs; x_r = x_l + 1.0;
440: aa = a->a + j*bs2;
441: for (k=0; k<bs; k++) {
442: for (l=0; l<bs; l++) {
443: if (PetscRealPart(*aa++) != 0.) continue;
444: PetscDrawRectangle(draw,x_l+k,y_l-l,x_r+k,y_r-l,color,color,color,color);
445: }
446: }
447: }
448: }
449:
450: color = PETSC_DRAW_RED;
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->rmap.N - 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: return(0);
465: }
469: static PetscErrorCode MatView_SeqSBAIJ_Draw(Mat A,PetscViewer viewer)
470: {
472: PetscReal xl,yl,xr,yr,w,h;
473: PetscDraw draw;
474: PetscTruth isnull;
475:
477:
478: PetscViewerDrawGetDraw(viewer,0,&draw);
479: PetscDrawIsNull(draw,&isnull); if (isnull) return(0);
480:
481: PetscObjectCompose((PetscObject)A,"Zoomviewer",(PetscObject)viewer);
482: xr = A->rmap.N; yr = A->rmap.N; h = yr/10.0; w = xr/10.0;
483: xr += w; yr += h; xl = -w; yl = -h;
484: PetscDrawSetCoordinates(draw,xl,yl,xr,yr);
485: PetscDrawZoom(draw,MatView_SeqSBAIJ_Draw_Zoom,A);
486: PetscObjectCompose((PetscObject)A,"Zoomviewer",PETSC_NULL);
487: return(0);
488: }
492: PetscErrorCode MatView_SeqSBAIJ(Mat A,PetscViewer viewer)
493: {
495: PetscTruth iascii,isdraw;
496:
498: PetscTypeCompare((PetscObject)viewer,PETSC_VIEWER_ASCII,&iascii);
499: PetscTypeCompare((PetscObject)viewer,PETSC_VIEWER_DRAW,&isdraw);
500: if (iascii){
501: MatView_SeqSBAIJ_ASCII(A,viewer);
502: } else if (isdraw) {
503: MatView_SeqSBAIJ_Draw(A,viewer);
504: } else {
505: Mat B;
506: MatConvert(A,MATSEQAIJ,MAT_INITIAL_MATRIX,&B);
507: MatView(B,viewer);
508: MatDestroy(B);
509: }
510: return(0);
511: }
516: PetscErrorCode MatGetValues_SeqSBAIJ(Mat A,PetscInt m,const PetscInt im[],PetscInt n,const PetscInt in[],PetscScalar v[])
517: {
518: Mat_SeqSBAIJ *a = (Mat_SeqSBAIJ*)A->data;
519: PetscInt *rp,k,low,high,t,row,nrow,i,col,l,*aj = a->j;
520: PetscInt *ai = a->i,*ailen = a->ilen;
521: PetscInt brow,bcol,ridx,cidx,bs=A->rmap.bs,bs2=a->bs2;
522: MatScalar *ap,*aa = a->a,zero = 0.0;
523:
525: for (k=0; k<m; k++) { /* loop over rows */
526: row = im[k]; brow = row/bs;
527: if (row < 0) SETERRQ1(PETSC_ERR_ARG_OUTOFRANGE,"Negative row: %D",row);
528: if (row >= A->rmap.N) SETERRQ2(PETSC_ERR_ARG_OUTOFRANGE,"Row too large: row %D max %D",row,A->rmap.N-1);
529: rp = aj + ai[brow] ; ap = aa + bs2*ai[brow] ;
530: nrow = ailen[brow];
531: for (l=0; l<n; l++) { /* loop over columns */
532: if (in[l] < 0) SETERRQ1(PETSC_ERR_ARG_OUTOFRANGE,"Negative column: %D",in[l]);
533: if (in[l] >= A->cmap.n) SETERRQ2(PETSC_ERR_ARG_OUTOFRANGE,"Column too large: col %D max %D",in[l],A->cmap.n-1);
534: col = in[l] ;
535: bcol = col/bs;
536: cidx = col%bs;
537: ridx = row%bs;
538: high = nrow;
539: low = 0; /* assume unsorted */
540: while (high-low > 5) {
541: t = (low+high)/2;
542: if (rp[t] > bcol) high = t;
543: else low = t;
544: }
545: for (i=low; i<high; i++) {
546: if (rp[i] > bcol) break;
547: if (rp[i] == bcol) {
548: *v++ = ap[bs2*i+bs*cidx+ridx];
549: goto finished;
550: }
551: }
552: *v++ = zero;
553: finished:;
554: }
555: }
556: return(0);
557: }
562: PetscErrorCode MatSetValuesBlocked_SeqSBAIJ(Mat A,PetscInt m,const PetscInt im[],PetscInt n,const PetscInt in[],const PetscScalar v[],InsertMode is)
563: {
564: Mat_SeqSBAIJ *a = (Mat_SeqSBAIJ*)A->data;
565: PetscErrorCode ierr;
566: PetscInt *rp,k,low,high,t,ii,jj,row,nrow,i,col,l,rmax,N,lastcol = -1;
567: PetscInt *imax=a->imax,*ai=a->i,*ailen=a->ilen;
568: PetscInt *aj=a->j,nonew=a->nonew,bs2=a->bs2,bs=A->rmap.bs,stepval;
569: PetscTruth roworiented=a->roworiented;
570: const MatScalar *value = v;
571: MatScalar *ap,*aa = a->a,*bap;
572:
574: if (roworiented) {
575: stepval = (n-1)*bs;
576: } else {
577: stepval = (m-1)*bs;
578: }
579: for (k=0; k<m; k++) { /* loop over added rows */
580: row = im[k];
581: if (row < 0) continue;
582: #if defined(PETSC_USE_DEBUG)
583: if (row >= a->mbs) SETERRQ2(PETSC_ERR_ARG_OUTOFRANGE,"Row too large: row %D max %D",row,a->mbs-1);
584: #endif
585: rp = aj + ai[row];
586: ap = aa + bs2*ai[row];
587: rmax = imax[row];
588: nrow = ailen[row];
589: low = 0;
590: high = nrow;
591: for (l=0; l<n; l++) { /* loop over added columns */
592: if (in[l] < 0) continue;
593: col = in[l];
594: #if defined(PETSC_USE_DEBUG)
595: if (col >= a->nbs) SETERRQ2(PETSC_ERR_ARG_OUTOFRANGE,"Column too large: col %D max %D",col,a->nbs-1);
596: #endif
597: if (col < row) continue; /* ignore lower triangular block */
598: if (roworiented) {
599: value = v + k*(stepval+bs)*bs + l*bs;
600: } else {
601: value = v + l*(stepval+bs)*bs + k*bs;
602: }
603: if (col <= lastcol) low = 0; else high = nrow;
604: lastcol = col;
605: while (high-low > 7) {
606: t = (low+high)/2;
607: if (rp[t] > col) high = t;
608: else low = t;
609: }
610: for (i=low; i<high; i++) {
611: if (rp[i] > col) break;
612: if (rp[i] == col) {
613: bap = ap + bs2*i;
614: if (roworiented) {
615: if (is == ADD_VALUES) {
616: for (ii=0; ii<bs; ii++,value+=stepval) {
617: for (jj=ii; jj<bs2; jj+=bs) {
618: bap[jj] += *value++;
619: }
620: }
621: } else {
622: for (ii=0; ii<bs; ii++,value+=stepval) {
623: for (jj=ii; jj<bs2; jj+=bs) {
624: bap[jj] = *value++;
625: }
626: }
627: }
628: } else {
629: if (is == ADD_VALUES) {
630: for (ii=0; ii<bs; ii++,value+=stepval) {
631: for (jj=0; jj<bs; jj++) {
632: *bap++ += *value++;
633: }
634: }
635: } else {
636: for (ii=0; ii<bs; ii++,value+=stepval) {
637: for (jj=0; jj<bs; jj++) {
638: *bap++ = *value++;
639: }
640: }
641: }
642: }
643: goto noinsert2;
644: }
645: }
646: if (nonew == 1) goto noinsert2;
647: if (nonew == -1) SETERRQ2(PETSC_ERR_ARG_OUTOFRANGE,"Inserting a new nonzero (%D, %D) in the matrix", row, col);
648: MatSeqXAIJReallocateAIJ(a,bs2,nrow,row,col,rmax,aa,ai,aj,a->mbs,rp,ap,imax,nonew);
649: N = nrow++ - 1; high++;
650: /* shift up all the later entries in this row */
651: for (ii=N; ii>=i; ii--) {
652: rp[ii+1] = rp[ii];
653: PetscMemcpy(ap+bs2*(ii+1),ap+bs2*(ii),bs2*sizeof(MatScalar));
654: }
655: if (N >= i) {
656: PetscMemzero(ap+bs2*i,bs2*sizeof(MatScalar));
657: }
658: rp[i] = col;
659: bap = ap + bs2*i;
660: if (roworiented) {
661: for (ii=0; ii<bs; ii++,value+=stepval) {
662: for (jj=ii; jj<bs2; jj+=bs) {
663: bap[jj] = *value++;
664: }
665: }
666: } else {
667: for (ii=0; ii<bs; ii++,value+=stepval) {
668: for (jj=0; jj<bs; jj++) {
669: *bap++ = *value++;
670: }
671: }
672: }
673: noinsert2:;
674: low = i;
675: }
676: ailen[row] = nrow;
677: }
678: return(0);
679: }
683: PetscErrorCode MatAssemblyEnd_SeqSBAIJ(Mat A,MatAssemblyType mode)
684: {
685: Mat_SeqSBAIJ *a = (Mat_SeqSBAIJ*)A->data;
687: PetscInt fshift = 0,i,j,*ai = a->i,*aj = a->j,*imax = a->imax;
688: PetscInt m = A->rmap.N,*ip,N,*ailen = a->ilen;
689: PetscInt mbs = a->mbs,bs2 = a->bs2,rmax = 0;
690: MatScalar *aa = a->a,*ap;
691:
693: if (mode == MAT_FLUSH_ASSEMBLY) return(0);
694:
695: if (m) rmax = ailen[0];
696: for (i=1; i<mbs; i++) {
697: /* move each row back by the amount of empty slots (fshift) before it*/
698: fshift += imax[i-1] - ailen[i-1];
699: rmax = PetscMax(rmax,ailen[i]);
700: if (fshift) {
701: ip = aj + ai[i]; ap = aa + bs2*ai[i];
702: N = ailen[i];
703: for (j=0; j<N; j++) {
704: ip[j-fshift] = ip[j];
705: PetscMemcpy(ap+(j-fshift)*bs2,ap+j*bs2,bs2*sizeof(MatScalar));
706: }
707: }
708: ai[i] = ai[i-1] + ailen[i-1];
709: }
710: if (mbs) {
711: fshift += imax[mbs-1] - ailen[mbs-1];
712: ai[mbs] = ai[mbs-1] + ailen[mbs-1];
713: }
714: /* reset ilen and imax for each row */
715: for (i=0; i<mbs; i++) {
716: ailen[i] = imax[i] = ai[i+1] - ai[i];
717: }
718: a->nz = ai[mbs];
719:
720: /* diagonals may have moved, reset it */
721: if (a->diag) {
722: PetscMemcpy(a->diag,ai,(mbs+1)*sizeof(PetscInt));
723: }
724: PetscInfo5(A,"Matrix size: %D X %D, block size %D; storage space: %D unneeded, %D used\n",m,A->rmap.N,A->rmap.bs,fshift*bs2,a->nz*bs2);
725: PetscInfo1(A,"Number of mallocs during MatSetValues is %D\n",a->reallocs);
726: PetscInfo1(A,"Most nonzeros blocks in any row is %D\n",rmax);
727: a->reallocs = 0;
728: A->info.nz_unneeded = (PetscReal)fshift*bs2;
729: return(0);
730: }
732: /*
733: This function returns an array of flags which indicate the locations of contiguous
734: blocks that should be zeroed. for eg: if bs = 3 and is = [0,1,2,3,5,6,7,8,9]
735: then the resulting sizes = [3,1,1,3,1] correspondig to sets [(0,1,2),(3),(5),(6,7,8),(9)]
736: Assume: sizes should be long enough to hold all the values.
737: */
740: PetscErrorCode MatZeroRows_SeqSBAIJ_Check_Blocks(PetscInt idx[],PetscInt n,PetscInt bs,PetscInt sizes[], PetscInt *bs_max)
741: {
742: PetscInt i,j,k,row;
743: PetscTruth flg;
744:
746: for (i=0,j=0; i<n; j++) {
747: row = idx[i];
748: if (row%bs!=0) { /* Not the begining of a block */
749: sizes[j] = 1;
750: i++;
751: } else if (i+bs > n) { /* Beginning of a block, but complete block doesn't exist (at idx end) */
752: sizes[j] = 1; /* Also makes sure atleast 'bs' values exist for next else */
753: i++;
754: } else { /* Begining of the block, so check if the complete block exists */
755: flg = PETSC_TRUE;
756: for (k=1; k<bs; k++) {
757: if (row+k != idx[i+k]) { /* break in the block */
758: flg = PETSC_FALSE;
759: break;
760: }
761: }
762: if (flg) { /* No break in the bs */
763: sizes[j] = bs;
764: i+= bs;
765: } else {
766: sizes[j] = 1;
767: i++;
768: }
769: }
770: }
771: *bs_max = j;
772: return(0);
773: }
776: /* Only add/insert a(i,j) with i<=j (blocks).
777: Any a(i,j) with i>j input by user is ingored.
778: */
782: PetscErrorCode MatSetValues_SeqSBAIJ(Mat A,PetscInt m,const PetscInt im[],PetscInt n,const PetscInt in[],const PetscScalar v[],InsertMode is)
783: {
784: Mat_SeqSBAIJ *a = (Mat_SeqSBAIJ*)A->data;
786: PetscInt *rp,k,low,high,t,ii,row,nrow,i,col,l,rmax,N,lastcol = -1;
787: PetscInt *imax=a->imax,*ai=a->i,*ailen=a->ilen,roworiented=a->roworiented;
788: PetscInt *aj=a->j,nonew=a->nonew,bs=A->rmap.bs,brow,bcol;
789: PetscInt ridx,cidx,bs2=a->bs2;
790: MatScalar *ap,value,*aa=a->a,*bap;
791:
793: for (k=0; k<m; k++) { /* loop over added rows */
794: row = im[k]; /* row number */
795: brow = row/bs; /* block row number */
796: if (row < 0) continue;
797: #if defined(PETSC_USE_DEBUG)
798: if (row >= A->rmap.N) SETERRQ2(PETSC_ERR_ARG_OUTOFRANGE,"Row too large: row %D max %D",row,A->rmap.N-1);
799: #endif
800: rp = aj + ai[brow]; /*ptr to beginning of column value of the row block*/
801: ap = aa + bs2*ai[brow]; /*ptr to beginning of element value of the row block*/
802: rmax = imax[brow]; /* maximum space allocated for this row */
803: nrow = ailen[brow]; /* actual length of this row */
804: low = 0;
805:
806: for (l=0; l<n; l++) { /* loop over added columns */
807: if (in[l] < 0) continue;
808: #if defined(PETSC_USE_DEBUG)
809: if (in[l] >= A->rmap.N) SETERRQ2(PETSC_ERR_ARG_OUTOFRANGE,"Column too large: col %D max %D",in[l],A->rmap.N-1);
810: #endif
811: col = in[l];
812: bcol = col/bs; /* block col number */
813:
814: if (brow > bcol) {
815: if (a->ignore_ltriangular){
816: continue; /* ignore lower triangular values */
817: } else {
818: SETERRQ(PETSC_ERR_USER,"Lower triangular value cannot be set for sbaij format. Ignoring these values, run with -mat_ignore_lower_triangular or call MatSetOption(mat,MAT_IGNORE_LOWER_TRIANGULAR)");
819: }
820: }
821:
822: ridx = row % bs; cidx = col % bs; /*row and col index inside the block */
823: if ((brow==bcol && ridx<=cidx) || (brow<bcol)){
824: /* element value a(k,l) */
825: if (roworiented) {
826: value = v[l + k*n];
827: } else {
828: value = v[k + l*m];
829: }
830:
831: /* move pointer bap to a(k,l) quickly and add/insert value */
832: if (col <= lastcol) low = 0; high = nrow;
833: lastcol = col;
834: while (high-low > 7) {
835: t = (low+high)/2;
836: if (rp[t] > bcol) high = t;
837: else low = t;
838: }
839: for (i=low; i<high; i++) {
840: if (rp[i] > bcol) break;
841: if (rp[i] == bcol) {
842: bap = ap + bs2*i + bs*cidx + ridx;
843: if (is == ADD_VALUES) *bap += value;
844: else *bap = value;
845: /* for diag block, add/insert its symmetric element a(cidx,ridx) */
846: if (brow == bcol && ridx < cidx){
847: bap = ap + bs2*i + bs*ridx + cidx;
848: if (is == ADD_VALUES) *bap += value;
849: else *bap = value;
850: }
851: goto noinsert1;
852: }
853: }
854:
855: if (nonew == 1) goto noinsert1;
856: if (nonew == -1) SETERRQ2(PETSC_ERR_ARG_OUTOFRANGE,"Inserting a new nonzero (%D, %D) in the matrix", row, col);
857: MatSeqXAIJReallocateAIJ(a,bs2,nrow,brow,bcol,rmax,aa,ai,aj,a->mbs,rp,ap,imax,nonew);
858:
859: N = nrow++ - 1; high++;
860: /* shift up all the later entries in this row */
861: for (ii=N; ii>=i; ii--) {
862: rp[ii+1] = rp[ii];
863: PetscMemcpy(ap+bs2*(ii+1),ap+bs2*(ii),bs2*sizeof(MatScalar));
864: }
865: if (N>=i) {
866: PetscMemzero(ap+bs2*i,bs2*sizeof(MatScalar));
867: }
868: rp[i] = bcol;
869: ap[bs2*i + bs*cidx + ridx] = value;
870: noinsert1:;
871: low = i;
872: }
873: } /* end of loop over added columns */
874: ailen[brow] = nrow;
875: } /* end of loop over added rows */
876: return(0);
877: }
879: EXTERN PetscErrorCode MatCholeskyFactorSymbolic_SeqSBAIJ(Mat,IS,MatFactorInfo*,Mat*);
880: EXTERN PetscErrorCode MatCholeskyFactor_SeqSBAIJ(Mat,IS,MatFactorInfo*);
881: EXTERN PetscErrorCode MatIncreaseOverlap_SeqSBAIJ(Mat,PetscInt,IS[],PetscInt);
882: EXTERN PetscErrorCode MatGetSubMatrix_SeqSBAIJ(Mat,IS,IS,PetscInt,MatReuse,Mat*);
883: EXTERN PetscErrorCode MatGetSubMatrices_SeqSBAIJ(Mat,PetscInt,const IS[],const IS[],MatReuse,Mat*[]);
884: EXTERN PetscErrorCode MatScale_SeqSBAIJ(Mat,PetscScalar);
885: EXTERN PetscErrorCode MatNorm_SeqSBAIJ(Mat,NormType,PetscReal *);
886: EXTERN PetscErrorCode MatEqual_SeqSBAIJ(Mat,Mat,PetscTruth*);
887: EXTERN PetscErrorCode MatGetDiagonal_SeqSBAIJ(Mat,Vec);
888: EXTERN PetscErrorCode MatDiagonalScale_SeqSBAIJ(Mat,Vec,Vec);
889: EXTERN PetscErrorCode MatGetInfo_SeqSBAIJ(Mat,MatInfoType,MatInfo *);
890: EXTERN PetscErrorCode MatZeroEntries_SeqSBAIJ(Mat);
891: EXTERN PetscErrorCode MatGetRowMax_SeqSBAIJ(Mat,Vec);
893: EXTERN PetscErrorCode MatSolve_SeqSBAIJ_N(Mat,Vec,Vec);
894: EXTERN PetscErrorCode MatSolve_SeqSBAIJ_1(Mat,Vec,Vec);
895: EXTERN PetscErrorCode MatSolve_SeqSBAIJ_2(Mat,Vec,Vec);
896: EXTERN PetscErrorCode MatSolve_SeqSBAIJ_3(Mat,Vec,Vec);
897: EXTERN PetscErrorCode MatSolve_SeqSBAIJ_4(Mat,Vec,Vec);
898: EXTERN PetscErrorCode MatSolve_SeqSBAIJ_5(Mat,Vec,Vec);
899: EXTERN PetscErrorCode MatSolve_SeqSBAIJ_6(Mat,Vec,Vec);
900: EXTERN PetscErrorCode MatSolve_SeqSBAIJ_7(Mat,Vec,Vec);
902: EXTERN PetscErrorCode MatSolves_SeqSBAIJ_1(Mat,Vecs,Vecs);
904: EXTERN PetscErrorCode MatSolve_SeqSBAIJ_1_NaturalOrdering(Mat,Vec,Vec);
905: EXTERN PetscErrorCode MatSolve_SeqSBAIJ_2_NaturalOrdering(Mat,Vec,Vec);
906: EXTERN PetscErrorCode MatSolve_SeqSBAIJ_3_NaturalOrdering(Mat,Vec,Vec);
907: EXTERN PetscErrorCode MatSolve_SeqSBAIJ_4_NaturalOrdering(Mat,Vec,Vec);
908: EXTERN PetscErrorCode MatSolve_SeqSBAIJ_5_NaturalOrdering(Mat,Vec,Vec);
909: EXTERN PetscErrorCode MatSolve_SeqSBAIJ_6_NaturalOrdering(Mat,Vec,Vec);
910: EXTERN PetscErrorCode MatSolve_SeqSBAIJ_7_NaturalOrdering(Mat,Vec,Vec);
911: EXTERN PetscErrorCode MatSolve_SeqSBAIJ_N_NaturalOrdering(Mat,Vec,Vec);
913: EXTERN PetscErrorCode MatCholeskyFactorNumeric_SeqSBAIJ_N(Mat,MatFactorInfo*,Mat*);
914: EXTERN PetscErrorCode MatCholeskyFactorNumeric_SeqSBAIJ_1(Mat,MatFactorInfo*,Mat*);
915: EXTERN PetscErrorCode MatCholeskyFactorNumeric_SeqSBAIJ_2(Mat,MatFactorInfo*,Mat*);
916: EXTERN PetscErrorCode MatCholeskyFactorNumeric_SeqSBAIJ_3(Mat,MatFactorInfo*,Mat*);
917: EXTERN PetscErrorCode MatCholeskyFactorNumeric_SeqSBAIJ_4(Mat,MatFactorInfo*,Mat*);
918: EXTERN PetscErrorCode MatCholeskyFactorNumeric_SeqSBAIJ_5(Mat,MatFactorInfo*,Mat*);
919: EXTERN PetscErrorCode MatCholeskyFactorNumeric_SeqSBAIJ_6(Mat,MatFactorInfo*,Mat*);
920: EXTERN PetscErrorCode MatCholeskyFactorNumeric_SeqSBAIJ_7(Mat,MatFactorInfo*,Mat*);
921: EXTERN PetscErrorCode MatGetInertia_SeqSBAIJ(Mat,PetscInt*,PetscInt*,PetscInt*);
923: EXTERN PetscErrorCode MatMult_SeqSBAIJ_1(Mat,Vec,Vec);
924: EXTERN PetscErrorCode MatMult_SeqSBAIJ_2(Mat,Vec,Vec);
925: EXTERN PetscErrorCode MatMult_SeqSBAIJ_3(Mat,Vec,Vec);
926: EXTERN PetscErrorCode MatMult_SeqSBAIJ_4(Mat,Vec,Vec);
927: EXTERN PetscErrorCode MatMult_SeqSBAIJ_5(Mat,Vec,Vec);
928: EXTERN PetscErrorCode MatMult_SeqSBAIJ_6(Mat,Vec,Vec);
929: EXTERN PetscErrorCode MatMult_SeqSBAIJ_7(Mat,Vec,Vec);
930: EXTERN PetscErrorCode MatMult_SeqSBAIJ_N(Mat,Vec,Vec);
932: EXTERN PetscErrorCode MatMultAdd_SeqSBAIJ_1(Mat,Vec,Vec,Vec);
933: EXTERN PetscErrorCode MatMultAdd_SeqSBAIJ_2(Mat,Vec,Vec,Vec);
934: EXTERN PetscErrorCode MatMultAdd_SeqSBAIJ_3(Mat,Vec,Vec,Vec);
935: EXTERN PetscErrorCode MatMultAdd_SeqSBAIJ_4(Mat,Vec,Vec,Vec);
936: EXTERN PetscErrorCode MatMultAdd_SeqSBAIJ_5(Mat,Vec,Vec,Vec);
937: EXTERN PetscErrorCode MatMultAdd_SeqSBAIJ_6(Mat,Vec,Vec,Vec);
938: EXTERN PetscErrorCode MatMultAdd_SeqSBAIJ_7(Mat,Vec,Vec,Vec);
939: EXTERN PetscErrorCode MatMultAdd_SeqSBAIJ_N(Mat,Vec,Vec,Vec);
941: #ifdef HAVE_MatICCFactor
942: /* modified from MatILUFactor_SeqSBAIJ, needs further work! */
945: PetscErrorCode MatICCFactor_SeqSBAIJ(Mat inA,IS row,MatFactorInfo *info)
946: {
947: Mat_SeqSBAIJ *a = (Mat_SeqSBAIJ*)inA->data;
948: Mat outA;
950: PetscTruth row_identity,col_identity;
951:
953: outA = inA;
954: inA->factor = FACTOR_CHOLESKY;
955:
956: if (!a->diag) {
957: MatMarkDiagonal_SeqSBAIJ(inA);
958: }
959: /*
960: Blocksize 2, 3, 4, 5, 6 and 7 have a special faster factorization/solver
961: for ILU(0) factorization with natural ordering
962: */
963: switch (a->rmap.bs) {
964: case 1:
965: inA->ops->solve = MatSolve_SeqSBAIJ_1_NaturalOrdering;
966: inA->ops->solvetranspose = MatSolve_SeqSBAIJ_1_NaturalOrdering;
967: inA->ops->solves = MatSolves_SeqSBAIJ_1;
968: PetscInfo((inA,"Using special in-place natural ordering solvetrans BS=1\n");
969: case 2:
970: inA->ops->lufactornumeric = MatCholeskyFactorNumeric_SeqSBAIJ_2_NaturalOrdering;
971: inA->ops->solve = MatSolve_SeqSBAIJ_2_NaturalOrdering;
972: inA->ops->solvetranspose = MatSolve_SeqSBAIJ_2_NaturalOrdering;
973: PetscInfo(inA,"Using special in-place natural ordering factor and solve BS=2\n");
974: break;
975: case 3:
976: inA->ops->lufactornumeric = MatCholeskyFactorNumeric_SeqSBAIJ_3_NaturalOrdering;
977: inA->ops->solve = MatSolve_SeqSBAIJ_3_NaturalOrdering;
978: inA->ops->solvetranspose = MatSolve_SeqSBAIJ_3_NaturalOrdering;
979: PetscInfo(inA,"Using special in-place natural ordering factor and solve BS=3\n");
980: break;
981: case 4:
982: inA->ops->lufactornumeric = MatCholeskyFactorNumeric_SeqSBAIJ_4_NaturalOrdering;
983: inA->ops->solve = MatSolve_SeqSBAIJ_4_NaturalOrdering;
984: inA->ops->solvetranspose = MatSolve_SeqSBAIJ_4_NaturalOrdering;
985: PetscInfo(inA,"Using special in-place natural ordering factor and solve BS=4\n");
986: break;
987: case 5:
988: inA->ops->lufactornumeric = MatCholeskyFactorNumeric_SeqSBAIJ_5_NaturalOrdering;
989: inA->ops->solve = MatSolve_SeqSBAIJ_5_NaturalOrdering;
990: inA->ops->solvetranspose = MatSolve_SeqSBAIJ_5_NaturalOrdering;
991: PetscInfo(inA,"Using special in-place natural ordering factor and solve BS=5\n");
992: break;
993: case 6:
994: inA->ops->lufactornumeric = MatCholeskyFactorNumeric_SeqSBAIJ_6_NaturalOrdering;
995: inA->ops->solve = MatSolve_SeqSBAIJ_6_NaturalOrdering;
996: inA->ops->solvetranspose = MatSolve_SeqSBAIJ_6_NaturalOrdering;
997: PetscInfo(inA,"Using special in-place natural ordering factor and solve BS=6\n");
998: break;
999: case 7:
1000: inA->ops->lufactornumeric = MatCholeskyFactorNumeric_SeqSBAIJ_7_NaturalOrdering;
1001: inA->ops->solvetranspose = MatSolve_SeqSBAIJ_7_NaturalOrdering;
1002: inA->ops->solve = MatSolve_SeqSBAIJ_7_NaturalOrdering;
1003: PetscInfo(inA,"Using special in-place natural ordering factor and solve BS=7\n");
1004: break;
1005: default:
1006: a->row = row;
1007: a->icol = col;
1008: PetscObjectReference((PetscObject)row);
1009: PetscObjectReference((PetscObject)col);
1010:
1011: /* Create the invert permutation so that it can be used in MatLUFactorNumeric() */
1012: ISInvertPermutation(col,PETSC_DECIDE, &(a->icol));
1013: PetscLogObjectParent(inA,a->icol);
1014:
1015: if (!a->solve_work) {
1016: PetscMalloc((A->rmap.N+a->rmap.bs)*sizeof(PetscScalar),&a->solve_work);
1017: PetscLogObjectMemory(inA,(A->rmap.N+a->rmap.bs)*sizeof(PetscScalar));
1018: }
1019: }
1020:
1021: MatCholeskyFactorNumeric(inA,info,&outA);
1022: return(0);
1023: }
1024: #endif
1028: PetscErrorCode MatPrintHelp_SeqSBAIJ(Mat A)
1029: {
1030: static PetscTruth called = PETSC_FALSE;
1031: MPI_Comm comm = A->comm;
1032: PetscErrorCode ierr;
1033:
1035: if (called) {return(0);} else called = PETSC_TRUE;
1036: (*PetscHelpPrintf)(comm," Options for MATSEQSBAIJ and MATMPISBAIJ matrix formats (the defaults):\n");
1037: (*PetscHelpPrintf)(comm," -mat_block_size <block_size>\n");
1038: (*PetscHelpPrintf)(comm," -mat_ignore_lower_triangular: Ignore lower triangular values set by user\n");
1039: (*PetscHelpPrintf)(comm," -mat_getrow_uppertriangular: Enable MatGetRow() for retrieving the upper triangular part of the row\n");
1040: return(0);
1041: }
1046: PetscErrorCode PETSCMAT_DLLEXPORT MatSeqSBAIJSetColumnIndices_SeqSBAIJ(Mat mat,PetscInt *indices)
1047: {
1048: Mat_SeqSBAIJ *baij = (Mat_SeqSBAIJ *)mat->data;
1049: PetscInt i,nz,n;
1050:
1052: nz = baij->maxnz;
1053: n = mat->cmap.n;
1054: for (i=0; i<nz; i++) {
1055: baij->j[i] = indices[i];
1056: }
1057: baij->nz = nz;
1058: for (i=0; i<n; i++) {
1059: baij->ilen[i] = baij->imax[i];
1060: }
1061: return(0);
1062: }
1067: /*@
1068: MatSeqSBAIJSetColumnIndices - Set the column indices for all the rows
1069: in the matrix.
1070:
1071: Input Parameters:
1072: + mat - the SeqSBAIJ matrix
1073: - indices - the column indices
1074:
1075: Level: advanced
1076:
1077: Notes:
1078: This can be called if you have precomputed the nonzero structure of the
1079: matrix and want to provide it to the matrix object to improve the performance
1080: of the MatSetValues() operation.
1081:
1082: You MUST have set the correct numbers of nonzeros per row in the call to
1083: MatCreateSeqSBAIJ(), and the columns indices MUST be sorted.
1084:
1085: MUST be called before any calls to MatSetValues()
1086:
1087: .seealso: MatCreateSeqSBAIJ
1088: @*/
1089: PetscErrorCode PETSCMAT_DLLEXPORT MatSeqSBAIJSetColumnIndices(Mat mat,PetscInt *indices)
1090: {
1091: PetscErrorCode ierr,(*f)(Mat,PetscInt *);
1092:
1096: PetscObjectQueryFunction((PetscObject)mat,"MatSeqSBAIJSetColumnIndices_C",(void (**)(void))&f);
1097: if (f) {
1098: (*f)(mat,indices);
1099: } else {
1100: SETERRQ(PETSC_ERR_SUP,"Wrong type of matrix to set column indices");
1101: }
1102: return(0);
1103: }
1107: PetscErrorCode MatCopy_SeqSBAIJ(Mat A,Mat B,MatStructure str)
1108: {
1112: /* If the two matrices have the same copy implementation, use fast copy. */
1113: if (str == SAME_NONZERO_PATTERN && (A->ops->copy == B->ops->copy)) {
1114: Mat_SeqSBAIJ *a = (Mat_SeqSBAIJ*)A->data;
1115: Mat_SeqSBAIJ *b = (Mat_SeqSBAIJ*)B->data;
1117: if (a->i[A->rmap.N] != b->i[B->rmap.N]) {
1118: SETERRQ(PETSC_ERR_ARG_INCOMP,"Number of nonzeros in two matrices are different");
1119: }
1120: PetscMemcpy(b->a,a->a,(a->i[A->rmap.N])*sizeof(PetscScalar));
1121: } else {
1122: MatGetRowUpperTriangular(A);
1123: MatCopy_Basic(A,B,str);
1124: MatRestoreRowUpperTriangular(A);
1125: }
1126: return(0);
1127: }
1131: PetscErrorCode MatSetUpPreallocation_SeqSBAIJ(Mat A)
1132: {
1134:
1136: MatSeqSBAIJSetPreallocation_SeqSBAIJ(A,PetscMax(A->rmap.bs,1),PETSC_DEFAULT,0);
1137: return(0);
1138: }
1142: PetscErrorCode MatGetArray_SeqSBAIJ(Mat A,PetscScalar *array[])
1143: {
1144: Mat_SeqSBAIJ *a = (Mat_SeqSBAIJ*)A->data;
1146: *array = a->a;
1147: return(0);
1148: }
1152: PetscErrorCode MatRestoreArray_SeqSBAIJ(Mat A,PetscScalar *array[])
1153: {
1155: return(0);
1156: }
1158: #include petscblaslapack.h
1161: PetscErrorCode MatAXPY_SeqSBAIJ(Mat Y,PetscScalar a,Mat X,MatStructure str)
1162: {
1163: Mat_SeqSBAIJ *x=(Mat_SeqSBAIJ *)X->data, *y=(Mat_SeqSBAIJ *)Y->data;
1165: PetscInt i,bs=Y->rmap.bs,bs2,j;
1166: PetscBLASInt bnz = (PetscBLASInt)x->nz,one = 1;
1167:
1169: if (str == SAME_NONZERO_PATTERN) {
1170: PetscScalar alpha = a;
1171: BLASaxpy_(&bnz,&alpha,x->a,&one,y->a,&one);
1172: } else if (str == SUBSET_NONZERO_PATTERN) { /* nonzeros of X is a subset of Y's */
1173: if (y->xtoy && y->XtoY != X) {
1174: PetscFree(y->xtoy);
1175: MatDestroy(y->XtoY);
1176: }
1177: if (!y->xtoy) { /* get xtoy */
1178: MatAXPYGetxtoy_Private(x->mbs,x->i,x->j,PETSC_NULL, y->i,y->j,PETSC_NULL, &y->xtoy);
1179: y->XtoY = X;
1180: }
1181: bs2 = bs*bs;
1182: for (i=0; i<x->nz; i++) {
1183: j = 0;
1184: while (j < bs2){
1185: y->a[bs2*y->xtoy[i]+j] += a*(x->a[bs2*i+j]);
1186: j++;
1187: }
1188: }
1189: PetscInfo3(0,"ratio of nnz_s(X)/nnz_s(Y): %D/%D = %G\n",bs2*x->nz,bs2*y->nz,(PetscReal)(bs2*x->nz)/(bs2*y->nz));
1190: } else {
1191: MatGetRowUpperTriangular(X);
1192: MatAXPY_Basic(Y,a,X,str);
1193: MatRestoreRowUpperTriangular(X);
1194: }
1195: return(0);
1196: }
1200: PetscErrorCode MatIsSymmetric_SeqSBAIJ(Mat A,PetscReal tol,PetscTruth *flg)
1201: {
1203: *flg = PETSC_TRUE;
1204: return(0);
1205: }
1209: PetscErrorCode MatIsStructurallySymmetric_SeqSBAIJ(Mat A,PetscTruth *flg)
1210: {
1212: *flg = PETSC_TRUE;
1213: return(0);
1214: }
1218: PetscErrorCode MatIsHermitian_SeqSBAIJ(Mat A,PetscTruth *flg)
1219: {
1221: *flg = PETSC_FALSE;
1222: return(0);
1223: }
1227: PetscErrorCode MatRealPart_SeqSBAIJ(Mat A)
1228: {
1229: Mat_SeqSBAIJ *a = (Mat_SeqSBAIJ*)A->data;
1230: PetscInt i,nz = a->bs2*a->i[a->mbs];
1231: PetscScalar *aa = a->a;
1234: for (i=0; i<nz; i++) aa[i] = PetscRealPart(aa[i]);
1235: return(0);
1236: }
1240: PetscErrorCode MatImaginaryPart_SeqSBAIJ(Mat A)
1241: {
1242: Mat_SeqSBAIJ *a = (Mat_SeqSBAIJ*)A->data;
1243: PetscInt i,nz = a->bs2*a->i[a->mbs];
1244: PetscScalar *aa = a->a;
1247: for (i=0; i<nz; i++) aa[i] = PetscImaginaryPart(aa[i]);
1248: return(0);
1249: }
1251: /* -------------------------------------------------------------------*/
1252: static struct _MatOps MatOps_Values = {MatSetValues_SeqSBAIJ,
1253: MatGetRow_SeqSBAIJ,
1254: MatRestoreRow_SeqSBAIJ,
1255: MatMult_SeqSBAIJ_N,
1256: /* 4*/ MatMultAdd_SeqSBAIJ_N,
1257: MatMult_SeqSBAIJ_N, /* transpose versions are same as non-transpose versions */
1258: MatMultAdd_SeqSBAIJ_N,
1259: MatSolve_SeqSBAIJ_N,
1260: 0,
1261: 0,
1262: /*10*/ 0,
1263: 0,
1264: MatCholeskyFactor_SeqSBAIJ,
1265: MatRelax_SeqSBAIJ,
1266: MatTranspose_SeqSBAIJ,
1267: /*15*/ MatGetInfo_SeqSBAIJ,
1268: MatEqual_SeqSBAIJ,
1269: MatGetDiagonal_SeqSBAIJ,
1270: MatDiagonalScale_SeqSBAIJ,
1271: MatNorm_SeqSBAIJ,
1272: /*20*/ 0,
1273: MatAssemblyEnd_SeqSBAIJ,
1274: 0,
1275: MatSetOption_SeqSBAIJ,
1276: MatZeroEntries_SeqSBAIJ,
1277: /*25*/ 0,
1278: 0,
1279: 0,
1280: MatCholeskyFactorSymbolic_SeqSBAIJ,
1281: MatCholeskyFactorNumeric_SeqSBAIJ_N,
1282: /*30*/ MatSetUpPreallocation_SeqSBAIJ,
1283: 0,
1284: MatICCFactorSymbolic_SeqSBAIJ,
1285: MatGetArray_SeqSBAIJ,
1286: MatRestoreArray_SeqSBAIJ,
1287: /*35*/ MatDuplicate_SeqSBAIJ,
1288: 0,
1289: 0,
1290: 0,
1291: 0,
1292: /*40*/ MatAXPY_SeqSBAIJ,
1293: MatGetSubMatrices_SeqSBAIJ,
1294: MatIncreaseOverlap_SeqSBAIJ,
1295: MatGetValues_SeqSBAIJ,
1296: MatCopy_SeqSBAIJ,
1297: /*45*/ MatPrintHelp_SeqSBAIJ,
1298: MatScale_SeqSBAIJ,
1299: 0,
1300: 0,
1301: 0,
1302: /*50*/ 0,
1303: MatGetRowIJ_SeqSBAIJ,
1304: MatRestoreRowIJ_SeqSBAIJ,
1305: 0,
1306: 0,
1307: /*55*/ 0,
1308: 0,
1309: 0,
1310: 0,
1311: MatSetValuesBlocked_SeqSBAIJ,
1312: /*60*/ MatGetSubMatrix_SeqSBAIJ,
1313: 0,
1314: 0,
1315: 0,
1316: 0,
1317: /*65*/ 0,
1318: 0,
1319: 0,
1320: 0,
1321: 0,
1322: /*70*/ MatGetRowMax_SeqSBAIJ,
1323: 0,
1324: 0,
1325: 0,
1326: 0,
1327: /*75*/ 0,
1328: 0,
1329: 0,
1330: 0,
1331: 0,
1332: /*80*/ 0,
1333: 0,
1334: 0,
1335: #if !defined(PETSC_USE_COMPLEX)
1336: MatGetInertia_SeqSBAIJ,
1337: #else
1338: 0,
1339: #endif
1340: MatLoad_SeqSBAIJ,
1341: /*85*/ MatIsSymmetric_SeqSBAIJ,
1342: MatIsHermitian_SeqSBAIJ,
1343: MatIsStructurallySymmetric_SeqSBAIJ,
1344: 0,
1345: 0,
1346: /*90*/ 0,
1347: 0,
1348: 0,
1349: 0,
1350: 0,
1351: /*95*/ 0,
1352: 0,
1353: 0,
1354: 0,
1355: 0,
1356: /*100*/0,
1357: 0,
1358: 0,
1359: 0,
1360: 0,
1361: /*105*/0,
1362: MatRealPart_SeqSBAIJ,
1363: MatImaginaryPart_SeqSBAIJ,
1364: MatGetRowUpperTriangular_SeqSBAIJ,
1365: MatRestoreRowUpperTriangular_SeqSBAIJ
1366: };
1371: PetscErrorCode PETSCMAT_DLLEXPORT MatStoreValues_SeqSBAIJ(Mat mat)
1372: {
1373: Mat_SeqSBAIJ *aij = (Mat_SeqSBAIJ *)mat->data;
1374: PetscInt nz = aij->i[mat->rmap.N]*mat->rmap.bs*aij->bs2;
1376:
1378: if (aij->nonew != 1) {
1379: SETERRQ(PETSC_ERR_ORDER,"Must call MatSetOption(A,MAT_NO_NEW_NONZERO_LOCATIONS);first");
1380: }
1381:
1382: /* allocate space for values if not already there */
1383: if (!aij->saved_values) {
1384: PetscMalloc((nz+1)*sizeof(PetscScalar),&aij->saved_values);
1385: }
1386:
1387: /* copy values over */
1388: PetscMemcpy(aij->saved_values,aij->a,nz*sizeof(PetscScalar));
1389: return(0);
1390: }
1396: PetscErrorCode PETSCMAT_DLLEXPORT MatRetrieveValues_SeqSBAIJ(Mat mat)
1397: {
1398: Mat_SeqSBAIJ *aij = (Mat_SeqSBAIJ *)mat->data;
1400: PetscInt nz = aij->i[mat->rmap.N]*mat->rmap.bs*aij->bs2;
1401:
1403: if (aij->nonew != 1) {
1404: SETERRQ(PETSC_ERR_ORDER,"Must call MatSetOption(A,MAT_NO_NEW_NONZERO_LOCATIONS);first");
1405: }
1406: if (!aij->saved_values) {
1407: SETERRQ(PETSC_ERR_ORDER,"Must call MatStoreValues(A);first");
1408: }
1409:
1410: /* copy values over */
1411: PetscMemcpy(aij->a,aij->saved_values,nz*sizeof(PetscScalar));
1412: return(0);
1413: }
1419: PetscErrorCode PETSCMAT_DLLEXPORT MatSeqSBAIJSetPreallocation_SeqSBAIJ(Mat B,PetscInt bs,PetscInt nz,PetscInt *nnz)
1420: {
1421: Mat_SeqSBAIJ *b = (Mat_SeqSBAIJ*)B->data;
1423: PetscInt i,mbs,bs2;
1424: PetscTruth skipallocation = PETSC_FALSE,flg;
1425:
1427: B->preallocated = PETSC_TRUE;
1428: PetscOptionsGetInt(B->prefix,"-mat_block_size",&bs,PETSC_NULL);
1429: B->rmap.bs = B->cmap.bs = bs;
1430: PetscMapInitialize(B->comm,&B->rmap);
1431: PetscMapInitialize(B->comm,&B->cmap);
1433: mbs = B->rmap.N/bs;
1434: bs2 = bs*bs;
1435:
1436: if (mbs*bs != B->rmap.N) {
1437: SETERRQ(PETSC_ERR_ARG_SIZ,"Number rows, cols must be divisible by blocksize");
1438: }
1439:
1440: if (nz == MAT_SKIP_ALLOCATION) {
1441: skipallocation = PETSC_TRUE;
1442: nz = 0;
1443: }
1445: if (nz == PETSC_DEFAULT || nz == PETSC_DECIDE) nz = 3;
1446: if (nz < 0) SETERRQ1(PETSC_ERR_ARG_OUTOFRANGE,"nz cannot be less than 0: value %D",nz);
1447: if (nnz) {
1448: for (i=0; i<mbs; i++) {
1449: if (nnz[i] < 0) SETERRQ2(PETSC_ERR_ARG_OUTOFRANGE,"nnz cannot be less than 0: local row %D value %D",i,nnz[i]);
1450: 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);
1451: }
1452: }
1453:
1454: PetscOptionsHasName(B->prefix,"-mat_no_unroll",&flg);
1455: if (!flg) {
1456: switch (bs) {
1457: case 1:
1458: B->ops->choleskyfactornumeric = MatCholeskyFactorNumeric_SeqSBAIJ_1;
1459: B->ops->solve = MatSolve_SeqSBAIJ_1;
1460: B->ops->solves = MatSolves_SeqSBAIJ_1;
1461: B->ops->solvetranspose = MatSolve_SeqSBAIJ_1;
1462: B->ops->mult = MatMult_SeqSBAIJ_1;
1463: B->ops->multadd = MatMultAdd_SeqSBAIJ_1;
1464: B->ops->multtranspose = MatMult_SeqSBAIJ_1;
1465: B->ops->multtransposeadd = MatMultAdd_SeqSBAIJ_1;
1466: break;
1467: case 2:
1468: B->ops->choleskyfactornumeric = MatCholeskyFactorNumeric_SeqSBAIJ_2;
1469: B->ops->solve = MatSolve_SeqSBAIJ_2;
1470: B->ops->solvetranspose = MatSolve_SeqSBAIJ_2;
1471: B->ops->mult = MatMult_SeqSBAIJ_2;
1472: B->ops->multadd = MatMultAdd_SeqSBAIJ_2;
1473: B->ops->multtranspose = MatMult_SeqSBAIJ_2;
1474: B->ops->multtransposeadd = MatMultAdd_SeqSBAIJ_2;
1475: break;
1476: case 3:
1477: B->ops->choleskyfactornumeric = MatCholeskyFactorNumeric_SeqSBAIJ_3;
1478: B->ops->solve = MatSolve_SeqSBAIJ_3;
1479: B->ops->solvetranspose = MatSolve_SeqSBAIJ_3;
1480: B->ops->mult = MatMult_SeqSBAIJ_3;
1481: B->ops->multadd = MatMultAdd_SeqSBAIJ_3;
1482: B->ops->multtranspose = MatMult_SeqSBAIJ_3;
1483: B->ops->multtransposeadd = MatMultAdd_SeqSBAIJ_3;
1484: break;
1485: case 4:
1486: B->ops->choleskyfactornumeric = MatCholeskyFactorNumeric_SeqSBAIJ_4;
1487: B->ops->solve = MatSolve_SeqSBAIJ_4;
1488: B->ops->solvetranspose = MatSolve_SeqSBAIJ_4;
1489: B->ops->mult = MatMult_SeqSBAIJ_4;
1490: B->ops->multadd = MatMultAdd_SeqSBAIJ_4;
1491: B->ops->multtranspose = MatMult_SeqSBAIJ_4;
1492: B->ops->multtransposeadd = MatMultAdd_SeqSBAIJ_4;
1493: break;
1494: case 5:
1495: B->ops->choleskyfactornumeric = MatCholeskyFactorNumeric_SeqSBAIJ_5;
1496: B->ops->solve = MatSolve_SeqSBAIJ_5;
1497: B->ops->solvetranspose = MatSolve_SeqSBAIJ_5;
1498: B->ops->mult = MatMult_SeqSBAIJ_5;
1499: B->ops->multadd = MatMultAdd_SeqSBAIJ_5;
1500: B->ops->multtranspose = MatMult_SeqSBAIJ_5;
1501: B->ops->multtransposeadd = MatMultAdd_SeqSBAIJ_5;
1502: break;
1503: case 6:
1504: B->ops->choleskyfactornumeric = MatCholeskyFactorNumeric_SeqSBAIJ_6;
1505: B->ops->solve = MatSolve_SeqSBAIJ_6;
1506: B->ops->solvetranspose = MatSolve_SeqSBAIJ_6;
1507: B->ops->mult = MatMult_SeqSBAIJ_6;
1508: B->ops->multadd = MatMultAdd_SeqSBAIJ_6;
1509: B->ops->multtranspose = MatMult_SeqSBAIJ_6;
1510: B->ops->multtransposeadd = MatMultAdd_SeqSBAIJ_6;
1511: break;
1512: case 7:
1513: B->ops->choleskyfactornumeric = MatCholeskyFactorNumeric_SeqSBAIJ_7;
1514: B->ops->solve = MatSolve_SeqSBAIJ_7;
1515: B->ops->solvetranspose = MatSolve_SeqSBAIJ_7;
1516: B->ops->mult = MatMult_SeqSBAIJ_7;
1517: B->ops->multadd = MatMultAdd_SeqSBAIJ_7;
1518: B->ops->multtranspose = MatMult_SeqSBAIJ_7;
1519: B->ops->multtransposeadd = MatMultAdd_SeqSBAIJ_7;
1520: break;
1521: }
1522: }
1523:
1524: b->mbs = mbs;
1525: b->nbs = mbs;
1526: if (!skipallocation) {
1527: /* b->ilen will count nonzeros in each block row so far. */
1528: PetscMalloc2(mbs,PetscInt,&b->imax,mbs,PetscInt,&b->ilen);
1529: for (i=0; i<mbs; i++) { b->ilen[i] = 0;}
1530: if (!nnz) {
1531: if (nz == PETSC_DEFAULT || nz == PETSC_DECIDE) nz = 5;
1532: else if (nz <= 0) nz = 1;
1533: for (i=0; i<mbs; i++) {
1534: b->imax[i] = nz;
1535: }
1536: nz = nz*mbs; /* total nz */
1537: } else {
1538: nz = 0;
1539: for (i=0; i<mbs; i++) {b->imax[i] = nnz[i]; nz += nnz[i];}
1540: }
1541: /* nz=(nz+mbs)/2; */ /* total diagonal and superdiagonal nonzero blocks */
1542:
1543: /* allocate the matrix space */
1544: PetscMalloc3(bs2*nz,PetscScalar,&b->a,nz,PetscInt,&b->j,B->rmap.N+1,PetscInt,&b->i);
1545: PetscMemzero(b->a,nz*bs2*sizeof(MatScalar));
1546: PetscMemzero(b->j,nz*sizeof(PetscInt));
1547: b->singlemalloc = PETSC_TRUE;
1548:
1549: /* pointer to beginning of each row */
1550: b->i[0] = 0;
1551: for (i=1; i<mbs+1; i++) {
1552: b->i[i] = b->i[i-1] + b->imax[i-1];
1553: }
1554: }
1555:
1556: B->rmap.bs = bs;
1557: b->bs2 = bs2;
1558: b->nz = 0;
1559: b->maxnz = 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: }
1571: EXTERN PetscErrorCode PETSCMAT_DLLEXPORT MatConvert_SeqSBAIJ_SeqAIJ(Mat, MatType,MatReuse,Mat*);
1572: EXTERN PetscErrorCode PETSCMAT_DLLEXPORT MatConvert_SeqSBAIJ_SeqBAIJ(Mat, MatType,MatReuse,Mat*);
1575: /*MC
1576: MATSEQSBAIJ - MATSEQSBAIJ = "seqsbaij" - A matrix type to be used for sequential symmetric block sparse matrices,
1577: based on block compressed sparse row format. Only the upper triangular portion of the matrix is stored.
1578:
1579: Options Database Keys:
1580: . -mat_type seqsbaij - sets the matrix type to "seqsbaij" during a call to MatSetFromOptions()
1581:
1582: Level: beginner
1583:
1584: .seealso: MatCreateSeqSBAIJ
1585: M*/
1590: PetscErrorCode PETSCMAT_DLLEXPORT MatCreate_SeqSBAIJ(Mat B)
1591: {
1592: Mat_SeqSBAIJ *b;
1594: PetscMPIInt size;
1595: PetscTruth flg;
1596:
1598: MPI_Comm_size(B->comm,&size);
1599: if (size > 1) SETERRQ(PETSC_ERR_ARG_WRONG,"Comm must be of size 1");
1600:
1601: PetscNew(Mat_SeqSBAIJ,&b);
1602: B->data = (void*)b;
1603: PetscMemcpy(B->ops,&MatOps_Values,sizeof(struct _MatOps));
1604: B->ops->destroy = MatDestroy_SeqSBAIJ;
1605: B->ops->view = MatView_SeqSBAIJ;
1606: B->factor = 0;
1607: B->mapping = 0;
1608: b->row = 0;
1609: b->icol = 0;
1610: b->reallocs = 0;
1611: b->saved_values = 0;
1612:
1613:
1614: b->sorted = PETSC_FALSE;
1615: b->roworiented = PETSC_TRUE;
1616: b->nonew = 0;
1617: b->diag = 0;
1618: b->solve_work = 0;
1619: b->mult_work = 0;
1620: B->spptr = 0;
1621: b->keepzeroedrows = PETSC_FALSE;
1622: b->xtoy = 0;
1623: b->XtoY = 0;
1624:
1625: b->inew = 0;
1626: b->jnew = 0;
1627: b->anew = 0;
1628: b->a2anew = 0;
1629: b->permute = PETSC_FALSE;
1631: b->ignore_ltriangular = PETSC_FALSE;
1632: PetscOptionsHasName(PETSC_NULL,"-mat_ignore_lower_triangular",&flg);
1633: if (flg) b->ignore_ltriangular = PETSC_TRUE;
1635: b->getrow_utriangular = PETSC_FALSE;
1636: PetscOptionsHasName(PETSC_NULL,"-mat_getrow_uppertriangular",&flg);
1637: if (flg) b->getrow_utriangular = PETSC_TRUE;
1639: PetscObjectComposeFunctionDynamic((PetscObject)B,"MatStoreValues_C",
1640: "MatStoreValues_SeqSBAIJ",
1641: MatStoreValues_SeqSBAIJ);
1642: PetscObjectComposeFunctionDynamic((PetscObject)B,"MatRetrieveValues_C",
1643: "MatRetrieveValues_SeqSBAIJ",
1644: (void*)MatRetrieveValues_SeqSBAIJ);
1645: PetscObjectComposeFunctionDynamic((PetscObject)B,"MatSeqSBAIJSetColumnIndices_C",
1646: "MatSeqSBAIJSetColumnIndices_SeqSBAIJ",
1647: MatSeqSBAIJSetColumnIndices_SeqSBAIJ);
1648: PetscObjectComposeFunctionDynamic((PetscObject)B,"MatConvert_seqsbaij_seqaij_C",
1649: "MatConvert_SeqSBAIJ_SeqAIJ",
1650: MatConvert_SeqSBAIJ_SeqAIJ);
1651: PetscObjectComposeFunctionDynamic((PetscObject)B,"MatConvert_seqsbaij_seqbaij_C",
1652: "MatConvert_SeqSBAIJ_SeqBAIJ",
1653: MatConvert_SeqSBAIJ_SeqBAIJ);
1654: PetscObjectComposeFunctionDynamic((PetscObject)B,"MatSeqSBAIJSetPreallocation_C",
1655: "MatSeqSBAIJSetPreallocation_SeqSBAIJ",
1656: MatSeqSBAIJSetPreallocation_SeqSBAIJ);
1658: B->symmetric = PETSC_TRUE;
1659: B->structurally_symmetric = PETSC_TRUE;
1660: B->symmetric_set = PETSC_TRUE;
1661: B->structurally_symmetric_set = PETSC_TRUE;
1662: return(0);
1663: }
1668: /*@C
1669: MatSeqSBAIJSetPreallocation - Creates a sparse symmetric matrix in block AIJ (block
1670: compressed row) format. For good matrix assembly performance the
1671: user should preallocate the matrix storage by setting the parameter nz
1672: (or the array nnz). By setting these parameters accurately, performance
1673: during matrix assembly can be increased by more than a factor of 50.
1675: Collective on Mat
1677: Input Parameters:
1678: + A - the symmetric matrix
1679: . bs - size of block
1680: . nz - number of block nonzeros per block row (same for all rows)
1681: - nnz - array containing the number of block nonzeros in the upper triangular plus
1682: diagonal portion of each block (possibly different for each block row) or PETSC_NULL
1684: Options Database Keys:
1685: . -mat_no_unroll - uses code that does not unroll the loops in the
1686: block calculations (much slower)
1687: . -mat_block_size - size of the blocks to use
1689: Level: intermediate
1691: Notes:
1692: Specify the preallocated storage with either nz or nnz (not both).
1693: Set nz=PETSC_DEFAULT and nnz=PETSC_NULL for PETSc to control dynamic memory
1694: allocation. For additional details, see the users manual chapter on
1695: matrices.
1697: If the nnz parameter is given then the nz parameter is ignored
1700: .seealso: MatCreate(), MatCreateSeqAIJ(), MatSetValues(), MatCreateMPISBAIJ()
1701: @*/
1702: PetscErrorCode PETSCMAT_DLLEXPORT MatSeqSBAIJSetPreallocation(Mat B,PetscInt bs,PetscInt nz,const PetscInt nnz[])
1703: {
1704: PetscErrorCode ierr,(*f)(Mat,PetscInt,PetscInt,const PetscInt[]);
1707: PetscObjectQueryFunction((PetscObject)B,"MatSeqSBAIJSetPreallocation_C",(void (**)(void))&f);
1708: if (f) {
1709: (*f)(B,bs,nz,nnz);
1710: }
1711: return(0);
1712: }
1716: /*@C
1717: MatCreateSeqSBAIJ - Creates a sparse symmetric matrix in block AIJ (block
1718: compressed row) format. For good matrix assembly performance the
1719: user should preallocate the matrix storage by setting the parameter nz
1720: (or the array nnz). By setting these parameters accurately, performance
1721: during matrix assembly can be increased by more than a factor of 50.
1723: Collective on MPI_Comm
1725: Input Parameters:
1726: + comm - MPI communicator, set to PETSC_COMM_SELF
1727: . bs - size of block
1728: . m - number of rows, or number of columns
1729: . nz - number of block nonzeros per block row (same for all rows)
1730: - nnz - array containing the number of block nonzeros in the upper triangular plus
1731: diagonal portion of each block (possibly different for each block row) or PETSC_NULL
1733: Output Parameter:
1734: . A - the symmetric matrix
1736: Options Database Keys:
1737: . -mat_no_unroll - uses code that does not unroll the loops in the
1738: block calculations (much slower)
1739: . -mat_block_size - size of the blocks to use
1741: Level: intermediate
1743: Notes:
1745: Specify the preallocated storage with either nz or nnz (not both).
1746: Set nz=PETSC_DEFAULT and nnz=PETSC_NULL for PETSc to control dynamic memory
1747: allocation. For additional details, see the users manual chapter on
1748: matrices.
1750: If the nnz parameter is given then the nz parameter is ignored
1752: .seealso: MatCreate(), MatCreateSeqAIJ(), MatSetValues(), MatCreateMPISBAIJ()
1753: @*/
1754: PetscErrorCode PETSCMAT_DLLEXPORT MatCreateSeqSBAIJ(MPI_Comm comm,PetscInt bs,PetscInt m,PetscInt n,PetscInt nz,const PetscInt nnz[],Mat *A)
1755: {
1757:
1759: MatCreate(comm,A);
1760: MatSetSizes(*A,m,n,m,n);
1761: MatSetType(*A,MATSEQSBAIJ);
1762: MatSeqSBAIJSetPreallocation_SeqSBAIJ(*A,bs,nz,(PetscInt*)nnz);
1763: return(0);
1764: }
1768: PetscErrorCode MatDuplicate_SeqSBAIJ(Mat A,MatDuplicateOption cpvalues,Mat *B)
1769: {
1770: Mat C;
1771: Mat_SeqSBAIJ *c,*a = (Mat_SeqSBAIJ*)A->data;
1773: PetscInt i,mbs = a->mbs,nz = a->nz,bs2 =a->bs2;
1776: if (a->i[mbs] != nz) SETERRQ(PETSC_ERR_PLIB,"Corrupt matrix");
1778: *B = 0;
1779: MatCreate(A->comm,&C);
1780: MatSetSizes(C,A->rmap.N,A->cmap.n,A->rmap.N,A->cmap.n);
1781: MatSetType(C,A->type_name);
1782: PetscMemcpy(C->ops,A->ops,sizeof(struct _MatOps));
1783: c = (Mat_SeqSBAIJ*)C->data;
1785: C->preallocated = PETSC_TRUE;
1786: C->factor = A->factor;
1787: c->row = 0;
1788: c->icol = 0;
1789: c->saved_values = 0;
1790: c->keepzeroedrows = a->keepzeroedrows;
1791: C->assembled = PETSC_TRUE;
1793: PetscMapCopy(A->comm,&A->rmap,&C->rmap);
1794: PetscMapCopy(A->comm,&A->cmap,&C->cmap);
1795: c->bs2 = a->bs2;
1796: c->mbs = a->mbs;
1797: c->nbs = a->nbs;
1799: PetscMalloc((mbs+1)*sizeof(PetscInt),&c->imax);
1800: PetscMalloc((mbs+1)*sizeof(PetscInt),&c->ilen);
1801: for (i=0; i<mbs; i++) {
1802: c->imax[i] = a->imax[i];
1803: c->ilen[i] = a->ilen[i];
1804: }
1806: /* allocate the matrix space */
1807: PetscMalloc3(bs2*nz,MatScalar,&c->a,nz,PetscInt,&c->j,mbs+1,PetscInt,&c->i);
1808: c->singlemalloc = PETSC_TRUE;
1809: PetscMemcpy(c->i,a->i,(mbs+1)*sizeof(PetscInt));
1810: PetscLogObjectMemory(C,(mbs+1)*sizeof(PetscInt) + nz*(bs2*sizeof(MatScalar) + sizeof(PetscInt)));
1811: if (mbs > 0) {
1812: PetscMemcpy(c->j,a->j,nz*sizeof(PetscInt));
1813: if (cpvalues == MAT_COPY_VALUES) {
1814: PetscMemcpy(c->a,a->a,bs2*nz*sizeof(MatScalar));
1815: } else {
1816: PetscMemzero(c->a,bs2*nz*sizeof(MatScalar));
1817: }
1818: }
1820: c->sorted = a->sorted;
1821: c->roworiented = a->roworiented;
1822: c->nonew = a->nonew;
1824: if (a->diag) {
1825: PetscMalloc((mbs+1)*sizeof(PetscInt),&c->diag);
1826: PetscLogObjectMemory(C,(mbs+1)*sizeof(PetscInt));
1827: for (i=0; i<mbs; i++) {
1828: c->diag[i] = a->diag[i];
1829: }
1830: } else c->diag = 0;
1831: c->nz = a->nz;
1832: c->maxnz = a->maxnz;
1833: c->solve_work = 0;
1834: c->mult_work = 0;
1835: *B = C;
1836: PetscFListDuplicate(A->qlist,&C->qlist);
1837: return(0);
1838: }
1842: PetscErrorCode MatLoad_SeqSBAIJ(PetscViewer viewer, MatType type,Mat *A)
1843: {
1844: Mat_SeqSBAIJ *a;
1845: Mat B;
1847: int fd;
1848: PetscMPIInt size;
1849: PetscInt i,nz,header[4],*rowlengths=0,M,N,bs=1;
1850: PetscInt *mask,mbs,*jj,j,rowcount,nzcount,k,*s_browlengths,maskcount;
1851: PetscInt kmax,jcount,block,idx,point,nzcountb,extra_rows;
1852: PetscInt *masked,nmask,tmp,bs2,ishift;
1853: PetscScalar *aa;
1854: MPI_Comm comm = ((PetscObject)viewer)->comm;
1857: PetscOptionsGetInt(PETSC_NULL,"-matload_block_size",&bs,PETSC_NULL);
1858: bs2 = bs*bs;
1860: MPI_Comm_size(comm,&size);
1861: if (size > 1) SETERRQ(PETSC_ERR_ARG_WRONG,"view must have one processor");
1862: PetscViewerBinaryGetDescriptor(viewer,&fd);
1863: PetscBinaryRead(fd,header,4,PETSC_INT);
1864: if (header[0] != MAT_FILE_COOKIE) SETERRQ(PETSC_ERR_FILE_UNEXPECTED,"not Mat object");
1865: M = header[1]; N = header[2]; nz = header[3];
1867: if (header[3] < 0) {
1868: SETERRQ(PETSC_ERR_FILE_UNEXPECTED,"Matrix stored in special format, cannot load as SeqSBAIJ");
1869: }
1871: if (M != N) SETERRQ(PETSC_ERR_SUP,"Can only do square matrices");
1873: /*
1874: This code adds extra rows to make sure the number of rows is
1875: divisible by the blocksize
1876: */
1877: mbs = M/bs;
1878: extra_rows = bs - M + bs*(mbs);
1879: if (extra_rows == bs) extra_rows = 0;
1880: else mbs++;
1881: if (extra_rows) {
1882: PetscInfo(0,"Padding loaded matrix to match blocksize\n");
1883: }
1885: /* read in row lengths */
1886: PetscMalloc((M+extra_rows)*sizeof(PetscInt),&rowlengths);
1887: PetscBinaryRead(fd,rowlengths,M,PETSC_INT);
1888: for (i=0; i<extra_rows; i++) rowlengths[M+i] = 1;
1890: /* read in column indices */
1891: PetscMalloc((nz+extra_rows)*sizeof(PetscInt),&jj);
1892: PetscBinaryRead(fd,jj,nz,PETSC_INT);
1893: for (i=0; i<extra_rows; i++) jj[nz+i] = M+i;
1895: /* loop over row lengths determining block row lengths */
1896: PetscMalloc(mbs*sizeof(PetscInt),&s_browlengths);
1897: PetscMemzero(s_browlengths,mbs*sizeof(PetscInt));
1898: PetscMalloc(2*mbs*sizeof(PetscInt),&mask);
1899: PetscMemzero(mask,mbs*sizeof(PetscInt));
1900: masked = mask + mbs;
1901: rowcount = 0; nzcount = 0;
1902: for (i=0; i<mbs; i++) {
1903: nmask = 0;
1904: for (j=0; j<bs; j++) {
1905: kmax = rowlengths[rowcount];
1906: for (k=0; k<kmax; k++) {
1907: tmp = jj[nzcount++]/bs; /* block col. index */
1908: if (!mask[tmp] && tmp >= i) {masked[nmask++] = tmp; mask[tmp] = 1;}
1909: }
1910: rowcount++;
1911: }
1912: s_browlengths[i] += nmask;
1913:
1914: /* zero out the mask elements we set */
1915: for (j=0; j<nmask; j++) mask[masked[j]] = 0;
1916: }
1918: /* create our matrix */
1919: MatCreate(comm,&B);
1920: MatSetSizes(B,M+extra_rows,N+extra_rows,M+extra_rows,N+extra_rows);
1921: MatSetType(B,type);
1922: MatSeqSBAIJSetPreallocation_SeqSBAIJ(B,bs,0,s_browlengths);
1923: a = (Mat_SeqSBAIJ*)B->data;
1925: /* set matrix "i" values */
1926: a->i[0] = 0;
1927: for (i=1; i<= mbs; i++) {
1928: a->i[i] = a->i[i-1] + s_browlengths[i-1];
1929: a->ilen[i-1] = s_browlengths[i-1];
1930: }
1931: a->nz = a->i[mbs];
1933: /* read in nonzero values */
1934: PetscMalloc((nz+extra_rows)*sizeof(PetscScalar),&aa);
1935: PetscBinaryRead(fd,aa,nz,PETSC_SCALAR);
1936: for (i=0; i<extra_rows; i++) aa[nz+i] = 1.0;
1938: /* set "a" and "j" values into matrix */
1939: nzcount = 0; jcount = 0;
1940: for (i=0; i<mbs; i++) {
1941: nzcountb = nzcount;
1942: nmask = 0;
1943: for (j=0; j<bs; j++) {
1944: kmax = rowlengths[i*bs+j];
1945: for (k=0; k<kmax; k++) {
1946: tmp = jj[nzcount++]/bs; /* block col. index */
1947: if (!mask[tmp] && tmp >= i) { masked[nmask++] = tmp; mask[tmp] = 1;}
1948: }
1949: }
1950: /* sort the masked values */
1951: PetscSortInt(nmask,masked);
1953: /* set "j" values into matrix */
1954: maskcount = 1;
1955: for (j=0; j<nmask; j++) {
1956: a->j[jcount++] = masked[j];
1957: mask[masked[j]] = maskcount++;
1958: }
1960: /* set "a" values into matrix */
1961: ishift = bs2*a->i[i];
1962: for (j=0; j<bs; j++) {
1963: kmax = rowlengths[i*bs+j];
1964: for (k=0; k<kmax; k++) {
1965: tmp = jj[nzcountb]/bs ; /* block col. index */
1966: if (tmp >= i){
1967: block = mask[tmp] - 1;
1968: point = jj[nzcountb] - bs*tmp;
1969: idx = ishift + bs2*block + j + bs*point;
1970: a->a[idx] = aa[nzcountb];
1971: }
1972: nzcountb++;
1973: }
1974: }
1975: /* zero out the mask elements we set */
1976: for (j=0; j<nmask; j++) mask[masked[j]] = 0;
1977: }
1978: if (jcount != a->nz) SETERRQ(PETSC_ERR_FILE_UNEXPECTED,"Bad binary matrix");
1980: PetscFree(rowlengths);
1981: PetscFree(s_browlengths);
1982: PetscFree(aa);
1983: PetscFree(jj);
1984: PetscFree(mask);
1986: MatAssemblyBegin(B,MAT_FINAL_ASSEMBLY);
1987: MatAssemblyEnd(B,MAT_FINAL_ASSEMBLY);
1988: MatView_Private(B);
1989: *A = B;
1990: return(0);
1991: }
1995: PetscErrorCode MatRelax_SeqSBAIJ(Mat A,Vec bb,PetscReal omega,MatSORType flag,PetscReal fshift,PetscInt its,PetscInt lits,Vec xx)
1996: {
1997: Mat_SeqSBAIJ *a = (Mat_SeqSBAIJ*)A->data;
1998: MatScalar *aa=a->a,*v,*v1;
1999: PetscScalar *x,*b,*t,sum,d;
2001: PetscInt m=a->mbs,bs=A->rmap.bs,*ai=a->i,*aj=a->j;
2002: PetscInt nz,nz1,*vj,*vj1,i;
2005: its = its*lits;
2006: if (its <= 0) SETERRQ2(PETSC_ERR_ARG_WRONG,"Relaxation requires global its %D and local its %D both positive",its,lits);
2008: if (bs > 1)
2009: SETERRQ(PETSC_ERR_SUP,"SSOR for block size > 1 is not yet implemented");
2011: VecGetArray(xx,&x);
2012: if (xx != bb) {
2013: VecGetArray(bb,&b);
2014: } else {
2015: b = x;
2016: }
2018: PetscMalloc(m*sizeof(PetscScalar),&t);
2019:
2020: if (flag & SOR_ZERO_INITIAL_GUESS) {
2021: if (flag & SOR_FORWARD_SWEEP || flag & SOR_LOCAL_FORWARD_SWEEP){
2022: for (i=0; i<m; i++)
2023: t[i] = b[i];
2025: for (i=0; i<m; i++){
2026: d = *(aa + ai[i]); /* diag[i] */
2027: v = aa + ai[i] + 1;
2028: vj = aj + ai[i] + 1;
2029: nz = ai[i+1] - ai[i] - 1;
2030: x[i] = omega*t[i]/d;
2031: while (nz--) t[*vj++] -= x[i]*(*v++); /* update rhs */
2032: PetscLogFlops(2*nz-1);
2033: }
2034: }
2036: if (flag & SOR_BACKWARD_SWEEP || flag & SOR_LOCAL_BACKWARD_SWEEP){
2037: for (i=0; i<m; i++)
2038: t[i] = b[i];
2039:
2040: for (i=0; i<m-1; i++){ /* update rhs */
2041: v = aa + ai[i] + 1;
2042: vj = aj + ai[i] + 1;
2043: nz = ai[i+1] - ai[i] - 1;
2044: while (nz--) t[*vj++] -= x[i]*(*v++);
2045: PetscLogFlops(2*nz-1);
2046: }
2047: for (i=m-1; i>=0; i--){
2048: d = *(aa + ai[i]);
2049: v = aa + ai[i] + 1;
2050: vj = aj + ai[i] + 1;
2051: nz = ai[i+1] - ai[i] - 1;
2052: sum = t[i];
2053: while (nz--) sum -= x[*vj++]*(*v++);
2054: PetscLogFlops(2*nz-1);
2055: x[i] = (1-omega)*x[i] + omega*sum/d;
2056: }
2057: }
2058: its--;
2059: }
2061: while (its--) {
2062: /*
2063: forward sweep:
2064: for i=0,...,m-1:
2065: sum[i] = (b[i] - U(i,:)x )/d[i];
2066: x[i] = (1-omega)x[i] + omega*sum[i];
2067: b = b - x[i]*U^T(i,:);
2068:
2069: */
2070: if (flag & SOR_FORWARD_SWEEP || flag & SOR_LOCAL_FORWARD_SWEEP){
2071: for (i=0; i<m; i++)
2072: t[i] = b[i];
2074: for (i=0; i<m; i++){
2075: d = *(aa + ai[i]); /* diag[i] */
2076: v = aa + ai[i] + 1; v1=v;
2077: vj = aj + ai[i] + 1; vj1=vj;
2078: nz = ai[i+1] - ai[i] - 1; nz1=nz;
2079: sum = t[i];
2080: while (nz1--) sum -= (*v1++)*x[*vj1++];
2081: x[i] = (1-omega)*x[i] + omega*sum/d;
2082: while (nz--) t[*vj++] -= x[i]*(*v++);
2083: PetscLogFlops(4*nz-2);
2084: }
2085: }
2086:
2087: if (flag & SOR_BACKWARD_SWEEP || flag & SOR_LOCAL_BACKWARD_SWEEP){
2088: /*
2089: backward sweep:
2090: b = b - x[i]*U^T(i,:), i=0,...,n-2
2091: for i=m-1,...,0:
2092: sum[i] = (b[i] - U(i,:)x )/d[i];
2093: x[i] = (1-omega)x[i] + omega*sum[i];
2094: */
2095: for (i=0; i<m; i++)
2096: t[i] = b[i];
2097:
2098: for (i=0; i<m-1; i++){ /* update rhs */
2099: v = aa + ai[i] + 1;
2100: vj = aj + ai[i] + 1;
2101: nz = ai[i+1] - ai[i] - 1;
2102: while (nz--) t[*vj++] -= x[i]*(*v++);
2103: PetscLogFlops(2*nz-1);
2104: }
2105: for (i=m-1; i>=0; i--){
2106: d = *(aa + ai[i]);
2107: v = aa + ai[i] + 1;
2108: vj = aj + ai[i] + 1;
2109: nz = ai[i+1] - ai[i] - 1;
2110: sum = t[i];
2111: while (nz--) sum -= x[*vj++]*(*v++);
2112: PetscLogFlops(2*nz-1);
2113: x[i] = (1-omega)*x[i] + omega*sum/d;
2114: }
2115: }
2116: }
2118: PetscFree(t);
2119: VecRestoreArray(xx,&x);
2120: if (bb != xx) {
2121: VecRestoreArray(bb,&b);
2122: }
2123: return(0);
2124: }