Actual source code: baijsolvnat3.c

petsc-3.11.3 2019-06-26
Report Typos and Errors
  1:  #include <../src/mat/impls/baij/seq/baij.h>
  2:  #include <petsc/private/kernels/blockinvert.h>

  4: /*
  5:       Special case where the matrix was ILU(0) factored in the natural
  6:    ordering. This eliminates the need for the column and row permutation.
  7: */
  8: PetscErrorCode MatSolve_SeqBAIJ_3_NaturalOrdering_inplace(Mat A,Vec bb,Vec xx)
  9: {
 10:   Mat_SeqBAIJ       *a = (Mat_SeqBAIJ*)A->data;
 11:   const PetscInt    n  =a->mbs,*ai=a->i,*aj=a->j;
 12:   PetscErrorCode    ierr;
 13:   const PetscInt    *diag = a->diag,*vi;
 14:   const MatScalar   *aa   =a->a,*v;
 15:   PetscScalar       *x,s1,s2,s3,x1,x2,x3;
 16:   const PetscScalar *b;
 17:   PetscInt          jdx,idt,idx,nz,i;

 20:   VecGetArrayRead(bb,&b);
 21:   VecGetArray(xx,&x);

 23:   /* forward solve the lower triangular */
 24:   idx  = 0;
 25:   x[0] = b[0]; x[1] = b[1]; x[2] = b[2];
 26:   for (i=1; i<n; i++) {
 27:     v    =  aa      + 9*ai[i];
 28:     vi   =  aj      + ai[i];
 29:     nz   =  diag[i] - ai[i];
 30:     idx +=  3;
 31:     s1   =  b[idx];s2 = b[1+idx];s3 = b[2+idx];
 32:     while (nz--) {
 33:       jdx = 3*(*vi++);
 34:       x1  = x[jdx];x2 = x[1+jdx];x3 = x[2+jdx];
 35:       s1 -= v[0]*x1 + v[3]*x2 + v[6]*x3;
 36:       s2 -= v[1]*x1 + v[4]*x2 + v[7]*x3;
 37:       s3 -= v[2]*x1 + v[5]*x2 + v[8]*x3;
 38:       v  += 9;
 39:     }
 40:     x[idx]   = s1;
 41:     x[1+idx] = s2;
 42:     x[2+idx] = s3;
 43:   }
 44:   /* backward solve the upper triangular */
 45:   for (i=n-1; i>=0; i--) {
 46:     v   = aa + 9*diag[i] + 9;
 47:     vi  = aj + diag[i] + 1;
 48:     nz  = ai[i+1] - diag[i] - 1;
 49:     idt = 3*i;
 50:     s1  = x[idt];  s2 = x[1+idt];
 51:     s3  = x[2+idt];
 52:     while (nz--) {
 53:       idx = 3*(*vi++);
 54:       x1  = x[idx];   x2 = x[1+idx];x3    = x[2+idx];
 55:       s1 -= v[0]*x1 + v[3]*x2 + v[6]*x3;
 56:       s2 -= v[1]*x1 + v[4]*x2 + v[7]*x3;
 57:       s3 -= v[2]*x1 + v[5]*x2 + v[8]*x3;
 58:       v  += 9;
 59:     }
 60:     v        = aa +  9*diag[i];
 61:     x[idt]   = v[0]*s1 + v[3]*s2 + v[6]*s3;
 62:     x[1+idt] = v[1]*s1 + v[4]*s2 + v[7]*s3;
 63:     x[2+idt] = v[2]*s1 + v[5]*s2 + v[8]*s3;
 64:   }

 66:   VecRestoreArrayRead(bb,&b);
 67:   VecRestoreArray(xx,&x);
 68:   PetscLogFlops(2.0*9*(a->nz) - 3.0*A->cmap->n);
 69:   return(0);
 70: }

 72: PetscErrorCode MatSolve_SeqBAIJ_3_NaturalOrdering(Mat A,Vec bb,Vec xx)
 73: {
 74:   Mat_SeqBAIJ       *a = (Mat_SeqBAIJ*)A->data;
 75:   const PetscInt    n  =a->mbs,*vi,*ai=a->i,*aj=a->j,*adiag=a->diag;
 76:   PetscErrorCode    ierr;
 77:   PetscInt          i,k,nz,idx,jdx,idt;
 78:   const PetscInt    bs = A->rmap->bs,bs2 = a->bs2;
 79:   const MatScalar   *aa=a->a,*v;
 80:   PetscScalar       *x;
 81:   const PetscScalar *b;
 82:   PetscScalar       s1,s2,s3,x1,x2,x3;

 85:   VecGetArrayRead(bb,&b);
 86:   VecGetArray(xx,&x);
 87:   /* forward solve the lower triangular */
 88:   idx  = 0;
 89:   x[0] = b[idx]; x[1] = b[1+idx];x[2] = b[2+idx];
 90:   for (i=1; i<n; i++) {
 91:     v   = aa + bs2*ai[i];
 92:     vi  = aj + ai[i];
 93:     nz  = ai[i+1] - ai[i];
 94:     idx = bs*i;
 95:     s1  = b[idx];s2 = b[1+idx];s3 = b[2+idx];
 96:     for (k=0; k<nz; k++) {
 97:       jdx = bs*vi[k];
 98:       x1  = x[jdx];x2 = x[1+jdx]; x3 =x[2+jdx];
 99:       s1 -= v[0]*x1 + v[3]*x2 + v[6]*x3;
100:       s2 -= v[1]*x1 + v[4]*x2 + v[7]*x3;
101:       s3 -= v[2]*x1 + v[5]*x2 + v[8]*x3;

103:       v +=  bs2;
104:     }

106:     x[idx]   = s1;
107:     x[1+idx] = s2;
108:     x[2+idx] = s3;
109:   }

111:   /* backward solve the upper triangular */
112:   for (i=n-1; i>=0; i--) {
113:     v   = aa + bs2*(adiag[i+1]+1);
114:     vi  = aj + adiag[i+1]+1;
115:     nz  = adiag[i] - adiag[i+1]-1;
116:     idt = bs*i;
117:     s1  = x[idt];  s2 = x[1+idt];s3 = x[2+idt];

119:     for (k=0; k<nz; k++) {
120:       idx = bs*vi[k];
121:       x1  = x[idx];   x2 = x[1+idx]; x3 = x[2+idx];
122:       s1 -= v[0]*x1 + v[3]*x2 + v[6]*x3;
123:       s2 -= v[1]*x1 + v[4]*x2 + v[7]*x3;
124:       s3 -= v[2]*x1 + v[5]*x2 + v[8]*x3;

126:       v +=  bs2;
127:     }
128:     /* x = inv_diagonal*x */
129:     x[idt]   = v[0]*s1 + v[3]*s2 + v[6]*s3;
130:     x[1+idt] = v[1]*s1 + v[4]*s2 + v[7]*s3;
131:     x[2+idt] = v[2]*s1 + v[5]*s2 + v[8]*s3;

133:   }

135:   VecRestoreArrayRead(bb,&b);
136:   VecRestoreArray(xx,&x);
137:   PetscLogFlops(2.0*bs2*(a->nz) - bs*A->cmap->n);
138:   return(0);
139: }

