Actual source code: pastix.c

petsc-master 2014-12-18
Report Typos and Errors
  1: /*
  2:  Provides an interface to the PaStiX sparse solver
  3:  */
  4: #include <../src/mat/impls/aij/seq/aij.h>
  5: #include <../src/mat/impls/aij/mpi/mpiaij.h>
  6: #include <../src/mat/impls/sbaij/seq/sbaij.h>
  7: #include <../src/mat/impls/sbaij/mpi/mpisbaij.h>

  9: #if defined(PETSC_USE_COMPLEX)
 10: #define _H_COMPLEX
 11: #endif

 13: EXTERN_C_BEGIN
 14: #include <pastix.h>
 15: EXTERN_C_END

 17: #if defined(PETSC_USE_COMPLEX)
 18: #if defined(PETSC_USE_REAL_SINGLE)
 19: #define PASTIX_CALL c_pastix
 20: #define PASTIX_CHECKMATRIX c_pastix_checkMatrix
 21: #else
 22: #define PASTIX_CALL z_pastix
 23: #define PASTIX_CHECKMATRIX z_pastix_checkMatrix
 24: #endif

 26: #else /* PETSC_USE_COMPLEX */

 28: #if defined(PETSC_USE_REAL_SINGLE)
 29: #define PASTIX_CALL s_pastix
 30: #define PASTIX_CHECKMATRIX s_pastix_checkMatrix
 31: #else
 32: #define PASTIX_CALL d_pastix
 33: #define PASTIX_CHECKMATRIX d_pastix_checkMatrix
 34: #endif

 36: #endif /* PETSC_USE_COMPLEX */

 38: typedef PetscScalar PastixScalar;

 40: typedef struct Mat_Pastix_ {
 41:   pastix_data_t *pastix_data;    /* Pastix data storage structure                        */
 42:   MatStructure  matstruc;
 43:   PetscInt      n;               /* Number of columns in the matrix                      */
 44:   PetscInt      *colptr;         /* Index of first element of each column in row and val */
 45:   PetscInt      *row;            /* Row of each element of the matrix                    */
 46:   PetscScalar   *val;            /* Value of each element of the matrix                  */
 47:   PetscInt      *perm;           /* Permutation tabular                                  */
 48:   PetscInt      *invp;           /* Reverse permutation tabular                          */
 49:   PetscScalar   *rhs;            /* Rhight-hand-side member                              */
 50:   PetscInt      rhsnbr;          /* Rhight-hand-side number (must be 1)                  */
 51:   PetscInt      iparm[64];       /* Integer parameters                                   */
 52:   double        dparm[64];       /* Floating point parameters                            */
 53:   MPI_Comm      pastix_comm;     /* PaStiX MPI communicator                              */
 54:   PetscMPIInt   commRank;        /* MPI rank                                             */
 55:   PetscMPIInt   commSize;        /* MPI communicator size                                */
 56:   PetscBool     CleanUpPastix;   /* Boolean indicating if we call PaStiX clean step      */
 57:   VecScatter    scat_rhs;
 58:   VecScatter    scat_sol;
 59:   Vec           b_seq;
 60:   PetscBool     isAIJ;
 61:   PetscErrorCode (*Destroy)(Mat);
 62: } Mat_Pastix;

 64: extern PetscErrorCode MatDuplicate_Pastix(Mat,MatDuplicateOption,Mat*);

 68: /*
 69:    convert Petsc seqaij matrix to CSC: colptr[n], row[nz], val[nz]

 71:   input:
 72:     A       - matrix in seqaij or mpisbaij (bs=1) format
 73:     valOnly - FALSE: spaces are allocated and values are set for the CSC
 74:               TRUE:  Only fill values
 75:   output:
 76:     n       - Size of the matrix
 77:     colptr  - Index of first element of each column in row and val
 78:     row     - Row of each element of the matrix
 79:     values  - Value of each element of the matrix
 80:  */
 81: PetscErrorCode MatConvertToCSC(Mat A,PetscBool valOnly,PetscInt *n,PetscInt **colptr,PetscInt **row,PetscScalar **values)
 82: {
 83:   Mat_SeqAIJ     *aa      = (Mat_SeqAIJ*)A->data;
 84:   PetscInt       *rowptr  = aa->i;
 85:   PetscInt       *col     = aa->j;
 86:   PetscScalar    *rvalues = aa->a;
 87:   PetscInt       m        = A->rmap->N;
 88:   PetscInt       nnz;
 89:   PetscInt       i,j, k;
 90:   PetscInt       base = 1;
 91:   PetscInt       idx;
 93:   PetscInt       colidx;
 94:   PetscInt       *colcount;
 95:   PetscBool      isSBAIJ;
 96:   PetscBool      isSeqSBAIJ;
 97:   PetscBool      isMpiSBAIJ;
 98:   PetscBool      isSym;
 99:   PetscBool      flg;
100:   PetscInt       icntl;
101:   PetscInt       verb;
102:   PetscInt       check;

105:   MatIsSymmetric(A,0.0,&isSym);
106:   PetscObjectTypeCompare((PetscObject)A,MATSBAIJ,&isSBAIJ);
107:   PetscObjectTypeCompare((PetscObject)A,MATSEQSBAIJ,&isSeqSBAIJ);
108:   PetscObjectTypeCompare((PetscObject)A,MATMPISBAIJ,&isMpiSBAIJ);

110:   *n = A->cmap->N;

112:   /* PaStiX only needs triangular matrix if matrix is symmetric
113:    */
114:   if (isSym && !(isSBAIJ || isSeqSBAIJ || isMpiSBAIJ)) nnz = (aa->nz - *n)/2 + *n;
115:   else nnz = aa->nz;

117:   if (!valOnly) {
118:     PetscMalloc1((*n)+1,colptr);
119:     PetscMalloc1(nnz,row);
120:     PetscMalloc1(nnz,values);

122:     if (isSBAIJ || isSeqSBAIJ || isMpiSBAIJ) {
123:       PetscMemcpy (*colptr, rowptr, ((*n)+1)*sizeof(PetscInt));
124:       for (i = 0; i < *n+1; i++) (*colptr)[i] += base;
125:       PetscMemcpy (*row, col, (nnz)*sizeof(PetscInt));
126:       for (i = 0; i < nnz; i++) (*row)[i] += base;
127:       PetscMemcpy (*values, rvalues, (nnz)*sizeof(PetscScalar));
128:     } else {
129:       PetscMalloc1(*n,&colcount);

131:       for (i = 0; i < m; i++) colcount[i] = 0;
132:       /* Fill-in colptr */
133:       for (i = 0; i < m; i++) {
134:         for (j = rowptr[i]; j < rowptr[i+1]; j++) {
135:           if (!isSym || col[j] <= i)  colcount[col[j]]++;
136:         }
137:       }

139:       (*colptr)[0] = base;
140:       for (j = 0; j < *n; j++) {
141:         (*colptr)[j+1] = (*colptr)[j] + colcount[j];
142:         /* in next loop we fill starting from (*colptr)[colidx] - base */
143:         colcount[j] = -base;
144:       }

146:       /* Fill-in rows and values */
147:       for (i = 0; i < m; i++) {
148:         for (j = rowptr[i]; j < rowptr[i+1]; j++) {
149:           if (!isSym || col[j] <= i) {
150:             colidx         = col[j];
151:             idx            = (*colptr)[colidx] + colcount[colidx];
152:             (*row)[idx]    = i + base;
153:             (*values)[idx] = rvalues[j];
154:             colcount[colidx]++;
155:           }
156:         }
157:       }
158:       PetscFree(colcount);
159:     }
160:   } else {
161:     /* Fill-in only values */
162:     for (i = 0; i < m; i++) {
163:       for (j = rowptr[i]; j < rowptr[i+1]; j++) {
164:         colidx = col[j];
165:         if ((isSBAIJ || isSeqSBAIJ || isMpiSBAIJ) ||!isSym || col[j] <= i) {
166:           /* look for the value to fill */
167:           for (k = (*colptr)[colidx] - base; k < (*colptr)[colidx + 1] - base; k++) {
168:             if (((*row)[k]-base) == i) {
169:               (*values)[k] = rvalues[j];
170:               break;
171:             }
172:           }
173:           /* data structure of sparse matrix has changed */
174:           if (k == (*colptr)[colidx + 1] - base) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_PLIB,"overflow on k %D",k);
175:         }
176:       }
177:     }
178:   }

