Actual source code: baijfact.c
1: /*
2: Factorization code for BAIJ format.
3: */
4: #include src/mat/impls/baij/seq/baij.h
5: #include src/inline/ilu.h
7: /* ------------------------------------------------------------*/
8: /*
9: Version for when blocks are 2 by 2
10: */
13: PetscErrorCode MatLUFactorNumeric_SeqBAIJ_2(Mat A,Mat *B)
14: {
15: Mat C = *B;
16: Mat_SeqBAIJ *a = (Mat_SeqBAIJ*)A->data,*b = (Mat_SeqBAIJ *)C->data;
17: IS isrow = b->row,isicol = b->icol;
19: PetscInt *r,*ic,i,j,n = a->mbs,*bi = b->i,*bj = b->j;
20: PetscInt *ajtmpold,*ajtmp,nz,row;
21: PetscInt *diag_offset=b->diag,idx,*ai=a->i,*aj=a->j,*pj;
22: MatScalar *pv,*v,*rtmp,m1,m2,m3,m4,*pc,*w,*x,x1,x2,x3,x4;
23: MatScalar p1,p2,p3,p4;
24: MatScalar *ba = b->a,*aa = a->a;
27: ISGetIndices(isrow,&r);
28: ISGetIndices(isicol,&ic);
29: PetscMalloc(4*(n+1)*sizeof(MatScalar),&rtmp);
31: for (i=0; i<n; i++) {
32: nz = bi[i+1] - bi[i];
33: ajtmp = bj + bi[i];
34: for (j=0; j<nz; j++) {
35: x = rtmp+4*ajtmp[j]; x[0] = x[1] = x[2] = x[3] = 0.0;
36: }
37: /* load in initial (unfactored row) */
38: idx = r[i];
39: nz = ai[idx+1] - ai[idx];
40: ajtmpold = aj + ai[idx];
41: v = aa + 4*ai[idx];
42: for (j=0; j<nz; j++) {
43: x = rtmp+4*ic[ajtmpold[j]];
44: x[0] = v[0]; x[1] = v[1]; x[2] = v[2]; x[3] = v[3];
45: v += 4;
46: }
47: row = *ajtmp++;
48: while (row < i) {
49: pc = rtmp + 4*row;
50: p1 = pc[0]; p2 = pc[1]; p3 = pc[2]; p4 = pc[3];
51: if (p1 != 0.0 || p2 != 0.0 || p3 != 0.0 || p4 != 0.0) {
52: pv = ba + 4*diag_offset[row];
53: pj = bj + diag_offset[row] + 1;
54: x1 = pv[0]; x2 = pv[1]; x3 = pv[2]; x4 = pv[3];
55: pc[0] = m1 = p1*x1 + p3*x2;
56: pc[1] = m2 = p2*x1 + p4*x2;
57: pc[2] = m3 = p1*x3 + p3*x4;
58: pc[3] = m4 = p2*x3 + p4*x4;
59: nz = bi[row+1] - diag_offset[row] - 1;
60: pv += 4;
61: for (j=0; j<nz; j++) {
62: x1 = pv[0]; x2 = pv[1]; x3 = pv[2]; x4 = pv[3];
63: x = rtmp + 4*pj[j];
64: x[0] -= m1*x1 + m3*x2;
65: x[1] -= m2*x1 + m4*x2;
66: x[2] -= m1*x3 + m3*x4;
67: x[3] -= m2*x3 + m4*x4;
68: pv += 4;
69: }
70: PetscLogFlops(16*nz+12);
71: }
72: row = *ajtmp++;
73: }
74: /* finished row so stick it into b->a */
75: pv = ba + 4*bi[i];
76: pj = bj + bi[i];
77: nz = bi[i+1] - bi[i];
78: for (j=0; j<nz; j++) {
79: x = rtmp+4*pj[j];
80: pv[0] = x[0]; pv[1] = x[1]; pv[2] = x[2]; pv[3] = x[3];
81: pv += 4;
82: }
83: /* invert diagonal block */
84: w = ba + 4*diag_offset[i];
85: Kernel_A_gets_inverse_A_2(w);
86: }
88: PetscFree(rtmp);
89: ISRestoreIndices(isicol,&ic);
90: ISRestoreIndices(isrow,&r);
91: C->factor = FACTOR_LU;
92: C->assembled = PETSC_TRUE;
93: PetscLogFlops(1.3333*8*b->mbs); /* from inverting diagonal blocks */
94: return(0);
95: }
96: /*
97: Version for when blocks are 2 by 2 Using natural ordering
98: */
101: PetscErrorCode MatLUFactorNumeric_SeqBAIJ_2_NaturalOrdering(Mat A,Mat *B)
102: {
103: Mat C = *B;
104: Mat_SeqBAIJ *a = (Mat_SeqBAIJ*)A->data,*b = (Mat_SeqBAIJ *)C->data;
106: PetscInt i,j,n = a->mbs,*bi = b->i,*bj = b->j;
107: PetscInt *ajtmpold,*ajtmp,nz,row;
108: PetscInt *diag_offset = b->diag,*ai=a->i,*aj=a->j,*pj;
109: MatScalar *pv,*v,*rtmp,*pc,*w,*x;
110: MatScalar p1,p2,p3,p4,m1,m2,m3,m4,x1,x2,x3,x4;
111: MatScalar *ba = b->a,*aa = a->a;
114: PetscMalloc(4*(n+1)*sizeof(MatScalar),&rtmp);
116: for (i=0; i<n; i++) {
117: nz = bi[i+1] - bi[i];
118: ajtmp = bj + bi[i];
119: for (j=0; j<nz; j++) {
120: x = rtmp+4*ajtmp[j];
121: x[0] = x[1] = x[2] = x[3] = 0.0;
122: }
123: /* load in initial (unfactored row) */
124: nz = ai[i+1] - ai[i];
125: ajtmpold = aj + ai[i];
126: v = aa + 4*ai[i];
127: for (j=0; j<nz; j++) {
128: x = rtmp+4*ajtmpold[j];
129: x[0] = v[0]; x[1] = v[1]; x[2] = v[2]; x[3] = v[3];
130: v += 4;
131: }
132: row = *ajtmp++;
133: while (row < i) {
134: pc = rtmp + 4*row;
135: p1 = pc[0]; p2 = pc[1]; p3 = pc[2]; p4 = pc[3];
136: if (p1 != 0.0 || p2 != 0.0 || p3 != 0.0 || p4 != 0.0) {
137: pv = ba + 4*diag_offset[row];
138: pj = bj + diag_offset[row] + 1;
139: x1 = pv[0]; x2 = pv[1]; x3 = pv[2]; x4 = pv[3];
140: pc[0] = m1 = p1*x1 + p3*x2;
141: pc[1] = m2 = p2*x1 + p4*x2;
142: pc[2] = m3 = p1*x3 + p3*x4;
143: pc[3] = m4 = p2*x3 + p4*x4;
144: nz = bi[row+1] - diag_offset[row] - 1;
145: pv += 4;
146: for (j=0; j<nz; j++) {
147: x1 = pv[0]; x2 = pv[1]; x3 = pv[2]; x4 = pv[3];
148: x = rtmp + 4*pj[j];
149: x[0] -= m1*x1 + m3*x2;
150: x[1] -= m2*x1 + m4*x2;
151: x[2] -= m1*x3 + m3*x4;
152: x[3] -= m2*x3 + m4*x4;
153: pv += 4;
154: }
155: PetscLogFlops(16*nz+12);
156: }
157: row = *ajtmp++;
158: }
159: /* finished row so stick it into b->a */
160: pv = ba + 4*bi[i];
161: pj = bj + bi[i];
162: nz = bi[i+1] - bi[i];
163: for (j=0; j<nz; j++) {
164: x = rtmp+4*pj[j];
165: pv[0] = x[0]; pv[1] = x[1]; pv[2] = x[2]; pv[3] = x[3];
166: pv += 4;
167: }
168: /* invert diagonal block */
169: w = ba + 4*diag_offset[i];
170: Kernel_A_gets_inverse_A_2(w);
171: /*Kernel_A_gets_inverse_A(bs,w,v_pivots,v_work);*/
172: }
174: PetscFree(rtmp);
175: C->factor = FACTOR_LU;
176: C->assembled = PETSC_TRUE;
177: PetscLogFlops(1.3333*8*b->mbs); /* from inverting diagonal blocks */
178: return(0);
179: }
181: /* ----------------------------------------------------------- */
182: /*
183: Version for when blocks are 1 by 1.
184: */
187: PetscErrorCode MatLUFactorNumeric_SeqBAIJ_1(Mat A,Mat *B)
188: {
189: Mat C = *B;
190: Mat_SeqBAIJ *a = (Mat_SeqBAIJ*)A->data,*b = (Mat_SeqBAIJ *)C->data;
191: IS isrow = b->row,isicol = b->icol;
193: PetscInt *r,*ic,i,j,n = a->mbs,*bi = b->i,*bj = b->j;
194: PetscInt *ajtmpold,*ajtmp,nz,row,*ai = a->i,*aj = a->j;
195: PetscInt *diag_offset = b->diag,diag,*pj;
196: MatScalar *pv,*v,*rtmp,multiplier,*pc;
197: MatScalar *ba = b->a,*aa = a->a;
200: ISGetIndices(isrow,&r);
201: ISGetIndices(isicol,&ic);
202: PetscMalloc((n+1)*sizeof(MatScalar),&rtmp);
204: for (i=0; i<n; i++) {
205: nz = bi[i+1] - bi[i];
206: ajtmp = bj + bi[i];
207: for (j=0; j<nz; j++) rtmp[ajtmp[j]] = 0.0;
209: /* load in initial (unfactored row) */
210: nz = ai[r[i]+1] - ai[r[i]];
211: ajtmpold = aj + ai[r[i]];
212: v = aa + ai[r[i]];
213: for (j=0; j<nz; j++) rtmp[ic[ajtmpold[j]]] = v[j];
215: row = *ajtmp++;
216: while (row < i) {
217: pc = rtmp + row;
218: if (*pc != 0.0) {
219: pv = ba + diag_offset[row];
220: pj = bj + diag_offset[row] + 1;
221: multiplier = *pc * *pv++;
222: *pc = multiplier;
223: nz = bi[row+1] - diag_offset[row] - 1;
224: for (j=0; j<nz; j++) rtmp[pj[j]] -= multiplier * pv[j];
225: PetscLogFlops(1+2*nz);
226: }
227: row = *ajtmp++;
228: }
229: /* finished row so stick it into b->a */
230: pv = ba + bi[i];
231: pj = bj + bi[i];
232: nz = bi[i+1] - bi[i];
233: for (j=0; j<nz; j++) {pv[j] = rtmp[pj[j]];}
234: diag = diag_offset[i] - bi[i];
235: /* check pivot entry for current row */
236: if (pv[diag] == 0.0) {
237: SETERRQ(PETSC_ERR_MAT_LU_ZRPVT,"Zero pivot");
238: }
239: pv[diag] = 1.0/pv[diag];
240: }
242: PetscFree(rtmp);
243: ISRestoreIndices(isicol,&ic);
244: ISRestoreIndices(isrow,&r);
245: C->factor = FACTOR_LU;
246: C->assembled = PETSC_TRUE;
247: PetscLogFlops(C->n);
248: return(0);
249: }
252: /* ----------------------------------------------------------- */
255: PetscErrorCode MatLUFactor_SeqBAIJ(Mat A,IS row,IS col,MatFactorInfo *info)
256: {
258: Mat C;
261: MatLUFactorSymbolic(A,row,col,info,&C);
262: MatLUFactorNumeric(A,&C);
263: MatHeaderCopy(A,C);
264: PetscLogObjectParent(A,((Mat_SeqBAIJ*)(A->data))->icol);
265: return(0);
266: }