Actual source code: mumps.c

      1: #define PETSCMAT_DLL

      3: /*
      4:     Provides an interface to the MUMPS_4.3.1 sparse solver
      5: */
     6:  #include src/mat/impls/aij/seq/aij.h
     7:  #include src/mat/impls/aij/mpi/mpiaij.h
     8:  #include src/mat/impls/sbaij/seq/sbaij.h
     9:  #include src/mat/impls/sbaij/mpi/mpisbaij.h

     12: #if defined(PETSC_USE_COMPLEX)
     13: #include "zmumps_c.h"
     14: #else
     15: #include "dmumps_c.h"
     16: #endif
     18: #define JOB_INIT -1
     19: #define JOB_END -2
     20: /* macros s.t. indices match MUMPS documentation */
     21: #define ICNTL(I) icntl[(I)-1]
     22: #define CNTL(I) cntl[(I)-1]
     23: #define INFOG(I) infog[(I)-1]
     24: #define INFO(I) info[(I)-1]
     25: #define RINFOG(I) rinfog[(I)-1]
     26: #define RINFO(I) rinfo[(I)-1]

     28: typedef struct {
     29: #if defined(PETSC_USE_COMPLEX)
     30:   ZMUMPS_STRUC_C id;
     31: #else
     32:   DMUMPS_STRUC_C id;
     33: #endif
     34:   MatStructure   matstruc;
     35:   int            myid,size,*irn,*jcn,sym;
     36:   PetscScalar    *val;
     37:   MPI_Comm       comm_mumps;

     39:   PetscTruth     isAIJ,CleanUpMUMPS;
     40:   PetscErrorCode (*MatDuplicate)(Mat,MatDuplicateOption,Mat*);
     41:   PetscErrorCode (*MatView)(Mat,PetscViewer);
     42:   PetscErrorCode (*MatAssemblyEnd)(Mat,MatAssemblyType);
     43:   PetscErrorCode (*MatLUFactorSymbolic)(Mat,IS,IS,MatFactorInfo*,Mat*);
     44:   PetscErrorCode (*MatCholeskyFactorSymbolic)(Mat,IS,MatFactorInfo*,Mat*);
     45:   PetscErrorCode (*MatDestroy)(Mat);
     46:   PetscErrorCode (*specialdestroy)(Mat);
     47:   PetscErrorCode (*MatPreallocate)(Mat,int,int,int*,int,int*);
     48: } Mat_MUMPS;

     50: EXTERN PetscErrorCode MatDuplicate_MUMPS(Mat,MatDuplicateOption,Mat*);
     52: PetscErrorCode PETSCMAT_DLLEXPORT MatConvert_SBAIJ_SBAIJMUMPS(Mat,MatType,MatReuse,Mat*);
     54: /* convert Petsc mpiaij matrix to triples: row[nz], col[nz], val[nz] */
     55: /*
     56:   input:
     57:     A       - matrix in mpiaij or mpisbaij (bs=1) format
     58:     shift   - 0: C style output triple; 1: Fortran style output triple.
     59:     valOnly - FALSE: spaces are allocated and values are set for the triple
     60:               TRUE:  only the values in v array are updated
     61:   output:
     62:     nnz     - dim of r, c, and v (number of local nonzero entries of A)
     63:     r, c, v - row and col index, matrix values (matrix triples)
     64:  */
     65: PetscErrorCode MatConvertToTriples(Mat A,int shift,PetscTruth valOnly,int *nnz,int **r, int **c, PetscScalar **v) {
     66:   int         *ai, *aj, *bi, *bj, rstart,nz, *garray;
     68:   int         i,j,jj,jB,irow,m=A->m,*ajj,*bjj,countA,countB,colA_start,jcol;
     69:   int         *row,*col;
     70:   PetscScalar *av, *bv,*val;
     71:   Mat_MUMPS   *mumps=(Mat_MUMPS*)A->spptr;

     74:   if (mumps->isAIJ){
     75:     Mat_MPIAIJ    *mat =  (Mat_MPIAIJ*)A->data;
     76:     Mat_SeqAIJ    *aa=(Mat_SeqAIJ*)(mat->A)->data;
     77:     Mat_SeqAIJ    *bb=(Mat_SeqAIJ*)(mat->B)->data;
     78:     nz = aa->nz + bb->nz;
     79:     ai=aa->i; aj=aa->j; bi=bb->i; bj=bb->j; rstart= mat->rstart;
     80:     garray = mat->garray;
     81:     av=aa->a; bv=bb->a;
     82:
     83:   } else {
     84:     Mat_MPISBAIJ  *mat =  (Mat_MPISBAIJ*)A->data;
     85:     Mat_SeqSBAIJ  *aa=(Mat_SeqSBAIJ*)(mat->A)->data;
     86:     Mat_SeqBAIJ    *bb=(Mat_SeqBAIJ*)(mat->B)->data;
     87:     if (A->bs > 1) SETERRQ1(PETSC_ERR_SUP," bs=%d is not supported yet\n", A->bs);
     88:     nz = aa->nz + bb->nz;
     89:     ai=aa->i; aj=aa->j; bi=bb->i; bj=bb->j; rstart= mat->rstart;
     90:     garray = mat->garray;
     91:     av=aa->a; bv=bb->a;
     92:   }

     94:   if (!valOnly){
     95:     PetscMalloc(nz*sizeof(PetscInt) ,&row);
     96:     PetscMalloc(nz*sizeof(PetscInt),&col);
     97:     PetscMalloc(nz*sizeof(PetscScalar),&val);
     98:     *r = row; *c = col; *v = val;
     99:   } else {
    100:     row = *r; col = *c; val = *v;
    101:   }
    102:   *nnz = nz;

    104:   jj = 0; irow = rstart;
    105:   for ( i=0; i<m; i++ ) {
    106:     ajj = aj + ai[i];                 /* ptr to the beginning of this row */
    107:     countA = ai[i+1] - ai[i];
    108:     countB = bi[i+1] - bi[i];
    109:     bjj = bj + bi[i];

    111:     /* get jB, the starting local col index for the 2nd B-part */
    112:     colA_start = rstart + ajj[0]; /* the smallest col index for A */
    113:     j=-1;
    114:     do {
    115:       j++;
    116:       if (j == countB) break;
    117:       jcol = garray[bjj[j]];
    118:     } while (jcol < colA_start);
    119:     jB = j;
    120:
    121:     /* B-part, smaller col index */
    122:     colA_start = rstart + ajj[0]; /* the smallest col index for A */
    123:     for (j=0; j<jB; j++){
    124:       jcol = garray[bjj[j]];
    125:       if (!valOnly){
    126:         row[jj] = irow + shift; col[jj] = jcol + shift;

    128:       }
    129:       val[jj++] = *bv++;
    130:     }
    131:     /* A-part */
    132:     for (j=0; j<countA; j++){
    133:       if (!valOnly){
    134:         row[jj] = irow + shift; col[jj] = rstart + ajj[j] + shift;
    135:       }
    136:       val[jj++] = *av++;
    137:     }
    138:     /* B-part, larger col index */
    139:     for (j=jB; j<countB; j++){
    140:       if (!valOnly){
    141:         row[jj] = irow + shift; col[jj] = garray[bjj[j]] + shift;
    142:       }
    143:       val[jj++] = *bv++;
    144:     }
    145:     irow++;
    146:   }
    147:
    148:   return(0);
    149: }

    154: PetscErrorCode PETSCMAT_DLLEXPORT MatConvert_MUMPS_Base(Mat A,MatType type,MatReuse reuse,Mat *newmat) \
    155: {
    157:   Mat            B=*newmat;
    158:   Mat_MUMPS      *mumps=(Mat_MUMPS*)A->spptr;
    159:   void           (*f)(void);

    162:   if (reuse == MAT_INITIAL_MATRIX) {
    163:     MatDuplicate(A,MAT_COPY_VALUES,&B);
    164:   }
    165:   B->ops->duplicate              = mumps->MatDuplicate;
    166:   B->ops->view                   = mumps->MatView;
    167:   B->ops->assemblyend            = mumps->MatAssemblyEnd;
    168:   B->ops->lufactorsymbolic       = mumps->MatLUFactorSymbolic;
    169:   B->ops->choleskyfactorsymbolic = mumps->MatCholeskyFactorSymbolic;
    170:   B->ops->destroy                = mumps->MatDestroy;

    172:   PetscObjectQueryFunction((PetscObject)B,"MatMPISBAIJSetPreallocation_C",&f);
    173:   if (f) {
    174:     PetscObjectComposeFunction((PetscObject)B,"MatMPISBAIJSetPreallocation_C","",(FCNVOID)mumps->MatPreallocate);
    175:   }
    176:   PetscFree(mumps);

    178:   PetscObjectComposeFunction((PetscObject)B,"MatConvert_seqaij_aijmumps_C","",PETSC_NULL);
    179:   PetscObjectComposeFunction((PetscObject)B,"MatConvert_aijmumps_seqaij_C","",PETSC_NULL);
    180:   PetscObjectComposeFunction((PetscObject)B,"MatConvert_mpiaij_aijmumps_C","",PETSC_NULL);
    181:   PetscObjectComposeFunction((PetscObject)B,"MatConvert_aijmumps_mpiaij_C","",PETSC_NULL);
    182:   PetscObjectComposeFunction((PetscObject)B,"MatConvert_seqsbaij_sbaijmumps_C","",PETSC_NULL);
    183:   PetscObjectComposeFunction((PetscObject)B,"MatConvert_sbaijmumps_seqsbaij_C","",PETSC_NULL);
    184:   PetscObjectComposeFunction((PetscObject)B,"MatConvert_mpisbaij_sbaijmumps_C","",PETSC_NULL);
    185:   PetscObjectComposeFunction((PetscObject)B,"MatConvert_sbaijmumps_mpisbaij_C","",PETSC_NULL);

    187:   PetscObjectChangeTypeName((PetscObject)B,type);
    188:   *newmat = B;
    189:   return(0);
    190: }

    195: PetscErrorCode MatDestroy_MUMPS(Mat A)
    196: {
    197:   Mat_MUMPS *lu=(Mat_MUMPS*)A->spptr;
    199:   int       size=lu->size;
    200:   PetscErrorCode (*specialdestroy)(Mat);
    202:   if (lu->CleanUpMUMPS) {
    203:     /* Terminate instance, deallocate memories */
    204:     lu->id.job=JOB_END;
    205: #if defined(PETSC_USE_COMPLEX)
    206:     zmumps_c(&lu->id);
    207: #else
    208:     dmumps_c(&lu->id);
    209: #endif
    210:     if (lu->irn) {
    211:       PetscFree(lu->irn);
    212:     }
    213:     if (lu->jcn) {
    214:       PetscFree(lu->jcn);
    215:     }
    216:     if (size>1 && lu->val) {
    217:       PetscFree(lu->val);
    218:     }
    219:     MPI_Comm_free(&(lu->comm_mumps));
    220:   }
    221:   specialdestroy = lu->specialdestroy;
    222:   (*specialdestroy)(A);
    223:   (*A->ops->destroy)(A);
    224:   return(0);
    225: }

    229: PetscErrorCode MatDestroy_AIJMUMPS(Mat A)
    230: {
    232:   int  size;

    235:   MPI_Comm_size(A->comm,&size);
    236:   if (size==1) {
    237:     MatConvert_MUMPS_Base(A,MATSEQAIJ,MAT_REUSE_MATRIX,&A);
    238:   } else {
    239:     MatConvert_MUMPS_Base(A,MATMPIAIJ,MAT_REUSE_MATRIX,&A);
    240:   }
    241:   return(0);
    242: }

    246: PetscErrorCode MatDestroy_SBAIJMUMPS(Mat A)
    247: {
    249:   int  size;

    252:   MPI_Comm_size(A->comm,&size);
    253:   if (size==1) {
    254:     MatConvert_MUMPS_Base(A,MATSEQSBAIJ,MAT_REUSE_MATRIX,&A);
    255:   } else {
    256:     MatConvert_MUMPS_Base(A,MATMPISBAIJ,MAT_REUSE_MATRIX,&A);
    257:   }
    258:   return(0);
    259: }

    263: PetscErrorCode MatFactorInfo_MUMPS(Mat A,PetscViewer viewer) {
    264:   Mat_MUMPS *lu=(Mat_MUMPS*)A->spptr;

    268:   PetscViewerASCIIPrintf(viewer,"MUMPS run parameters:\n");
    269:   PetscViewerASCIIPrintf(viewer,"  SYM (matrix type):                  %d \n",lu->id.sym);
    270:   PetscViewerASCIIPrintf(viewer,"  PAR (host participation):           %d \n",lu->id.par);
    271:   PetscViewerASCIIPrintf(viewer,"  ICNTL(4) (level of printing):       %d \n",lu->id.ICNTL(4));
    272:   PetscViewerASCIIPrintf(viewer,"  ICNTL(5) (input mat struct):        %d \n",lu->id.ICNTL(5));
    273:   PetscViewerASCIIPrintf(viewer,"  ICNTL(6) (matrix prescaling):       %d \n",lu->id.ICNTL(6));
    274:   PetscViewerASCIIPrintf(viewer,"  ICNTL(7) (matrix ordering):         %d \n",lu->id.ICNTL(7));
    275:   PetscViewerASCIIPrintf(viewer,"  ICNTL(9) (A/A^T x=b is solved):     %d \n",lu->id.ICNTL(9));
    276:   PetscViewerASCIIPrintf(viewer,"  ICNTL(10) (max num of refinements): %d \n",lu->id.ICNTL(10));
    277:   PetscViewerASCIIPrintf(viewer,"  ICNTL(11) (error analysis):         %d \n",lu->id.ICNTL(11));
    278:   if (!lu->myid && lu->id.ICNTL(11)>0) {
    279:     PetscPrintf(PETSC_COMM_SELF,"        RINFOG(4) (inf norm of input mat):        %g\n",lu->id.RINFOG(4));
    280:     PetscPrintf(PETSC_COMM_SELF,"        RINFOG(5) (inf norm of solution):         %g\n",lu->id.RINFOG(5));
    281:     PetscPrintf(PETSC_COMM_SELF,"        RINFOG(6) (inf norm of residual):         %g\n",lu->id.RINFOG(6));
    282:     PetscPrintf(PETSC_COMM_SELF,"        RINFOG(7),RINFOG(8) (backward error est): %g, %g\n",lu->id.RINFOG(7),lu->id.RINFOG(8));
    283:     PetscPrintf(PETSC_COMM_SELF,"        RINFOG(9) (error estimate):               %g \n",lu->id.RINFOG(9));
    284:     PetscPrintf(PETSC_COMM_SELF,"        RINFOG(10),RINFOG(11)(condition numbers): %g, %g\n",lu->id.RINFOG(10),lu->id.RINFOG(11));
    285:
    286:   }
    287:   PetscViewerASCIIPrintf(viewer,"  ICNTL(12) (efficiency control):                         %d \n",lu->id.ICNTL(12));
    288:   PetscViewerASCIIPrintf(viewer,"  ICNTL(13) (efficiency control):                         %d \n",lu->id.ICNTL(13));
    289:   PetscViewerASCIIPrintf(viewer,"  ICNTL(14) (percentage of estimated workspace increase): %d \n",lu->id.ICNTL(14));
    290:   PetscViewerASCIIPrintf(viewer,"  ICNTL(15) (efficiency control):                         %d \n",lu->id.ICNTL(15));
    291:   PetscViewerASCIIPrintf(viewer,"  ICNTL(18) (input mat struct):                           %d \n",lu->id.ICNTL(18));

    293:   PetscViewerASCIIPrintf(viewer,"  CNTL(1) (relative pivoting threshold):      %g \n",lu->id.CNTL(1));
    294:   PetscViewerASCIIPrintf(viewer,"  CNTL(2) (stopping criterion of refinement): %g \n",lu->id.CNTL(2));
    295:   PetscViewerASCIIPrintf(viewer,"  CNTL(3) (absolute pivoting threshold):      %g \n",lu->id.CNTL(3));

    297:   /* infomation local to each processor */
    298:   if (!lu->myid) PetscPrintf(PETSC_COMM_SELF, "      RINFO(1) (local estimated flops for the elimination after analysis): \n");
    299:   PetscSynchronizedPrintf(A->comm,"             [%d] %g \n",lu->myid,lu->id.RINFO(1));
    300:   PetscSynchronizedFlush(A->comm);
    301:   if (!lu->myid) PetscPrintf(PETSC_COMM_SELF, "      RINFO(2) (local estimated flops for the assembly after factorization): \n");
    302:   PetscSynchronizedPrintf(A->comm,"             [%d]  %g \n",lu->myid,lu->id.RINFO(2));
    303:   PetscSynchronizedFlush(A->comm);
    304:   if (!lu->myid) PetscPrintf(PETSC_COMM_SELF, "      RINFO(3) (local estimated flops for the elimination after factorization): \n");
    305:   PetscSynchronizedPrintf(A->comm,"             [%d]  %g \n",lu->myid,lu->id.RINFO(3));
    306:   PetscSynchronizedFlush(A->comm);

    308:   if (!lu->myid){ /* information from the host */
    309:     PetscViewerASCIIPrintf(viewer,"  RINFOG(1) (global estimated flops for the elimination after analysis): %g \n",lu->id.RINFOG(1));
    310:     PetscViewerASCIIPrintf(viewer,"  RINFOG(2) (global estimated flops for the assembly after factorization): %g \n",lu->id.RINFOG(2));
    311:     PetscViewerASCIIPrintf(viewer,"  RINFOG(3) (global estimated flops for the elimination after factorization): %g \n",lu->id.RINFOG(3));

    313:     PetscViewerASCIIPrintf(viewer,"  INFOG(3) (estimated real workspace for factors on all processors after analysis): %d \n",lu->id.INFOG(3));
    314:     PetscViewerASCIIPrintf(viewer,"  INFOG(4) (estimated integer workspace for factors on all processors after analysis): %d \n",lu->id.INFOG(4));
    315:     PetscViewerASCIIPrintf(viewer,"  INFOG(5) (estimated maximum front size in the complete tree): %d \n",lu->id.INFOG(5));
    316:     PetscViewerASCIIPrintf(viewer,"  INFOG(6) (number of nodes in the complete tree): %d \n",lu->id.INFOG(6));
    317:     PetscViewerASCIIPrintf(viewer,"  INFOG(7) (ordering option effectively uese after analysis): %d \n",lu->id.INFOG(7));
    318:     PetscViewerASCIIPrintf(viewer,"  INFOG(8) (structural symmetry in percent of the permuted matrix after analysis): %d \n",lu->id.INFOG(8));
    319:     PetscViewerASCIIPrintf(viewer,"  INFOG(9) (total real space store the matrix factors after analysis): %d \n",lu->id.INFOG(9));
    320:     PetscViewerASCIIPrintf(viewer,"  INFOG(10) (total integer space store the matrix factors after analysis): %d \n",lu->id.INFOG(10));
    321:     PetscViewerASCIIPrintf(viewer,"  INFOG(11) (order of largest frontal matrix): %d \n",lu->id.INFOG(11));
    322:     PetscViewerASCIIPrintf(viewer,"  INFOG(12) (number of off-diagonal pivots): %d \n",lu->id.INFOG(12));
    323:     PetscViewerASCIIPrintf(viewer,"  INFOG(13) (number of delayed pivots after factorization): %d \n",lu->id.INFOG(13));
    324:     PetscViewerASCIIPrintf(viewer,"  INFOG(14) (number of memory compress after factorization): %d \n",lu->id.INFOG(14));
    325:     PetscViewerASCIIPrintf(viewer,"  INFOG(15) (number of steps of iterative refinement after solution): %d \n",lu->id.INFOG(15));
    326:     PetscViewerASCIIPrintf(viewer,"  INFOG(16) (estimated size (in million of bytes) of all MUMPS internal data for factorization after analysis: value on the most memory consuming processor): %d \n",lu->id.INFOG(16));
    327:     PetscViewerASCIIPrintf(viewer,"  INFOG(17) (estimated size of all MUMPS internal data for factorization after analysis: sum over all processors): %d \n",lu->id.INFOG(17));
    328:     PetscViewerASCIIPrintf(viewer,"  INFOG(18) (size of all MUMPS internal data allocated during factorization: value on the most memory consuming processor): %d \n",lu->id.INFOG(18));
    329:     PetscViewerASCIIPrintf(viewer,"  INFOG(19) (size of all MUMPS internal data allocated during factorization: sum over all processors): %d \n",lu->id.INFOG(19));
    330:      PetscViewerASCIIPrintf(viewer,"  INFOG(20) (estimated number of entries in the factors): %d \n",lu->id.INFOG(20));
    331:   }

    333:   return(0);
    334: }

    338: PetscErrorCode MatView_AIJMUMPS(Mat A,PetscViewer viewer) {
    340:   PetscTruth        iascii;
    341:   PetscViewerFormat format;
    342:   Mat_MUMPS         *mumps=(Mat_MUMPS*)(A->spptr);

    345:   (*mumps->MatView)(A,viewer);

    347:   PetscTypeCompare((PetscObject)viewer,PETSC_VIEWER_ASCII,&iascii);
    348:   if (iascii) {
    349:     PetscViewerGetFormat(viewer,&format);
    350:     if (format == PETSC_VIEWER_ASCII_FACTOR_INFO) {
    351:       MatFactorInfo_MUMPS(A,viewer);
    352:     }
    353:   }
    354:   return(0);
    355: }

    359: PetscErrorCode MatSolve_AIJMUMPS(Mat A,Vec b,Vec x) {
    360:   Mat_MUMPS   *lu=(Mat_MUMPS*)A->spptr;
    361:   PetscScalar *array;
    362:   Vec         x_seq;
    363:   IS          iden;
    364:   VecScatter  scat;

    368:   if (lu->size > 1){
    369:     if (!lu->myid){
    370:       VecCreateSeq(PETSC_COMM_SELF,A->N,&x_seq);
    371:       ISCreateStride(PETSC_COMM_SELF,A->N,0,1,&iden);
    372:     } else {
    373:       VecCreateSeq(PETSC_COMM_SELF,0,&x_seq);
    374:       ISCreateStride(PETSC_COMM_SELF,0,0,1,&iden);
    375:     }
    376:     VecScatterCreate(b,iden,x_seq,iden,&scat);
    377:     ISDestroy(iden);

    379:     VecScatterBegin(b,x_seq,INSERT_VALUES,SCATTER_FORWARD,scat);
    380:     VecScatterEnd(b,x_seq,INSERT_VALUES,SCATTER_FORWARD,scat);
    381:     if (!lu->myid) {VecGetArray(x_seq,&array);}
    382:   } else {  /* size == 1 */
    383:     VecCopy(b,x);
    384:     VecGetArray(x,&array);
    385:   }
    386:   if (!lu->myid) { /* define rhs on the host */
    387: #if defined(PETSC_USE_COMPLEX)
    388:     lu->id.rhs = (mumps_double_complex*)array;
    389: #else
    390:     lu->id.rhs = array;
    391: #endif
    392:   }

    394:   /* solve phase */
    395:   lu->id.job=3;
    396: #if defined(PETSC_USE_COMPLEX)
    397:   zmumps_c(&lu->id);
    398: #else
    399:   dmumps_c(&lu->id);
    400: #endif
    401:   if (lu->id.INFOG(1) < 0) {
    402:     SETERRQ1(PETSC_ERR_LIB,"Error reported by MUMPS in solve phase: INFOG(1)=%d\n",lu->id.INFOG(1));
    403:   }

    405:   /* convert mumps solution x_seq to petsc mpi x */
    406:   if (lu->size > 1) {
    407:     if (!lu->myid){
    408:       VecRestoreArray(x_seq,&array);
    409:     }
    410:     VecScatterBegin(x_seq,x,INSERT_VALUES,SCATTER_REVERSE,scat);
    411:     VecScatterEnd(x_seq,x,INSERT_VALUES,SCATTER_REVERSE,scat);
    412:     VecScatterDestroy(scat);
    413:     VecDestroy(x_seq);
    414:   } else {
    415:     VecRestoreArray(x,&array);
    416:   }
    417:
    418:   return(0);
    419: }

    421: /*
    422:   input:
    423:    F:        numeric factor
    424:   output:
    425:    nneg:     total number of negative pivots
    426:    nzero:    0
    427:    npos:     (global dimension of F) - nneg
    428: */

    432: PetscErrorCode MatGetInertia_SBAIJMUMPS(Mat F,int *nneg,int *nzero,int *npos)
    433: {
    434:   Mat_MUMPS  *lu =(Mat_MUMPS*)F->spptr;
    436:   int        size;

    439:   MPI_Comm_size(F->comm,&size);
    440:   /* MUMPS 4.3.1 calls ScaLAPACK when ICNTL(13)=0 (default), which does not offer the possibility to compute the inertia of a dense matrix. Set ICNTL(13)=1 to skip ScaLAPACK */
    441:   if (size > 1 && lu->id.ICNTL(13) != 1){
    442:     SETERRQ1(PETSC_ERR_ARG_WRONG,"ICNTL(13)=%d. -mat_mumps_icntl_13 must be set as 1 for correct global matrix inertia\n",lu->id.INFOG(13));
    443:   }
    444:   if (nneg){
    445:     if (!lu->myid){
    446:       *nneg = lu->id.INFOG(12);
    447:     }
    448:     MPI_Bcast(nneg,1,MPI_INT,0,lu->comm_mumps);
    449:   }
    450:   if (nzero) *nzero = 0;
    451:   if (npos)  *npos  = F->M - (*nneg);
    452:   return(0);
    453: }

    457: PetscErrorCode MatFactorNumeric_AIJMUMPS(Mat A,MatFactorInfo *info,Mat *F)
    458: {
    459:   Mat_MUMPS      *lu =(Mat_MUMPS*)(*F)->spptr;
    460:   Mat_MUMPS      *lua=(Mat_MUMPS*)(A)->spptr;
    462:   PetscInt       rnz,nnz,nz,i,M=A->M,*ai,*aj,icntl;
    463:   PetscTruth     valOnly,flg;

    466:   if (lu->matstruc == DIFFERENT_NONZERO_PATTERN){
    467:     (*F)->ops->solve    = MatSolve_AIJMUMPS;

    469:     /* Initialize a MUMPS instance */
    470:     MPI_Comm_rank(A->comm, &lu->myid);
    471:     MPI_Comm_size(A->comm,&lu->size);
    472:     lua->myid = lu->myid; lua->size = lu->size;
    473:     lu->id.job = JOB_INIT;
    474:     MPI_Comm_dup(A->comm,&(lu->comm_mumps));
    475:     lu->id.comm_fortran = lu->comm_mumps;

    477:     /* Set mumps options */
    478:     PetscOptionsBegin(A->comm,A->prefix,"MUMPS Options","Mat");
    479:     lu->id.par=1;  /* host participates factorizaton and solve */
    480:     lu->id.sym=lu->sym;
    481:     if (lu->sym == 2){
    482:       PetscOptionsInt("-mat_mumps_sym","SYM: (1,2)","None",lu->id.sym,&icntl,&flg);
    483:       if (flg && icntl == 1) lu->id.sym=icntl;  /* matrix is spd */
    484:     }
    485: #if defined(PETSC_USE_COMPLEX)
    486:     zmumps_c(&lu->id);
    487: #else
    488:     dmumps_c(&lu->id);
    489: #endif
    490:
    491:     if (lu->size == 1){
    492:       lu->id.ICNTL(18) = 0;   /* centralized assembled matrix input */
    493:     } else {
    494:       lu->id.ICNTL(18) = 3;   /* distributed assembled matrix input */
    495:     }

    497:     icntl=-1;
    498:     PetscOptionsInt("-mat_mumps_icntl_4","ICNTL(4): level of printing (0 to 4)","None",lu->id.ICNTL(4),&icntl,&flg);
    499:     if ((flg && icntl > 0) || PetscLogPrintInfo) {
    500:       lu->id.ICNTL(4)=icntl; /* and use mumps default icntl(i), i=1,2,3 */
    501:     } else { /* no output */
    502:       lu->id.ICNTL(1) = 0;  /* error message, default= 6 */
    503:       lu->id.ICNTL(2) = -1; /* output stream for diagnostic printing, statistics, and warning. default=0 */
    504:       lu->id.ICNTL(3) = -1; /* output stream for global information, default=6 */
    505:       lu->id.ICNTL(4) = 0;  /* level of printing, 0,1,2,3,4, default=2 */
    506:     }
    507:     PetscOptionsInt("-mat_mumps_icntl_6","ICNTL(6): matrix prescaling (0 to 7)","None",lu->id.ICNTL(6),&lu->id.ICNTL(6),PETSC_NULL);
    508:     icntl=-1;
    509:     PetscOptionsInt("-mat_mumps_icntl_7","ICNTL(7): matrix ordering (0 to 7)","None",lu->id.ICNTL(7),&icntl,&flg);
    510:     if (flg) {
    511:       if (icntl== 1){
    512:         SETERRQ(PETSC_ERR_SUP,"pivot order be set by the user in PERM_IN -- not supported by the PETSc/MUMPS interface\n");
    513:       } else {
    514:         lu->id.ICNTL(7) = icntl;
    515:       }
    516:     }
    517:     PetscOptionsInt("-mat_mumps_icntl_9","ICNTL(9): A or A^T x=b to be solved. 1: A; otherwise: A^T","None",lu->id.ICNTL(9),&lu->id.ICNTL(9),PETSC_NULL);
    518:     PetscOptionsInt("-mat_mumps_icntl_10","ICNTL(10): max num of refinements","None",lu->id.ICNTL(10),&lu->id.ICNTL(10),PETSC_NULL);
    519:     PetscOptionsInt("-mat_mumps_icntl_11","ICNTL(11): error analysis, a positive value returns statistics (by -ksp_view)","None",lu->id.ICNTL(11),&lu->id.ICNTL(11),PETSC_NULL);
    520:     PetscOptionsInt("-mat_mumps_icntl_12","ICNTL(12): efficiency control","None",lu->id.ICNTL(12),&lu->id.ICNTL(12),PETSC_NULL);
    521:     PetscOptionsInt("-mat_mumps_icntl_13","ICNTL(13): efficiency control","None",lu->id.ICNTL(13),&lu->id.ICNTL(13),PETSC_NULL);
    522:     PetscOptionsInt("-mat_mumps_icntl_14","ICNTL(14): percentage of estimated workspace increase","None",lu->id.ICNTL(14),&lu->id.ICNTL(14),PETSC_NULL);
    523:     PetscOptionsInt("-mat_mumps_icntl_15","ICNTL(15): efficiency control","None",lu->id.ICNTL(15),&lu->id.ICNTL(15),PETSC_NULL);

    525:     /*
    526:     PetscOptionsInt("-mat_mumps_icntl_16","ICNTL(16): 1: rank detection; 2: rank detection and nullspace","None",lu->id.ICNTL(16),&icntl,&flg);
    527:     if (flg){
    528:       if (icntl >-1 && icntl <3 ){
    529:         if (lu->myid==0) lu->id.ICNTL(16) = icntl;
    530:       } else {
    531:         SETERRQ1(PETSC_ERR_SUP,"ICNTL(16)=%d -- not supported\n",icntl);
    532:       }
    533:     }
    534:     */

    536:     PetscOptionsReal("-mat_mumps_cntl_1","CNTL(1): relative pivoting threshold","None",lu->id.CNTL(1),&lu->id.CNTL(1),PETSC_NULL);
    537:     PetscOptionsReal("-mat_mumps_cntl_2","CNTL(2): stopping criterion of refinement","None",lu->id.CNTL(2),&lu->id.CNTL(2),PETSC_NULL);
    538:     PetscOptionsReal("-mat_mumps_cntl_3","CNTL(3): absolute pivoting threshold","None",lu->id.CNTL(3),&lu->id.CNTL(3),PETSC_NULL);
    539:     PetscOptionsEnd();
    540:   }

    542:   /* define matrix A */
    543:   switch (lu->id.ICNTL(18)){
    544:   case 0:  /* centralized assembled matrix input (size=1) */
    545:     if (!lu->myid) {
    546:       if (lua->isAIJ){
    547:         Mat_SeqAIJ   *aa = (Mat_SeqAIJ*)A->data;
    548:         nz               = aa->nz;
    549:         ai = aa->i; aj = aa->j; lu->val = aa->a;
    550:       } else {
    551:         Mat_SeqSBAIJ *aa = (Mat_SeqSBAIJ*)A->data;
    552:         nz                  =  aa->nz;
    553:         ai = aa->i; aj = aa->j; lu->val = aa->a;
    554:       }
    555:       if (lu->matstruc == DIFFERENT_NONZERO_PATTERN){ /* first numeric factorization, get irn and jcn */
    556:         PetscMalloc(nz*sizeof(PetscInt),&lu->irn);
    557:         PetscMalloc(nz*sizeof(PetscInt),&lu->jcn);
    558:         nz = 0;
    559:         for (i=0; i<M; i++){
    560:           rnz = ai[i+1] - ai[i];
    561:           while (rnz--) {  /* Fortran row/col index! */
    562:             lu->irn[nz] = i+1; lu->jcn[nz] = (*aj)+1; aj++; nz++;
    563:           }
    564:         }
    565:       }
    566:     }
    567:     break;
    568:   case 3:  /* distributed assembled matrix input (size>1) */
    569:     if (lu->matstruc == DIFFERENT_NONZERO_PATTERN){
    570:       valOnly = PETSC_FALSE;
    571:     } else {
    572:       valOnly = PETSC_TRUE; /* only update mat values, not row and col index */
    573:     }
    574:     MatConvertToTriples(A,1,valOnly, &nnz, &lu->irn, &lu->jcn, &lu->val);
    575:     break;
    576:   default: SETERRQ(PETSC_ERR_SUP,"Matrix input format is not supported by MUMPS.");
    577:   }

    579:   /* analysis phase */
    580:   if (lu->matstruc == DIFFERENT_NONZERO_PATTERN){
    581:      lu->id.n = M;
    582:     switch (lu->id.ICNTL(18)){
    583:     case 0:  /* centralized assembled matrix input */
    584:       if (!lu->myid) {
    585:         lu->id.nz =nz; lu->id.irn=lu->irn; lu->id.jcn=lu->jcn;
    586:         if (lu->id.ICNTL(6)>1){
    587: #if defined(PETSC_USE_COMPLEX)
    588:           lu->id.a = (mumps_double_complex*)lu->val;
    589: #else
    590:           lu->id.a = lu->val;
    591: #endif
    592:         }
    593:       }
    594:       break;
    595:     case 3:  /* distributed assembled matrix input (size>1) */
    596:       lu->id.nz_loc = nnz;
    597:       lu->id.irn_loc=lu->irn; lu->id.jcn_loc=lu->jcn;
    598:       if (lu->id.ICNTL(6)>1) {
    599: #if defined(PETSC_USE_COMPLEX)
    600:         lu->id.a_loc = (mumps_double_complex*)lu->val;
    601: #else
    602:         lu->id.a_loc = lu->val;
    603: #endif
    604:       }
    605:       break;
    606:     }
    607:     lu->id.job=1;
    608: #if defined(PETSC_USE_COMPLEX)
    609:     zmumps_c(&lu->id);
    610: #else
    611:     dmumps_c(&lu->id);
    612: #endif
    613:     if (lu->id.INFOG(1) < 0) {
    614:       SETERRQ1(PETSC_ERR_LIB,"Error reported by MUMPS in analysis phase: INFOG(1)=%d\n",lu->id.INFOG(1));
    615:     }
    616:   }

    618:   /* numerical factorization phase */
    619:   if(!lu->id.ICNTL(18)) {
    620:     if (!lu->myid) {
    621: #if defined(PETSC_USE_COMPLEX)
    622:       lu->id.a = (mumps_double_complex*)lu->val;
    623: #else
    624:       lu->id.a = lu->val;
    625: #endif
    626:     }
    627:   } else {
    628: #if defined(PETSC_USE_COMPLEX)
    629:     lu->id.a_loc = (mumps_double_complex*)lu->val;
    630: #else
    631:     lu->id.a_loc = lu->val;
    632: #endif
    633:   }
    634:   lu->id.job=2;
    635: #if defined(PETSC_USE_COMPLEX)
    636:   zmumps_c(&lu->id);
    637: #else
    638:   dmumps_c(&lu->id);
    639: #endif
    640:   if (lu->id.INFOG(1) < 0) {
    641:     if (lu->id.INFO(1) == -13) {
    642:       SETERRQ1(PETSC_ERR_LIB,"Error reported by MUMPS in numerical factorization phase: Cannot allocate required memory %d megabytes\n",lu->id.INFO(2));
    643:     } else {
    644:       SETERRQ2(PETSC_ERR_LIB,"Error reported by MUMPS in numerical factorization phase: INFO(1)=%d, INFO(2)=%d\n",lu->id.INFO(1),lu->id.INFO(2));
    645:     }
    646:   }

    648:   if (!lu->myid && lu->id.ICNTL(16) > 0){
    649:     SETERRQ1(PETSC_ERR_LIB,"  lu->id.ICNTL(16):=%d\n",lu->id.INFOG(16));
    650:   }
    651:
    652:   (*F)->assembled  = PETSC_TRUE;
    653:   lu->matstruc     = SAME_NONZERO_PATTERN;
    654:   lu->CleanUpMUMPS = PETSC_TRUE;
    655:   return(0);
    656: }

    658: /* Note the Petsc r and c permutations are ignored */
    661: PetscErrorCode MatLUFactorSymbolic_AIJMUMPS(Mat A,IS r,IS c,MatFactorInfo *info,Mat *F) {
    662:   Mat            B;
    663:   Mat_MUMPS      *lu;

    668:   /* Create the factorization matrix */
    669:   MatCreate(A->comm,&B);
    670:   MatSetSizes(B,A->m,A->n,A->M,A->N);
    671:   MatSetType(B,A->type_name);
    672:   MatSeqAIJSetPreallocation(B,0,PETSC_NULL);
    673:   MatMPIAIJSetPreallocation(B,0,PETSC_NULL,0,PETSC_NULL);

    675:   B->ops->lufactornumeric = MatFactorNumeric_AIJMUMPS;
    676:   B->factor               = FACTOR_LU;
    677:   lu                      = (Mat_MUMPS*)B->spptr;
    678:   lu->sym                 = 0;
    679:   lu->matstruc            = DIFFERENT_NONZERO_PATTERN;

    681:   *F = B;
    682:   return(0);
    683: }

    685: /* Note the Petsc r permutation is ignored */
    688: PetscErrorCode MatCholeskyFactorSymbolic_SBAIJMUMPS(Mat A,IS r,MatFactorInfo *info,Mat *F) {
    689:   Mat       B;
    690:   Mat_MUMPS *lu;

    694:   /* Create the factorization matrix */
    695:   MatCreate(A->comm,&B);
    696:   MatSetSizes(B,A->m,A->n,A->M,A->N);
    697:   MatSetType(B,A->type_name);
    698:   MatSeqSBAIJSetPreallocation(B,1,0,PETSC_NULL);
    699:   MatMPISBAIJSetPreallocation(B,1,0,PETSC_NULL,0,PETSC_NULL);

    701:   B->ops->choleskyfactornumeric = MatFactorNumeric_AIJMUMPS;
    702:   B->ops->getinertia            = MatGetInertia_SBAIJMUMPS;
    703:   B->factor                     = FACTOR_CHOLESKY;
    704:   lu                            = (Mat_MUMPS*)B->spptr;
    705:   lu->sym                       = 2;
    706:   lu->matstruc                  = DIFFERENT_NONZERO_PATTERN;

    708:   *F = B;
    709:   return(0);
    710: }

    714: PetscErrorCode MatAssemblyEnd_AIJMUMPS(Mat A,MatAssemblyType mode) {
    716:   Mat_MUMPS *mumps=(Mat_MUMPS*)A->spptr;

    719:   (*mumps->MatAssemblyEnd)(A,mode);

    721:   mumps->MatLUFactorSymbolic       = A->ops->lufactorsymbolic;
    722:   mumps->MatCholeskyFactorSymbolic = A->ops->choleskyfactorsymbolic;
    723:   A->ops->lufactorsymbolic         = MatLUFactorSymbolic_AIJMUMPS;
    724:   return(0);
    725: }

    730: PetscErrorCode PETSCMAT_DLLEXPORT MatConvert_AIJ_AIJMUMPS(Mat A,MatType newtype,MatReuse reuse,Mat *newmat)
    731: {
    733:   PetscMPIInt    size;
    734:   MPI_Comm       comm;
    735:   Mat            B=*newmat;
    736:   Mat_MUMPS      *mumps;

    739:   if (reuse == MAT_INITIAL_MATRIX) {
    740:     MatDuplicate(A,MAT_COPY_VALUES,&B);
    741:   }

    743:   PetscObjectGetComm((PetscObject)A,&comm);
    744:   PetscNew(Mat_MUMPS,&mumps);

    746:   mumps->MatDuplicate              = A->ops->duplicate;
    747:   mumps->MatView                   = A->ops->view;
    748:   mumps->MatAssemblyEnd            = A->ops->assemblyend;
    749:   mumps->MatLUFactorSymbolic       = A->ops->lufactorsymbolic;
    750:   mumps->MatCholeskyFactorSymbolic = A->ops->choleskyfactorsymbolic;
    751:   mumps->MatDestroy                = A->ops->destroy;
    752:   mumps->specialdestroy            = MatDestroy_AIJMUMPS;
    753:   mumps->CleanUpMUMPS              = PETSC_FALSE;
    754:   mumps->isAIJ                     = PETSC_TRUE;

    756:   B->spptr                         = (void*)mumps;
    757:   B->ops->duplicate                = MatDuplicate_MUMPS;
    758:   B->ops->view                     = MatView_AIJMUMPS;
    759:   B->ops->assemblyend              = MatAssemblyEnd_AIJMUMPS;
    760:   B->ops->lufactorsymbolic         = MatLUFactorSymbolic_AIJMUMPS;
    761:   B->ops->destroy                  = MatDestroy_MUMPS;

    763:   MPI_Comm_size(comm,&size);
    764:   if (size == 1) {
    765:     PetscObjectComposeFunctionDynamic((PetscObject)B,"MatConvert_seqaij_aijmumps_C",
    766:                                              "MatConvert_AIJ_AIJMUMPS",MatConvert_AIJ_AIJMUMPS);
    767:     PetscObjectComposeFunctionDynamic((PetscObject)B,"MatConvert_aijmumps_seqaij_C",
    768:                                              "MatConvert_MUMPS_Base",MatConvert_MUMPS_Base);
    769:   } else {
    770:     PetscObjectComposeFunctionDynamic((PetscObject)B,"MatConvert_mpiaij_aijmumps_C",
    771:                                              "MatConvert_AIJ_AIJMUMPS",MatConvert_AIJ_AIJMUMPS);
    772:     PetscObjectComposeFunctionDynamic((PetscObject)B,"MatConvert_aijmumps_mpiaij_C",
    773:                                              "MatConvert_MUMPS_Base",MatConvert_MUMPS_Base);
    774:   }

    776:   PetscLogInfo((0,"MatConvert_AIJ_AIJMUMPS:Using MUMPS for LU factorization and solves.\n"));
    777:   PetscObjectChangeTypeName((PetscObject)B,newtype);
    778:   *newmat = B;
    779:   return(0);
    780: }

    783: /*MC
    784:   MATAIJMUMPS - MATAIJMUMPS = "aijmumps" - A matrix type providing direct solvers (LU) for distributed
    785:   and sequential matrices via the external package MUMPS.

    787:   If MUMPS is installed (see the manual for instructions
    788:   on how to declare the existence of external packages),
    789:   a matrix type can be constructed which invokes MUMPS solvers.
    790:   After calling MatCreate(...,A), simply call MatSetType(A,MATAIJMUMPS).

    792:   If created with a single process communicator, this matrix type inherits from MATSEQAIJ.
    793:   Otherwise, this matrix type inherits from MATMPIAIJ.  Hence for single process communicators,
    794:   MatSeqAIJSetPreallocation is supported, and similarly MatMPIAIJSetPreallocation is supported
    795:   for communicators controlling multiple processes.  It is recommended that you call both of
    796:   the above preallocation routines for simplicity.  One can also call MatConvert for an inplace
    797:   conversion to or from the MATSEQAIJ or MATMPIAIJ type (depending on the communicator size)
    798:   without data copy.

    800:   Options Database Keys:
    801: + -mat_type aijmumps - sets the matrix type to "aijmumps" during a call to MatSetFromOptions()
    802: . -mat_mumps_sym <0,1,2> - 0 the matrix is unsymmetric, 1 symmetric positive definite, 2 symmetric
    803: . -mat_mumps_icntl_4 <0,1,2,3,4> - print level
    804: . -mat_mumps_icntl_6 <0,...,7> - matrix prescaling options (see MUMPS User's Guide)
    805: . -mat_mumps_icntl_7 <0,...,7> - matrix orderings (see MUMPS User's Guide)
    806: . -mat_mumps_icntl_9 <1,2> - A or A^T x=b to be solved: 1 denotes A, 2 denotes A^T
    807: . -mat_mumps_icntl_10 <n> - maximum number of iterative refinements
    808: . -mat_mumps_icntl_11 <n> - error analysis, a positive value returns statistics during -ksp_view
    809: . -mat_mumps_icntl_12 <n> - efficiency control (see MUMPS User's Guide)
    810: . -mat_mumps_icntl_13 <n> - efficiency control (see MUMPS User's Guide)
    811: . -mat_mumps_icntl_14 <n> - efficiency control (see MUMPS User's Guide)
    812: . -mat_mumps_icntl_15 <n> - efficiency control (see MUMPS User's Guide)
    813: . -mat_mumps_cntl_1 <delta> - relative pivoting threshold
    814: . -mat_mumps_cntl_2 <tol> - stopping criterion for refinement
    815: - -mat_mumps_cntl_3 <adelta> - absolute pivoting threshold

    817:   Level: beginner

    819: .seealso: MATSBAIJMUMPS
    820: M*/

    825: PetscErrorCode PETSCMAT_DLLEXPORT MatCreate_AIJMUMPS(Mat A)
    826: {
    828:   int      size;
    829:   Mat      A_diag;
    830:   MPI_Comm comm;
    831:
    833:   /* Change type name before calling MatSetType to force proper construction of SeqAIJ or MPIAIJ */
    834:   /*   and AIJMUMPS types */
    835:   PetscObjectChangeTypeName((PetscObject)A,MATAIJMUMPS);
    836:   PetscObjectGetComm((PetscObject)A,&comm);
    837:   MPI_Comm_size(comm,&size);
    838:   if (size == 1) {
    839:     MatSetType(A,MATSEQAIJ);
    840:   } else {
    841:     MatSetType(A,MATMPIAIJ);
    842:     A_diag = ((Mat_MPIAIJ *)A->data)->A;
    843:     MatConvert_AIJ_AIJMUMPS(A_diag,MATAIJMUMPS,MAT_REUSE_MATRIX,&A_diag);
    844:   }
    845:   MatConvert_AIJ_AIJMUMPS(A,MATAIJMUMPS,MAT_REUSE_MATRIX,&A);
    846:   return(0);
    847: }

    852: PetscErrorCode MatAssemblyEnd_SBAIJMUMPS(Mat A,MatAssemblyType mode)
    853: {
    855:   Mat_MUMPS *mumps=(Mat_MUMPS*)A->spptr;

    858:   (*mumps->MatAssemblyEnd)(A,mode);
    859:   mumps->MatLUFactorSymbolic       = A->ops->lufactorsymbolic;
    860:   mumps->MatCholeskyFactorSymbolic = A->ops->choleskyfactorsymbolic;
    861:   A->ops->choleskyfactorsymbolic   = MatCholeskyFactorSymbolic_SBAIJMUMPS;
    862:   return(0);
    863: }

    868: PetscErrorCode PETSCMAT_DLLEXPORT MatMPISBAIJSetPreallocation_MPISBAIJMUMPS(Mat  B,int bs,int d_nz,int *d_nnz,int o_nz,int *o_nnz)
    869: {
    870:   Mat       A;
    871:   Mat_MUMPS *mumps=(Mat_MUMPS*)B->spptr;

    875:   /*
    876:     After performing the MPISBAIJ Preallocation, we need to convert the local diagonal block matrix
    877:     into MUMPS type so that the block jacobi preconditioner (for example) can use MUMPS.  I would
    878:     like this to be done in the MatCreate routine, but the creation of this inner matrix requires
    879:     block size info so that PETSc can determine the local size properly.  The block size info is set
    880:     in the preallocation routine.
    881:   */
    882:   (*mumps->MatPreallocate)(B,bs,d_nz,d_nnz,o_nz,o_nnz);
    883:   A    = ((Mat_MPISBAIJ *)B->data)->A;
    884:   MatConvert_SBAIJ_SBAIJMUMPS(A,MATSBAIJMUMPS,MAT_REUSE_MATRIX,&A);
    885:   return(0);
    886: }

    892: PetscErrorCode PETSCMAT_DLLEXPORT MatConvert_SBAIJ_SBAIJMUMPS(Mat A,MatType newtype,MatReuse reuse,Mat *newmat)
    893: {
    895:   PetscMPIInt    size;
    896:   MPI_Comm       comm;
    897:   Mat            B=*newmat;
    898:   Mat_MUMPS      *mumps;
    899:   void           (*f)(void);

    902:   if (reuse == MAT_INITIAL_MATRIX) {
    903:     MatDuplicate(A,MAT_COPY_VALUES,&B);
    904:   }

    906:   PetscObjectGetComm((PetscObject)A,&comm);
    907:   PetscNew(Mat_MUMPS,&mumps);

    909:   mumps->MatDuplicate              = A->ops->duplicate;
    910:   mumps->MatView                   = A->ops->view;
    911:   mumps->MatAssemblyEnd            = A->ops->assemblyend;
    912:   mumps->MatLUFactorSymbolic       = A->ops->lufactorsymbolic;
    913:   mumps->MatCholeskyFactorSymbolic = A->ops->choleskyfactorsymbolic;
    914:   mumps->MatDestroy                = A->ops->destroy;
    915:   mumps->specialdestroy            = MatDestroy_SBAIJMUMPS;
    916:   mumps->CleanUpMUMPS              = PETSC_FALSE;
    917:   mumps->isAIJ                     = PETSC_FALSE;
    918:
    919:   B->spptr                         = (void*)mumps;
    920:   B->ops->duplicate                = MatDuplicate_MUMPS;
    921:   B->ops->view                     = MatView_AIJMUMPS;
    922:   B->ops->assemblyend              = MatAssemblyEnd_SBAIJMUMPS;
    923:   B->ops->choleskyfactorsymbolic   = MatCholeskyFactorSymbolic_SBAIJMUMPS;
    924:   B->ops->destroy                  = MatDestroy_MUMPS;

    926:   MPI_Comm_size(comm,&size);
    927:   if (size == 1) {
    928:     PetscObjectComposeFunctionDynamic((PetscObject)B,"MatConvert_seqsbaij_sbaijmumps_C",
    929:                                              "MatConvert_SBAIJ_SBAIJMUMPS",MatConvert_SBAIJ_SBAIJMUMPS);
    930:     PetscObjectComposeFunctionDynamic((PetscObject)B,"MatConvert_sbaijmumps_seqsbaij_C",
    931:                                              "MatConvert_MUMPS_Base",MatConvert_MUMPS_Base);
    932:   } else {
    933:   /* I really don't like needing to know the tag: MatMPISBAIJSetPreallocation_C */
    934:     PetscObjectQueryFunction((PetscObject)B,"MatMPISBAIJSetPreallocation_C",&f);
    935:     if (f) { /* This case should always be true when this routine is called */
    936:       mumps->MatPreallocate = (PetscErrorCode (*)(Mat,int,int,int*,int,int*))f;
    937:       PetscObjectComposeFunctionDynamic((PetscObject)B,"MatMPISBAIJSetPreallocation_C",
    938:                                                "MatMPISBAIJSetPreallocation_MPISBAIJMUMPS",
    939:                                                MatMPISBAIJSetPreallocation_MPISBAIJMUMPS);
    940:     }
    941:     PetscObjectComposeFunctionDynamic((PetscObject)B,"MatConvert_mpisbaij_sbaijmumps_C",
    942:                                              "MatConvert_SBAIJ_SBAIJMUMPS",MatConvert_SBAIJ_SBAIJMUMPS);
    943:     PetscObjectComposeFunctionDynamic((PetscObject)B,"MatConvert_sbaijmumps_mpisbaij_C",
    944:                                              "MatConvert_MUMPS_Base",MatConvert_MUMPS_Base);
    945:   }

    947:   PetscLogInfo((0,"MatConvert_AIJ_AIJMUMPS:Using MUMPS for Cholesky factorization and solves.\n"));
    948:   PetscObjectChangeTypeName((PetscObject)B,newtype);
    949:   *newmat = B;
    950:   return(0);
    951: }

    956: PetscErrorCode MatDuplicate_MUMPS(Mat A, MatDuplicateOption op, Mat *M) {
    958:   Mat_MUMPS   *lu=(Mat_MUMPS *)A->spptr;

    961:   (*lu->MatDuplicate)(A,op,M);
    962:   PetscMemcpy((*M)->spptr,lu,sizeof(Mat_MUMPS));
    963:   return(0);
    964: }

    966: /*MC
    967:   MATSBAIJMUMPS - MATSBAIJMUMPS = "sbaijmumps" - A symmetric matrix type providing direct solvers (Cholesky) for
    968:   distributed and sequential matrices via the external package MUMPS.

    970:   If MUMPS is installed (see the manual for instructions
    971:   on how to declare the existence of external packages),
    972:   a matrix type can be constructed which invokes MUMPS solvers.
    973:   After calling MatCreate(...,A), simply call MatSetType(A,MATSBAIJMUMPS).

    975:   If created with a single process communicator, this matrix type inherits from MATSEQSBAIJ.
    976:   Otherwise, this matrix type inherits from MATMPISBAIJ.  Hence for single process communicators,
    977:   MatSeqSBAIJSetPreallocation is supported, and similarly MatMPISBAIJSetPreallocation is supported
    978:   for communicators controlling multiple processes.  It is recommended that you call both of
    979:   the above preallocation routines for simplicity.  One can also call MatConvert for an inplace
    980:   conversion to or from the MATSEQSBAIJ or MATMPISBAIJ type (depending on the communicator size)
    981:   without data copy.

    983:   Options Database Keys:
    984: + -mat_type sbaijmumps - sets the matrix type to "sbaijmumps" during a call to MatSetFromOptions()
    985: . -mat_mumps_sym <0,1,2> - 0 the matrix is unsymmetric, 1 symmetric positive definite, 2 symmetric
    986: . -mat_mumps_icntl_4 <0,...,4> - print level
    987: . -mat_mumps_icntl_6 <0,...,7> - matrix prescaling options (see MUMPS User's Guide)
    988: . -mat_mumps_icntl_7 <0,...,7> - matrix orderings (see MUMPS User's Guide)
    989: . -mat_mumps_icntl_9 <1,2> - A or A^T x=b to be solved: 1 denotes A, 2 denotes A^T
    990: . -mat_mumps_icntl_10 <n> - maximum number of iterative refinements
    991: . -mat_mumps_icntl_11 <n> - error analysis, a positive value returns statistics during -ksp_view
    992: . -mat_mumps_icntl_12 <n> - efficiency control (see MUMPS User's Guide)
    993: . -mat_mumps_icntl_13 <n> - efficiency control (see MUMPS User's Guide)
    994: . -mat_mumps_icntl_14 <n> - efficiency control (see MUMPS User's Guide)
    995: . -mat_mumps_icntl_15 <n> - efficiency control (see MUMPS User's Guide)
    996: . -mat_mumps_cntl_1 <delta> - relative pivoting threshold
    997: . -mat_mumps_cntl_2 <tol> - stopping criterion for refinement
    998: - -mat_mumps_cntl_3 <adelta> - absolute pivoting threshold

    1000:   Level: beginner

    1002: .seealso: MATAIJMUMPS
    1003: M*/

    1008: PetscErrorCode PETSCMAT_DLLEXPORT MatCreate_SBAIJMUMPS(Mat A)
    1009: {
    1011:   int size;

    1014:   /* Change type name before calling MatSetType to force proper construction of SeqSBAIJ or MPISBAIJ */
    1015:   /*   and SBAIJMUMPS types */
    1016:   PetscObjectChangeTypeName((PetscObject)A,MATSBAIJMUMPS);
    1017:   MPI_Comm_size(A->comm,&size);
    1018:   if (size == 1) {
    1019:     MatSetType(A,MATSEQSBAIJ);
    1020:   } else {
    1021:     MatSetType(A,MATMPISBAIJ);
    1022:   }
    1023:   MatConvert_SBAIJ_SBAIJMUMPS(A,MATSBAIJMUMPS,MAT_REUSE_MATRIX,&A);
    1024:   return(0);
    1025: }