180:   icntl =-1;
181:   check = 0;
182:   PetscOptionsGetInt(((PetscObject) A)->prefix, "-mat_pastix_check", &icntl, &flg);
183:   if ((flg && icntl >= 0) || PetscLogPrintInfo) check =  icntl;

185:   if (check == 1) {
186:     PetscScalar *tmpvalues;
187:     PetscInt    *tmprows,*tmpcolptr;
188:     tmpvalues = (PetscScalar*)malloc(nnz*sizeof(PetscScalar));    if (!tmpvalues) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_MEM,"Unable to allocate memory");
189:     tmprows   = (PetscInt*)   malloc(nnz*sizeof(PetscInt));       if (!tmprows)   SETERRQ(PETSC_COMM_SELF,PETSC_ERR_MEM,"Unable to allocate memory");
190:     tmpcolptr = (PetscInt*)   malloc((*n+1)*sizeof(PetscInt));    if (!tmpcolptr) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_MEM,"Unable to allocate memory");

192:     PetscMemcpy(tmpcolptr,*colptr,(*n+1)*sizeof(PetscInt));
193:     PetscMemcpy(tmprows,*row,nnz*sizeof(PetscInt));
194:     PetscMemcpy(tmpvalues,*values,nnz*sizeof(PetscScalar));
195:     PetscFree(*row);
196:     PetscFree(*values);

