static PetscErrorCode MatMPIAdjCreateNonemptySubcommMat_MPIAdj(Mat A,Mat *B)
{
Mat_MPIAdj *a = (Mat_MPIAdj*)A->data;
PetscErrorCode ierr;
const PetscInt *ranges;
MPI_Comm acomm,bcomm;
MPI_Group agroup,bgroup;
PetscMPIInt i,rank,size,nranks,*ranks;
PetscFunctionBegin;
*B = NULL;
ierr = PetscObjectGetComm((PetscObject)A,&acomm);CHKERRQ(ierr);
ierr = MPI_Comm_size(acomm,&size);CHKERRQ(ierr);
ierr = MPI_Comm_size(acomm,&rank);CHKERRQ(ierr);
ierr = MatGetOwnershipRanges(A,&ranges);CHKERRQ(ierr);
for (i=0,nranks=0; i<size; i++) {
if (ranges[i+1] - ranges[i] > 0) nranks++;
}
if (nranks == size) { /* All ranks have a positive number of rows, so we do not need to create a subcomm; */
ierr = PetscObjectReference((PetscObject)A);CHKERRQ(ierr);
*B = A;
PetscFunctionReturn(0);
}
ierr = PetscMalloc1(nranks,&ranks);CHKERRQ(ierr);
for (i=0,nranks=0; i<size; i++) {
if (ranges[i+1] - ranges[i] > 0) ranks[nranks++] = i;
}
ierr = MPI_Comm_group(acomm,&agroup);CHKERRQ(ierr);
ierr = MPI_Group_incl(agroup,nranks,ranks,&bgroup);CHKERRQ(ierr);
ierr = PetscFree(ranks);CHKERRQ(ierr);
ierr = MPI_Comm_create(acomm,bgroup,&bcomm);CHKERRQ(ierr);
ierr = MPI_Group_free(&agroup);CHKERRQ(ierr);
ierr = MPI_Group_free(&bgroup);CHKERRQ(ierr);
if (bcomm != MPI_COMM_NULL) {
PetscInt m,N;
Mat_MPIAdj *b;
ierr = MatGetLocalSize(A,&m,NULL);CHKERRQ(ierr);
ierr = MatGetSize(A,NULL,&N);CHKERRQ(ierr);
ierr = MatCreateMPIAdj(bcomm,m,N,a->i,a->j,a->values,B);CHKERRQ(ierr);
b = (Mat_MPIAdj*)(*B)->data;
b->freeaij = PETSC_FALSE;
ierr = MPI_Comm_free(&bcomm);CHKERRQ(ierr);
}
PetscFunctionReturn(0);
}
static PetscErrorCode PCSetUp_PARMS(PC pc)
{
Mat pmat;
PC_PARMS *parms = (PC_PARMS*)pc->data;
const PetscInt *mapptr0;
PetscInt n, lsize, low, high, i, pos, ncols, length;
int *maptmp, *mapptr, *ia, *ja, *ja1, *im;
PetscScalar *aa, *aa1;
const PetscInt *cols;
PetscInt meth[8];
const PetscScalar *values;
PetscErrorCode ierr;
MatInfo matinfo;
PetscMPIInt rank, npro;
PetscFunctionBegin;
/* Get preconditioner matrix from PETSc and setup pARMS structs */
ierr = PCGetOperators(pc,PETSC_NULL,&pmat,PETSC_NULL);CHKERRQ(ierr);
MPI_Comm_size(((PetscObject)pmat)->comm,&npro);
MPI_Comm_rank(((PetscObject)pmat)->comm,&rank);
ierr = MatGetSize(pmat,&n,PETSC_NULL);CHKERRQ(ierr);
ierr = PetscMalloc((npro+1)*sizeof(int),&mapptr);CHKERRQ(ierr);
ierr = PetscMalloc(n*sizeof(int),&maptmp);CHKERRQ(ierr);
ierr = MatGetOwnershipRanges(pmat,&mapptr0);CHKERRQ(ierr);
low = mapptr0[rank];
high = mapptr0[rank+1];
lsize = high - low;
for (i=0; i<npro+1; i++)
mapptr[i] = mapptr0[i]+1;
for (i = 0; i<n; i++)
maptmp[i] = i+1;
/* if created, destroy the previous map */
if (parms->map) {
parms_MapFree(&parms->map);
parms->map = PETSC_NULL;
}
/* create pARMS map object */
parms_MapCreateFromPtr(&parms->map,(int)n,maptmp,mapptr,((PetscObject)pmat)->comm,1,NONINTERLACED);
/* if created, destroy the previous pARMS matrix */
if (parms->A) {
parms_MatFree(&parms->A);
parms->A = PETSC_NULL;
}
/* create pARMS mat object */
parms_MatCreate(&parms->A,parms->map);
/* setup and copy csr data structure for pARMS */
ierr = PetscMalloc((lsize+1)*sizeof(int),&ia);CHKERRQ(ierr);
ia[0] = 1;
ierr = MatGetInfo(pmat,MAT_LOCAL,&matinfo);CHKERRQ(ierr);
length = matinfo.nz_used;
ierr = PetscMalloc(length*sizeof(int),&ja);CHKERRQ(ierr);
ierr = PetscMalloc(length*sizeof(PetscScalar),&aa);CHKERRQ(ierr);
for (i = low; i<high; i++) {
pos = ia[i-low]-1;
ierr = MatGetRow(pmat,i,&ncols,&cols,&values);CHKERRQ(ierr);
ia[i-low+1] = ia[i-low] + ncols;
if (ia[i-low+1] >= length) {
length += ncols;
ierr = PetscMalloc(length*sizeof(int),&ja1);CHKERRQ(ierr);
ierr = PetscMemcpy(ja1,ja,(ia[i-low]-1)*sizeof(int));CHKERRQ(ierr);
ierr = PetscFree(ja);CHKERRQ(ierr);
ja = ja1;
ierr = PetscMalloc(length*sizeof(PetscScalar),&aa1);CHKERRQ(ierr);
ierr = PetscMemcpy(aa1,aa,(ia[i-low]-1)*sizeof(PetscScalar));CHKERRQ(ierr);
ierr = PetscFree(aa);CHKERRQ(ierr);
aa = aa1;
}
ierr = PetscMemcpy(&ja[pos],cols,ncols*sizeof(int));CHKERRQ(ierr);
ierr = PetscMemcpy(&aa[pos],values,ncols*sizeof(PetscScalar));CHKERRQ(ierr);
ierr = MatRestoreRow(pmat,i,&ncols,&cols,&values);CHKERRQ(ierr);
}
/* csr info is for local matrix so initialize im[] locally */
ierr = PetscMalloc(lsize*sizeof(int),&im);CHKERRQ(ierr);
ierr = PetscMemcpy(im,&maptmp[mapptr[rank]-1],lsize*sizeof(int));CHKERRQ(ierr);
/* 1-based indexing */
for (i=0; i<ia[lsize]-1; i++)
ja[i] = ja[i]+1;
/* Now copy csr matrix to parms_mat object */
parms_MatSetValues(parms->A,(int)lsize,im,ia,ja,aa,INSERT);
/* free memory */
ierr = PetscFree(maptmp);CHKERRQ(ierr);
ierr = PetscFree(mapptr);CHKERRQ(ierr);
ierr = PetscFree(aa);CHKERRQ(ierr);
ierr = PetscFree(ja);CHKERRQ(ierr);
ierr = PetscFree(ia);CHKERRQ(ierr);
ierr = PetscFree(im);CHKERRQ(ierr);
/* setup parms matrix */
parms_MatSetup(parms->A);
/* if created, destroy the previous pARMS pc */
if (parms->pc) {
parms_PCFree(&parms->pc);
parms->pc = PETSC_NULL;
}
/* Now create pARMS preconditioner object based on A */
parms_PCCreate(&parms->pc,parms->A);
/* Transfer options from PC to pARMS */
switch(parms->global) {
case 0: parms_PCSetType(parms->pc, PCRAS); break;
case 1: parms_PCSetType(parms->pc, PCSCHUR); break;
case 2: parms_PCSetType(parms->pc, PCBJ); break;
}
switch(parms->local) {
case 0: parms_PCSetILUType(parms->pc, PCILU0); break;
case 1: parms_PCSetILUType(parms->pc, PCILUK); break;
case 2: parms_PCSetILUType(parms->pc, PCILUT); break;
case 3: parms_PCSetILUType(parms->pc, PCARMS); break;
}
parms_PCSetInnerEps(parms->pc, parms->solvetol);
parms_PCSetNlevels(parms->pc, parms->levels);
parms_PCSetPermType(parms->pc, parms->nonsymperm?1:0);
parms_PCSetBsize(parms->pc, parms->blocksize);
parms_PCSetTolInd(parms->pc, parms->indtol);
parms_PCSetInnerKSize(parms->pc, parms->maxdim);
parms_PCSetInnerMaxits(parms->pc, parms->maxits);
for (i=0; i<8; i++) meth[i] = parms->meth[i]?1:0;
parms_PCSetPermScalOptions(parms->pc, &meth[0], 1);
parms_PCSetPermScalOptions(parms->pc, &meth[4], 0);
parms_PCSetFill(parms->pc, parms->lfil);
parms_PCSetTol(parms->pc, parms->droptol);
parms_PCSetup(parms->pc);
/* Allocate two auxiliary vector of length lsize */
if (parms->lvec0) { ierr = PetscFree(parms->lvec0);CHKERRQ(ierr); }
ierr = PetscMalloc(lsize*sizeof(PetscScalar), &parms->lvec0);CHKERRQ(ierr);
if (parms->lvec1) { ierr = PetscFree(parms->lvec1);CHKERRQ(ierr); }
ierr = PetscMalloc(lsize*sizeof(PetscScalar), &parms->lvec1);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
PETSC_EXTERN PetscErrorCode MatISSetMPIXAIJPreallocation_Private(Mat A, Mat B, PetscBool maxreduce)
{
Mat_IS *matis = (Mat_IS*)(A->data);
PetscInt *my_dnz,*my_onz,*dnz,*onz,*mat_ranges,*row_ownership;
const PetscInt *global_indices_r,*global_indices_c;
PetscInt i,j,bs,rows,cols;
PetscInt lrows,lcols;
PetscInt local_rows,local_cols;
PetscMPIInt nsubdomains;
PetscBool isdense,issbaij;
PetscErrorCode ierr;
PetscFunctionBegin;
ierr = MPI_Comm_size(PetscObjectComm((PetscObject)A),&nsubdomains);CHKERRQ(ierr);
ierr = MatGetSize(A,&rows,&cols);CHKERRQ(ierr);
ierr = MatGetBlockSize(A,&bs);CHKERRQ(ierr);
ierr = MatGetSize(matis->A,&local_rows,&local_cols);CHKERRQ(ierr);
ierr = PetscObjectTypeCompare((PetscObject)matis->A,MATSEQDENSE,&isdense);CHKERRQ(ierr);
ierr = PetscObjectTypeCompare((PetscObject)matis->A,MATSEQSBAIJ,&issbaij);CHKERRQ(ierr);
ierr = ISLocalToGlobalMappingGetIndices(A->rmap->mapping,&global_indices_r);CHKERRQ(ierr);
if (A->rmap->mapping != A->cmap->mapping) {
ierr = ISLocalToGlobalMappingGetIndices(A->rmap->mapping,&global_indices_c);CHKERRQ(ierr);
} else {
global_indices_c = global_indices_r;
}
if (issbaij) {
ierr = MatGetRowUpperTriangular(matis->A);CHKERRQ(ierr);
}
/*
An SF reduce is needed to sum up properly on shared rows.
Note that generally preallocation is not exact, since it overestimates nonzeros
*/
if (!matis->sf) { /* setup SF if not yet created and allocate rootdata and leafdata */
ierr = MatISComputeSF_Private(A);CHKERRQ(ierr);
}
ierr = MatGetLocalSize(A,&lrows,&lcols);CHKERRQ(ierr);
ierr = MatPreallocateInitialize(PetscObjectComm((PetscObject)A),lrows,lcols,dnz,onz);CHKERRQ(ierr);
/* All processes need to compute entire row ownership */
ierr = PetscMalloc1(rows,&row_ownership);CHKERRQ(ierr);
ierr = MatGetOwnershipRanges(A,(const PetscInt**)&mat_ranges);CHKERRQ(ierr);
for (i=0;i<nsubdomains;i++) {
for (j=mat_ranges[i];j<mat_ranges[i+1];j++) {
row_ownership[j] = i;
}
}
/*
my_dnz and my_onz contains exact contribution to preallocation from each local mat
then, they will be summed up properly. This way, preallocation is always sufficient
*/
ierr = PetscCalloc2(local_rows,&my_dnz,local_rows,&my_onz);CHKERRQ(ierr);
/* preallocation as a MATAIJ */
if (isdense) { /* special case for dense local matrices */
for (i=0;i<local_rows;i++) {
PetscInt index_row = global_indices_r[i];
for (j=i;j<local_rows;j++) {
PetscInt owner = row_ownership[index_row];
PetscInt index_col = global_indices_c[j];
if (index_col > mat_ranges[owner]-1 && index_col < mat_ranges[owner+1] ) { /* diag block */
my_dnz[i] += 1;
} else { /* offdiag block */
my_onz[i] += 1;
}
/* same as before, interchanging rows and cols */
if (i != j) {
owner = row_ownership[index_col];
if (index_row > mat_ranges[owner]-1 && index_row < mat_ranges[owner+1] ) {
my_dnz[j] += 1;
} else {
my_onz[j] += 1;
}
}
}
}
} else { /* TODO: this could be optimized using MatGetRowIJ */
for (i=0;i<local_rows;i++) {
const PetscInt *cols;
PetscInt ncols,index_row = global_indices_r[i];
ierr = MatGetRow(matis->A,i,&ncols,&cols,NULL);CHKERRQ(ierr);
for (j=0;j<ncols;j++) {
PetscInt owner = row_ownership[index_row];
PetscInt index_col = global_indices_c[cols[j]];
if (index_col > mat_ranges[owner]-1 && index_col < mat_ranges[owner+1] ) { /* diag block */
my_dnz[i] += 1;
} else { /* offdiag block */
my_onz[i] += 1;
}
/* same as before, interchanging rows and cols */
if (issbaij && index_col != index_row) {
owner = row_ownership[index_col];
if (index_row > mat_ranges[owner]-1 && index_row < mat_ranges[owner+1] ) {
my_dnz[cols[j]] += 1;
} else {
my_onz[cols[j]] += 1;
}
}
}
ierr = MatRestoreRow(matis->A,i,&ncols,&cols,NULL);CHKERRQ(ierr);
}
}
ierr = ISLocalToGlobalMappingRestoreIndices(A->rmap->mapping,&global_indices_r);CHKERRQ(ierr);
if (global_indices_c != global_indices_r) {
ierr = ISLocalToGlobalMappingRestoreIndices(A->rmap->mapping,&global_indices_c);CHKERRQ(ierr);
}
ierr = PetscFree(row_ownership);CHKERRQ(ierr);
/* Reduce my_dnz and my_onz */
if (maxreduce) {
ierr = PetscSFReduceBegin(matis->sf,MPIU_INT,my_dnz,dnz,MPI_MAX);CHKERRQ(ierr);
ierr = PetscSFReduceEnd(matis->sf,MPIU_INT,my_dnz,dnz,MPI_MAX);CHKERRQ(ierr);
ierr = PetscSFReduceBegin(matis->sf,MPIU_INT,my_onz,onz,MPI_MAX);CHKERRQ(ierr);
ierr = PetscSFReduceEnd(matis->sf,MPIU_INT,my_onz,onz,MPI_MAX);CHKERRQ(ierr);
} else {
ierr = PetscSFReduceBegin(matis->sf,MPIU_INT,my_dnz,dnz,MPI_SUM);CHKERRQ(ierr);
ierr = PetscSFReduceEnd(matis->sf,MPIU_INT,my_dnz,dnz,MPI_SUM);CHKERRQ(ierr);
ierr = PetscSFReduceBegin(matis->sf,MPIU_INT,my_onz,onz,MPI_SUM);CHKERRQ(ierr);
ierr = PetscSFReduceEnd(matis->sf,MPIU_INT,my_onz,onz,MPI_SUM);CHKERRQ(ierr);
}
ierr = PetscFree2(my_dnz,my_onz);CHKERRQ(ierr);
/* Resize preallocation if overestimated */
for (i=0;i<lrows;i++) {
dnz[i] = PetscMin(dnz[i],lcols);
onz[i] = PetscMin(onz[i],cols-lcols);
}
/* set preallocation */
ierr = MatMPIAIJSetPreallocation(B,0,dnz,0,onz);CHKERRQ(ierr);
for (i=0;i<lrows/bs;i++) {
dnz[i] = dnz[i*bs]/bs;
onz[i] = onz[i*bs]/bs;
}
ierr = MatMPIBAIJSetPreallocation(B,bs,0,dnz,0,onz);CHKERRQ(ierr);
ierr = MatMPISBAIJSetPreallocation(B,bs,0,dnz,0,onz);CHKERRQ(ierr);
ierr = MatPreallocateFinalize(dnz,onz);CHKERRQ(ierr);
if (issbaij) {
ierr = MatRestoreRowUpperTriangular(matis->A);CHKERRQ(ierr);
}
PetscFunctionReturn(0);
}
static PetscErrorCode DMCreateMatrix_Composite_AIJ(DM dm,MatType mtype,Mat *J)
{
PetscErrorCode ierr;
DM_Composite *com = (DM_Composite*)dm->data;
struct DMCompositeLink *next;
PetscInt m,*dnz,*onz,i,j,mA;
Mat Atmp;
PetscMPIInt rank;
PetscBool dense = PETSC_FALSE;
PetscFunctionBegin;
/* use global vector to determine layout needed for matrix */
m = com->n;
ierr = MatCreate(PetscObjectComm((PetscObject)dm),J);CHKERRQ(ierr);
ierr = MatSetSizes(*J,m,m,PETSC_DETERMINE,PETSC_DETERMINE);CHKERRQ(ierr);
ierr = MatSetType(*J,mtype);CHKERRQ(ierr);
/*
Extremely inefficient but will compute entire Jacobian for testing
*/
ierr = PetscOptionsGetBool(((PetscObject)dm)->prefix,"-dmcomposite_dense_jacobian",&dense,NULL);CHKERRQ(ierr);
if (dense) {
PetscInt rstart,rend,*indices;
PetscScalar *values;
mA = com->N;
ierr = MatMPIAIJSetPreallocation(*J,mA,NULL,mA-m,NULL);CHKERRQ(ierr);
ierr = MatSeqAIJSetPreallocation(*J,mA,NULL);CHKERRQ(ierr);
ierr = MatGetOwnershipRange(*J,&rstart,&rend);CHKERRQ(ierr);
ierr = PetscMalloc2(mA,PetscScalar,&values,mA,PetscInt,&indices);CHKERRQ(ierr);
ierr = PetscMemzero(values,mA*sizeof(PetscScalar));CHKERRQ(ierr);
for (i=0; i<mA; i++) indices[i] = i;
for (i=rstart; i<rend; i++) {
ierr = MatSetValues(*J,1,&i,mA,indices,values,INSERT_VALUES);CHKERRQ(ierr);
}
ierr = PetscFree2(values,indices);CHKERRQ(ierr);
ierr = MatAssemblyBegin(*J,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
ierr = MatAssemblyEnd(*J,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
ierr = MPI_Comm_rank(PetscObjectComm((PetscObject)dm),&rank);CHKERRQ(ierr);
ierr = MatPreallocateInitialize(PetscObjectComm((PetscObject)dm),m,m,dnz,onz);CHKERRQ(ierr);
/* loop over packed objects, handling one at at time */
next = com->next;
while (next) {
PetscInt nc,rstart,*ccols,maxnc;
const PetscInt *cols,*rstarts;
PetscMPIInt proc;
ierr = DMCreateMatrix(next->dm,mtype,&Atmp);CHKERRQ(ierr);
ierr = MatGetOwnershipRange(Atmp,&rstart,NULL);CHKERRQ(ierr);
ierr = MatGetOwnershipRanges(Atmp,&rstarts);CHKERRQ(ierr);
ierr = MatGetLocalSize(Atmp,&mA,NULL);CHKERRQ(ierr);
maxnc = 0;
for (i=0; i<mA; i++) {
ierr = MatGetRow(Atmp,rstart+i,&nc,NULL,NULL);CHKERRQ(ierr);
ierr = MatRestoreRow(Atmp,rstart+i,&nc,NULL,NULL);CHKERRQ(ierr);
maxnc = PetscMax(nc,maxnc);
}
ierr = PetscMalloc(maxnc*sizeof(PetscInt),&ccols);CHKERRQ(ierr);
for (i=0; i<mA; i++) {
ierr = MatGetRow(Atmp,rstart+i,&nc,&cols,NULL);CHKERRQ(ierr);
/* remap the columns taking into how much they are shifted on each process */
for (j=0; j<nc; j++) {
proc = 0;
while (cols[j] >= rstarts[proc+1]) proc++;
ccols[j] = cols[j] + next->grstarts[proc] - rstarts[proc];
}
ierr = MatPreallocateSet(com->rstart+next->rstart+i,nc,ccols,dnz,onz);CHKERRQ(ierr);
ierr = MatRestoreRow(Atmp,rstart+i,&nc,&cols,NULL);CHKERRQ(ierr);
}
ierr = PetscFree(ccols);CHKERRQ(ierr);
ierr = MatDestroy(&Atmp);CHKERRQ(ierr);
next = next->next;
}
if (com->FormCoupleLocations) {
ierr = (*com->FormCoupleLocations)(dm,NULL,dnz,onz,__rstart,__nrows,__start,__end);CHKERRQ(ierr);
}
ierr = MatMPIAIJSetPreallocation(*J,0,dnz,0,onz);CHKERRQ(ierr);
ierr = MatSeqAIJSetPreallocation(*J,0,dnz);CHKERRQ(ierr);
ierr = MatPreallocateFinalize(dnz,onz);CHKERRQ(ierr);
if (dm->prealloc_only) PetscFunctionReturn(0);
next = com->next;
while (next) {
PetscInt nc,rstart,row,maxnc,*ccols;
const PetscInt *cols,*rstarts;
const PetscScalar *values;
PetscMPIInt proc;
ierr = DMCreateMatrix(next->dm,mtype,&Atmp);CHKERRQ(ierr);
ierr = MatGetOwnershipRange(Atmp,&rstart,NULL);CHKERRQ(ierr);
ierr = MatGetOwnershipRanges(Atmp,&rstarts);CHKERRQ(ierr);
ierr = MatGetLocalSize(Atmp,&mA,NULL);CHKERRQ(ierr);
maxnc = 0;
for (i=0; i<mA; i++) {
ierr = MatGetRow(Atmp,rstart+i,&nc,NULL,NULL);CHKERRQ(ierr);
ierr = MatRestoreRow(Atmp,rstart+i,&nc,NULL,NULL);CHKERRQ(ierr);
maxnc = PetscMax(nc,maxnc);
}
ierr = PetscMalloc(maxnc*sizeof(PetscInt),&ccols);CHKERRQ(ierr);
for (i=0; i<mA; i++) {
ierr = MatGetRow(Atmp,rstart+i,&nc,(const PetscInt**)&cols,&values);CHKERRQ(ierr);
for (j=0; j<nc; j++) {
proc = 0;
while (cols[j] >= rstarts[proc+1]) proc++;
ccols[j] = cols[j] + next->grstarts[proc] - rstarts[proc];
}
row = com->rstart+next->rstart+i;
ierr = MatSetValues(*J,1,&row,nc,ccols,values,INSERT_VALUES);CHKERRQ(ierr);
ierr = MatRestoreRow(Atmp,rstart+i,&nc,(const PetscInt**)&cols,&values);CHKERRQ(ierr);
}
ierr = PetscFree(ccols);CHKERRQ(ierr);
ierr = MatDestroy(&Atmp);CHKERRQ(ierr);
next = next->next;
}
if (com->FormCoupleLocations) {
PetscInt __rstart;
ierr = MatGetOwnershipRange(*J,&__rstart,NULL);CHKERRQ(ierr);
ierr = (*com->FormCoupleLocations)(dm,*J,NULL,NULL,__rstart,0,0,0);CHKERRQ(ierr);
}
ierr = MatAssemblyBegin(*J,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
ierr = MatAssemblyEnd(*J,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
PetscErrorCode MatISGetMPIXAIJ_IS(Mat mat, MatReuse reuse, Mat *M)
{
Mat_IS *matis = (Mat_IS*)(mat->data);
/* info on mat */
/* ISLocalToGlobalMapping rmapping,cmapping; */
PetscInt bs,rows,cols;
PetscInt lrows,lcols;
PetscInt local_rows,local_cols;
PetscBool isdense,issbaij,issbaij_red;
/* values insertion */
PetscScalar *array;
PetscInt *local_indices,*global_indices;
/* work */
PetscInt i,j,index_row;
PetscErrorCode ierr;
PetscFunctionBegin;
/* MISSING CHECKS
- rectangular case not covered (it is not allowed by MATIS)
*/
/* get info from mat */
/* ierr = MatGetLocalToGlobalMapping(mat,&rmapping,&cmapping);CHKERRQ(ierr); */
ierr = MatGetSize(mat,&rows,&cols);CHKERRQ(ierr);
ierr = MatGetBlockSize(mat,&bs);CHKERRQ(ierr);
ierr = MatGetSize(matis->A,&local_rows,&local_cols);CHKERRQ(ierr);
ierr = PetscObjectTypeCompare((PetscObject)matis->A,MATSEQDENSE,&isdense);CHKERRQ(ierr);
ierr = PetscObjectTypeCompare((PetscObject)matis->A,MATSEQSBAIJ,&issbaij);CHKERRQ(ierr);
/* work */
ierr = PetscMalloc1(local_rows,&local_indices);CHKERRQ(ierr);
for (i=0;i<local_rows;i++) local_indices[i]=i;
/* map indices of local mat to global values */
ierr = PetscMalloc(PetscMax(local_cols,local_rows)*sizeof(*global_indices),&global_indices);CHKERRQ(ierr);
/* ierr = ISLocalToGlobalMappingApply(rmapping,local_rows,local_indices,global_indices);CHKERRQ(ierr); */
ierr = ISLocalToGlobalMappingApply(matis->mapping,local_rows,local_indices,global_indices);CHKERRQ(ierr);
if (issbaij) {
ierr = MatGetRowUpperTriangular(matis->A);CHKERRQ(ierr);
}
if (reuse == MAT_INITIAL_MATRIX) {
Mat new_mat;
MatType new_mat_type;
Vec vec_dnz,vec_onz;
PetscScalar *my_dnz,*my_onz;
PetscInt *dnz,*onz,*mat_ranges,*row_ownership;
PetscInt index_col,owner;
PetscMPIInt nsubdomains;
/* determining new matrix type */
ierr = MPI_Allreduce(&issbaij,&issbaij_red,1,MPIU_BOOL,MPI_LAND,PetscObjectComm((PetscObject)mat));CHKERRQ(ierr);
if (issbaij_red) {
new_mat_type = MATSBAIJ;
} else {
if (bs>1) {
new_mat_type = MATBAIJ;
} else {
new_mat_type = MATAIJ;
}
}
ierr = MPI_Comm_size(PetscObjectComm((PetscObject)mat),&nsubdomains);CHKERRQ(ierr);
ierr = MatCreate(PetscObjectComm((PetscObject)mat),&new_mat);CHKERRQ(ierr);
ierr = MatSetSizes(new_mat,PETSC_DECIDE,PETSC_DECIDE,rows,cols);CHKERRQ(ierr);
ierr = MatSetBlockSize(new_mat,bs);CHKERRQ(ierr);
ierr = MatSetType(new_mat,new_mat_type);CHKERRQ(ierr);
ierr = MatSetUp(new_mat);CHKERRQ(ierr);
ierr = MatGetLocalSize(new_mat,&lrows,&lcols);CHKERRQ(ierr);
/*
preallocation
*/
ierr = MatPreallocateInitialize(PetscObjectComm((PetscObject)new_mat),lrows,lcols,dnz,onz);CHKERRQ(ierr);
/*
Some vectors are needed to sum up properly on shared interface dofs.
Preallocation macros cannot do the job.
Note that preallocation is not exact, since it overestimates nonzeros
*/
ierr = MatCreateVecs(new_mat,NULL,&vec_dnz);CHKERRQ(ierr);
/* ierr = VecSetLocalToGlobalMapping(vec_dnz,rmapping);CHKERRQ(ierr); */
ierr = VecSetLocalToGlobalMapping(vec_dnz,matis->mapping);CHKERRQ(ierr);
ierr = VecDuplicate(vec_dnz,&vec_onz);CHKERRQ(ierr);
/* All processes need to compute entire row ownership */
ierr = PetscMalloc1(rows,&row_ownership);CHKERRQ(ierr);
ierr = MatGetOwnershipRanges(new_mat,(const PetscInt**)&mat_ranges);CHKERRQ(ierr);
for (i=0;i<nsubdomains;i++) {
for (j=mat_ranges[i];j<mat_ranges[i+1];j++) {
row_ownership[j]=i;
}
}
/*
my_dnz and my_onz contains exact contribution to preallocation from each local mat
then, they will be summed up properly. This way, preallocation is always sufficient
*/
ierr = PetscMalloc1(local_rows,&my_dnz);CHKERRQ(ierr);
ierr = PetscMalloc1(local_rows,&my_onz);CHKERRQ(ierr);
ierr = PetscMemzero(my_dnz,local_rows*sizeof(*my_dnz));CHKERRQ(ierr);
ierr = PetscMemzero(my_onz,local_rows*sizeof(*my_onz));CHKERRQ(ierr);
/* preallocation as a MATAIJ */
if (isdense) { /* special case for dense local matrices */
for (i=0;i<local_rows;i++) {
index_row = global_indices[i];
for (j=i;j<local_rows;j++) {
owner = row_ownership[index_row];
index_col = global_indices[j];
if (index_col > mat_ranges[owner]-1 && index_col < mat_ranges[owner+1] ) { /* diag block */
my_dnz[i] += 1.0;
} else { /* offdiag block */
my_onz[i] += 1.0;
}
/* same as before, interchanging rows and cols */
if (i != j) {
owner = row_ownership[index_col];
if (index_row > mat_ranges[owner]-1 && index_row < mat_ranges[owner+1] ) {
my_dnz[j] += 1.0;
} else {
my_onz[j] += 1.0;
}
}
}
}
} else {
for (i=0;i<local_rows;i++) {
PetscInt ncols;
const PetscInt *cols;
index_row = global_indices[i];
ierr = MatGetRow(matis->A,i,&ncols,&cols,NULL);CHKERRQ(ierr);
for (j=0;j<ncols;j++) {
owner = row_ownership[index_row];
index_col = global_indices[cols[j]];
if (index_col > mat_ranges[owner]-1 && index_col < mat_ranges[owner+1] ) { /* diag block */
my_dnz[i] += 1.0;
} else { /* offdiag block */
my_onz[i] += 1.0;
}
/* same as before, interchanging rows and cols */
if (issbaij) {
owner = row_ownership[index_col];
if (index_row > mat_ranges[owner]-1 && index_row < mat_ranges[owner+1] ) {
my_dnz[j] += 1.0;
} else {
my_onz[j] += 1.0;
}
}
}
ierr = MatRestoreRow(matis->A,i,&ncols,&cols,NULL);CHKERRQ(ierr);
}
}
ierr = VecSet(vec_dnz,0.0);CHKERRQ(ierr);
ierr = VecSet(vec_onz,0.0);CHKERRQ(ierr);
if (local_rows) { /* multilevel guard */
ierr = VecSetValuesLocal(vec_dnz,local_rows,local_indices,my_dnz,ADD_VALUES);CHKERRQ(ierr);
ierr = VecSetValuesLocal(vec_onz,local_rows,local_indices,my_onz,ADD_VALUES);CHKERRQ(ierr);
}
ierr = VecAssemblyBegin(vec_dnz);CHKERRQ(ierr);
ierr = VecAssemblyBegin(vec_onz);CHKERRQ(ierr);
ierr = VecAssemblyEnd(vec_dnz);CHKERRQ(ierr);
ierr = VecAssemblyEnd(vec_onz);CHKERRQ(ierr);
ierr = PetscFree(my_dnz);CHKERRQ(ierr);
ierr = PetscFree(my_onz);CHKERRQ(ierr);
ierr = PetscFree(row_ownership);CHKERRQ(ierr);
/* set computed preallocation in dnz and onz */
ierr = VecGetArray(vec_dnz,&array);CHKERRQ(ierr);
for (i=0; i<lrows; i++) dnz[i] = (PetscInt)PetscRealPart(array[i]);
ierr = VecRestoreArray(vec_dnz,&array);CHKERRQ(ierr);
ierr = VecGetArray(vec_onz,&array);CHKERRQ(ierr);
for (i=0;i<lrows;i++) onz[i] = (PetscInt)PetscRealPart(array[i]);
ierr = VecRestoreArray(vec_onz,&array);CHKERRQ(ierr);
ierr = VecDestroy(&vec_dnz);CHKERRQ(ierr);
ierr = VecDestroy(&vec_onz);CHKERRQ(ierr);
/* Resize preallocation if overestimated */
for (i=0;i<lrows;i++) {
dnz[i] = PetscMin(dnz[i],lcols);
onz[i] = PetscMin(onz[i],cols-lcols);
}
/* set preallocation */
ierr = MatMPIAIJSetPreallocation(new_mat,0,dnz,0,onz);CHKERRQ(ierr);
for (i=0;i<lrows/bs;i++) {
dnz[i] = dnz[i*bs]/bs;
onz[i] = onz[i*bs]/bs;
}
ierr = MatMPIBAIJSetPreallocation(new_mat,bs,0,dnz,0,onz);CHKERRQ(ierr);
for (i=0;i<lrows/bs;i++) {
dnz[i] = dnz[i]-i;
}
ierr = MatMPISBAIJSetPreallocation(new_mat,bs,0,dnz,0,onz);CHKERRQ(ierr);
ierr = MatPreallocateFinalize(dnz,onz);CHKERRQ(ierr);
*M = new_mat;
} else {
PetscInt mbs,mrows,mcols;
/* some checks */
ierr = MatGetBlockSize(*M,&mbs);CHKERRQ(ierr);
ierr = MatGetSize(*M,&mrows,&mcols);CHKERRQ(ierr);
if (mrows != rows) {
SETERRQ2(PetscObjectComm((PetscObject)mat),PETSC_ERR_SUP,"Cannot reuse matrix. Wrong number of rows (%d != %d)",rows,mrows);
}
if (mrows != rows) {
SETERRQ2(PetscObjectComm((PetscObject)mat),PETSC_ERR_SUP,"Cannot reuse matrix. Wrong number of cols (%d != %d)",cols,mcols);
}
if (mbs != bs) {
SETERRQ2(PetscObjectComm((PetscObject)mat),PETSC_ERR_SUP,"Cannot reuse matrix. Wrong block size (%d != %d)",bs,mbs);
}
ierr = MatZeroEntries(*M);CHKERRQ(ierr);
}
/* set local to global mappings */
/* ierr = MatSetLocalToGlobalMapping(*M,rmapping,cmapping);CHKERRQ(ierr); */
/* Set values */
if (isdense) { /* special case for dense local matrices */
ierr = MatSetOption(*M,MAT_ROW_ORIENTED,PETSC_FALSE);CHKERRQ(ierr);
ierr = MatDenseGetArray(matis->A,&array);CHKERRQ(ierr);
ierr = MatSetValues(*M,local_rows,global_indices,local_cols,global_indices,array,ADD_VALUES);CHKERRQ(ierr);
ierr = MatDenseRestoreArray(matis->A,&array);CHKERRQ(ierr);
ierr = PetscFree(local_indices);CHKERRQ(ierr);
ierr = PetscFree(global_indices);CHKERRQ(ierr);
} else { /* very basic values insertion for all other matrix types */
ierr = PetscFree(local_indices);CHKERRQ(ierr);
for (i=0;i<local_rows;i++) {
ierr = MatGetRow(matis->A,i,&j,(const PetscInt**)&local_indices,(const PetscScalar**)&array);CHKERRQ(ierr);
/* ierr = MatSetValuesLocal(*M,1,&i,j,local_indices,array,ADD_VALUES);CHKERRQ(ierr); */
ierr = ISLocalToGlobalMappingApply(matis->mapping,j,local_indices,global_indices);CHKERRQ(ierr);
ierr = ISLocalToGlobalMappingApply(matis->mapping,1,&i,&index_row);CHKERRQ(ierr);
ierr = MatSetValues(*M,1,&index_row,j,global_indices,array,ADD_VALUES);CHKERRQ(ierr);
ierr = MatRestoreRow(matis->A,i,&j,(const PetscInt**)&local_indices,(const PetscScalar**)&array);CHKERRQ(ierr);
}
ierr = PetscFree(global_indices);CHKERRQ(ierr);
}
ierr = MatAssemblyBegin(*M,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
ierr = MatAssemblyEnd(*M,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
if (isdense) {
ierr = MatSetOption(*M,MAT_ROW_ORIENTED,PETSC_TRUE);CHKERRQ(ierr);
}
if (issbaij) {
ierr = MatRestoreRowUpperTriangular(matis->A);CHKERRQ(ierr);
}
PetscFunctionReturn(0);
}
/*
* It's supposed the global matrix is assembled for all (free and dirichlet)
* nodes. For the current FVM used, where system of equation is assembled in
* a sub-domain by sub-domain approach, work becomes easier using all nodes.
* After that, it's desired to solve the system of equation only for
* the free ones as expected. Each rank needs to import some rows from the
* assembled matrix to a new matrix. The function below does this job.
*
* - nrows: number of rows will be imported and will be local to that rank.
* - rows: array with number of rows indices that correspond to a free node. *
* */
int MeshData::rowsToImport(pMesh theMesh, int &nrows, int *&rows){
Mat temp;
PetscErrorCode ierr = MatCreateAIJ(PETSC_COMM_WORLD,PETSC_DECIDE,PETSC_DECIDE,numGF,numGF,0,PETSC_NULL,0,PETSC_NULL,&temp);
// get range of local owned rows of each process
const PetscInt *ranges[P_size()];
ierr = MatGetOwnershipRanges(temp,ranges);
//printf("[%d] - ranges[0] %d, ranges[1] %d, ranges[2] %d, ranges[3] %d\n",P_pid(),ranges[0][0],ranges[0][1],ranges[0][2],ranges[0][3]);
// each rank should take from matrix A row indices associated to free nodes
// that fill exactly the number of local rows of LHS, i.e,
// - rank 0 takes the first n1 rows from A, even if it is not local to rank 0.
// - rank 1 takes from the first n1 rows to n1+n2
// - rank 2 takes from the first n1+n2 rows to n1+n2+n3
// - (...)
// - rank p takes from the first sum(ni),i=1:p rows to sum(ni),i=i:p+1
int i,k;
int RANGE[P_size()];
for (i=0; i<P_size(); i++){
RANGE[i] = ranges[0][i+1]-ranges[0][i];
}
//printf("[%d] - RANGE %d %d %d\n",P_pid(),RANGE[0],RANGE[1],RANGE[2]);
const int from = ranges[0][P_pid()];
const int to = ranges[0][P_pid()+1];
//printf("[%d] - from %d to %d\n",P_pid(),from,to); exit(1);
ierr = MatDestroy(&temp); CHKERRQ(ierr);
// Inform which ROWS from A, on processor p, must be copied to assembly LHS matrix (free nodes). For each rank, the number of
// rows associated to free nodes cannot be forecast so a list is used.
list<int> freerowsList;
k = 0;
if (P_pid()==0){
for (i=1; i<=numGN; i++){
if ( !getDirichletValue(i,0) && k<to ){
freerowsList.push_back(i-1);
k++;
}
}
}
else{
for (i=1; i<=numGN; i++){
if ( !getDirichletValue(i,0) ){
if ( k>=from && k<to )
freerowsList.push_back(i-1);
k++;
}
}
}
// transfer row indices from list to array
nrows = freerowsList.size();
if ( !nrows ){
throw Exception(__LINE__,__FILE__,"numLocalRows = 0\n");
}
rows = new int[nrows];
i=0;
for(list<int>::iterator lit=freerowsList.begin(); lit!=freerowsList.end(); lit++){
rows[i++] = *lit;
// if (P_pid()==1) printf("rows[%d] = %d\n",i-1,rows[i-1]);
}
freerowsList.clear();
//printf("[%d] rows: %d\n",P_pid(),nrows);
// Rogerio, try to think in something more clear in the future!
/*
* Create a local array consisting of only local free IDs
* */
set<int> setLFNodes;
VIter vit = M_vertexIter(theMesh);
while (pEntity node = VIter_next(vit)){
int ID = get_AppToPETSc_Ordering(EN_id(node));
if ( !getDirichletValue(ID,0) ) {
setLFNodes.insert(ID);
}
}
if (setLFNodes.size()==0){
throw Exception(__LINE__,__FILE__,"No local free nodes.\n");
}
set<int>::iterator setLFN_Iter = setLFNodes.begin();
numLocalIDs = setLFNodes.size();
localIDs = new int[numLocalIDs];
for (i=0; i<numLocalIDs; i++){
localIDs[i] = *setLFN_Iter-1;
setLFN_Iter++;
}
setLFNodes.clear();
return 0;
}
static PetscErrorCode PCSetUp_Redundant(PC pc)
{
PC_Redundant *red = (PC_Redundant*)pc->data;
PetscErrorCode ierr;
PetscInt mstart,mend,mlocal,m,mlocal_sub,rstart_sub,rend_sub,mloc_sub;
PetscMPIInt size;
MatReuse reuse = MAT_INITIAL_MATRIX;
MatStructure str = DIFFERENT_NONZERO_PATTERN;
MPI_Comm comm = ((PetscObject)pc)->comm,subcomm;
Vec vec;
PetscMPIInt subsize,subrank;
const char *prefix;
const PetscInt *range;
PetscFunctionBegin;
ierr = MatGetVecs(pc->pmat,&vec,0);CHKERRQ(ierr);
ierr = VecGetSize(vec,&m);CHKERRQ(ierr);
if (!pc->setupcalled) {
if (!red->psubcomm) {
ierr = PetscSubcommCreate(comm,red->nsubcomm,&red->psubcomm);CHKERRQ(ierr);
ierr = PetscLogObjectMemory(pc,sizeof(PetscSubcomm));CHKERRQ(ierr);
/* create a new PC that processors in each subcomm have copy of */
subcomm = red->psubcomm->comm;
ierr = KSPCreate(subcomm,&red->ksp);CHKERRQ(ierr);
ierr = PetscObjectIncrementTabLevel((PetscObject)red->ksp,(PetscObject)pc,1);CHKERRQ(ierr);
ierr = PetscLogObjectParent(pc,red->ksp);CHKERRQ(ierr);
ierr = KSPSetType(red->ksp,KSPPREONLY);CHKERRQ(ierr);
ierr = KSPGetPC(red->ksp,&red->pc);CHKERRQ(ierr);
ierr = PCSetType(red->pc,PCLU);CHKERRQ(ierr);
ierr = PCGetOptionsPrefix(pc,&prefix);CHKERRQ(ierr);
ierr = KSPSetOptionsPrefix(red->ksp,prefix);CHKERRQ(ierr);
ierr = KSPAppendOptionsPrefix(red->ksp,"redundant_");CHKERRQ(ierr);
} else {
subcomm = red->psubcomm->comm;
}
/* create working vectors xsub/ysub and xdup/ydup */
ierr = VecGetLocalSize(vec,&mlocal);CHKERRQ(ierr);
ierr = VecGetOwnershipRange(vec,&mstart,&mend);CHKERRQ(ierr);
/* get local size of xsub/ysub */
ierr = MPI_Comm_size(subcomm,&subsize);CHKERRQ(ierr);
ierr = MPI_Comm_rank(subcomm,&subrank);CHKERRQ(ierr);
ierr = MatGetOwnershipRanges(pc->pmat,&range);CHKERRQ(ierr);
rstart_sub = range[red->psubcomm->n*subrank]; /* rstart in xsub/ysub */
if (subrank+1 < subsize){
rend_sub = range[red->psubcomm->n*(subrank+1)];
} else {
rend_sub = m;
}
mloc_sub = rend_sub - rstart_sub;
ierr = VecCreateMPI(subcomm,mloc_sub,PETSC_DECIDE,&red->ysub);CHKERRQ(ierr);
/* create xsub with empty local arrays, because xdup's arrays will be placed into it */
ierr = VecCreateMPIWithArray(subcomm,mloc_sub,PETSC_DECIDE,PETSC_NULL,&red->xsub);CHKERRQ(ierr);
/* create xdup and ydup. ydup has empty local arrays because ysub's arrays will be place into it.
Note: we use communicator dupcomm, not ((PetscObject)pc)->comm! */
ierr = VecCreateMPI(red->psubcomm->dupparent,mloc_sub,PETSC_DECIDE,&red->xdup);CHKERRQ(ierr);
ierr = VecCreateMPIWithArray(red->psubcomm->dupparent,mloc_sub,PETSC_DECIDE,PETSC_NULL,&red->ydup);CHKERRQ(ierr);
/* create vec scatters */
if (!red->scatterin){
IS is1,is2;
PetscInt *idx1,*idx2,i,j,k;
ierr = PetscMalloc2(red->psubcomm->n*mlocal,PetscInt,&idx1,red->psubcomm->n*mlocal,PetscInt,&idx2);CHKERRQ(ierr);
j = 0;
for (k=0; k<red->psubcomm->n; k++){
for (i=mstart; i<mend; i++){
idx1[j] = i;
idx2[j++] = i + m*k;
}
}
ierr = ISCreateGeneral(comm,red->psubcomm->n*mlocal,idx1,&is1);CHKERRQ(ierr);
ierr = ISCreateGeneral(comm,red->psubcomm->n*mlocal,idx2,&is2);CHKERRQ(ierr);
ierr = VecScatterCreate(vec,is1,red->xdup,is2,&red->scatterin);CHKERRQ(ierr);
ierr = ISDestroy(is1);CHKERRQ(ierr);
ierr = ISDestroy(is2);CHKERRQ(ierr);
ierr = ISCreateStride(comm,mlocal,mstart+ red->psubcomm->color*m,1,&is1);CHKERRQ(ierr);
ierr = ISCreateStride(comm,mlocal,mstart,1,&is2);CHKERRQ(ierr);
ierr = VecScatterCreate(red->xdup,is1,vec,is2,&red->scatterout);CHKERRQ(ierr);
ierr = ISDestroy(is1);CHKERRQ(ierr);
ierr = ISDestroy(is2);CHKERRQ(ierr);
ierr = PetscFree2(idx1,idx2);CHKERRQ(ierr);
}
}
ierr = VecDestroy(vec);CHKERRQ(ierr);
/* if pmatrix set by user is sequential then we do not need to gather the parallel matrix */
ierr = MPI_Comm_size(comm,&size);CHKERRQ(ierr);
if (size == 1) {
red->useparallelmat = PETSC_FALSE;
}
if (red->useparallelmat) {
if (pc->setupcalled == 1 && pc->flag == DIFFERENT_NONZERO_PATTERN) {
/* destroy old matrices */
if (red->pmats) {
ierr = MatDestroy(red->pmats);CHKERRQ(ierr);
}
} else if (pc->setupcalled == 1) {
reuse = MAT_REUSE_MATRIX;
str = SAME_NONZERO_PATTERN;
}
/* grab the parallel matrix and put it into processors of a subcomminicator */
/*--------------------------------------------------------------------------*/
ierr = VecGetLocalSize(red->ysub,&mlocal_sub);CHKERRQ(ierr);
ierr = MatGetRedundantMatrix(pc->pmat,red->psubcomm->n,red->psubcomm->comm,mlocal_sub,reuse,&red->pmats);CHKERRQ(ierr);
/* tell PC of the subcommunicator its operators */
ierr = KSPSetOperators(red->ksp,red->pmats,red->pmats,str);CHKERRQ(ierr);
} else {
ierr = KSPSetOperators(red->ksp,pc->mat,pc->pmat,pc->flag);CHKERRQ(ierr);
}
if (pc->setfromoptionscalled){
ierr = KSPSetFromOptions(red->ksp);CHKERRQ(ierr);
}
ierr = KSPSetUp(red->ksp);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