141: PetscErrorCode MatForwardSolve_SeqBAIJ_3_NaturalOrdering(Mat A,Vec bb,Vec xx)
142: {
143:   Mat_SeqBAIJ       *a = (Mat_SeqBAIJ*)A->data;
144:   const PetscInt    n  =a->mbs,*vi,*ai=a->i,*aj=a->j;
145:   PetscErrorCode    ierr;
146:   PetscInt          i,k,nz,idx,jdx;
147:   const PetscInt    bs = A->rmap->bs,bs2 = a->bs2;
148:   const MatScalar   *aa=a->a,*v;
149:   PetscScalar       *x;
150:   const PetscScalar *b;
151:   PetscScalar       s1,s2,s3,x1,x2,x3;

154:   VecGetArrayRead(bb,&b);
155:   VecGetArray(xx,&x);
156:   /* forward solve the lower triangular */
157:   idx  = 0;
158:   x[0] = b[idx]; x[1] = b[1+idx];x[2] = b[2+idx];
159:   for (i=1; i<n; i++) {
160:     v   = aa + bs2*ai[i];
161:     vi  = aj + ai[i];
162:     nz  = ai[i+1] - ai[i];
163:     idx = bs*i;
164:     s1  = b[idx];s2 = b[1+idx];s3 = b[2+idx];
165:     for (k=0; k<nz; k++) {
166:       jdx = bs*vi[k];
167:       x1  = x[jdx];x2 = x[1+jdx]; x3 =x[2+jdx];
168:       s1 -= v[0]*x1 + v[3]*x2 + v[6]*x3;
169:       s2 -= v[1]*x1 + v[4]*x2 + v[7]*x3;
170:       s3 -= v[2]*x1 + v[5]*x2 + v[8]*x3;

172:       v +=  bs2;
173:     }

175:     x[idx]   = s1;
176:     x[1+idx] = s2;
177:     x[2+idx] = s3;
178:   }

180:   VecRestoreArrayRead(bb,&b);
181:   VecRestoreArray(xx,&x);
182:   PetscLogFlops(1.0*bs2*(a->nz) - bs*A->cmap->n);
183:   return(0);
184: }