198:     icntl=-1;
199:     verb = API_VERBOSE_NOT;
200:     /* "iparm[IPARM_VERBOSE] : level of printing (0 to 2)" */
201:     PetscOptionsGetInt(((PetscObject) A)->prefix, "-mat_pastix_verbose", &icntl, &flg);
202:     if ((flg && icntl >= 0) || PetscLogPrintInfo) verb =  icntl;
203:     PASTIX_CHECKMATRIX(MPI_COMM_WORLD,verb,((isSym != 0) ? API_SYM_YES : API_SYM_NO),API_YES,*n,&tmpcolptr,&tmprows,(PastixScalar**)&tmpvalues,NULL,1);

205:     PetscMemcpy(*colptr,tmpcolptr,(*n+1)*sizeof(PetscInt));
206:     PetscMalloc1(((*colptr)[*n]-1),row);
207:     PetscMemcpy(*row,tmprows,((*colptr)[*n]-1)*sizeof(PetscInt));
208:     PetscMalloc1(((*colptr)[*n]-1),values);
209:     PetscMemcpy(*values,tmpvalues,((*colptr)[*n]-1)*sizeof(PetscScalar));
210:     free(tmpvalues);
211:     free(tmprows);
212:     free(tmpcolptr);

214:   }
215:   return(0);
216: }

220: PetscErrorCode MatGetDiagonal_Pastix(Mat A,Vec v)
221: {
223:   SETERRQ(PetscObjectComm((PetscObject)A),PETSC_ERR_SUP,"Mat type: Pastix factor");
224:   return(0);
225: }

229: /*
230:   Call clean step of PaStiX if lu->CleanUpPastix == true.
231:   Free the CSC matrix.
232:  */
233: PetscErrorCode MatDestroy_Pastix(Mat A)
234: {
235:   Mat_Pastix     *lu=(Mat_Pastix*)A->spptr;
237:   PetscMPIInt    size=lu->commSize;

240:   if (lu && lu->CleanUpPastix) {
241:     /* Terminate instance, deallocate memories */
242:     if (size > 1) {
243:       VecScatterDestroy(&lu->scat_rhs);
244:       VecDestroy(&lu->b_seq);
245:       VecScatterDestroy(&lu->scat_sol);
246:     }

248:     lu->iparm[IPARM_START_TASK]=API_TASK_CLEAN;
249:     lu->iparm[IPARM_END_TASK]  =API_TASK_CLEAN;

251:     PASTIX_CALL(&(lu->pastix_data),
252:                 lu->pastix_comm,
253:                 lu->n,
254:                 lu->colptr,
255:                 lu->row,
256:                 (PastixScalar*)lu->val,
257:                 lu->perm,
258:                 lu->invp,
259:                 (PastixScalar*)lu->rhs,
260:                 lu->rhsnbr,
261:                 lu->iparm,
262:                 lu->dparm);

264:     PetscFree(lu->colptr);
265:     PetscFree(lu->row);
266:     PetscFree(lu->val);
267:     PetscFree(lu->perm);
268:     PetscFree(lu->invp);
269:     MPI_Comm_free(&(lu->pastix_comm));
270:   }
271:   if (lu && lu->Destroy) {
272:     (lu->Destroy)(A);
273:   }
274:   PetscFree(A->spptr);
275:   return(0);
276: }

