void sparse_local_matrix_use_ilu(local_matrix_t* matrix,
ilu_params_t* ilu_params)
{
ASSERT(ilu_params != NULL);
slm_t* mat = local_matrix_context(matrix);
mat->ilu_params = ilu_params;
ilu_set_default_options(&mat->options);
mat->options.DiagPivotThresh = ilu_params->diag_pivot_threshold;
if (ilu_params->row_perm == ILU_NO_ROW_PERM)
mat->options.RowPerm = NOROWPERM;
else
mat->options.RowPerm = LargeDiag;
mat->options.ILU_DropRule = ilu_params->drop_rule;
mat->options.ILU_DropTol = ilu_params->drop_tolerance;
mat->options.ILU_FillFactor = ilu_params->fill_factor;
if (ilu_params->milu_variant == ILU_SILU)
mat->options.ILU_MILU = SILU;
else if (ilu_params->milu_variant == ILU_MILU1)
mat->options.ILU_MILU = SMILU_1;
else if (ilu_params->milu_variant == ILU_MILU2)
mat->options.ILU_MILU = SMILU_2;
else
mat->options.ILU_MILU = SMILU_3;
mat->options.ILU_FillTol = ilu_params->fill_tolerance;
if (ilu_params->norm == ILU_L1)
mat->options.ILU_Norm = ONE_NORM;
else if (ilu_params->norm == ILU_L2)
mat->options.ILU_Norm = TWO_NORM;
else
mat->options.ILU_Norm = INF_NORM;
}
int main(int argc, char *argv[])
{
void smatvec_mult(float alpha, float x[], float beta, float y[]);
void spsolve(int n, float x[], float y[]);
extern int sfgmr( int n,
void (*matvec_mult)(float, float [], float, float []),
void (*psolve)(int n, float [], float[]),
float *rhs, float *sol, double tol, int restrt, int *itmax,
FILE *fits);
extern int sfill_diag(int n, NCformat *Astore);
char equed[1] = {'B'};
yes_no_t equil;
trans_t trans;
SuperMatrix A, L, U;
SuperMatrix B, X;
NCformat *Astore;
NCformat *Ustore;
SCformat *Lstore;
GlobalLU_t Glu; /* facilitate multiple factorizations with
SamePattern_SameRowPerm */
float *a;
int *asub, *xa;
int *etree;
int *perm_c; /* column permutation vector */
int *perm_r; /* row permutations from partial pivoting */
int nrhs, ldx, lwork, info, m, n, nnz;
float *rhsb, *rhsx, *xact;
float *work = NULL;
float *R, *C;
float u, rpg, rcond;
float zero = 0.0;
float one = 1.0;
mem_usage_t mem_usage;
superlu_options_t options;
SuperLUStat_t stat;
FILE *fp = stdin;
int restrt, iter, maxit, i;
double resid;
float *x, *b;
#ifdef DEBUG
extern int num_drop_L, num_drop_U;
#endif
#if ( DEBUGlevel>=1 )
CHECK_MALLOC("Enter main()");
#endif
/* Defaults */
lwork = 0;
nrhs = 1;
trans = NOTRANS;
/* Set the default input options:
options.Fact = DOFACT;
options.Equil = YES;
options.ColPerm = COLAMD;
options.DiagPivotThresh = 0.1; //different from complete LU
options.Trans = NOTRANS;
options.IterRefine = NOREFINE;
options.SymmetricMode = NO;
options.PivotGrowth = NO;
options.ConditionNumber = NO;
options.PrintStat = YES;
options.RowPerm = LargeDiag;
options.ILU_DropTol = 1e-4;
options.ILU_FillTol = 1e-2;
options.ILU_FillFactor = 10.0;
options.ILU_DropRule = DROP_BASIC | DROP_AREA;
options.ILU_Norm = INF_NORM;
options.ILU_MILU = SILU;
*/
ilu_set_default_options(&options);
/* Modify the defaults. */
options.PivotGrowth = YES; /* Compute reciprocal pivot growth */
options.ConditionNumber = YES;/* Compute reciprocal condition number */
if ( lwork > 0 ) {
work = SUPERLU_MALLOC(lwork);
if ( !work ) ABORT("Malloc fails for work[].");
}
/* Read matrix A from a file in Harwell-Boeing format.*/
if (argc < 2)
{
printf("Usage:\n%s [OPTION] < [INPUT] > [OUTPUT]\nOPTION:\n"
"-h -hb:\n\t[INPUT] is a Harwell-Boeing format matrix.\n"
"-r -rb:\n\t[INPUT] is a Rutherford-Boeing format matrix.\n"
"-t -triplet:\n\t[INPUT] is a triplet format matrix.\n",
argv[0]);
return 0;
}
else
{
switch (argv[1][1])
{
case 'H':
case 'h':
printf("Input a Harwell-Boeing format matrix:\n");
sreadhb(fp, &m, &n, &nnz, &a, &asub, &xa);
break;
case 'R':
case 'r':
printf("Input a Rutherford-Boeing format matrix:\n");
sreadrb(&m, &n, &nnz, &a, &asub, &xa);
break;
case 'T':
case 't':
printf("Input a triplet format matrix:\n");
sreadtriple(&m, &n, &nnz, &a, &asub, &xa);
break;
default:
printf("Unrecognized format.\n");
return 0;
}
}
sCreate_CompCol_Matrix(&A, m, n, nnz, a, asub, xa,
SLU_NC, SLU_S, SLU_GE);
Astore = A.Store;
sfill_diag(n, Astore);
printf("Dimension %dx%d; # nonzeros %d\n", A.nrow, A.ncol, Astore->nnz);
fflush(stdout);
/* Generate the right-hand side */
if ( !(rhsb = floatMalloc(m * nrhs)) ) ABORT("Malloc fails for rhsb[].");
if ( !(rhsx = floatMalloc(m * nrhs)) ) ABORT("Malloc fails for rhsx[].");
sCreate_Dense_Matrix(&B, m, nrhs, rhsb, m, SLU_DN, SLU_S, SLU_GE);
sCreate_Dense_Matrix(&X, m, nrhs, rhsx, m, SLU_DN, SLU_S, SLU_GE);
xact = floatMalloc(n * nrhs);
ldx = n;
sGenXtrue(n, nrhs, xact, ldx);
sFillRHS(trans, nrhs, xact, ldx, &A, &B);
if ( !(etree = intMalloc(n)) ) ABORT("Malloc fails for etree[].");
if ( !(perm_r = intMalloc(m)) ) ABORT("Malloc fails for perm_r[].");
if ( !(perm_c = intMalloc(n)) ) ABORT("Malloc fails for perm_c[].");
if ( !(R = (float *) SUPERLU_MALLOC(A.nrow * sizeof(float))) )
ABORT("SUPERLU_MALLOC fails for R[].");
if ( !(C = (float *) SUPERLU_MALLOC(A.ncol * sizeof(float))) )
ABORT("SUPERLU_MALLOC fails for C[].");
info = 0;
#ifdef DEBUG
num_drop_L = 0;
num_drop_U = 0;
#endif
/* Initialize the statistics variables. */
StatInit(&stat);
/* Compute the incomplete factorization and compute the condition number
and pivot growth using dgsisx. */
B.ncol = 0; /* not to perform triangular solution */
sgsisx(&options, &A, perm_c, perm_r, etree, equed, R, C, &L, &U, work,
lwork, &B, &X, &rpg, &rcond, &Glu, &mem_usage, &stat, &info);
/* Set RHS for GMRES. */
if (!(b = floatMalloc(m))) ABORT("Malloc fails for b[].");
if (*equed == 'R' || *equed == 'B') {
for (i = 0; i < n; ++i) b[i] = rhsb[i] * R[i];
} else {
for (i = 0; i < m; i++) b[i] = rhsb[i];
}
printf("sgsisx(): info %d, equed %c\n", info, equed[0]);
if (info > 0 || rcond < 1e-8 || rpg > 1e8)
printf("WARNING: This preconditioner might be unstable.\n");
if ( info == 0 || info == n+1 ) {
if ( options.PivotGrowth == YES )
printf("Recip. pivot growth = %e\n", rpg);
if ( options.ConditionNumber == YES )
printf("Recip. condition number = %e\n", rcond);
} else if ( info > 0 && lwork == -1 ) {
printf("** Estimated memory: %d bytes\n", info - n);
}
Lstore = (SCformat *) L.Store;
Ustore = (NCformat *) U.Store;
printf("n(A) = %d, nnz(A) = %d\n", n, Astore->nnz);
printf("No of nonzeros in factor L = %d\n", Lstore->nnz);
printf("No of nonzeros in factor U = %d\n", Ustore->nnz);
printf("No of nonzeros in L+U = %d\n", Lstore->nnz + Ustore->nnz - n);
printf("Fill ratio: nnz(F)/nnz(A) = %.3f\n",
((double)(Lstore->nnz) + (double)(Ustore->nnz) - (double)n)
/ (double)Astore->nnz);
printf("L\\U MB %.3f\ttotal MB needed %.3f\n",
mem_usage.for_lu/1e6, mem_usage.total_needed/1e6);
fflush(stdout);
/* Set the global variables. */
GLOBAL_A = &A;
GLOBAL_L = &L;
GLOBAL_U = &U;
GLOBAL_STAT = &stat;
GLOBAL_PERM_C = perm_c;
GLOBAL_PERM_R = perm_r;
GLOBAL_OPTIONS = &options;
GLOBAL_R = R;
GLOBAL_C = C;
GLOBAL_MEM_USAGE = &mem_usage;
/* Set the options to do solve-only. */
options.Fact = FACTORED;
options.PivotGrowth = NO;
options.ConditionNumber = NO;
/* Set the variables used by GMRES. */
restrt = SUPERLU_MIN(n / 3 + 1, 50);
maxit = 1000;
iter = maxit;
resid = 1e-8;
if (!(x = floatMalloc(n))) ABORT("Malloc fails for x[].");
if (info <= n + 1)
{
int i_1 = 1;
double maxferr = 0.0, nrmA, nrmB, res, t;
float temp;
extern float snrm2_(int *, float [], int *);
extern void saxpy_(int *, float *, float [], int *, float [], int *);
/* Initial guess */
for (i = 0; i < n; i++) x[i] = zero;
t = SuperLU_timer_();
/* Call GMRES */
sfgmr(n, smatvec_mult, spsolve, b, x, resid, restrt, &iter, stdout);
t = SuperLU_timer_() - t;
/* Output the result. */
nrmA = snrm2_(&(Astore->nnz), (float *)((DNformat *)A.Store)->nzval,
&i_1);
nrmB = snrm2_(&m, b, &i_1);
sp_sgemv("N", -1.0, &A, x, 1, 1.0, b, 1);
res = snrm2_(&m, b, &i_1);
resid = res / nrmB;
printf("||A||_F = %.1e, ||B||_2 = %.1e, ||B-A*X||_2 = %.1e, "
"relres = %.1e\n", nrmA, nrmB, res, resid);
if (iter >= maxit)
{
if (resid >= 1.0) iter = -180;
else if (resid > 1e-8) iter = -111;
}
printf("iteration: %d\nresidual: %.1e\nGMRES time: %.2f seconds.\n",
iter, resid, t);
/* Scale the solution back if equilibration was performed. */
if (*equed == 'C' || *equed == 'B')
for (i = 0; i < n; i++) x[i] *= C[i];
for (i = 0; i < m; i++) {
maxferr = SUPERLU_MAX(maxferr, fabs(x[i] - xact[i]));
}
printf("||X-X_true||_oo = %.1e\n", maxferr);
}
#ifdef DEBUG
printf("%d entries in L and %d entries in U dropped.\n",
num_drop_L, num_drop_U);
#endif
fflush(stdout);
if ( options.PrintStat ) StatPrint(&stat);
StatFree(&stat);
SUPERLU_FREE (rhsb);
SUPERLU_FREE (rhsx);
SUPERLU_FREE (xact);
SUPERLU_FREE (etree);
SUPERLU_FREE (perm_r);
SUPERLU_FREE (perm_c);
SUPERLU_FREE (R);
SUPERLU_FREE (C);
Destroy_CompCol_Matrix(&A);
Destroy_SuperMatrix_Store(&B);
Destroy_SuperMatrix_Store(&X);
if ( lwork >= 0 ) {
Destroy_SuperNode_Matrix(&L);
Destroy_CompCol_Matrix(&U);
}
SUPERLU_FREE(b);
SUPERLU_FREE(x);
#if ( DEBUGlevel>=1 )
CHECK_MALLOC("Exit main()");
#endif
return 0;
}
int set_superlu_options_from_dict(superlu_options_t * options,
int ilu, PyObject * option_dict,
int *panel_size, int *relax)
{
PyObject *args;
int ret;
int _relax, _panel_size;
static char *kwlist[] = {
"Fact", "Equil", "ColPerm", "Trans", "IterRefine",
"DiagPivotThresh", "PivotGrowth", "ConditionNumber",
"RowPerm", "SymmetricMode", "PrintStat", "ReplaceTinyPivot",
"SolveInitialized", "RefineInitialized", "ILU_Norm",
"ILU_MILU", "ILU_DropTol", "ILU_FillTol", "ILU_FillFactor",
"ILU_DropRule", "PanelSize", "Relax", NULL
};
if (ilu) {
ilu_set_default_options(options);
}
else {
set_default_options(options);
}
_panel_size = sp_ienv(1);
_relax = sp_ienv(2);
if (option_dict == NULL) {
/* Proceed with default options */
ret = 1;
}
else {
args = PyTuple_New(0);
ret = PyArg_ParseTupleAndKeywords(args, option_dict,
"|O&O&O&O&O&O&O&O&O&O&O&O&O&O&O&O&O&O&O&O&O&O&",
kwlist, fact_cvt, &options->Fact,
yes_no_cvt, &options->Equil,
colperm_cvt, &options->ColPerm,
trans_cvt, &options->Trans,
iterrefine_cvt, &options->IterRefine,
double_cvt,
&options->DiagPivotThresh,
yes_no_cvt, &options->PivotGrowth,
yes_no_cvt,
&options->ConditionNumber,
rowperm_cvt, &options->RowPerm,
yes_no_cvt, &options->SymmetricMode,
yes_no_cvt, &options->PrintStat,
yes_no_cvt,
&options->ReplaceTinyPivot,
yes_no_cvt,
&options->SolveInitialized,
yes_no_cvt,
&options->RefineInitialized,
norm_cvt, &options->ILU_Norm,
milu_cvt, &options->ILU_MILU,
double_cvt, &options->ILU_DropTol,
double_cvt, &options->ILU_FillTol,
double_cvt, &options->ILU_FillFactor,
droprule_cvt, &options->ILU_DropRule,
int_cvt, &_panel_size, int_cvt,
&_relax);
Py_DECREF(args);
}
if (panel_size != NULL) {
*panel_size = _panel_size;
}
if (relax != NULL) {
*relax = _relax;
}
return ret;
}
EXTERN_C_END
/*MC
MATSOLVERSUPERLU = "superlu" - A solver package providing solvers LU and ILU for sequential matrices
via the external package SuperLU.
Use ./configure --download-superlu to have PETSc installed with SuperLU
Options Database Keys:
+ -mat_superlu_equil <FALSE> - Equil (None)
. -mat_superlu_colperm <COLAMD> - (choose one of) NATURAL MMD_ATA MMD_AT_PLUS_A COLAMD
. -mat_superlu_iterrefine <NOREFINE> - (choose one of) NOREFINE SINGLE DOUBLE EXTRA
. -mat_superlu_symmetricmode: <FALSE> - SymmetricMode (None)
. -mat_superlu_diagpivotthresh <1> - DiagPivotThresh (None)
. -mat_superlu_pivotgrowth <FALSE> - PivotGrowth (None)
. -mat_superlu_conditionnumber <FALSE> - ConditionNumber (None)
. -mat_superlu_rowperm <NOROWPERM> - (choose one of) NOROWPERM LargeDiag
. -mat_superlu_replacetinypivot <FALSE> - ReplaceTinyPivot (None)
. -mat_superlu_printstat <FALSE> - PrintStat (None)
. -mat_superlu_lwork <0> - size of work array in bytes used by factorization (None)
. -mat_superlu_ilu_droptol <0> - ILU_DropTol (None)
. -mat_superlu_ilu_filltol <0> - ILU_FillTol (None)
. -mat_superlu_ilu_fillfactor <0> - ILU_FillFactor (None)
. -mat_superlu_ilu_droprull <0> - ILU_DropRule (None)
. -mat_superlu_ilu_norm <0> - ILU_Norm (None)
- -mat_superlu_ilu_milu <0> - ILU_MILU (None)
Notes: Do not confuse this with MATSOLVERSUPERLU_DIST which is for parallel sparse solves
Level: beginner
.seealso: PCLU, PCILU, MATSOLVERSUPERLU_DIST, MATSOLVERMUMPS, MATSOLVERSPOOLES, PCFactorSetMatSolverPackage(), MatSolverPackage
M*/
EXTERN_C_BEGIN
#undef __FUNCT__
#define __FUNCT__ "MatGetFactor_seqaij_superlu"
PetscErrorCode MatGetFactor_seqaij_superlu(Mat A,MatFactorType ftype,Mat *F)
{
Mat B;
Mat_SuperLU *lu;
PetscErrorCode ierr;
PetscInt indx,m=A->rmap->n,n=A->cmap->n;
PetscBool flg;
const char *colperm[]={"NATURAL","MMD_ATA","MMD_AT_PLUS_A","COLAMD"}; /* MY_PERMC - not supported by the petsc interface yet */
const char *iterrefine[]={"NOREFINE", "SINGLE", "DOUBLE", "EXTRA"};
const char *rowperm[]={"NOROWPERM", "LargeDiag"}; /* MY_PERMC - not supported by the petsc interface yet */
PetscFunctionBegin;
ierr = MatCreate(((PetscObject)A)->comm,&B);CHKERRQ(ierr);
ierr = MatSetSizes(B,A->rmap->n,A->cmap->n,PETSC_DETERMINE,PETSC_DETERMINE);CHKERRQ(ierr);
ierr = MatSetType(B,((PetscObject)A)->type_name);CHKERRQ(ierr);
ierr = MatSeqAIJSetPreallocation(B,0,PETSC_NULL);CHKERRQ(ierr);
if (ftype == MAT_FACTOR_LU || ftype == MAT_FACTOR_ILU){
B->ops->lufactorsymbolic = MatLUFactorSymbolic_SuperLU;
B->ops->ilufactorsymbolic = MatLUFactorSymbolic_SuperLU;
} else SETERRQ(PETSC_COMM_SELF,PETSC_ERR_SUP,"Factor type not supported");
B->ops->destroy = MatDestroy_SuperLU;
B->ops->view = MatView_SuperLU;
B->factortype = ftype;
B->assembled = PETSC_TRUE; /* required by -ksp_view */
B->preallocated = PETSC_TRUE;
ierr = PetscNewLog(B,Mat_SuperLU,&lu);CHKERRQ(ierr);
if (ftype == MAT_FACTOR_LU){
set_default_options(&lu->options);
/* Comments from SuperLU_4.0/SRC/dgssvx.c:
"Whether or not the system will be equilibrated depends on the
scaling of the matrix A, but if equilibration is used, A is
overwritten by diag(R)*A*diag(C) and B by diag(R)*B
(if options->Trans=NOTRANS) or diag(C)*B (if options->Trans = TRANS or CONJ)."
We set 'options.Equil = NO' as default because additional space is needed for it.
*/
lu->options.Equil = NO;
} else if (ftype == MAT_FACTOR_ILU){
/* Set the default input options of ilu: */
ilu_set_default_options(&lu->options);
}
lu->options.PrintStat = NO;
/* Initialize the statistics variables. */
StatInit(&lu->stat);
lu->lwork = 0; /* allocate space internally by system malloc */
ierr = PetscOptionsBegin(((PetscObject)A)->comm,((PetscObject)A)->prefix,"SuperLU Options","Mat");CHKERRQ(ierr);
ierr = PetscOptionsBool("-mat_superlu_equil","Equil","None",(PetscBool)lu->options.Equil,(PetscBool*)&lu->options.Equil,0);CHKERRQ(ierr);
ierr = PetscOptionsEList("-mat_superlu_colperm","ColPerm","None",colperm,4,colperm[3],&indx,&flg);CHKERRQ(ierr);
if (flg) {lu->options.ColPerm = (colperm_t)indx;}
ierr = PetscOptionsEList("-mat_superlu_iterrefine","IterRefine","None",iterrefine,4,iterrefine[0],&indx,&flg);CHKERRQ(ierr);
if (flg) { lu->options.IterRefine = (IterRefine_t)indx;}
ierr = PetscOptionsBool("-mat_superlu_symmetricmode","SymmetricMode","None",(PetscBool)lu->options.SymmetricMode,&flg,0);CHKERRQ(ierr);
if (flg) lu->options.SymmetricMode = YES;
ierr = PetscOptionsReal("-mat_superlu_diagpivotthresh","DiagPivotThresh","None",lu->options.DiagPivotThresh,&lu->options.DiagPivotThresh,PETSC_NULL);CHKERRQ(ierr);
ierr = PetscOptionsBool("-mat_superlu_pivotgrowth","PivotGrowth","None",(PetscBool)lu->options.PivotGrowth,&flg,0);CHKERRQ(ierr);
if (flg) lu->options.PivotGrowth = YES;
ierr = PetscOptionsBool("-mat_superlu_conditionnumber","ConditionNumber","None",(PetscBool)lu->options.ConditionNumber,&flg,0);CHKERRQ(ierr);
if (flg) lu->options.ConditionNumber = YES;
ierr = PetscOptionsEList("-mat_superlu_rowperm","rowperm","None",rowperm,2,rowperm[lu->options.RowPerm],&indx,&flg);CHKERRQ(ierr);
if (flg) {lu->options.RowPerm = (rowperm_t)indx;}
ierr = PetscOptionsBool("-mat_superlu_replacetinypivot","ReplaceTinyPivot","None",(PetscBool)lu->options.ReplaceTinyPivot,&flg,0);CHKERRQ(ierr);
if (flg) lu->options.ReplaceTinyPivot = YES;
ierr = PetscOptionsBool("-mat_superlu_printstat","PrintStat","None",(PetscBool)lu->options.PrintStat,&flg,0);CHKERRQ(ierr);
if (flg) lu->options.PrintStat = YES;
ierr = PetscOptionsInt("-mat_superlu_lwork","size of work array in bytes used by factorization","None",lu->lwork,&lu->lwork,PETSC_NULL);CHKERRQ(ierr);
if (lu->lwork > 0 ){
ierr = PetscMalloc(lu->lwork,&lu->work);CHKERRQ(ierr);
} else if (lu->lwork != 0 && lu->lwork != -1){
ierr = PetscPrintf(PETSC_COMM_SELF," Warning: lwork %D is not supported by SUPERLU. The default lwork=0 is used.\n",lu->lwork);
lu->lwork = 0;
}
/* ilu options */
ierr = PetscOptionsReal("-mat_superlu_ilu_droptol","ILU_DropTol","None",lu->options.ILU_DropTol,&lu->options.ILU_DropTol,PETSC_NULL);CHKERRQ(ierr);
ierr = PetscOptionsReal("-mat_superlu_ilu_filltol","ILU_FillTol","None",lu->options.ILU_FillTol,&lu->options.ILU_FillTol,PETSC_NULL);CHKERRQ(ierr);
ierr = PetscOptionsReal("-mat_superlu_ilu_fillfactor","ILU_FillFactor","None",lu->options.ILU_FillFactor,&lu->options.ILU_FillFactor,PETSC_NULL);CHKERRQ(ierr);
ierr = PetscOptionsInt("-mat_superlu_ilu_droprull","ILU_DropRule","None",lu->options.ILU_DropRule,&lu->options.ILU_DropRule,PETSC_NULL);CHKERRQ(ierr);
ierr = PetscOptionsInt("-mat_superlu_ilu_norm","ILU_Norm","None",lu->options.ILU_Norm,&indx,&flg);CHKERRQ(ierr);
if (flg){
lu->options.ILU_Norm = (norm_t)indx;
}
ierr = PetscOptionsInt("-mat_superlu_ilu_milu","ILU_MILU","None",lu->options.ILU_MILU,&indx,&flg);CHKERRQ(ierr);
if (flg){
lu->options.ILU_MILU = (milu_t)indx;
}
PetscOptionsEnd();
if (lu->options.Equil == YES) {
/* superlu overwrites input matrix and rhs when Equil is used, thus create A_dup to keep user's A unchanged */
ierr = MatDuplicate_SeqAIJ(A,MAT_COPY_VALUES,&lu->A_dup);CHKERRQ(ierr);
}
/* Allocate spaces (notice sizes are for the transpose) */
ierr = PetscMalloc(m*sizeof(PetscInt),&lu->etree);CHKERRQ(ierr);
ierr = PetscMalloc(n*sizeof(PetscInt),&lu->perm_r);CHKERRQ(ierr);
ierr = PetscMalloc(m*sizeof(PetscInt),&lu->perm_c);CHKERRQ(ierr);
ierr = PetscMalloc(n*sizeof(PetscScalar),&lu->R);CHKERRQ(ierr);
ierr = PetscMalloc(m*sizeof(PetscScalar),&lu->C);CHKERRQ(ierr);
/* create rhs and solution x without allocate space for .Store */
#if defined(PETSC_USE_COMPLEX)
zCreate_Dense_Matrix(&lu->B, m, 1, PETSC_NULL, m, SLU_DN, SLU_Z, SLU_GE);
zCreate_Dense_Matrix(&lu->X, m, 1, PETSC_NULL, m, SLU_DN, SLU_Z, SLU_GE);
#else
dCreate_Dense_Matrix(&lu->B, m, 1, PETSC_NULL, m, SLU_DN, SLU_D, SLU_GE);
dCreate_Dense_Matrix(&lu->X, m, 1, PETSC_NULL, m, SLU_DN, SLU_D, SLU_GE);
#endif
#ifdef SUPERLU2
ierr = PetscObjectComposeFunctionDynamic((PetscObject)B,"MatCreateNull","MatCreateNull_SuperLU",(void(*)(void))MatCreateNull_SuperLU);CHKERRQ(ierr);
#endif
ierr = PetscObjectComposeFunctionDynamic((PetscObject)B,"MatFactorGetSolverPackage_C","MatFactorGetSolverPackage_seqaij_superlu",MatFactorGetSolverPackage_seqaij_superlu);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)B,"MatSuperluSetILUDropTol_C","MatSuperluSetILUDropTol_SuperLU",MatSuperluSetILUDropTol_SuperLU);CHKERRQ(ierr);
B->spptr = lu;
*F = B;
PetscFunctionReturn(0);
}