187: PetscErrorCode MatBackwardSolve_SeqBAIJ_3_NaturalOrdering(Mat A,Vec bb,Vec xx)
188: {
189:   Mat_SeqBAIJ       *a = (Mat_SeqBAIJ*)A->data;
190:   const PetscInt    n  =a->mbs,*vi,*aj=a->j,*adiag=a->diag;
191:   PetscErrorCode    ierr;
192:   PetscInt          i,k,nz,idx,idt;
193:   const PetscInt    bs = A->rmap->bs,bs2 = a->bs2;
194:   const MatScalar   *aa=a->a,*v;
195:   PetscScalar       *x;
196:   const PetscScalar *b;
197:   PetscScalar       s1,s2,s3,x1,x2,x3;

200:   VecGetArrayRead(bb,&b);
201:   VecGetArray(xx,&x);

203:   /* backward solve the upper triangular */
204:   for (i=n-1; i>=0; i--) {
205:     v   = aa + bs2*(adiag[i+1]+1);
206:     vi  = aj + adiag[i+1]+1;
207:     nz  = adiag[i] - adiag[i+1]-1;
208:     idt = bs*i;
209:     s1  = b[idt];  s2 = b[1+idt];s3 = b[2+idt];

211:     for (k=0; k<nz; k++) {
212:       idx = bs*vi[k];
213:       x1  = x[idx];   x2 = x[1+idx]; x3 = x[2+idx];
214:       s1 -= v[0]*x1 + v[3]*x2 + v[6]*x3;
215:       s2 -= v[1]*x1 + v[4]*x2 + v[7]*x3;
216:       s3 -= v[2]*x1 + v[5]*x2 + v[8]*x3;

218:       v +=  bs2;
219:     }
220:     /* x = inv_diagonal*x */
221:     x[idt]   = v[0]*s1 + v[3]*s2 + v[6]*s3;
222:     x[1+idt] = v[1]*s1 + v[4]*s2 + v[7]*s3;
223:     x[2+idt] = v[2]*s1 + v[5]*s2 + v[8]*s3;

225:   }

227:   VecRestoreArrayRead(bb,&b);
228:   VecRestoreArray(xx,&x);
229:   PetscLogFlops(2.0*bs2*(a->nz) - bs*A->cmap->n);
230:   return(0);
231: }