280: /*
281:   Gather right-hand-side.
282:   Call for Solve step.
283:   Scatter solution.
284:  */
285: PetscErrorCode MatSolve_PaStiX(Mat A,Vec b,Vec x)
286: {
287:   Mat_Pastix     *lu=(Mat_Pastix*)A->spptr;
288:   PetscScalar    *array;
289:   Vec            x_seq;

293:   lu->rhsnbr = 1;
294:   x_seq      = lu->b_seq;
295:   if (lu->commSize > 1) {
296:     /* PaStiX only supports centralized rhs. Scatter b into a seqential rhs vector */
297:     VecScatterBegin(lu->scat_rhs,b,x_seq,INSERT_VALUES,SCATTER_FORWARD);
298:     VecScatterEnd(lu->scat_rhs,b,x_seq,INSERT_VALUES,SCATTER_FORWARD);
299:     VecGetArray(x_seq,&array);
300:   } else {  /* size == 1 */
301:     VecCopy(b,x);
302:     VecGetArray(x,&array);
303:   }
304:   lu->rhs = array;
305:   if (lu->commSize == 1) {
306:     VecRestoreArray(x,&array);
307:   } else {
308:     VecRestoreArray(x_seq,&array);
309:   }

311:   /* solve phase */
312:   /*-------------*/
313:   lu->iparm[IPARM_START_TASK] = API_TASK_SOLVE;
314:   lu->iparm[IPARM_END_TASK]   = API_TASK_REFINE;
315:   lu->iparm[IPARM_RHS_MAKING] = API_RHS_B;

317:   PASTIX_CALL(&(lu->pastix_data),
318:               lu->pastix_comm,
319:               lu->n,
320:               lu->colptr,
321:               lu->row,
322:               (PastixScalar*)lu->val,
323:               lu->perm,
324:               lu->invp,
325:               (PastixScalar*)lu->rhs,
326:               lu->rhsnbr,
327:               lu->iparm,
328:               lu->dparm);

330:   if (lu->iparm[IPARM_ERROR_NUMBER] < 0) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_LIB,"Error reported by PaStiX in solve phase: lu->iparm[IPARM_ERROR_NUMBER] = %d\n",lu->iparm[IPARM_ERROR_NUMBER]);

332:   if (lu->commSize == 1) {
333:     VecRestoreArray(x,&(lu->rhs));
334:   } else {
335:     VecRestoreArray(x_seq,&(lu->rhs));
336:   }

338:   if (lu->commSize > 1) { /* convert PaStiX centralized solution to petsc mpi x */
339:     VecScatterBegin(lu->scat_sol,x_seq,x,INSERT_VALUES,SCATTER_FORWARD);
340:     VecScatterEnd(lu->scat_sol,x_seq,x,INSERT_VALUES,SCATTER_FORWARD);
341:   }
342:   return(0);
343: }

345: /*
346:   Numeric factorisation using PaStiX solver.

348:  */
351: PetscErrorCode MatFactorNumeric_PaStiX(Mat F,Mat A,const MatFactorInfo *info)
352: {
353:   Mat_Pastix     *lu =(Mat_Pastix*)(F)->spptr;
354:   Mat            *tseq;
355:   PetscErrorCode 0;
356:   PetscInt       icntl;
357:   PetscInt       M=A->rmap->N;
358:   PetscBool      valOnly,flg, isSym;
359:   Mat            F_diag;
360:   IS             is_iden;
361:   Vec            b;
362:   IS             isrow;
363:   PetscBool      isSeqAIJ,isSeqSBAIJ,isMPIAIJ;

366:   PetscObjectTypeCompare((PetscObject)A,MATSEQAIJ,&isSeqAIJ);
367:   PetscObjectTypeCompare((PetscObject)A,MATMPIAIJ,&isMPIAIJ);
368:   PetscObjectTypeCompare((PetscObject)A,MATSEQSBAIJ,&isSeqSBAIJ);
369:   if (lu->matstruc == DIFFERENT_NONZERO_PATTERN) {
370:     (F)->ops->solve = MatSolve_PaStiX;

372:     /* Initialize a PASTIX instance */
373:     MPI_Comm_dup(PetscObjectComm((PetscObject)A),&(lu->pastix_comm));
374:     MPI_Comm_rank(lu->pastix_comm, &lu->commRank);
375:     MPI_Comm_size(lu->pastix_comm, &lu->commSize);

377:     /* Set pastix options */
378:     lu->iparm[IPARM_MODIFY_PARAMETER] = API_NO;
379:     lu->iparm[IPARM_START_TASK]       = API_TASK_INIT;
380:     lu->iparm[IPARM_END_TASK]         = API_TASK_INIT;

382:     lu->rhsnbr = 1;

384:     /* Call to set default pastix options */
385:     PASTIX_CALL(&(lu->pastix_data),
386:                 lu->pastix_comm,
387:                 lu->n,
388:                 lu->colptr,
389:                 lu->row,
390:                 (PastixScalar*)lu->val,
391:                 lu->perm,
392:                 lu->invp,
393:                 (PastixScalar*)lu->rhs,
394:                 lu->rhsnbr,
395:                 lu->iparm,
396:                 lu->dparm);

398:     PetscOptionsBegin(PetscObjectComm((PetscObject)A),((PetscObject)A)->prefix,"PaStiX Options","Mat");

400:     icntl = -1;

402:     lu->iparm[IPARM_VERBOSE] = API_VERBOSE_NOT;

404:     PetscOptionsInt("-mat_pastix_verbose","iparm[IPARM_VERBOSE] : level of printing (0 to 2)","None",lu->iparm[IPARM_VERBOSE],&icntl,&flg);
405:     if ((flg && icntl >= 0) || PetscLogPrintInfo) {
406:       lu->iparm[IPARM_VERBOSE] =  icntl;
407:     }
408:     icntl=-1;
409:     PetscOptionsInt("-mat_pastix_threadnbr","iparm[IPARM_THREAD_NBR] : Number of thread by MPI node","None",lu->iparm[IPARM_THREAD_NBR],&icntl,&flg);
410:     if ((flg && icntl > 0)) {
411:       lu->iparm[IPARM_THREAD_NBR] = icntl;
412:     }
413:     PetscOptionsEnd();
414:     valOnly = PETSC_FALSE;
415:   } else {
416:     if (isSeqAIJ || isMPIAIJ) {
417:       PetscFree(lu->colptr);
418:       PetscFree(lu->row);
419:       PetscFree(lu->val);
420:       valOnly = PETSC_FALSE;
421:     } else valOnly = PETSC_TRUE;
422:   }

424:   lu->iparm[IPARM_MATRIX_VERIFICATION] = API_YES;

426:   /* convert mpi A to seq mat A */
427:   ISCreateStride(PETSC_COMM_SELF,M,0,1,&isrow);
428:   MatGetSubMatrices(A,1,&isrow,&isrow,MAT_INITIAL_MATRIX,&tseq);
429:   ISDestroy(&isrow);

431:   MatConvertToCSC(*tseq,valOnly, &lu->n, &lu->colptr, &lu->row, &lu->val);
432:   MatIsSymmetric(*tseq,0.0,&isSym);
433:   MatDestroyMatrices(1,&tseq);

435:   if (!lu->perm) {
436:     PetscMalloc1(lu->n,&(lu->perm));
437:     PetscMalloc1(lu->n,&(lu->invp));
438:   }

440:   if (isSym) {
441:     /* On symmetric matrix, LLT */
442:     lu->iparm[IPARM_SYM]           = API_SYM_YES;
443:     lu->iparm[IPARM_FACTORIZATION] = API_FACT_LDLT;
444:   } else {
445:     /* On unsymmetric matrix, LU */
446:     lu->iparm[IPARM_SYM]           = API_SYM_NO;
447:     lu->iparm[IPARM_FACTORIZATION] = API_FACT_LU;
448:   }

450:   /*----------------*/
451:   if (lu->matstruc == DIFFERENT_NONZERO_PATTERN) {
452:     if (!(isSeqAIJ || isSeqSBAIJ)) {
453:       /* PaStiX only supports centralized rhs. Create scatter scat_rhs for repeated use in MatSolve() */
454:       VecCreateSeq(PETSC_COMM_SELF,A->cmap->N,&lu->b_seq);
455:       ISCreateStride(PETSC_COMM_SELF,A->cmap->N,0,1,&is_iden);
456:       MatCreateVecs(A,NULL,&b);
457:       VecScatterCreate(b,is_iden,lu->b_seq,is_iden,&lu->scat_rhs);
458:       VecScatterCreate(lu->b_seq,is_iden,b,is_iden,&lu->scat_sol);
459:       ISDestroy(&is_iden);
460:       VecDestroy(&b);
461:     }
462:     lu->iparm[IPARM_START_TASK] = API_TASK_ORDERING;
463:     lu->iparm[IPARM_END_TASK]   = API_TASK_NUMFACT;

465:     PASTIX_CALL(&(lu->pastix_data),
466:                 lu->pastix_comm,
467:                 lu->n,
468:                 lu->colptr,
469:                 lu->row,
470:                 (PastixScalar*)lu->val,
471:                 lu->perm,
472:                 lu->invp,
473:                 (PastixScalar*)lu->rhs,
474:                 lu->rhsnbr,
475:                 lu->iparm,
476:                 lu->dparm);
477:     if (lu->iparm[IPARM_ERROR_NUMBER] < 0) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_LIB,"Error reported by PaStiX in analysis phase: iparm(IPARM_ERROR_NUMBER)=%d\n",lu->iparm[IPARM_ERROR_NUMBER]);
478:   } else {
479:     lu->iparm[IPARM_START_TASK] = API_TASK_NUMFACT;
480:     lu->iparm[IPARM_END_TASK]   = API_TASK_NUMFACT;
481:     PASTIX_CALL(&(lu->pastix_data),
482:                 lu->pastix_comm,
483:                 lu->n,
484:                 lu->colptr,
485:                 lu->row,
486:                 (PastixScalar*)lu->val,
487:                 lu->perm,
488:                 lu->invp,
489:                 (PastixScalar*)lu->rhs,
490:                 lu->rhsnbr,
491:                 lu->iparm,
492:                 lu->dparm);

494:     if (lu->iparm[IPARM_ERROR_NUMBER] < 0) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_LIB,"Error reported by PaStiX in analysis phase: iparm(IPARM_ERROR_NUMBER)=%d\n",lu->iparm[IPARM_ERROR_NUMBER]);
495:   }

497:   if (lu->commSize > 1) {
498:     if ((F)->factortype == MAT_FACTOR_LU) {
499:       F_diag = ((Mat_MPIAIJ*)(F)->data)->A;
500:     } else {
501:       F_diag = ((Mat_MPISBAIJ*)(F)->data)->A;
502:     }
503:     F_diag->assembled = PETSC_TRUE;
504:   }
505:   (F)->assembled    = PETSC_TRUE;
506:   lu->matstruc      = SAME_NONZERO_PATTERN;
507:   lu->CleanUpPastix = PETSC_TRUE;
508:   return(0);
509: }

511: /* Note the Petsc r and c permutations are ignored */
514: PetscErrorCode MatLUFactorSymbolic_AIJPASTIX(Mat F,Mat A,IS r,IS c,const MatFactorInfo *info)
515: {
516:   Mat_Pastix *lu = (Mat_Pastix*)F->spptr;

519:   lu->iparm[IPARM_FACTORIZATION] = API_FACT_LU;
520:   lu->iparm[IPARM_SYM]           = API_SYM_YES;
521:   lu->matstruc                   = DIFFERENT_NONZERO_PATTERN;
522:   F->ops->lufactornumeric        = MatFactorNumeric_PaStiX;
523:   return(0);
524: }


527: /* Note the Petsc r permutation is ignored */
530: PetscErrorCode MatCholeskyFactorSymbolic_SBAIJPASTIX(Mat F,Mat A,IS r,const MatFactorInfo *info)
531: {
532:   Mat_Pastix *lu = (Mat_Pastix*)(F)->spptr;

535:   lu->iparm[IPARM_FACTORIZATION]  = API_FACT_LLT;
536:   lu->iparm[IPARM_SYM]            = API_SYM_NO;
537:   lu->matstruc                    = DIFFERENT_NONZERO_PATTERN;
538:   (F)->ops->choleskyfactornumeric = MatFactorNumeric_PaStiX;
539:   return(0);
540: }

544: PetscErrorCode MatView_PaStiX(Mat A,PetscViewer viewer)
545: {
546:   PetscErrorCode    ierr;
547:   PetscBool         iascii;
548:   PetscViewerFormat format;

551:   PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERASCII,&iascii);
552:   if (iascii) {
553:     PetscViewerGetFormat(viewer,&format);
554:     if (format == PETSC_VIEWER_ASCII_INFO) {
555:       Mat_Pastix *lu=(Mat_Pastix*)A->spptr;

557:       PetscViewerASCIIPrintf(viewer,"PaStiX run parameters:\n");
558:       PetscViewerASCIIPrintf(viewer,"  Matrix type :                      %s \n",((lu->iparm[IPARM_SYM] == API_SYM_YES) ? "Symmetric" : "Unsymmetric"));
559:       PetscViewerASCIIPrintf(viewer,"  Level of printing (0,1,2):         %d \n",lu->iparm[IPARM_VERBOSE]);
560:       PetscViewerASCIIPrintf(viewer,"  Number of refinements iterations : %d \n",lu->iparm[IPARM_NBITER]);
561:       PetscPrintf(PETSC_COMM_SELF,"  Error :                        %g \n",lu->dparm[DPARM_RELATIVE_ERROR]);
562:     }
563:   }
564:   return(0);
565: }


568: /*MC
569:      MATSOLVERPASTIX  - A solver package providing direct solvers (LU) for distributed
570:   and sequential matrices via the external package PaStiX.

572:   Use ./configure --download-pastix to have PETSc installed with PaStiX

574:   Options Database Keys:
575: + -mat_pastix_verbose   <0,1,2>   - print level
576: - -mat_pastix_threadnbr <integer> - Set the thread number by MPI task.

578:   Level: beginner

580: .seealso: PCFactorSetMatSolverPackage(), MatSolverPackage

582: M*/


587: PetscErrorCode MatGetInfo_PaStiX(Mat A,MatInfoType flag,MatInfo *info)
588: {
589:   Mat_Pastix *lu =(Mat_Pastix*)A->spptr;

592:   info->block_size        = 1.0;
593:   info->nz_allocated      = lu->iparm[IPARM_NNZEROS];
594:   info->nz_used           = lu->iparm[IPARM_NNZEROS];
595:   info->nz_unneeded       = 0.0;
596:   info->assemblies        = 0.0;
597:   info->mallocs           = 0.0;
598:   info->memory            = 0.0;
599:   info->fill_ratio_given  = 0;
600:   info->fill_ratio_needed = 0;
601:   info->factor_mallocs    = 0;
602:   return(0);
603: }

607: PetscErrorCode MatFactorGetSolverPackage_pastix(Mat A,const MatSolverPackage *type)
608: {
610:   *type = MATSOLVERPASTIX;
611:   return(0);
612: }

614: /*
615:     The seq and mpi versions of this function are the same
616: */
619: PETSC_EXTERN PetscErrorCode MatGetFactor_seqaij_pastix(Mat A,MatFactorType ftype,Mat *F)
620: {
621:   Mat            B;
623:   Mat_Pastix     *pastix;

626:   if (ftype != MAT_FACTOR_LU) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_SUP,"Cannot use PETSc AIJ matrices with PaStiX Cholesky, use SBAIJ matrix");
627:   /* Create the factorization matrix */
628:   MatCreate(PetscObjectComm((PetscObject)A),&B);
629:   MatSetSizes(B,A->rmap->n,A->cmap->n,A->rmap->N,A->cmap->N);
630:   MatSetType(B,((PetscObject)A)->type_name);
631:   MatSeqAIJSetPreallocation(B,0,NULL);

633:   B->ops->lufactorsymbolic = MatLUFactorSymbolic_AIJPASTIX;
634:   B->ops->view             = MatView_PaStiX;
635:   B->ops->getinfo          = MatGetInfo_PaStiX;
636:   B->ops->getdiagonal      = MatGetDiagonal_Pastix;

638:   PetscObjectComposeFunction((PetscObject)B,"MatFactorGetSolverPackage_C",MatFactorGetSolverPackage_pastix);

640:   B->factortype = MAT_FACTOR_LU;

642:   PetscNewLog(B,&pastix);

644:   pastix->CleanUpPastix = PETSC_FALSE;
645:   pastix->isAIJ         = PETSC_TRUE;
646:   pastix->scat_rhs      = NULL;
647:   pastix->scat_sol      = NULL;
648:   pastix->Destroy       = B->ops->destroy;
649:   B->ops->destroy       = MatDestroy_Pastix;
650:   B->spptr              = (void*)pastix;

652:   *F = B;
653:   return(0);
654: }

658: PETSC_EXTERN PetscErrorCode MatGetFactor_mpiaij_pastix(Mat A,MatFactorType ftype,Mat *F)
659: {
660:   Mat            B;
662:   Mat_Pastix     *pastix;

665:   if (ftype != MAT_FACTOR_LU) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_SUP,"Cannot use PETSc AIJ matrices with PaStiX Cholesky, use SBAIJ matrix");
666:   /* Create the factorization matrix */
667:   MatCreate(PetscObjectComm((PetscObject)A),&B);
668:   MatSetSizes(B,A->rmap->n,A->cmap->n,A->rmap->N,A->cmap->N);
669:   MatSetType(B,((PetscObject)A)->type_name);
670:   MatSeqAIJSetPreallocation(B,0,NULL);
671:   MatMPIAIJSetPreallocation(B,0,NULL,0,NULL);

673:   B->ops->lufactorsymbolic = MatLUFactorSymbolic_AIJPASTIX;
674:   B->ops->view             = MatView_PaStiX;
675:   B->ops->getdiagonal      = MatGetDiagonal_Pastix;

677:   PetscObjectComposeFunction((PetscObject)B,"MatFactorGetSolverPackage_C",MatFactorGetSolverPackage_pastix);

679:   B->factortype = MAT_FACTOR_LU;

681:   PetscNewLog(B,&pastix);

683:   pastix->CleanUpPastix = PETSC_FALSE;
684:   pastix->isAIJ         = PETSC_TRUE;
685:   pastix->scat_rhs      = NULL;
686:   pastix->scat_sol      = NULL;
687:   pastix->Destroy       = B->ops->destroy;
688:   B->ops->destroy       = MatDestroy_Pastix;
689:   B->spptr              = (void*)pastix;

691:   *F = B;
692:   return(0);
693: }

697: PETSC_EXTERN PetscErrorCode MatGetFactor_seqsbaij_pastix(Mat A,MatFactorType ftype,Mat *F)
698: {
699:   Mat            B;
701:   Mat_Pastix     *pastix;

704:   if (ftype != MAT_FACTOR_CHOLESKY) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_SUP,"Cannot use PETSc SBAIJ matrices with PaStiX LU, use AIJ matrix");
705:   /* Create the factorization matrix */
706:   MatCreate(PetscObjectComm((PetscObject)A),&B);
707:   MatSetSizes(B,A->rmap->n,A->cmap->n,A->rmap->N,A->cmap->N);
708:   MatSetType(B,((PetscObject)A)->type_name);
709:   MatSeqSBAIJSetPreallocation(B,1,0,NULL);
710:   MatMPISBAIJSetPreallocation(B,1,0,NULL,0,NULL);

712:   B->ops->choleskyfactorsymbolic = MatCholeskyFactorSymbolic_SBAIJPASTIX;
713:   B->ops->view                   = MatView_PaStiX;
714:   B->ops->getdiagonal            = MatGetDiagonal_Pastix;

716:   PetscObjectComposeFunction((PetscObject)B,"MatFactorGetSolverPackage_C",MatFactorGetSolverPackage_pastix);

718:   B->factortype = MAT_FACTOR_CHOLESKY;

720:   PetscNewLog(B,&pastix);

722:   pastix->CleanUpPastix = PETSC_FALSE;
723:   pastix->isAIJ         = PETSC_TRUE;
724:   pastix->scat_rhs      = NULL;
725:   pastix->scat_sol      = NULL;
726:   pastix->Destroy       = B->ops->destroy;
727:   B->ops->destroy       = MatDestroy_Pastix;
728:   B->spptr              = (void*)pastix;

730:   *F = B;
731:   return(0);
732: }

736: PETSC_EXTERN PetscErrorCode MatGetFactor_mpisbaij_pastix(Mat A,MatFactorType ftype,Mat *F)
737: {
738:   Mat            B;
740:   Mat_Pastix     *pastix;

743:   if (ftype != MAT_FACTOR_CHOLESKY) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_SUP,"Cannot use PETSc SBAIJ matrices with PaStiX LU, use AIJ matrix");

745:   /* Create the factorization matrix */
746:   MatCreate(PetscObjectComm((PetscObject)A),&B);
747:   MatSetSizes(B,A->rmap->n,A->cmap->n,A->rmap->N,A->cmap->N);
748:   MatSetType(B,((PetscObject)A)->type_name);
749:   MatSeqSBAIJSetPreallocation(B,1,0,NULL);
750:   MatMPISBAIJSetPreallocation(B,1,0,NULL,0,NULL);

752:   B->ops->choleskyfactorsymbolic = MatCholeskyFactorSymbolic_SBAIJPASTIX;
753:   B->ops->view                   = MatView_PaStiX;
754:   B->ops->getdiagonal            = MatGetDiagonal_Pastix;

756:   PetscObjectComposeFunction((PetscObject)B,"MatFactorGetSolverPackage_C",MatFactorGetSolverPackage_pastix);

758:   B->factortype = MAT_FACTOR_CHOLESKY;

760:   PetscNewLog(B,&pastix);

762:   pastix->CleanUpPastix = PETSC_FALSE;
763:   pastix->isAIJ         = PETSC_TRUE;
764:   pastix->scat_rhs      = NULL;
765:   pastix->scat_sol      = NULL;
766:   pastix->Destroy       = B->ops->destroy;
767:   B->ops->destroy       = MatDestroy_Pastix;
768:   B->spptr              = (void*)pastix;

770:   *F = B;
771:   return(0);
772: }

776: PETSC_EXTERN PetscErrorCode MatSolverPackageRegister_Pastix(void)
777: {

781:   MatSolverPackageRegister(MATSOLVERPASTIX,MATMPIAIJ,        MAT_FACTOR_LU,MatGetFactor_mpiaij_pastix);
782:   MatSolverPackageRegister(MATSOLVERPASTIX,MATSEQAIJ,        MAT_FACTOR_LU,MatGetFactor_seqaij_pastix);
783:   MatSolverPackageRegister(MATSOLVERPASTIX,MATMPISBAIJ,      MAT_FACTOR_CHOLESKY,MatGetFactor_mpisbaij_pastix);
784:   MatSolverPackageRegister(MATSOLVERPASTIX,MATSEQSBAIJ,      MAT_FACTOR_CHOLESKY,MatGetFactor_seqsbaij_pastix);
785:   return(0);
786: }