bool SAMpatchPETSc::expandSolution(const SystemVector& solVec,
Vector& dofVec, Real scaleSD) const
{
PETScVector* Bptr = const_cast<PETScVector*>(dynamic_cast<const PETScVector*>(&solVec));
if (!Bptr)
return false;
#ifdef HAVE_MPI
if (adm.isParallel()) {
if (!glob2LocEq) {
std::vector<int> mlgeq(adm.dd.getMLGEQ());
for (auto& it : mlgeq)
--it;
ISCreateGeneral(*adm.getCommunicator(),adm.dd.getMLGEQ().size(),
mlgeq.data(), PETSC_COPY_VALUES, &glob2LocEq);
}
Vec solution;
VecCreateSeq(PETSC_COMM_SELF, Bptr->dim(), &solution);
VecScatter ctx;
VecScatterCreate(Bptr->getVector(), glob2LocEq, solution, nullptr, &ctx);
VecScatterBegin(ctx, Bptr->getVector(), solution, INSERT_VALUES, SCATTER_FORWARD);
VecScatterEnd(ctx, Bptr->getVector(),solution,INSERT_VALUES,SCATTER_FORWARD);
VecScatterDestroy(&ctx);
PetscScalar* data;
VecGetArray(solution, &data);
std::copy(data, data + Bptr->dim(), Bptr->getPtr());
VecDestroy(&solution);
} else
#endif
{
PetscScalar* data;
VecGetArray(Bptr->getVector(), &data);
std::copy(data, data + Bptr->dim(), Bptr->getPtr());
VecRestoreArray(Bptr->getVector(), &data);
}
return this->SAMpatch::expandSolution(solVec, dofVec, scaleSD);
}
PetscErrorCode Monitor(TS ts,PetscInt step,PetscReal time,Vec global,void *ctx)
{
VecScatter scatter;
IS from,to;
PetscInt i,n,*idx;
Vec tmp_vec;
PetscErrorCode ierr;
PetscScalar *tmp;
/* Get the size of the vector */
ierr = VecGetSize(global,&n);CHKERRQ(ierr);
/* Set the index sets */
ierr = PetscMalloc(n*sizeof(PetscInt),&idx);CHKERRQ(ierr);
for(i=0; i<n; i++) idx[i]=i;
/* Create local sequential vectors */
ierr = VecCreateSeq(PETSC_COMM_SELF,n,&tmp_vec);CHKERRQ(ierr);
/* Create scatter context */
ierr = ISCreateGeneral(PETSC_COMM_SELF,n,idx,PETSC_COPY_VALUES,&from);CHKERRQ(ierr);
ierr = ISCreateGeneral(PETSC_COMM_SELF,n,idx,PETSC_COPY_VALUES,&to);CHKERRQ(ierr);
ierr = VecScatterCreate(global,from,tmp_vec,to,&scatter);CHKERRQ(ierr);
ierr = VecScatterBegin(scatter,global,tmp_vec,INSERT_VALUES,SCATTER_FORWARD);CHKERRQ(ierr);
ierr = VecScatterEnd(scatter,global,tmp_vec,INSERT_VALUES,SCATTER_FORWARD);CHKERRQ(ierr);
ierr = VecGetArray(tmp_vec,&tmp);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"At t =%14.6e u = %14.6e %14.6e %14.6e \n",
time,PetscRealPart(tmp[0]),PetscRealPart(tmp[1]),PetscRealPart(tmp[2]));CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"At t =%14.6e errors = %14.6e %14.6e %14.6e \n",
time,PetscRealPart(tmp[0]-solx(time)),PetscRealPart(tmp[1]-soly(time)),PetscRealPart(tmp[2]-solz(time)));CHKERRQ(ierr);
ierr = VecRestoreArray(tmp_vec,&tmp);CHKERRQ(ierr);
ierr = VecScatterDestroy(&scatter);CHKERRQ(ierr);
ierr = ISDestroy(&from);CHKERRQ(ierr);
ierr = ISDestroy(&to);CHKERRQ(ierr);
ierr = PetscFree(idx);CHKERRQ(ierr);
ierr = VecDestroy(&tmp_vec);CHKERRQ(ierr);
return 0;
}
void ProfilerTest::test_petsc_memory() {
int ierr, mpi_rank;
ierr = MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
EXPECT_EQ( ierr, 0 );
Profiler::initialize(); {
PetscLogDouble mem;
START_TIMER("A");
PetscInt size = 100*1000;
PetscScalar value = 0.1;
Vec tmp_vector;
VecCreateSeq(PETSC_COMM_SELF, size, &tmp_vector);
VecSet(tmp_vector, value);
// VecSetRandom(tmp_vector, NULL);
END_TIMER("A");
START_TIMER("A");
// allocated memory MUST be greater or equal to size * size of double
EXPECT_GE(AN.petsc_memory_difference, size*sizeof(double));
END_TIMER("A");
START_TIMER("B");
PetscScalar sum;
VecSum(tmp_vector, &sum);
END_TIMER("B");
START_TIMER("C");
VecDestroy(&tmp_vector);
END_TIMER("C");
START_TIMER("C");
// since we are destroying vector, we expect to see negative memory difference
EXPECT_LE(AN.petsc_memory_difference, 0);
END_TIMER("C");
}
PI->output(MPI_COMM_WORLD, cout);
Profiler::uninitialize();
}
inline void PetscVector::init (const int n,
const int n_local,
const bool fast,
const ParallelType type) {
int ierr=0;
int petsc_n=static_cast<int>(n);
int petsc_n_local=static_cast<int>(n_local);
// Clear initialized vectors
if (this->initialized()) this->clear();
if (type == AUTOMATIC) {
if (n == n_local) this->_type = SERIAL;
else this->_type = PARALLEL;
} else this->_type = type;
assert ((this->_type==SERIAL && n==n_local) || this->_type==PARALLEL);
// create a sequential vector if on only 1 processor
if (this->_type == SERIAL) {
ierr = VecCreateSeq (PETSC_COMM_SELF, petsc_n, &_vec);
CHKERRABORT(PETSC_COMM_SELF,ierr);
ierr = VecSetFromOptions (_vec);
CHKERRABORT(PETSC_COMM_SELF,ierr);
}
// otherwise create an MPI-enabled vector
else if (this->_type == PARALLEL) {
assert (n_local <= n);
ierr = VecCreateMPI (MPI_COMM_WORLD, petsc_n_local, petsc_n, &_vec);
CHKERRABORT(MPI_COMM_WORLD,ierr);
ierr = VecSetFromOptions (_vec);
CHKERRABORT(MPI_COMM_WORLD,ierr);
} else {
std::cout << "Not good" <<std::endl;
abort();
}
this->_is_initialized = true;
this->_is_closed = true;
if (fast == false) this->zero ();
}
int main(int argc,char **argv)
{
PetscErrorCode ierr;
PetscInt n = 6,idx1[3] = {0,1,2},loc[6] = {0,1,2,3,4,5};
PetscScalar two = 2.0,vals[6] = {10,11,12,13,14,15};
Vec x,y;
IS is1,is2;
VecScatter ctx = 0;
ierr = PetscInitialize(&argc,&argv,(char*)0,help);if (ierr) return ierr;
/* create two vectors */
ierr = VecCreateSeq(PETSC_COMM_SELF,n,&x);CHKERRQ(ierr);
ierr = VecDuplicate(x,&y);CHKERRQ(ierr);
/* create two index sets */
ierr = ISCreateStride(PETSC_COMM_SELF,3,0,2,&is1);CHKERRQ(ierr);
ierr = ISCreateGeneral(PETSC_COMM_SELF,3,idx1,PETSC_COPY_VALUES,&is2);CHKERRQ(ierr);
ierr = VecSetValues(x,6,loc,vals,INSERT_VALUES);CHKERRQ(ierr);
ierr = VecView(x,PETSC_VIEWER_STDOUT_SELF);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_SELF,"----\n");CHKERRQ(ierr);
ierr = VecSet(y,two);CHKERRQ(ierr);
ierr = VecScatterCreate(x,is1,y,is2,&ctx);CHKERRQ(ierr);
ierr = VecScatterBegin(ctx,x,y,INSERT_VALUES,SCATTER_FORWARD);CHKERRQ(ierr);
ierr = VecScatterEnd(ctx,x,y,INSERT_VALUES,SCATTER_FORWARD);CHKERRQ(ierr);
ierr = VecScatterDestroy(&ctx);CHKERRQ(ierr);
ierr = VecView(y,PETSC_VIEWER_STDOUT_SELF);CHKERRQ(ierr);
ierr = ISDestroy(&is1);CHKERRQ(ierr);
ierr = ISDestroy(&is2);CHKERRQ(ierr);
ierr = VecDestroy(&x);CHKERRQ(ierr);
ierr = VecDestroy(&y);CHKERRQ(ierr);
ierr = PetscFinalize();
return ierr;
}
int main(int argc,char **argv)
{
KSP ksp;
PC pc;
Mat A,M;
Vec X,B,D;
MPI_Comm comm;
PetscScalar v;
KSPConvergedReason reason;
PetscInt i,j,its;
PetscErrorCode ierr;
PetscFunctionBegin;
ierr = PetscInitialize(&argc,&argv,0,help);CHKERRQ(ierr);
ierr = PetscOptionsSetValue("-options_left",PETSC_NULL);CHKERRQ(ierr);
comm = MPI_COMM_SELF;
/*
* Construct the Kershaw matrix
* and a suitable rhs / initial guess
*/
ierr = MatCreateSeqAIJ(comm,4,4,4,0,&A);CHKERRQ(ierr);
ierr = VecCreateSeq(comm,4,&B);CHKERRQ(ierr);
ierr = VecDuplicate(B,&X);CHKERRQ(ierr);
for (i=0; i<4; i++) {
v=3;
ierr = MatSetValues(A,1,&i,1,&i,&v,INSERT_VALUES);CHKERRQ(ierr);
v=1;
ierr = VecSetValues(B,1,&i,&v,INSERT_VALUES);CHKERRQ(ierr);
ierr = VecSetValues(X,1,&i,&v,INSERT_VALUES);CHKERRQ(ierr);
}
i=0; v=0;
ierr = VecSetValues(X,1,&i,&v,INSERT_VALUES);CHKERRQ(ierr);
for (i=0; i<3; i++) {
v=-2; j=i+1;
ierr = MatSetValues(A,1,&i,1,&j,&v,INSERT_VALUES);CHKERRQ(ierr);
ierr = MatSetValues(A,1,&j,1,&i,&v,INSERT_VALUES);CHKERRQ(ierr);
}
i=0; j=3; v=2;
ierr = MatSetValues(A,1,&i,1,&j,&v,INSERT_VALUES);CHKERRQ(ierr);
ierr = MatSetValues(A,1,&j,1,&i,&v,INSERT_VALUES);CHKERRQ(ierr);
ierr = MatAssemblyBegin(A,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
ierr = MatAssemblyEnd(A,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
ierr = VecAssemblyBegin(B);CHKERRQ(ierr);
ierr = VecAssemblyEnd(B);CHKERRQ(ierr);
printf("\nThe Kershaw matrix:\n\n"); MatView(A,0);
/*
* A Conjugate Gradient method
* with ILU(0) preconditioning
*/
ierr = KSPCreate(comm,&ksp);CHKERRQ(ierr);
ierr = KSPSetOperators(ksp,A,A,DIFFERENT_NONZERO_PATTERN);CHKERRQ(ierr);
ierr = KSPSetType(ksp,KSPCG);CHKERRQ(ierr);
ierr = KSPSetInitialGuessNonzero(ksp,PETSC_TRUE);CHKERRQ(ierr);
/*
* ILU preconditioner;
* The iterative method will break down unless you comment in the SetShift
* line below, or use the -pc_factor_shift_positive_definite option.
* Run the code twice: once as given to see the negative pivot and the
* divergence behaviour, then comment in the Shift line, or add the
* command line option, and see that the pivots are all positive and
* the method converges.
*/
ierr = KSPGetPC(ksp,&pc);CHKERRQ(ierr);
ierr = PCSetType(pc,PCICC);CHKERRQ(ierr);
/* ierr = PCFactorSetShiftType(prec,MAT_SHIFT_POSITIVE_DEFINITE);CHKERRQ(ierr); */
ierr = KSPSetFromOptions(ksp);CHKERRQ(ierr);
ierr = KSPSetUp(ksp);CHKERRQ(ierr);
/*
* Now that the factorisation is done, show the pivots;
* note that the last one is negative. This in itself is not an error,
* but it will make the iterative method diverge.
*/
ierr = PCFactorGetMatrix(pc,&M);CHKERRQ(ierr);
ierr = VecDuplicate(B,&D);CHKERRQ(ierr);
ierr = MatGetDiagonal(M,D);CHKERRQ(ierr);
printf("\nPivots:\n\n"); VecView(D,0);
/*
* Solve the system;
* without the shift this will diverge with
* an indefinite preconditioner
*/
ierr = KSPSolve(ksp,B,X);CHKERRQ(ierr);
ierr = KSPGetConvergedReason(ksp,&reason);CHKERRQ(ierr);
if (reason==KSP_DIVERGED_INDEFINITE_PC) {
printf("\nDivergence because of indefinite preconditioner;\n");
printf("Run the executable again but with -pc_factor_shift_positive_definite option.\n");
} else if (reason<0) {
printf("\nOther kind of divergence: this should not happen.\n");
} else {
ierr = KSPGetIterationNumber(ksp,&its);CHKERRQ(ierr);
printf("\nConvergence in %d iterations.\n",(int)its);
}
printf("\n");
ierr = KSPDestroy(&ksp);CHKERRQ(ierr);
ierr = MatDestroy(&A);CHKERRQ(ierr);
ierr = VecDestroy(&B);CHKERRQ(ierr);
ierr = VecDestroy(&X);CHKERRQ(ierr);
ierr = VecDestroy(&D);CHKERRQ(ierr);
PetscFinalize();
PetscFunctionReturn(0);
}
PetscErrorCode MatSetUpMultiply_MPIAIJ(Mat mat)
{
Mat_MPIAIJ *aij = (Mat_MPIAIJ*)mat->data;
Mat_SeqAIJ *B = (Mat_SeqAIJ*)(aij->B->data);
PetscErrorCode ierr;
PetscInt i,j,*aj = B->j,ec = 0,*garray;
IS from,to;
Vec gvec;
#if defined(PETSC_USE_CTABLE)
PetscTable gid1_lid1;
PetscTablePosition tpos;
PetscInt gid,lid;
#else
PetscInt N = mat->cmap->N,*indices;
#endif
PetscFunctionBegin;
if (!aij->garray) {
#if defined(PETSC_USE_CTABLE)
/* use a table */
ierr = PetscTableCreate(aij->B->rmap->n,mat->cmap->N+1,&gid1_lid1);CHKERRQ(ierr);
for (i=0; i<aij->B->rmap->n; i++) {
for (j=0; j<B->ilen[i]; j++) {
PetscInt data,gid1 = aj[B->i[i] + j] + 1;
ierr = PetscTableFind(gid1_lid1,gid1,&data);CHKERRQ(ierr);
if (!data) {
/* one based table */
ierr = PetscTableAdd(gid1_lid1,gid1,++ec,INSERT_VALUES);CHKERRQ(ierr);
}
}
}
/* form array of columns we need */
ierr = PetscMalloc1(ec+1,&garray);CHKERRQ(ierr);
ierr = PetscTableGetHeadPosition(gid1_lid1,&tpos);CHKERRQ(ierr);
while (tpos) {
ierr = PetscTableGetNext(gid1_lid1,&tpos,&gid,&lid);CHKERRQ(ierr);
gid--;
lid--;
garray[lid] = gid;
}
ierr = PetscSortInt(ec,garray);CHKERRQ(ierr); /* sort, and rebuild */
ierr = PetscTableRemoveAll(gid1_lid1);CHKERRQ(ierr);
for (i=0; i<ec; i++) {
ierr = PetscTableAdd(gid1_lid1,garray[i]+1,i+1,INSERT_VALUES);CHKERRQ(ierr);
}
/* compact out the extra columns in B */
for (i=0; i<aij->B->rmap->n; i++) {
for (j=0; j<B->ilen[i]; j++) {
PetscInt gid1 = aj[B->i[i] + j] + 1;
ierr = PetscTableFind(gid1_lid1,gid1,&lid);CHKERRQ(ierr);
lid--;
aj[B->i[i] + j] = lid;
}
}
aij->B->cmap->n = aij->B->cmap->N = ec;
aij->B->cmap->bs = 1;
ierr = PetscLayoutSetUp((aij->B->cmap));CHKERRQ(ierr);
ierr = PetscTableDestroy(&gid1_lid1);CHKERRQ(ierr);
#else
/* Make an array as long as the number of columns */
/* mark those columns that are in aij->B */
ierr = PetscCalloc1(N+1,&indices);CHKERRQ(ierr);
for (i=0; i<aij->B->rmap->n; i++) {
for (j=0; j<B->ilen[i]; j++) {
if (!indices[aj[B->i[i] + j]]) ec++;
indices[aj[B->i[i] + j]] = 1;
}
}
/* form array of columns we need */
ierr = PetscMalloc1(ec+1,&garray);CHKERRQ(ierr);
ec = 0;
for (i=0; i<N; i++) {
if (indices[i]) garray[ec++] = i;
}
/* make indices now point into garray */
for (i=0; i<ec; i++) {
indices[garray[i]] = i;
}
/* compact out the extra columns in B */
for (i=0; i<aij->B->rmap->n; i++) {
for (j=0; j<B->ilen[i]; j++) {
aj[B->i[i] + j] = indices[aj[B->i[i] + j]];
}
}
aij->B->cmap->n = aij->B->cmap->N = ec;
aij->B->cmap->bs = 1;
ierr = PetscLayoutSetUp((aij->B->cmap));CHKERRQ(ierr);
ierr = PetscFree(indices);CHKERRQ(ierr);
#endif
} else {
garray = aij->garray;
}
if (!aij->lvec) {
/* create local vector that is used to scatter into */
ierr = VecCreateSeq(PETSC_COMM_SELF,ec,&aij->lvec);CHKERRQ(ierr);
} else {
ierr = VecGetSize(aij->lvec,&ec);CHKERRQ(ierr);
}
/* create two temporary Index sets for build scatter gather */
ierr = ISCreateGeneral(((PetscObject)mat)->comm,ec,garray,PETSC_COPY_VALUES,&from);CHKERRQ(ierr);
ierr = ISCreateStride(PETSC_COMM_SELF,ec,0,1,&to);CHKERRQ(ierr);
/* create temporary global vector to generate scatter context */
/* This does not allocate the array's memory so is efficient */
ierr = VecCreateMPIWithArray(PetscObjectComm((PetscObject)mat),1,mat->cmap->n,mat->cmap->N,NULL,&gvec);CHKERRQ(ierr);
/* generate the scatter context */
if (aij->Mvctx_mpi1_flg) {
ierr = VecScatterDestroy(&aij->Mvctx_mpi1);CHKERRQ(ierr);
ierr = VecScatterCreate(gvec,from,aij->lvec,to,&aij->Mvctx_mpi1);CHKERRQ(ierr);
ierr = VecScatterSetType(aij->Mvctx_mpi1,VECSCATTERMPI1);CHKERRQ(ierr);
ierr = PetscLogObjectParent((PetscObject)mat,(PetscObject)aij->Mvctx_mpi1);CHKERRQ(ierr);
} else {
ierr = VecScatterDestroy(&aij->Mvctx);CHKERRQ(ierr);
ierr = VecScatterCreate(gvec,from,aij->lvec,to,&aij->Mvctx);CHKERRQ(ierr);
ierr = PetscLogObjectParent((PetscObject)mat,(PetscObject)aij->Mvctx);CHKERRQ(ierr);
ierr = PetscLogObjectParent((PetscObject)mat,(PetscObject)aij->lvec);CHKERRQ(ierr);
ierr = PetscLogObjectMemory((PetscObject)mat,(ec+1)*sizeof(PetscInt));CHKERRQ(ierr);
}
aij->garray = garray;
ierr = PetscLogObjectParent((PetscObject)mat,(PetscObject)from);CHKERRQ(ierr);
ierr = PetscLogObjectParent((PetscObject)mat,(PetscObject)to);CHKERRQ(ierr);
ierr = ISDestroy(&from);CHKERRQ(ierr);
ierr = ISDestroy(&to);CHKERRQ(ierr);
ierr = VecDestroy(&gvec);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
int main(int argc,char **args)
{
Mat C;
PetscInt i,j,m = 3,n = 3,Ii,J;
PetscErrorCode ierr;
PetscBool flg;
PetscScalar v;
IS perm,iperm;
Vec x,u,b,y;
PetscReal norm,tol=PETSC_SMALL;
MatFactorInfo info;
PetscMPIInt size;
ierr = PetscInitialize(&argc,&args,(char*)0,help);if (ierr) return ierr;
ierr = MPI_Comm_size(PETSC_COMM_WORLD,&size);CHKERRQ(ierr);
if (size != 1) SETERRQ(PETSC_COMM_WORLD,1,"This is a uniprocessor example only!");
ierr = MatCreate(PETSC_COMM_WORLD,&C);CHKERRQ(ierr);
ierr = MatSetSizes(C,PETSC_DECIDE,PETSC_DECIDE,m*n,m*n);CHKERRQ(ierr);
ierr = MatSetFromOptions(C);CHKERRQ(ierr);
ierr = MatSetUp(C);CHKERRQ(ierr);
ierr = PetscOptionsHasName(NULL,NULL,"-symmetric",&flg);CHKERRQ(ierr);
if (flg) { /* Treat matrix as symmetric only if we set this flag */
ierr = MatSetOption(C,MAT_SYMMETRIC,PETSC_TRUE);CHKERRQ(ierr);
ierr = MatSetOption(C,MAT_SYMMETRY_ETERNAL,PETSC_TRUE);CHKERRQ(ierr);
}
/* Create the matrix for the five point stencil, YET AGAIN */
for (i=0; i<m; i++) {
for (j=0; j<n; j++) {
v = -1.0; Ii = j + n*i;
if (i>0) {J = Ii - n; ierr = MatSetValues(C,1,&Ii,1,&J,&v,INSERT_VALUES);CHKERRQ(ierr);}
if (i<m-1) {J = Ii + n; ierr = MatSetValues(C,1,&Ii,1,&J,&v,INSERT_VALUES);CHKERRQ(ierr);}
if (j>0) {J = Ii - 1; ierr = MatSetValues(C,1,&Ii,1,&J,&v,INSERT_VALUES);CHKERRQ(ierr);}
if (j<n-1) {J = Ii + 1; ierr = MatSetValues(C,1,&Ii,1,&J,&v,INSERT_VALUES);CHKERRQ(ierr);}
v = 4.0; ierr = MatSetValues(C,1,&Ii,1,&Ii,&v,INSERT_VALUES);CHKERRQ(ierr);
}
}
ierr = MatAssemblyBegin(C,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
ierr = MatAssemblyEnd(C,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
ierr = MatGetOrdering(C,MATORDERINGRCM,&perm,&iperm);CHKERRQ(ierr);
ierr = MatView(C,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
ierr = ISView(perm,PETSC_VIEWER_STDOUT_SELF);CHKERRQ(ierr);
ierr = VecCreateSeq(PETSC_COMM_SELF,m*n,&u);CHKERRQ(ierr);
ierr = VecSet(u,1.0);CHKERRQ(ierr);
ierr = VecDuplicate(u,&x);CHKERRQ(ierr);
ierr = VecDuplicate(u,&b);CHKERRQ(ierr);
ierr = VecDuplicate(u,&y);CHKERRQ(ierr);
ierr = MatMult(C,u,b);CHKERRQ(ierr);
ierr = VecCopy(b,y);CHKERRQ(ierr);
ierr = VecScale(y,2.0);CHKERRQ(ierr);
ierr = MatNorm(C,NORM_FROBENIUS,&norm);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_SELF,"Frobenius norm of matrix %g\n",(double)norm);CHKERRQ(ierr);
ierr = MatNorm(C,NORM_1,&norm);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_SELF,"One norm of matrix %g\n",(double)norm);CHKERRQ(ierr);
ierr = MatNorm(C,NORM_INFINITY,&norm);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_SELF,"Infinity norm of matrix %g\n",(double)norm);CHKERRQ(ierr);
ierr = MatFactorInfoInitialize(&info);CHKERRQ(ierr);
info.fill = 2.0;
info.dtcol = 0.0;
info.zeropivot = 1.e-14;
info.pivotinblocks = 1.0;
ierr = MatLUFactor(C,perm,iperm,&info);CHKERRQ(ierr);
/* Test MatSolve */
ierr = MatSolve(C,b,x);CHKERRQ(ierr);
ierr = VecView(b,PETSC_VIEWER_STDOUT_SELF);CHKERRQ(ierr);
ierr = VecView(x,PETSC_VIEWER_STDOUT_SELF);CHKERRQ(ierr);
ierr = VecAXPY(x,-1.0,u);CHKERRQ(ierr);
ierr = VecNorm(x,NORM_2,&norm);CHKERRQ(ierr);
if (norm > tol) {
ierr = PetscPrintf(PETSC_COMM_SELF,"MatSolve: Norm of error %g\n",(double)norm);CHKERRQ(ierr);
}
/* Test MatSolveAdd */
ierr = MatSolveAdd(C,b,y,x);CHKERRQ(ierr);
ierr = VecAXPY(x,-1.0,y);CHKERRQ(ierr);
ierr = VecAXPY(x,-1.0,u);CHKERRQ(ierr);
ierr = VecNorm(x,NORM_2,&norm);CHKERRQ(ierr);
if (norm > tol) {
ierr = PetscPrintf(PETSC_COMM_SELF,"MatSolveAdd(): Norm of error %g\n",(double)norm);CHKERRQ(ierr);
}
ierr = ISDestroy(&perm);CHKERRQ(ierr);
ierr = ISDestroy(&iperm);CHKERRQ(ierr);
ierr = VecDestroy(&u);CHKERRQ(ierr);
ierr = VecDestroy(&y);CHKERRQ(ierr);
ierr = VecDestroy(&b);CHKERRQ(ierr);
ierr = VecDestroy(&x);CHKERRQ(ierr);
ierr = MatDestroy(&C);CHKERRQ(ierr);
ierr = PetscFinalize();
return ierr;
}
int main(int argc, char *args[])
{
PFLOTRANMesh data;
Mat Adj; /* The adjacency matrix of the mesh */
PetscInt bs = 3;
PetscScalar values[9],*cc;
PetscMPIInt size;
PetscInt i;
PetscErrorCode ierr;
PetscViewer binaryviewer;
Vec cellCenters;
PetscViewer hdf5viewer;
hid_t file_id, dataset_id, dataspace_id;
herr_t status;
PetscFunctionBegin;
ierr = PetscInitialize(&argc, &args, (char *) 0, help);
ierr = MPI_Comm_size(PETSC_COMM_WORLD, &size);CHKERRQ(ierr);
if (size > 1) SETERRQ(PETSC_ERR_SUP,"This preprocessor runs only on one process");
/* Open Glenn's file */
ierr = PetscViewerCreate(PETSC_COMM_SELF, &hdf5viewer);CHKERRQ(ierr);
ierr = PetscViewerSetType(hdf5viewer, PETSC_VIEWER_HDF5);CHKERRQ(ierr);
ierr = PetscViewerFileSetMode(hdf5viewer, FILE_MODE_READ);CHKERRQ(ierr);
ierr = PetscViewerFileSetName(hdf5viewer, "mesh.h5");CHKERRQ(ierr);
ierr = PetscViewerHDF5GetFileId(hdf5viewer, &file_id);CHKERRQ(ierr);
/* get number of cells and then number of edges */
dataset_id = H5Dopen(file_id, "/Cells/Natural IDs");
dataspace_id = H5Dget_space(dataset_id);
status = H5Sget_simple_extent_dims(dataspace_id, &data.numCells, NULL);if (status < 0) SETERRQ(PETSC_ERR_LIB,"Bad dimension");
status = H5Sclose(dataspace_id);CHKERRQ(status);
status = H5Dclose(dataset_id);CHKERRQ(status);
dataset_id = H5Dopen(file_id, "/Connections/Areas");
dataspace_id = H5Dget_space(dataset_id);
status = H5Sget_simple_extent_dims(dataspace_id, &data.numFaces, NULL);if (status < 0) SETERRQ(PETSC_ERR_LIB,"Bad dimension");
status = H5Sclose(dataspace_id);CHKERRQ(status);
status = H5Dclose(dataset_id);CHKERRQ(status);
ierr = PetscPrintf(PETSC_COMM_SELF, "Number of cells %D Number of faces %D \n",(PetscInt)data.numCells,(PetscInt)data.numFaces);CHKERRQ(ierr);
/* read face data */
ierr = PetscMalloc5(data.numFaces,double,&data.faceAreas,data.numFaces,int,&data.downCells,data.numFaces,double,&data.downX,data.numFaces,double,&data.downY,data.numFaces,double,&data.downZ);CHKERRQ(ierr);
dataset_id = H5Dopen(file_id, "/Connections/Areas");
status = H5Dread(dataset_id, H5T_IEEE_F64LE, H5S_ALL, H5S_ALL, H5P_DEFAULT, data.faceAreas);CHKERRQ(status);
status = H5Dclose(dataset_id);CHKERRQ(status);
dataset_id = H5Dopen(file_id, "/Connections/Downwind Cell IDs");
status = H5Dread(dataset_id, H5T_STD_I32LE, H5S_ALL, H5S_ALL, H5P_DEFAULT, data.downCells);CHKERRQ(status);
status = H5Dclose(dataset_id);CHKERRQ(status);
dataset_id = H5Dopen(file_id, "/Connections/Downwind Distance X");
status = H5Dread(dataset_id, H5T_IEEE_F64LE, H5S_ALL, H5S_ALL, H5P_DEFAULT, data.downX);CHKERRQ(status);
status = H5Dclose(dataset_id);CHKERRQ(status);
dataset_id = H5Dopen(file_id, "/Connections/Downwind Distance Y");
status = H5Dread(dataset_id, H5T_IEEE_F64LE, H5S_ALL, H5S_ALL, H5P_DEFAULT, data.downY);CHKERRQ(status);
status = H5Dclose(dataset_id);CHKERRQ(status);
dataset_id = H5Dopen(file_id, "/Connections/Downwind Distance Z");
status = H5Dread(dataset_id, H5T_IEEE_F64LE, H5S_ALL, H5S_ALL, H5P_DEFAULT, data.downZ);CHKERRQ(status);
status = H5Dclose(dataset_id);CHKERRQ(status);
ierr = PetscMalloc4(data.numFaces,int,&data.upCells,data.numFaces,double,&data.upX,data.numFaces,double,&data.upY,data.numFaces,double,&data.upZ);CHKERRQ(ierr);
dataset_id = H5Dopen(file_id, "/Connections/Upwind Cell IDs");
status = H5Dread(dataset_id, H5T_STD_I32LE, H5S_ALL, H5S_ALL, H5P_DEFAULT, data.upCells);CHKERRQ(status);
status = H5Dclose(dataset_id);CHKERRQ(status);
dataset_id = H5Dopen(file_id, "/Connections/Upwind Distance X");
status = H5Dread(dataset_id, H5T_IEEE_F64LE, H5S_ALL, H5S_ALL, H5P_DEFAULT, data.upX);CHKERRQ(status);
status = H5Dclose(dataset_id);CHKERRQ(status);
dataset_id = H5Dopen(file_id, "/Connections/Upwind Distance Y");
status = H5Dread(dataset_id, H5T_IEEE_F64LE, H5S_ALL, H5S_ALL, H5P_DEFAULT, data.upY);CHKERRQ(status);
status = H5Dclose(dataset_id);CHKERRQ(status);
dataset_id = H5Dopen(file_id, "/Connections/Upwind Distance Z");
status = H5Dread(dataset_id, H5T_IEEE_F64LE, H5S_ALL, H5S_ALL, H5P_DEFAULT, data.upZ);CHKERRQ(status);
status = H5Dclose(dataset_id);CHKERRQ(status);
// Put face data into matrix
ierr = MatCreate(PETSC_COMM_WORLD, &Adj);CHKERRQ(ierr);
ierr = MatSetSizes(Adj, data.numCells*bs, data.numCells*bs, PETSC_DECIDE, PETSC_DECIDE);CHKERRQ(ierr);
ierr = MatSetFromOptions(Adj);CHKERRQ(ierr);
ierr = MatSetType(Adj,MATSEQBAIJ);CHKERRQ(ierr);
ierr = MatSeqBAIJSetPreallocation(Adj, bs, 6,PETSC_NULL);CHKERRQ(ierr);
//ierr = MatSetType(Adj,MATSEQAIJ);CHKERRQ(ierr);
//ierr = MatSeqAIJSetPreallocation(Adj, 6,PETSC_NULL);CHKERRQ(ierr);
for(i = 0; i < data.numFaces; ++i) {
values[0] = data.faceAreas[i];
values[1] = data.downCells[i];
values[2] = data.downX[i];
values[3] = data.downY[i];
values[4] = data.downZ[i];
values[5] = data.upCells[i];
values[6] = data.upX[i];
values[7] = data.upY[i];
values[8] = data.upZ[i];
ierr = MatSetValuesBlocked(Adj, 1, &data.downCells[i], 1, &data.upCells[i], values, INSERT_VALUES);CHKERRQ(ierr);
ierr = MatSetValuesBlocked(Adj, 1, &data.upCells[i], 1, &data.downCells[i], values, INSERT_VALUES);CHKERRQ(ierr);
//ierr = MatSetValues(Adj, 1, &data.downCells[i], 1, &data.upCells[i], values, INSERT_VALUES);CHKERRQ(ierr);
//ierr = MatSetValues(Adj, 1, &data.upCells[i], 1, &data.downCells[i], values, INSERT_VALUES);CHKERRQ(ierr);
}
ierr = MatAssemblyBegin(Adj, MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
ierr = MatAssemblyEnd(Adj, MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
ierr = PetscFree5(data.faceAreas, data.downCells, data.downX, data.downY, data.downZ);CHKERRQ(ierr);
ierr = PetscFree4(data.upCells, data.upX, data.upY, data.upZ);CHKERRQ(ierr);
ierr = PetscViewerBinaryOpen(PETSC_COMM_SELF,"mesh.petsc", FILE_MODE_WRITE,&binaryviewer);CHKERRQ(ierr);
ierr = MatView(Adj, binaryviewer);CHKERRQ(ierr);
ierr = MatDestroy(Adj);CHKERRQ(ierr);
/* read cell information */
ierr = PetscMalloc5(data.numCells,int,&data.cellIds,data.numCells,double,&data.cellVols,data.numCells,double,&data.cellX,data.numCells,double,&data.cellY,data.numCells,double,&data.cellZ);CHKERRQ(ierr);
dataset_id = H5Dopen(file_id, "/Cells/Natural IDs");
status = H5Dread(dataset_id, H5T_STD_I32LE, H5S_ALL, H5S_ALL, H5P_DEFAULT, data.cellIds);CHKERRQ(status);
status = H5Dclose(dataset_id);CHKERRQ(status);
dataset_id = H5Dopen(file_id, "/Cells/Volumes");
status = H5Dread(dataset_id, H5T_IEEE_F64LE, H5S_ALL, H5S_ALL, H5P_DEFAULT, data.cellVols);CHKERRQ(status);
status = H5Dclose(dataset_id);CHKERRQ(status);
dataset_id = H5Dopen(file_id, "/Cells/X-Coordinates");
status = H5Dread(dataset_id, H5T_IEEE_F64LE, H5S_ALL, H5S_ALL, H5P_DEFAULT, data.cellX);CHKERRQ(status);
status = H5Dclose(dataset_id);CHKERRQ(status);
dataset_id = H5Dopen(file_id, "/Cells/Y-Coordinates");
status = H5Dread(dataset_id, H5T_IEEE_F64LE, H5S_ALL, H5S_ALL, H5P_DEFAULT, data.cellY);CHKERRQ(status);
status = H5Dclose(dataset_id);CHKERRQ(status);
dataset_id = H5Dopen(file_id, "/Cells/Z-Coordinates");
status = H5Dread(dataset_id, H5T_IEEE_F64LE, H5S_ALL, H5S_ALL, H5P_DEFAULT, data.cellZ);CHKERRQ(status);
status = H5Dclose(dataset_id);CHKERRQ(status);
ierr = PetscViewerDestroy(hdf5viewer);CHKERRQ(ierr);
/* put cell information into vectors */
ierr = VecCreateSeq(PETSC_COMM_SELF,3*data.numCells,&cellCenters);CHKERRQ(ierr);
ierr = VecSetBlockSize(cellCenters,3);CHKERRQ(ierr);
ierr = VecGetArray(cellCenters,&cc);CHKERRQ(ierr);
for (i=0; i<data.numCells; i++) {
cc[3*i] = data.cellX[i];
cc[3*i+1] = data.cellY[i];
cc[3*i+2] = data.cellZ[i];
}
ierr = VecRestoreArray(cellCenters,&cc);CHKERRQ(ierr);
ierr = VecView(cellCenters,binaryviewer);CHKERRQ(ierr);
ierr = VecGetArray(cellCenters,&cc);CHKERRQ(ierr);
for (i=0; i<data.numCells; i++) {
cc[3*i] = data.cellIds[i];
cc[3*i+1] = data.cellVols[i];
cc[3*i+2] = 0.0;
}
ierr = VecRestoreArray(cellCenters,&cc);CHKERRQ(ierr);
ierr = VecView(cellCenters,binaryviewer);CHKERRQ(ierr);
ierr = PetscFree5(data.cellIds, data.cellVols, data.cellX, data.cellY, data.cellZ);CHKERRQ(ierr);
ierr = VecDestroy(cellCenters);
ierr = PetscViewerDestroy(binaryviewer);CHKERRQ(ierr);
ierr = PetscFinalize();CHKERRQ(ierr);
PetscFunctionReturn(0);
}
PetscInt main(PetscInt argc,char **args)
{
typedef enum {RANDOM, CONSTANT, TANH, NUM_FUNCS} FuncType;
const char *funcNames[NUM_FUNCS] = {"random", "constant", "tanh"};
PetscMPIInt size;
PetscInt n = 10,N,Ny,ndim=4,dim[4],DIM,i;
Vec x,y,z;
PetscScalar s;
PetscRandom rdm;
PetscReal enorm;
PetscInt func=RANDOM;
FuncType function = RANDOM;
PetscBool view = PETSC_FALSE;
PetscErrorCode ierr;
PetscScalar *x_array,*y_array,*z_array;
fftw_plan fplan,bplan;
const ptrdiff_t N0 = 20, N1 = 20;
ptrdiff_t alloc_local, local_n0, local_0_start;
ierr = PetscInitialize(&argc,&args,(char *)0,help);CHKERRQ(ierr);
#if defined(PETSC_USE_COMPLEX)
SETERRQ(PETSC_COMM_WORLD,PETSC_ERR_SUP, "This example requires real numbers");
#endif
ierr = MPI_Comm_size(PETSC_COMM_WORLD, &size);CHKERRQ(ierr);
alloc_local=fftw_mpi_local_size_2d(N0, N1, PETSC_COMM_WORLD,
&local_n0, &local_0_start);
if (size != 1) SETERRQ(PETSC_COMM_WORLD,PETSC_ERR_SUP, "This is a uniprocessor example only!");
ierr = PetscOptionsBegin(PETSC_COMM_WORLD, PETSC_NULL, "FFTW Options", "ex142");CHKERRQ(ierr);
ierr = PetscOptionsEList("-function", "Function type", "ex142", funcNames, NUM_FUNCS, funcNames[function], &func, PETSC_NULL);CHKERRQ(ierr);
ierr = PetscOptionsBool("-vec_view draw", "View the functions", "ex112", view, &view, PETSC_NULL);CHKERRQ(ierr);
function = (FuncType) func;
ierr = PetscOptionsEnd();CHKERRQ(ierr);
for (DIM = 0; DIM < ndim; DIM++){
dim[DIM] = n; /* size of real space vector in DIM-dimension */
}
ierr = PetscRandomCreate(PETSC_COMM_SELF, &rdm);CHKERRQ(ierr);
ierr = PetscRandomSetFromOptions(rdm);CHKERRQ(ierr);
for (DIM = 1; DIM < 5; DIM++){
/* create vectors of length N=dim[0]*dim[1]* ...*dim[DIM-1] */
/*----------------------------------------------------------*/
N = Ny = 1;
for (i = 0; i < DIM-1; i++) {
N *= dim[i];
}
Ny = N; Ny *= 2*(dim[DIM-1]/2 + 1); /* add padding elements to output vector y */
N *= dim[DIM-1];
ierr = PetscPrintf(PETSC_COMM_SELF, "\n %d-D: FFTW on vector of size %d \n",DIM,N);CHKERRQ(ierr);
ierr = VecCreateSeq(PETSC_COMM_SELF,N,&x);CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) x, "Real space vector");CHKERRQ(ierr);
ierr = VecCreateSeq(PETSC_COMM_SELF,Ny,&y);CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) y, "Frequency space vector");CHKERRQ(ierr);
ierr = VecDuplicate(x,&z);CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) z, "Reconstructed vector");CHKERRQ(ierr);
/* Set fftw plan */
/*----------------------------------*/
ierr = VecGetArray(x,&x_array);CHKERRQ(ierr);
ierr = VecGetArray(y,&y_array);CHKERRQ(ierr);
ierr = VecGetArray(z,&z_array);CHKERRQ(ierr);
unsigned int flags = FFTW_ESTIMATE; //or FFTW_MEASURE
/* The data in the in/out arrays is overwritten during FFTW_MEASURE planning, so such planning
should be done before the input is initialized by the user. */
printf("DIM: %d, N %d, Ny %d\n",DIM,N,Ny);
switch (DIM){
case 1:
fplan = fftw_plan_dft_r2c_1d(dim[0], (double *)x_array, (fftw_complex*)y_array, flags);
bplan = fftw_plan_dft_c2r_1d(dim[0], (fftw_complex*)y_array, (double *)z_array, flags);
break;
case 2:
fplan = fftw_plan_dft_r2c_2d(dim[0],dim[1],(double *)x_array, (fftw_complex*)y_array,flags);
bplan = fftw_plan_dft_c2r_2d(dim[0],dim[1],(fftw_complex*)y_array,(double *)z_array,flags);
break;
case 3:
fplan = fftw_plan_dft_r2c_3d(dim[0],dim[1],dim[2],(double *)x_array, (fftw_complex*)y_array,flags);
bplan = fftw_plan_dft_c2r_3d(dim[0],dim[1],dim[2],(fftw_complex*)y_array,(double *)z_array,flags);
break;
default:
fplan = fftw_plan_dft_r2c(DIM,dim,(double *)x_array, (fftw_complex*)y_array,flags);
bplan = fftw_plan_dft_c2r(DIM,dim,(fftw_complex*)y_array,(double *)z_array,flags);
break;
}
ierr = VecRestoreArray(x,&x_array);CHKERRQ(ierr);
ierr = VecRestoreArray(y,&y_array);CHKERRQ(ierr);
ierr = VecRestoreArray(z,&z_array);CHKERRQ(ierr);
/* Initialize Real space vector x:
The data in the in/out arrays is overwritten during FFTW_MEASURE planning, so planning
should be done before the input is initialized by the user.
--------------------------------------------------------*/
if (function == RANDOM) {
ierr = VecSetRandom(x, rdm);CHKERRQ(ierr);
} else if (function == CONSTANT) {
ierr = VecSet(x, 1.0);CHKERRQ(ierr);
} else if (function == TANH) {
ierr = VecGetArray(x, &x_array);CHKERRQ(ierr);
for (i = 0; i < N; ++i) {
x_array[i] = tanh((i - N/2.0)*(10.0/N));
}
ierr = VecRestoreArray(x, &x_array);CHKERRQ(ierr);
}
if (view) {
ierr = VecView(x, PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
}
/* FFT - also test repeated transformation */
/*-------------------------------------------*/
ierr = VecGetArray(x,&x_array);CHKERRQ(ierr);
ierr = VecGetArray(y,&y_array);CHKERRQ(ierr);
ierr = VecGetArray(z,&z_array);CHKERRQ(ierr);
for (i=0; i<3; i++){
/* FFTW_FORWARD */
fftw_execute(fplan);
//printf("\n fout:\n");
//fftw_complex* fout = (fftw_complex*)y_array;
//for (i=0; i<N/2+1; i++) printf("%d (%g %g)\n",i,fout[i][0],fout[i][1]);
/* FFTW_BACKWARD: destroys its input array 'y_array' even for out-of-place transforms! */
fftw_execute(bplan);
}
ierr = VecRestoreArray(x,&x_array);CHKERRQ(ierr);
ierr = VecRestoreArray(y,&y_array);CHKERRQ(ierr);
ierr = VecRestoreArray(z,&z_array);CHKERRQ(ierr);
/* Compare x and z. FFTW computes an unnormalized DFT, thus z = N*x */
/*------------------------------------------------------------------*/
s = 1.0/(PetscReal)N;
ierr = VecScale(z,s);CHKERRQ(ierr);
if (view) {ierr = VecView(x, PETSC_VIEWER_DRAW_WORLD);CHKERRQ(ierr);}
if (view) {ierr = VecView(z, PETSC_VIEWER_DRAW_WORLD);CHKERRQ(ierr);}
ierr = VecAXPY(z,-1.0,x);CHKERRQ(ierr);
ierr = VecNorm(z,NORM_1,&enorm);CHKERRQ(ierr);
if (enorm > 1.e-11){
ierr = PetscPrintf(PETSC_COMM_SELF," Error norm of |x - z| %G\n",enorm);CHKERRQ(ierr);
}
/* free spaces */
fftw_destroy_plan(fplan);
fftw_destroy_plan(bplan);
ierr = VecDestroy(&x);CHKERRQ(ierr);
ierr = VecDestroy(&y);CHKERRQ(ierr);
ierr = VecDestroy(&z);CHKERRQ(ierr);
}
ierr = PetscRandomDestroy(&rdm);CHKERRQ(ierr);
ierr = PetscFinalize();
return 0;
}
PetscInt main(PetscInt argc,char **args)
{
typedef enum {RANDOM, CONSTANT, TANH, NUM_FUNCS} FuncType;
const char *funcNames[NUM_FUNCS] = {"random", "constant", "tanh"};
Mat A;
PetscMPIInt size;
PetscInt n = 10,N,ndim=4,dim[4],DIM,i;
Vec x,y,z;
PetscScalar s;
PetscRandom rdm;
PetscReal enorm;
PetscInt func;
FuncType function = RANDOM;
PetscBool view = PETSC_FALSE;
PetscErrorCode ierr;
ierr = PetscInitialize(&argc,&args,(char *)0,help);CHKERRQ(ierr);
#if !defined(PETSC_USE_COMPLEX)
SETERRQ(PETSC_COMM_WORLD,PETSC_ERR_SUP, "This example requires complex numbers");
#endif
ierr = MPI_Comm_size(PETSC_COMM_WORLD, &size);CHKERRQ(ierr);
if (size != 1) SETERRQ(PETSC_COMM_WORLD,PETSC_ERR_SUP, "This is a uniprocessor example only!");
ierr = PetscOptionsBegin(PETSC_COMM_WORLD, PETSC_NULL, "FFTW Options", "ex112");CHKERRQ(ierr);
ierr = PetscOptionsEList("-function", "Function type", "ex112", funcNames, NUM_FUNCS, funcNames[function], &func, PETSC_NULL);CHKERRQ(ierr);
ierr = PetscOptionsBool("-vec_view draw", "View the functions", "ex112", view, &view, PETSC_NULL);CHKERRQ(ierr);
function = (FuncType) func;
ierr = PetscOptionsEnd();CHKERRQ(ierr);
for (DIM = 0; DIM < ndim; DIM++){
dim[DIM] = n; /* size of transformation in DIM-dimension */
}
ierr = PetscRandomCreate(PETSC_COMM_SELF, &rdm);CHKERRQ(ierr);
ierr = PetscRandomSetFromOptions(rdm);CHKERRQ(ierr);
for (DIM = 1; DIM < 5; DIM++){
for (i = 0, N = 1; i < DIM; i++) N *= dim[i];
ierr = PetscPrintf(PETSC_COMM_SELF, "\n %d-D: FFTW on vector of size %d \n",DIM,N);CHKERRQ(ierr);
/* create FFTW object */
ierr = MatCreateFFT(PETSC_COMM_SELF,DIM,dim,MATFFTW,&A);CHKERRQ(ierr);
/* create vectors of length N=n^DIM */
ierr = MatGetVecs(A,&x,&y);CHKERRQ(ierr);
ierr = MatGetVecs(A,&z,PETSC_NULL);CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) x, "Real space vector");CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) y, "Frequency space vector");CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) z, "Reconstructed vector");CHKERRQ(ierr);
/* set values of space vector x */
if (function == RANDOM) {
ierr = VecSetRandom(x, rdm);CHKERRQ(ierr);
} else if (function == CONSTANT) {
ierr = VecSet(x, 1.0);CHKERRQ(ierr);
} else if (function == TANH) {
PetscScalar *a;
ierr = VecGetArray(x, &a);CHKERRQ(ierr);
for (i = 0; i < N; ++i) {
a[i] = tanh((i - N/2.0)*(10.0/N));
}
ierr = VecRestoreArray(x, &a);CHKERRQ(ierr);
}
if (view) {ierr = VecView(x, PETSC_VIEWER_DRAW_WORLD);CHKERRQ(ierr);}
/* apply FFTW_FORWARD and FFTW_BACKWARD several times on same x, y, and z */
for (i=0; i<3; i++){
ierr = MatMult(A,x,y);CHKERRQ(ierr);
if (view && i == 0) {ierr = VecView(y, PETSC_VIEWER_DRAW_WORLD);CHKERRQ(ierr);}
ierr = MatMultTranspose(A,y,z);CHKERRQ(ierr);
/* compare x and z. FFTW computes an unnormalized DFT, thus z = N*x */
s = 1.0/(PetscReal)N;
ierr = VecScale(z,s);CHKERRQ(ierr);
if (view && i == 0) {ierr = VecView(z, PETSC_VIEWER_DRAW_WORLD);CHKERRQ(ierr);}
ierr = VecAXPY(z,-1.0,x);CHKERRQ(ierr);
ierr = VecNorm(z,NORM_1,&enorm);CHKERRQ(ierr);
if (enorm > 1.e-11){
ierr = PetscPrintf(PETSC_COMM_SELF," Error norm of |x - z| %G\n",enorm);CHKERRQ(ierr);
}
}
/* apply FFTW_FORWARD and FFTW_BACKWARD several times on different x */
for (i=0; i<3; i++){
ierr = VecDestroy(&x);CHKERRQ(ierr);
ierr = VecCreateSeq(PETSC_COMM_SELF,N,&x);CHKERRQ(ierr);
ierr = VecSetRandom(x, rdm);CHKERRQ(ierr);
ierr = MatMult(A,x,y);CHKERRQ(ierr);
ierr = MatMultTranspose(A,y,z);CHKERRQ(ierr);
/* compare x and z. FFTW computes an unnormalized DFT, thus z = N*x */
s = 1.0/(PetscReal)N;
ierr = VecScale(z,s);CHKERRQ(ierr);
if (view && i == 0) {ierr = VecView(z, PETSC_VIEWER_DRAW_WORLD);CHKERRQ(ierr);}
ierr = VecAXPY(z,-1.0,x);CHKERRQ(ierr);
ierr = VecNorm(z,NORM_1,&enorm);CHKERRQ(ierr);
if (enorm > 1.e-11){
ierr = PetscPrintf(PETSC_COMM_SELF," Error norm of new |x - z| %G\n",enorm);CHKERRQ(ierr);
}
}
/* free spaces */
ierr = VecDestroy(&x);CHKERRQ(ierr);
ierr = VecDestroy(&y);CHKERRQ(ierr);
ierr = VecDestroy(&z);CHKERRQ(ierr);
ierr = MatDestroy(&A);CHKERRQ(ierr);
}
ierr = PetscRandomDestroy(&rdm);CHKERRQ(ierr);
ierr = PetscFinalize();
return 0;
}
int main(int argc, char** args){
PetscErrorCode err;
PetscViewer fd = NULL;
Mat invL1 = NULL, invU1 = NULL, invL2 = NULL, invU2 = NULL, H12 = NULL, H21 = NULL;
Vec order = NULL, r = NULL; //, or = NULL; //dimension: n: n1 + n2
Vec seeds = NULL;
// Vec r1 = NULL, q1 = NULL, t1_1 = NULL, t1_2 = NULL, t1_3 = NULL, t1_4 = NULL, t1_5 = NULL; // dimension: n1
// Vec r2 = NULL, q2 = NULL, q_tilda = NULL, t2_1 = NULL, t2_2 = NULL, t2_3 = NULL; // dimension: n2
PetscRandom rand;
PetscLogDouble tic, toc, total_time, time;
PetscInt n, i;
PetscMPIInt rank, size;
PetscInt seed;
PetscScalar c, val;
PetscInt QN = 100;
// Initialize PETSC and MPI
err = PetscInitialize(&argc, &args, (char*) 0, help); CHKERRQ(err);
err = MPI_Comm_size(PETSC_COMM_WORLD, &size); CHKERRQ(err);
err = MPI_Comm_rank(PETSC_COMM_WORLD, &rank); CHKERRQ(err);
err = PetscPrintf(PETSC_COMM_WORLD, "mpi size: %d\n", size); CHKERRQ(err);
// Read matrices and an ordering vector
err = PetscPrintf(PETSC_COMM_WORLD, "Read inputs (invL1, invU1, invL2, invU2, H12, H21, order)\n"); CHKERRQ(err);
err = loadMat("./data/invL1.dat", &invL1, PETSC_COMM_WORLD, MATMPIAIJ, &fd); CHKERRQ(err);
err = checkMat("invL1", invL1); CHKERRQ(err);
err = loadMat("./data/invU1.dat", &invU1, PETSC_COMM_WORLD, MATMPIAIJ, &fd); CHKERRQ(err);
err = checkMat("invU1", invU1); CHKERRQ(err);
err = loadMat("./data/invL2.dat", &invL2, PETSC_COMM_WORLD, MATMPIAIJ, &fd); CHKERRQ(err);
err = checkMat("invL2", invL2); CHKERRQ(err);
err = loadMat("./data/invU2.dat", &invU2, PETSC_COMM_WORLD, MATMPIAIJ, &fd); CHKERRQ(err);
err = checkMat("invU2", invU2); CHKERRQ(err);
err = loadMat("./data/H12.dat", &H12, PETSC_COMM_WORLD, MATMPIAIJ, &fd); CHKERRQ(err);
err = checkMat("H12", H12); CHKERRQ(err);
err = loadMat("./data/H21.dat", &H21, PETSC_COMM_WORLD, MATMPIAIJ, &fd); CHKERRQ(err);
err = checkMat("H21", H21); CHKERRQ(err);
err = loadVec("./data/order.dat", &order, PETSC_COMM_SELF, &fd); CHKERRQ(err); //all processes must have this vector for ordering the result vector.
err = checkVec("order", order); CHKERRQ(err);
// shift -1 for zero-based index
err = VecShift(order, -1); CHKERRQ(err);
err = VecGetSize(order, &n); CHKERRQ(err);
seed = 5;
c = 0.05;
err = PetscTime(&tic); CHKERRQ(err);
//err = BearQueryMat(seed, c, invL1, invU1, invL2, invU2, H12, H21, order); CHKERRQ(err);
//err = PetscTime(&toc); CHKERRQ(err);
//time = toc - tic;
//err = PetscPrintf(PETSC_COMM_WORLD, "running time: %f sec\n", time); CHKERRQ(err);
///* 100 times querying
err = VecCreateSeq(PETSC_COMM_SELF, QN, &seeds); CHKERRQ(err);
err = VecSetFromOptions(seeds); CHKERRQ(err);
err = PetscRandomCreate(PETSC_COMM_WORLD, &rand); CHKERRQ(err);
err = PetscRandomSetSeed(rand, 100); CHKERRQ(err);
err = PetscRandomSetInterval(rand, (PetscScalar) 0, (PetscScalar) n); CHKERRQ(err);
err = PetscRandomSetFromOptions(rand); CHKERRQ(err);
err = VecSetRandom(seeds, rand); CHKERRQ(err);
err = PetscRandomDestroy(&rand); CHKERRQ(err);
seed = 5; //seed is give by user on one-based index
c = 0.05;
i = 0;
err = VecDuplicate(order, &r); CHKERRQ(err);
for(i = 0; i < QN; i++){
err = VecGetValues(seeds, 1, &i, &val);
seed = (PetscInt) val;
//err = PetscPrintf(PETSC_COMM_SELF, "rank: %d, seed: %d\n", rank, seed);
err = PetscTime(&tic); CHKERRQ(err);
err = BearQuery(seed, c, invL1, invU1, invL2, invU2, H12, H21, order, r); CHKERRQ(err);
err = PetscTime(&toc); CHKERRQ(err);
time = toc - tic;
err = PetscPrintf(PETSC_COMM_WORLD, "running time: %f sec\n", time); CHKERRQ(err);
total_time += time;
}
err = PetscPrintf(PETSC_COMM_WORLD, "average running time: %f sec\n", total_time/QN); CHKERRQ(err);
err = VecDestroy(&r);
/* err = MatGetSize(H12, &n1, &n2); CHKERRQ(err);
n = n1 + n2;
err = PetscPrintf(PETSC_COMM_WORLD, "n1: %d, n2: %d\n", n1, n2); CHKERRQ(err);
err = VecCreateMPI(PETSC_COMM_WORLD, PETSC_DECIDE, n, &r); CHKERRQ(err);
err = VecCreateMPI(PETSC_COMM_WORLD, PETSC_DECIDE, n1, &q1); CHKERRQ(err);
err = VecCreateMPI(PETSC_COMM_WORLD, PETSC_DECIDE, n2, &q2); CHKERRQ(err);
err = VecSet(q1, 0); CHKERRQ(err);
err = VecSet(q2, 0); CHKERRQ(err);
seed = seed - 1; // shift -1 for zero-based index
err = VecGetValues(order, 1, &seed, &val); CHKERRQ(err);
oseed = (PetscInt) val;
err = PetscPrintf(PETSC_COMM_WORLD, "Given seed: %d, Reorered seed: %d (0 ~ n-1)\n", seed, oseed); CHKERRQ(err);
if(oseed < n1){
err = VecSetValues(q1, 1, &oseed, &one, INSERT_VALUES); CHKERRQ(err);
}else{
oseed = oseed - n1;
err = VecSetValues(q2, 1, &oseed, &one, INSERT_VALUES); CHKERRQ(err);
//err = printVecSum(q2);
}
err = VecAssemblyBegin(q1); CHKERRQ(err);
err = VecAssemblyBegin(q2); CHKERRQ(err);
err = VecAssemblyEnd(q1); CHKERRQ(err);
err = VecAssemblyEnd(q2); CHKERRQ(err);
err = VecDuplicate(q1, &r1); CHKERRQ(err);
err = VecDuplicate(q1, &t1_1); CHKERRQ(err);
err = VecDuplicate(q1, &t1_2); CHKERRQ(err);
err = VecDuplicate(q1, &t1_3); CHKERRQ(err);
err = VecDuplicate(q1, &t1_4); CHKERRQ(err);
err = VecDuplicate(q1, &t1_5); CHKERRQ(err);
err = VecDuplicate(q2, &r2); CHKERRQ(err);
err = VecDuplicate(q2, &q_tilda); CHKERRQ(err);
err = VecDuplicate(q2, &t2_1); CHKERRQ(err);
err = VecDuplicate(q2, &t2_2); CHKERRQ(err);
err = VecDuplicate(q2, &t2_3); CHKERRQ(err);
// Start matrix-vec multiplications
err = MatMult(invL1, q1, t1_1); CHKERRQ(err);
err = MatMult(invU1, t1_1, t1_2); CHKERRQ(err);
err = MatMult(H21, t1_2, t2_1); CHKERRQ(err);
err = VecAXPBYPCZ(q_tilda, 1.0, -1.0, 0.0, q2, t2_1); CHKERRQ(err);
err = MatMult(invL2, q_tilda, t2_2); CHKERRQ(err);
err = MatMult(invU2, t2_2, r2); CHKERRQ(err);
err = MatMult(H12, r2, t1_3); CHKERRQ(err);
err = VecAXPBYPCZ(t1_4, 1.0, -1.0, 0.0, q1, t1_3); CHKERRQ(err);
err = MatMult(invL1, t1_4, t1_5); CHKERRQ(err);
err = MatMult(invU1, t1_5, r1); CHKERRQ(err);
//err = printVecSum(r1);
//err = VecView(r2, PETSC_VIEWER_STDOUT_WORLD);
// Concatenate r1 and r2
err = VecMerge(r1, r2, r); CHKERRQ(err);
err = VecScale(r, c); CHKERRQ(err);
//err = VecView(r, PETSC_VIEWER_STDOUT_WORLD);
err = VecDuplicate(r, &or); CHKERRQ(err);
err = VecReorder(r, order, or); CHKERRQ(err);
//err = VecView(or, PETSC_VIEWER_STDOUT_WORLD);*/
// Destory matrices and vectors
err = MatDestroy(&invL1); CHKERRQ(err);
err = MatDestroy(&invU1); CHKERRQ(err);
err = MatDestroy(&invL2); CHKERRQ(err);
err = MatDestroy(&invU2); CHKERRQ(err);
err = MatDestroy(&H12); CHKERRQ(err);
err = MatDestroy(&H21); CHKERRQ(err);
err = VecDestroy(&order); CHKERRQ(err);
err = VecDestroy(&r); CHKERRQ(err);
err = VecDestroy(&seeds); CHKERRQ(err);
//err = VecDestroy(&or); CHKERRQ(err);
/* err = VecDestroy(&r1); CHKERRQ(err);
err = VecDestroy(&q1); CHKERRQ(err);
err = VecDestroy(&t1_1); CHKERRQ(err);
err = VecDestroy(&t1_2); CHKERRQ(err);
err = VecDestroy(&t1_3); CHKERRQ(err);
err = VecDestroy(&t1_4); CHKERRQ(err);
err = VecDestroy(&t1_5); CHKERRQ(err);
err = VecDestroy(&r2); CHKERRQ(err);
err = VecDestroy(&q2); CHKERRQ(err);
err = VecDestroy(&q_tilda); CHKERRQ(err);
err = VecDestroy(&t2_1); CHKERRQ(err);
err = VecDestroy(&t2_2); CHKERRQ(err);
err = VecDestroy(&t2_3); CHKERRQ(err);*/
// Finalize
err = PetscFinalize(); CHKERRQ(err);
return 0;
}
int main(int argc,char **args)
{
Vec x,y,b;
Mat A; /* linear system matrix */
Mat sA,sC; /* symmetric part of the matrices */
PetscInt n,mbs=16,bs=1,nz=3,prob=1,i,j,col[3],block, row,Ii,J,n1,lvl;
PetscErrorCode ierr;
PetscMPIInt size;
PetscReal norm2,tol=1.e-10,err[10];
PetscScalar neg_one = -1.0,four=4.0,value[3];
IS perm,cperm;
PetscRandom rdm;
PetscBool reorder = PETSC_FALSE,displ = PETSC_FALSE;
MatFactorInfo factinfo;
PetscBool equal;
PetscBool TestAIJ = PETSC_FALSE,TestBAIJ = PETSC_TRUE;
PetscInt TestShift=0;
ierr = PetscInitialize(&argc,&args,(char*)0,help);if (ierr) return ierr;
ierr = MPI_Comm_size(PETSC_COMM_WORLD,&size);CHKERRQ(ierr);
if (size != 1) SETERRQ(PETSC_COMM_WORLD,1,"This is a uniprocessor example only!");
ierr = PetscOptionsGetInt(NULL,NULL,"-bs",&bs,NULL);CHKERRQ(ierr);
ierr = PetscOptionsGetInt(NULL,NULL,"-mbs",&mbs,NULL);CHKERRQ(ierr);
ierr = PetscOptionsGetBool(NULL,NULL,"-reorder",&reorder,NULL);CHKERRQ(ierr);
ierr = PetscOptionsGetBool(NULL,NULL,"-testaij",&TestAIJ,NULL);CHKERRQ(ierr);
ierr = PetscOptionsGetInt(NULL,NULL,"-testShift",&TestShift,NULL);CHKERRQ(ierr);
ierr = PetscOptionsGetBool(NULL,NULL,"-displ",&displ,NULL);CHKERRQ(ierr);
n = mbs*bs;
if (TestAIJ) { /* A is in aij format */
ierr = MatCreateSeqAIJ(PETSC_COMM_WORLD,n,n,nz,NULL,&A);CHKERRQ(ierr);
TestBAIJ = PETSC_FALSE;
} else { /* A is in baij format */
ierr =MatCreateSeqBAIJ(PETSC_COMM_WORLD,bs,n,n,nz,NULL,&A);CHKERRQ(ierr);
TestAIJ = PETSC_FALSE;
}
/* Assemble matrix */
if (bs == 1) {
ierr = PetscOptionsGetInt(NULL,NULL,"-test_problem",&prob,NULL);CHKERRQ(ierr);
if (prob == 1) { /* tridiagonal matrix */
value[0] = -1.0; value[1] = 2.0; value[2] = -1.0;
for (i=1; i<n-1; i++) {
col[0] = i-1; col[1] = i; col[2] = i+1;
ierr = MatSetValues(A,1,&i,3,col,value,INSERT_VALUES);CHKERRQ(ierr);
}
i = n - 1; col[0]=0; col[1] = n - 2; col[2] = n - 1;
value[0]= 0.1; value[1]=-1; value[2]=2;
ierr = MatSetValues(A,1,&i,3,col,value,INSERT_VALUES);CHKERRQ(ierr);
i = 0; col[0] = 0; col[1] = 1; col[2]=n-1;
value[0] = 2.0; value[1] = -1.0; value[2]=0.1;
ierr = MatSetValues(A,1,&i,3,col,value,INSERT_VALUES);CHKERRQ(ierr);
} else if (prob ==2) { /* matrix for the five point stencil */
n1 = (PetscInt) (PetscSqrtReal((PetscReal)n) + 0.001);
if (n1*n1 - n) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONG,"sqrt(n) must be a positive interger!");
for (i=0; i<n1; i++) {
for (j=0; j<n1; j++) {
Ii = j + n1*i;
if (i>0) {
J = Ii - n1;
ierr = MatSetValues(A,1,&Ii,1,&J,&neg_one,INSERT_VALUES);CHKERRQ(ierr);
}
if (i<n1-1) {
J = Ii + n1;
ierr = MatSetValues(A,1,&Ii,1,&J,&neg_one,INSERT_VALUES);CHKERRQ(ierr);
}
if (j>0) {
J = Ii - 1;
ierr = MatSetValues(A,1,&Ii,1,&J,&neg_one,INSERT_VALUES);CHKERRQ(ierr);
}
if (j<n1-1) {
J = Ii + 1;
ierr = MatSetValues(A,1,&Ii,1,&J,&neg_one,INSERT_VALUES);CHKERRQ(ierr);
}
ierr = MatSetValues(A,1,&Ii,1,&Ii,&four,INSERT_VALUES);CHKERRQ(ierr);
}
}
}
} else { /* bs > 1 */
for (block=0; block<n/bs; block++) {
/* diagonal blocks */
value[0] = -1.0; value[1] = 4.0; value[2] = -1.0;
for (i=1+block*bs; i<bs-1+block*bs; i++) {
col[0] = i-1; col[1] = i; col[2] = i+1;
ierr = MatSetValues(A,1,&i,3,col,value,INSERT_VALUES);CHKERRQ(ierr);
}
i = bs - 1+block*bs; col[0] = bs - 2+block*bs; col[1] = bs - 1+block*bs;
value[0]=-1.0; value[1]=4.0;
ierr = MatSetValues(A,1,&i,2,col,value,INSERT_VALUES);CHKERRQ(ierr);
i = 0+block*bs; col[0] = 0+block*bs; col[1] = 1+block*bs;
value[0]=4.0; value[1] = -1.0;
ierr = MatSetValues(A,1,&i,2,col,value,INSERT_VALUES);CHKERRQ(ierr);
}
/* off-diagonal blocks */
value[0]=-1.0;
for (i=0; i<(n/bs-1)*bs; i++) {
col[0]=i+bs;
ierr = MatSetValues(A,1,&i,1,col,value,INSERT_VALUES);CHKERRQ(ierr);
col[0]=i; row=i+bs;
ierr = MatSetValues(A,1,&row,1,col,value,INSERT_VALUES);CHKERRQ(ierr);
}
}
if (TestShift) {
/* set diagonals in the 0-th block as 0 for testing shift numerical factor */
for (i=0; i<bs; i++) {
row = i; col[0] = i; value[0] = 0.0;
ierr = MatSetValues(A,1,&row,1,col,value,INSERT_VALUES);CHKERRQ(ierr);
}
}
ierr = MatAssemblyBegin(A,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
ierr = MatAssemblyEnd(A,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
/* Test MatConvert */
ierr = MatSetOption(A,MAT_SYMMETRIC,PETSC_TRUE);CHKERRQ(ierr);
ierr = MatConvert(A,MATSEQSBAIJ,MAT_INITIAL_MATRIX,&sA);CHKERRQ(ierr);
ierr = MatMultEqual(A,sA,20,&equal);CHKERRQ(ierr);
if (!equal) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_USER,"A != sA");
/* Test MatGetOwnershipRange() */
ierr = MatGetOwnershipRange(A,&Ii,&J);CHKERRQ(ierr);
ierr = MatGetOwnershipRange(sA,&i,&j);CHKERRQ(ierr);
if (i-Ii || j-J) {
PetscPrintf(PETSC_COMM_SELF,"Error: MatGetOwnershipRange() in MatSBAIJ format\n");CHKERRQ(ierr);
}
/* Vectors */
ierr = PetscRandomCreate(PETSC_COMM_SELF,&rdm);CHKERRQ(ierr);
ierr = PetscRandomSetFromOptions(rdm);CHKERRQ(ierr);
ierr = VecCreateSeq(PETSC_COMM_SELF,n,&x);CHKERRQ(ierr);
ierr = VecDuplicate(x,&b);CHKERRQ(ierr);
ierr = VecDuplicate(x,&y);CHKERRQ(ierr);
ierr = VecSetRandom(x,rdm);CHKERRQ(ierr);
/* Test MatReordering() - not work on sbaij matrix */
if (reorder) {
ierr = MatGetOrdering(A,MATORDERINGRCM,&perm,&cperm);CHKERRQ(ierr);
} else {
ierr = MatGetOrdering(A,MATORDERINGNATURAL,&perm,&cperm);CHKERRQ(ierr);
}
ierr = ISDestroy(&cperm);CHKERRQ(ierr);
/* initialize factinfo */
ierr = MatFactorInfoInitialize(&factinfo);CHKERRQ(ierr);
if (TestShift == 1) {
factinfo.shifttype = (PetscReal)MAT_SHIFT_NONZERO;
factinfo.shiftamount = 0.1;
} else if (TestShift == 2) {
factinfo.shifttype = (PetscReal)MAT_SHIFT_POSITIVE_DEFINITE;
}
/* Test MatCholeskyFactor(), MatICCFactor() */
/*------------------------------------------*/
/* Test aij matrix A */
if (TestAIJ) {
if (displ) {
ierr = PetscPrintf(PETSC_COMM_WORLD,"AIJ: \n");CHKERRQ(ierr);
}
i = 0;
for (lvl=-1; lvl<10; lvl++) {
if (lvl==-1) { /* Cholesky factor */
factinfo.fill = 5.0;
ierr = MatGetFactor(A,MATSOLVERPETSC,MAT_FACTOR_CHOLESKY,&sC);CHKERRQ(ierr);
ierr = MatCholeskyFactorSymbolic(sC,A,perm,&factinfo);CHKERRQ(ierr);
} else { /* incomplete Cholesky factor */
factinfo.fill = 5.0;
factinfo.levels = lvl;
ierr = MatGetFactor(A,MATSOLVERPETSC,MAT_FACTOR_ICC,&sC);CHKERRQ(ierr);
ierr = MatICCFactorSymbolic(sC,A,perm,&factinfo);CHKERRQ(ierr);
}
ierr = MatCholeskyFactorNumeric(sC,A,&factinfo);CHKERRQ(ierr);
ierr = MatMult(A,x,b);CHKERRQ(ierr);
ierr = MatSolve(sC,b,y);CHKERRQ(ierr);
ierr = MatDestroy(&sC);CHKERRQ(ierr);
/* Check the error */
ierr = VecAXPY(y,neg_one,x);CHKERRQ(ierr);
ierr = VecNorm(y,NORM_2,&norm2);CHKERRQ(ierr);
if (displ) {
ierr = PetscPrintf(PETSC_COMM_WORLD," lvl: %D, error: %g\n", lvl,(double)norm2);CHKERRQ(ierr);
}
err[i++] = norm2;
}
}
/* Test baij matrix A */
if (TestBAIJ) {
if (displ) {
ierr = PetscPrintf(PETSC_COMM_WORLD,"BAIJ: \n");CHKERRQ(ierr);
}
i = 0;
for (lvl=-1; lvl<10; lvl++) {
if (lvl==-1) { /* Cholesky factor */
factinfo.fill = 5.0;
ierr = MatGetFactor(A,MATSOLVERPETSC,MAT_FACTOR_CHOLESKY,&sC);CHKERRQ(ierr);
ierr = MatCholeskyFactorSymbolic(sC,A,perm,&factinfo);CHKERRQ(ierr);
} else { /* incomplete Cholesky factor */
factinfo.fill = 5.0;
factinfo.levels = lvl;
ierr = MatGetFactor(A,MATSOLVERPETSC,MAT_FACTOR_ICC,&sC);CHKERRQ(ierr);
ierr = MatICCFactorSymbolic(sC,A,perm,&factinfo);CHKERRQ(ierr);
}
ierr = MatCholeskyFactorNumeric(sC,A,&factinfo);CHKERRQ(ierr);
ierr = MatMult(A,x,b);CHKERRQ(ierr);
ierr = MatSolve(sC,b,y);CHKERRQ(ierr);
ierr = MatDestroy(&sC);CHKERRQ(ierr);
/* Check the error */
ierr = VecAXPY(y,neg_one,x);CHKERRQ(ierr);
ierr = VecNorm(y,NORM_2,&norm2);CHKERRQ(ierr);
if (displ) {
ierr = PetscPrintf(PETSC_COMM_WORLD," lvl: %D, error: %g\n", lvl,(double)norm2);CHKERRQ(ierr);
}
err[i++] = norm2;
}
}
/* Test sbaij matrix sA */
if (displ) {
ierr = PetscPrintf(PETSC_COMM_WORLD,"SBAIJ: \n");CHKERRQ(ierr);
}
i = 0;
for (lvl=-1; lvl<10; lvl++) {
if (lvl==-1) { /* Cholesky factor */
factinfo.fill = 5.0;
ierr = MatGetFactor(sA,MATSOLVERPETSC,MAT_FACTOR_CHOLESKY,&sC);CHKERRQ(ierr);
ierr = MatCholeskyFactorSymbolic(sC,sA,perm,&factinfo);CHKERRQ(ierr);
} else { /* incomplete Cholesky factor */
factinfo.fill = 5.0;
factinfo.levels = lvl;
ierr = MatGetFactor(sA,MATSOLVERPETSC,MAT_FACTOR_ICC,&sC);CHKERRQ(ierr);
ierr = MatICCFactorSymbolic(sC,sA,perm,&factinfo);CHKERRQ(ierr);
}
ierr = MatCholeskyFactorNumeric(sC,sA,&factinfo);CHKERRQ(ierr);
if (lvl==0 && bs==1) { /* Test inplace ICC(0) for sbaij sA - does not work for new datastructure */
/*
Mat B;
ierr = MatDuplicate(sA,MAT_COPY_VALUES,&B);CHKERRQ(ierr);
ierr = MatICCFactor(B,perm,&factinfo);CHKERRQ(ierr);
ierr = MatEqual(sC,B,&equal);CHKERRQ(ierr);
if (!equal) {
SETERRQ(PETSC_COMM_SELF,PETSC_ERR_USER,"in-place Cholesky factor != out-place Cholesky factor");
}
ierr = MatDestroy(&B);CHKERRQ(ierr);
*/
}
ierr = MatMult(sA,x,b);CHKERRQ(ierr);
ierr = MatSolve(sC,b,y);CHKERRQ(ierr);
/* Test MatSolves() */
if (bs == 1) {
Vecs xx,bb;
ierr = VecsCreateSeq(PETSC_COMM_SELF,n,4,&xx);CHKERRQ(ierr);
ierr = VecsDuplicate(xx,&bb);CHKERRQ(ierr);
ierr = MatSolves(sC,bb,xx);CHKERRQ(ierr);
ierr = VecsDestroy(xx);CHKERRQ(ierr);
ierr = VecsDestroy(bb);CHKERRQ(ierr);
}
ierr = MatDestroy(&sC);CHKERRQ(ierr);
/* Check the error */
ierr = VecAXPY(y,neg_one,x);CHKERRQ(ierr);
ierr = VecNorm(y,NORM_2,&norm2);CHKERRQ(ierr);
if (displ) {
ierr = PetscPrintf(PETSC_COMM_WORLD," lvl: %D, error: %g\n", lvl,(double)norm2);CHKERRQ(ierr);
}
err[i] -= norm2;
if (err[i] > tol) SETERRQ2(PETSC_COMM_WORLD,PETSC_ERR_USER," level: %d, err: %g\n", lvl,(double)err[i]);
}
ierr = ISDestroy(&perm);CHKERRQ(ierr);
ierr = MatDestroy(&A);CHKERRQ(ierr);
ierr = MatDestroy(&sA);CHKERRQ(ierr);
ierr = VecDestroy(&x);CHKERRQ(ierr);
ierr = VecDestroy(&y);CHKERRQ(ierr);
ierr = VecDestroy(&b);CHKERRQ(ierr);
ierr = PetscRandomDestroy(&rdm);CHKERRQ(ierr);
ierr = PetscFinalize();
return ierr;
}
int main(int argc,char **argv)
{
Vec p;
PetscScalar *x_ptr;
PetscErrorCode ierr;
PetscMPIInt size;
AppCtx ctx;
Vec lowerb,upperb;
Tao tao;
TaoConvergedReason reason;
KSP ksp;
PC pc;
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Initialize program
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
PetscInitialize(&argc,&argv,NULL,help);
PetscFunctionBeginUser;
ierr = MPI_Comm_size(PETSC_COMM_WORLD,&size);CHKERRQ(ierr);
if (size != 1) SETERRQ(PETSC_COMM_SELF,1,"This is a uniprocessor example only!");
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Set runtime options
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
ierr = PetscOptionsBegin(PETSC_COMM_WORLD,NULL,"Swing equation options","");CHKERRQ(ierr);
{
ctx.beta = 2;
ctx.c = 10000.0;
ctx.u_s = 1.0;
ctx.omega_s = 1.0;
ctx.omega_b = 120.0*PETSC_PI;
ctx.H = 5.0;
ierr = PetscOptionsScalar("-Inertia","","",ctx.H,&ctx.H,NULL);CHKERRQ(ierr);
ctx.D = 5.0;
ierr = PetscOptionsScalar("-D","","",ctx.D,&ctx.D,NULL);CHKERRQ(ierr);
ctx.E = 1.1378;
ctx.V = 1.0;
ctx.X = 0.545;
ctx.Pmax = ctx.E*ctx.V/ctx.X;;
ierr = PetscOptionsScalar("-Pmax","","",ctx.Pmax,&ctx.Pmax,NULL);CHKERRQ(ierr);
ctx.Pm = 0.4;
ierr = PetscOptionsScalar("-Pm","","",ctx.Pm,&ctx.Pm,NULL);CHKERRQ(ierr);
ctx.tf = 0.1;
ctx.tcl = 0.2;
ierr = PetscOptionsReal("-tf","Time to start fault","",ctx.tf,&ctx.tf,NULL);CHKERRQ(ierr);
ierr = PetscOptionsReal("-tcl","Time to end fault","",ctx.tcl,&ctx.tcl,NULL);CHKERRQ(ierr);
}
ierr = PetscOptionsEnd();CHKERRQ(ierr);
/* Create TAO solver and set desired solution method */
ierr = TaoCreate(PETSC_COMM_WORLD,&tao);CHKERRQ(ierr);
ierr = TaoSetType(tao,TAOBLMVM);CHKERRQ(ierr);
/*
Optimization starts
*/
/* Set initial solution guess */
ierr = VecCreateSeq(PETSC_COMM_WORLD,1,&p);CHKERRQ(ierr);
ierr = VecGetArray(p,&x_ptr);CHKERRQ(ierr);
x_ptr[0] = ctx.Pm;
ierr = VecRestoreArray(p,&x_ptr);CHKERRQ(ierr);
ierr = TaoSetInitialVector(tao,p);CHKERRQ(ierr);
/* Set routine for function and gradient evaluation */
ierr = TaoSetObjectiveRoutine(tao,FormFunction,(void *)&ctx);CHKERRQ(ierr);
ierr = TaoSetGradientRoutine(tao,TaoDefaultComputeGradient,(void *)&ctx);CHKERRQ(ierr);
/* Set bounds for the optimization */
ierr = VecDuplicate(p,&lowerb);CHKERRQ(ierr);
ierr = VecDuplicate(p,&upperb);CHKERRQ(ierr);
ierr = VecGetArray(lowerb,&x_ptr);CHKERRQ(ierr);
x_ptr[0] = 0.;
ierr = VecRestoreArray(lowerb,&x_ptr);CHKERRQ(ierr);
ierr = VecGetArray(upperb,&x_ptr);CHKERRQ(ierr);
x_ptr[0] = 1.1;;
ierr = VecRestoreArray(upperb,&x_ptr);CHKERRQ(ierr);
ierr = TaoSetVariableBounds(tao,lowerb,upperb);
/* Check for any TAO command line options */
ierr = TaoSetFromOptions(tao);CHKERRQ(ierr);
ierr = TaoGetKSP(tao,&ksp);CHKERRQ(ierr);
if (ksp) {
ierr = KSPGetPC(ksp,&pc);CHKERRQ(ierr);
ierr = PCSetType(pc,PCNONE);CHKERRQ(ierr);
}
ierr = TaoSetTolerances(tao,1e-15,1e-15,1e-15,1e-15,1e-15);
/* SOLVE THE APPLICATION */
ierr = TaoSolve(tao); CHKERRQ(ierr);
/* Get information on termination */
ierr = TaoGetConvergedReason(tao,&reason);CHKERRQ(ierr);
if (reason <= 0){
ierr=PetscPrintf(MPI_COMM_WORLD, "Try another method! \n");CHKERRQ(ierr);
}
ierr = VecView(p,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
/* Free TAO data structures */
ierr = TaoDestroy(&tao);CHKERRQ(ierr);
ierr = VecDestroy(&p);CHKERRQ(ierr);
ierr = VecDestroy(&lowerb);CHKERRQ(ierr);
ierr = VecDestroy(&upperb);CHKERRQ(ierr);
ierr = PetscFinalize();
return 0;
}
int main(int argc,char **argv)
{
SNES snes; /* nonlinear solver context */
KSP ksp; /* linear solver context */
PC pc; /* preconditioner context */
Vec x,r; /* solution, residual vectors */
Mat J; /* Jacobian matrix */
PetscErrorCode ierr;
PetscInt its;
PetscMPIInt size,rank;
PetscScalar pfive = .5,*xx;
PetscBool flg;
AppCtx user; /* user-defined work context */
IS isglobal,islocal;
PetscInitialize(&argc,&argv,(char *)0,help);
ierr = MPI_Comm_size(PETSC_COMM_WORLD,&size);CHKERRQ(ierr);
ierr = MPI_Comm_rank(PETSC_COMM_WORLD,&rank);CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Create nonlinear solver context
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
ierr = SNESCreate(PETSC_COMM_WORLD,&snes);CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Create matrix and vector data structures; set corresponding routines
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
/*
Create vectors for solution and nonlinear function
*/
ierr = VecCreate(PETSC_COMM_WORLD,&x);CHKERRQ(ierr);
ierr = VecSetSizes(x,PETSC_DECIDE,2);CHKERRQ(ierr);
ierr = VecSetFromOptions(x);CHKERRQ(ierr);
ierr = VecDuplicate(x,&r);CHKERRQ(ierr);
if (size > 1){
ierr = VecCreateSeq(PETSC_COMM_SELF,2,&user.xloc);CHKERRQ(ierr);
ierr = VecDuplicate(user.xloc,&user.rloc);CHKERRQ(ierr);
/* Create the scatter between the global x and local xloc */
ierr = ISCreateStride(MPI_COMM_SELF,2,0,1,&islocal);CHKERRQ(ierr);
ierr = ISCreateStride(MPI_COMM_SELF,2,0,1,&isglobal);CHKERRQ(ierr);
ierr = VecScatterCreate(x,isglobal,user.xloc,islocal,&user.scatter);CHKERRQ(ierr);
ierr = ISDestroy(&isglobal);CHKERRQ(ierr);
ierr = ISDestroy(&islocal);CHKERRQ(ierr);
}
/*
Create Jacobian matrix data structure
*/
ierr = MatCreate(PETSC_COMM_WORLD,&J);CHKERRQ(ierr);
ierr = MatSetSizes(J,PETSC_DECIDE,PETSC_DECIDE,2,2);CHKERRQ(ierr);
ierr = MatSetFromOptions(J);CHKERRQ(ierr);
ierr = MatSetUp(J);CHKERRQ(ierr);
ierr = PetscOptionsHasName(PETSC_NULL,"-hard",&flg);CHKERRQ(ierr);
if (!flg) {
/*
Set function evaluation routine and vector.
*/
ierr = SNESSetFunction(snes,r,FormFunction1,&user);CHKERRQ(ierr);
/*
Set Jacobian matrix data structure and Jacobian evaluation routine
*/
ierr = SNESSetJacobian(snes,J,J,FormJacobian1,PETSC_NULL);CHKERRQ(ierr);
} else {
if (size != 1) SETERRQ(PETSC_COMM_SELF,1,"This case is a uniprocessor example only!");
ierr = SNESSetFunction(snes,r,FormFunction2,PETSC_NULL);CHKERRQ(ierr);
ierr = SNESSetJacobian(snes,J,J,FormJacobian2,PETSC_NULL);CHKERRQ(ierr);
}
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Customize nonlinear solver; set runtime options
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
/*
Set linear solver defaults for this problem. By extracting the
KSP, KSP, and PC contexts from the SNES context, we can then
directly call any KSP, KSP, and PC routines to set various options.
*/
ierr = SNESGetKSP(snes,&ksp);CHKERRQ(ierr);
ierr = KSPGetPC(ksp,&pc);CHKERRQ(ierr);
ierr = PCSetType(pc,PCNONE);CHKERRQ(ierr);
ierr = KSPSetTolerances(ksp,1.e-4,PETSC_DEFAULT,PETSC_DEFAULT,20);CHKERRQ(ierr);
/*
Set SNES/KSP/KSP/PC runtime options, e.g.,
-snes_view -snes_monitor -ksp_type <ksp> -pc_type <pc>
These options will override those specified above as long as
SNESSetFromOptions() is called _after_ any other customization
routines.
*/
ierr = SNESSetFromOptions(snes);CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Evaluate initial guess; then solve nonlinear system
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
if (!flg) {
ierr = VecSet(x,pfive);CHKERRQ(ierr);
} else {
ierr = VecGetArray(x,&xx);CHKERRQ(ierr);
xx[0] = 2.0; xx[1] = 3.0;
ierr = VecRestoreArray(x,&xx);CHKERRQ(ierr);
}
/*
Note: The user should initialize the vector, x, with the initial guess
for the nonlinear solver prior to calling SNESSolve(). In particular,
to employ an initial guess of zero, the user should explicitly set
this vector to zero by calling VecSet().
*/
ierr = SNESSolve(snes,PETSC_NULL,x);CHKERRQ(ierr);
ierr = SNESGetIterationNumber(snes,&its);CHKERRQ(ierr);
if (flg) {
Vec f;
ierr = VecView(x,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
ierr = SNESGetFunction(snes,&f,0,0);CHKERRQ(ierr);
ierr = VecView(r,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
}
ierr = PetscPrintf(PETSC_COMM_WORLD,"number of SNES iterations = %D\n",its);CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Free work space. All PETSc objects should be destroyed when they
are no longer needed.
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
ierr = VecDestroy(&x);CHKERRQ(ierr); ierr = VecDestroy(&r);CHKERRQ(ierr);
ierr = MatDestroy(&J);CHKERRQ(ierr); ierr = SNESDestroy(&snes);CHKERRQ(ierr);
if (size > 1){
ierr = VecDestroy(&user.xloc);CHKERRQ(ierr);
ierr = VecDestroy(&user.rloc);CHKERRQ(ierr);
ierr = VecScatterDestroy(&user.scatter);CHKERRQ(ierr);
}
ierr = PetscFinalize();
return 0;
}
int main(int argc, char **argv)
{
PetscInitialize(&argc, &argv, "wave.opt", help);
int rank;
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
double startTime, endTime;
int Ns = 32;
unsigned int dof = 1;
// double dtratio = 1.0;
DA da; // Underlying DA
Vec rho; // density - elemental scalar
Vec nu; // Lame parameter - lambda - elemental scalar
std::vector < std::vector<Vec> > fBasis; // the scalar activation - nodal scalar
// std::vector<Vec> truth; // the ground truth.
// Initial conditions
Vec initialDisplacement;
Vec initialVelocity;
timeInfo ti;
// get Ns
CHKERRQ ( PetscOptionsGetInt(0,"-Ns", &Ns,0) );
double t0 = 0.0;
double dt = 1.0/(Ns);
double t1 = 1.0;
double nuVal = 1.0;
double beta = 0.0001;
int numParams = 5;
CHKERRQ ( PetscOptionsGetInt(0,"-nump",&numParams,0) );
CHKERRQ ( PetscOptionsGetScalar(0,"-t0",&t0,0) );
CHKERRQ ( PetscOptionsGetScalar(0,"-t1",&t1,0) );
CHKERRQ ( PetscOptionsGetScalar(0,"-dt",&dt,0) );
CHKERRQ ( PetscOptionsGetScalar(0,"-nu",&nuVal,0) );
CHKERRQ ( PetscOptionsGetScalar(0,"-beta",&beta,0) );
// CHKERRQ ( PetscOptionsGetString(PETSC_NULL, "-pn", problemName, PETSC_MAX_PATH_LEN-1, PETSC_NULL));
// Time info for timestepping
ti.start = t0;
ti.stop = t1;
ti.step = dt;
if (!rank) {
std::cout << "Problem size is " << Ns+1 << " spatially and NT = " << (int)ceil(1.0/dt) << std::endl << std::endl;
std::cout << "Number of parameters is " << numParams << std::endl;
}
// create DA
CHKERRQ ( DACreate3d ( PETSC_COMM_WORLD, DA_NONPERIODIC, DA_STENCIL_BOX,
Ns+1, Ns+1, Ns+1, PETSC_DECIDE, PETSC_DECIDE, PETSC_DECIDE,
1, 1, 0, 0, 0, &da) );
massMatrix *Mass = new massMatrix(feMat::PETSC); // Mass Matrix
stiffnessMatrix *Stiffness = new stiffnessMatrix(feMat::PETSC); // Stiffness matrix
waveDamping *Damping = new waveDamping(feMat::PETSC); // Damping Matrix
fdynamicVector *Force = new fdynamicVector(feVec::PETSC); // Force Vector
// create vectors
CHKERRQ( DACreateGlobalVector(da, &rho) );
CHKERRQ( DACreateGlobalVector(da, &nu) );
CHKERRQ( DACreateGlobalVector(da, &initialDisplacement) );
CHKERRQ( DACreateGlobalVector(da, &initialVelocity) );
// Set initial conditions
CHKERRQ( VecSet ( initialDisplacement, 0.0) );
CHKERRQ( VecSet ( initialVelocity, 0.0) );
VecZeroEntries( nu );
VecZeroEntries( rho );
CHKERRQ( VecSet ( nu, nuVal) );
CHKERRQ( VecSet ( rho, 1.0) );
int x, y, z, m, n, p;
int mx,my,mz;
CHKERRQ( DAGetCorners(da, &x, &y, &z, &m, &n, &p) );
CHKERRQ( DAGetInfo(da,0, &mx, &my, &mz, 0,0,0,0,0,0,0) );
double acx,acy,acz;
double hx = 1.0/((double)Ns);
// allocate for temporary buffers ...
// unsigned int elemSize = Ns*Ns*Ns;
// std::cout << "Elem size is " << elemSize << std::endl;
// unsigned int nodeSize = (Ns+1)*(Ns+1)*(Ns+1);
// Now set the activation ...
unsigned int numSteps = (unsigned int)(ceil(( ti.stop - ti.start)/ti.step));
// Vec tauVec;
// PetscScalar ***tauArray;
unsigned int paramTimeSteps = (unsigned int)(ceil(( (double)(numSteps))/ ((double)(2*numParams)) ));
/*
for (int b=0; b<numParams; b++) {
std::vector<Vec> tau;
unsigned int tBegin = paramTimeSteps*b;
unsigned int tEnd = tBegin + numSteps/2; // paramTimeSteps*(b+2);
// std::cout << "For param " << b << ": Time step range is " << tBegin << " -> " << tEnd << std::endl;
for (unsigned int t=0; t<numSteps+1; t++) {
double newTime = (dt*(t-tBegin)*numSteps)/((double)(paramTimeSteps));
// double fff = 0.0;
CHKERRQ( DACreateGlobalVector(da, &tauVec) );
CHKERRQ( VecSet( tauVec, 0.0));
if ( (t>=tBegin) && (t<=tEnd)) {
CHKERRQ(DAVecGetArray(da, tauVec, &tauArray));
for (int k = z; k < z + p ; k++) {
for (int j = y; j < y + n; j++) {
for (int i = x; i < x + m; i++) {
acx = (i)*hx; acy = (j)*hx; acz = (k)*hx;
tauArray[k][j][i] = sin(M_PI*newTime)*cos(2*M_PI*acx)*cos(2*M_PI*acy)*cos(2*M_PI*acz);
}
}
}
CHKERRQ( DAVecRestoreArray ( da, tauVec, &tauArray ) );
}
tau.push_back(tauVec);
}
fBasis.push_back(tau);
}
*/
// std::cout << "Finished setting basis" << std::endl;
/*
// Set initial velocity ...
CHKERRQ(DAVecGetArray(da, initialVelocity, &solArray));
for (int k = z; k < z + p ; k++) {
for (int j = y; j < y + n; j++) {
for (int i = x; i < x + m; i++) {
acx = (i)*hx; acy = (j)*hx; acz = (k)*hx;
solArray[k][j][i] = M_PI*cos(2*M_PI*acx)*cos(2*M_PI*acy)*cos(2*M_PI*acz);
}
}
}
CHKERRQ( DAVecRestoreArray ( da, initialVelocity, &solArray ) );
*/
std::vector<Vec> newF;
Vec alpha;
PetscScalar *avec;
VecCreateSeq(PETSC_COMM_SELF, numParams, &alpha);
/*
VecCreate(PETSC_COMM_WORLD, &alpha);
VecSetSizes(alpha, numParams, PETSC_DECIDE);
VecSetFromOptions(alpha);
*/
VecGetArray(alpha, &avec);
for (int j=0; j<numParams; j++)
avec[j] = 0.5 + 0.5*j;
VecRestoreArray(alpha, &avec);
// getForces(alpha, fBasis, newF);
getForces(alpha, newF, da, ti, numParams);
// Setup Matrices and Force Vector ...
Mass->setProblemDimensions(1.0, 1.0, 1.0);
Mass->setDA(da);
Mass->setDof(dof);
Mass->setNuVec(rho);
Stiffness->setProblemDimensions(1.0, 1.0, 1.0);
Stiffness->setDA(da);
Stiffness->setDof(dof);
Stiffness->setNuVec(nu);
Damping->setAlpha(0.0);
Damping->setBeta(0.00075);
Damping->setMassMatrix(Mass);
Damping->setStiffnessMatrix(Stiffness);
Damping->setDA(da);
Damping->setDof(dof);
// Force Vector
Force->setProblemDimensions(1.0,1.0,1.0);
Force->setDA(da);
Force->setFDynamic(newF);
Force->setTimeInfo(&ti);
// Newmark time stepper ...
newmark *ts = new newmark;
ts->setMassMatrix(Mass);
ts->setDampingMatrix(Damping);
ts->setStiffnessMatrix(Stiffness);
ts->damp(false);
ts->setTimeFrames(1);
ts->storeVec(true);
ts->setAdjoint(false);
ts->setForceVector(Force);
ts->setInitialDisplacement(initialDisplacement);
ts->setInitialVelocity(initialVelocity);
ts->setTimeInfo(&ti);
ts->setAdjoint(false); // set if adjoint or forward
ts->init(); // initialize IMPORTANT
// if (!rank)
// std::cout << RED"Starting initial forward solve"NRM << std::endl;
ts->solve();// solve
// if (!rank)
// std::cout << GRN"Finished with initial forward solve"NRM << std::endl;
std::vector<Vec> solvec = ts->getSolution();
// Now lets check the error ...
// Vec nr;
// concatenateVecs(solvec, nr);
// VecDestroy(nr);
// VecDestroy(gt);
// std::cout << std::endl;
/*************
* INVERSE *
*************/
// True solution is tau ... we want to recover it.
// The observations in this case are, solvec
/* Set very initial guess for the inverse problem*/
// Now can clear memory ...
/*
for (int i=0; i<newF.size(); i++) {
if (newF[i] != NULL) {
VecDestroy(newF[i]);
}
}
newF.clear();
for (int i=0; i<solvec.size(); i++) {
if (solvec[i] != NULL) {
VecDestroy(solvec[i]);
}
}
solvec.clear();
ts->destroy();
VecDestroy(rho);
VecDestroy(nu);
VecDestroy(initialDisplacement);
VecDestroy(initialVelocity);
VecDestroy(alpha);
DADestroy(da);
PetscFinalize();
return 0;
*/
Vec gt, nr;
concatenateVecs(solvec, gt);
Vec guess;
VecDuplicate(alpha, &guess);
VecZeroEntries(guess);
// VecDuplicate(guess, &Out);
// VecZeroEntries(Out);
// double norm;
/*
PetscRandom rctx;
PetscRandomCreate(PETSC_COMM_WORLD, &rctx);
PetscRandomSetFromOptions(rctx);
VecSetRandom(guess, rctx);
VecNorm(guess, NORM_2, &norm);
PetscPrintf(0, "guess norm = %g\n", norm);
*/
// double errnorm;
// double exsolnorm;
// Inverse solver set up
// std::cout << RED"Setting up Inverse Solver"NRM << std::endl;
parametricWaveInverse* hyperInv = new parametricWaveInverse;
// std::cout << GRN"Finished setting up Inverse Solver"NRM << std::endl;
hyperInv->setTimeStepper(ts); // set the timestepper
hyperInv->setForwardInitialConditions(initialDisplacement, initialVelocity);
// std::cout << RED"Setting initial guess"NRM << std::endl;
// hyperInv->setInitialGuess(truth);// set the initial guess
hyperInv->setInitialGuess(guess);// set the initial guess
// std::cout << GRN"Done setting initial guess"NRM << std::endl;
hyperInv->setRegularizationParameter(beta); // set the regularization paramter
hyperInv->setAdjoints(solvec); // set the data for the problem
// hyperInv->setForceBasis(fBasis);
hyperInv->setNumberOfParameter(numParams);
// std::cout << RED"Initializing Inverse Solver"NRM << std::endl;
hyperInv->init(); // initialize the inverse solver
// if (!rank)
// std::cout << RED"Starting Inverse Solve"NRM << std::endl;
startTime = MPI_Wtime();
hyperInv->solve(); // solve
endTime = MPI_Wtime();
// if (!rank)
// std::cout << GRN"FINISHED HESSIAN SOLVE"NRM << std::endl;
hyperInv->getCurrentControl(guess); // get the solution
hyperInv->destroy();
/*
for (int i=0; i<solvec.size(); i++) {
if (solvec[i] != NULL) {
VecDestroy(solvec[i]);
}
}
solvec.clear();
*/
// VecView(guess, 0);
if (!rank)
std::cout << std::endl << "Error Norms " << std::endl;
Vec Err;
double gtNorm, solNorm, errNorm;
VecDuplicate(guess, &Err);
VecWAXPY(Err, -1.0, guess, alpha);
VecNorm(alpha, NORM_2, >Norm);
VecNorm(guess, NORM_2, &solNorm);
VecNorm(Err, NORM_2, &errNorm);
if (!rank) {
std::cout << "The norms are " << gtNorm << ", " << solNorm << ", " << errNorm << std::endl;
std::cout << "Relative error is " << errNorm/gtNorm << std::endl;
}
// Now we shall do another forward solve ...
getForces(guess, newF, da, ti, numParams);
Force->setFDynamic(newF);
ts->setInitialDisplacement(initialDisplacement);
ts->setInitialVelocity(initialVelocity);
ts->setAdjoint(false);
ts->clearMonitor();
ts->solve();
std::vector<Vec> solvec2 = ts->getSolution();
ts->destroy();
concatenateVecs(solvec2, nr);
// Now can clear memory ...
for (int i=0; i<solvec2.size(); i++) {
if (solvec2[i] != NULL) {
VecDestroy(solvec2[i]);
}
}
solvec2.clear();
// Now can clear memory ...
for (int i=0; i<newF.size(); i++) {
if (newF[i] != NULL) {
VecDestroy(newF[i]);
}
}
newF.clear();
/*
for (unsigned int i=0; i<truth.size(); i++) {
VecNorm(truth[i], NORM_2, >Norm);
VecNorm(solvec[i], NORM_2, &solNorm);
VecAXPY(solvec[i], -1.0, truth[i]);
VecNorm(solvec[i], NORM_2, &errNorm);
PetscPrintf(0, "Ground truth at timestep %d is %g, %g, %g\n", i, gtNorm, solNorm, errNorm);
// PetscPrintf(0, "Relative Error at timestep %d is %g\n", i, errNorm/gtNorm);
}
*/
VecNorm(gt, NORM_2, >Norm);
VecAXPY(nr, -1.0, gt);
VecNorm(nr, NORM_2, &errNorm);
if (!rank)
std::cout << "Total Relative error on state is " << errNorm/gtNorm << std::endl;
if (!rank)
std::cout << "Wall time is " << endTime - startTime << std::endl;
VecDestroy(gt);
VecDestroy(nr);
VecDestroy(Err);
VecDestroy(alpha);
VecDestroy(guess);
VecDestroy(rho);
VecDestroy(nu);
VecDestroy(initialDisplacement);
VecDestroy(initialVelocity);
DADestroy(da);
PetscFinalize();
}
PetscErrorCode MatMPIBAIJDiagonalScaleLocalSetUp(Mat inA,Vec scale)
{
Mat_MPIBAIJ *ina = (Mat_MPIBAIJ*) inA->data; /*access private part of matrix */
Mat_SeqBAIJ *B = (Mat_SeqBAIJ*)ina->B->data;
PetscErrorCode ierr;
PetscInt bs = inA->rmap->bs,i,n,nt,j,cstart,cend,no,*garray = ina->garray,*lindices;
PetscInt *r_rmapd,*r_rmapo;
PetscFunctionBegin;
ierr = MatGetOwnershipRange(inA,&cstart,&cend);CHKERRQ(ierr);
ierr = MatGetSize(ina->A,NULL,&n);CHKERRQ(ierr);
ierr = PetscMalloc((inA->rmap->bmapping->n+1)*sizeof(PetscInt),&r_rmapd);CHKERRQ(ierr);
ierr = PetscMemzero(r_rmapd,inA->rmap->bmapping->n*sizeof(PetscInt));CHKERRQ(ierr);
nt = 0;
for (i=0; i<inA->rmap->bmapping->n; i++) {
if (inA->rmap->bmapping->indices[i]*bs >= cstart && inA->rmap->bmapping->indices[i]*bs < cend) {
nt++;
r_rmapd[i] = inA->rmap->bmapping->indices[i] + 1;
}
}
if (nt*bs != n) SETERRQ2(PETSC_COMM_SELF,PETSC_ERR_PLIB,"Hmm nt*bs %D n %D",nt*bs,n);
ierr = PetscMalloc((n+1)*sizeof(PetscInt),&uglyrmapd);CHKERRQ(ierr);
for (i=0; i<inA->rmap->bmapping->n; i++) {
if (r_rmapd[i]) {
for (j=0; j<bs; j++) {
uglyrmapd[(r_rmapd[i]-1)*bs+j-cstart] = i*bs + j;
}
}
}
ierr = PetscFree(r_rmapd);CHKERRQ(ierr);
ierr = VecCreateSeq(PETSC_COMM_SELF,n,&uglydd);CHKERRQ(ierr);
ierr = PetscMalloc((ina->Nbs+1)*sizeof(PetscInt),&lindices);CHKERRQ(ierr);
ierr = PetscMemzero(lindices,ina->Nbs*sizeof(PetscInt));CHKERRQ(ierr);
for (i=0; i<B->nbs; i++) {
lindices[garray[i]] = i+1;
}
no = inA->rmap->bmapping->n - nt;
ierr = PetscMalloc((inA->rmap->bmapping->n+1)*sizeof(PetscInt),&r_rmapo);CHKERRQ(ierr);
ierr = PetscMemzero(r_rmapo,inA->rmap->bmapping->n*sizeof(PetscInt));CHKERRQ(ierr);
nt = 0;
for (i=0; i<inA->rmap->bmapping->n; i++) {
if (lindices[inA->rmap->bmapping->indices[i]]) {
nt++;
r_rmapo[i] = lindices[inA->rmap->bmapping->indices[i]];
}
}
if (nt > no) SETERRQ2(PETSC_COMM_SELF,PETSC_ERR_PLIB,"Hmm nt %D no %D",nt,n);
ierr = PetscFree(lindices);CHKERRQ(ierr);
ierr = PetscMalloc((nt*bs+1)*sizeof(PetscInt),&uglyrmapo);CHKERRQ(ierr);
for (i=0; i<inA->rmap->bmapping->n; i++) {
if (r_rmapo[i]) {
for (j=0; j<bs; j++) {
uglyrmapo[(r_rmapo[i]-1)*bs+j] = i*bs + j;
}
}
}
ierr = PetscFree(r_rmapo);CHKERRQ(ierr);
ierr = VecCreateSeq(PETSC_COMM_SELF,nt*bs,&uglyoo);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
PetscErrorCode MatSetUpMultiply_MPIBAIJ(Mat mat)
{
Mat_MPIBAIJ *baij = (Mat_MPIBAIJ*)mat->data;
Mat_SeqBAIJ *B = (Mat_SeqBAIJ*)(baij->B->data);
PetscErrorCode ierr;
PetscInt i,j,*aj = B->j,ec = 0,*garray;
PetscInt bs = mat->rmap->bs,*stmp;
IS from,to;
Vec gvec;
#if defined(PETSC_USE_CTABLE)
PetscTable gid1_lid1;
PetscTablePosition tpos;
PetscInt gid,lid;
#else
PetscInt Nbs = baij->Nbs,*indices;
#endif
PetscFunctionBegin;
#if defined(PETSC_USE_CTABLE)
/* use a table - Mark Adams */
ierr = PetscTableCreate(B->mbs,baij->Nbs+1,&gid1_lid1);CHKERRQ(ierr);
for (i=0; i<B->mbs; i++) {
for (j=0; j<B->ilen[i]; j++) {
PetscInt data,gid1 = aj[B->i[i]+j] + 1;
ierr = PetscTableFind(gid1_lid1,gid1,&data);CHKERRQ(ierr);
if (!data) {
/* one based table */
ierr = PetscTableAdd(gid1_lid1,gid1,++ec,INSERT_VALUES);CHKERRQ(ierr);
}
}
}
/* form array of columns we need */
ierr = PetscMalloc((ec+1)*sizeof(PetscInt),&garray);CHKERRQ(ierr);
ierr = PetscTableGetHeadPosition(gid1_lid1,&tpos);CHKERRQ(ierr);
while (tpos) {
ierr = PetscTableGetNext(gid1_lid1,&tpos,&gid,&lid);CHKERRQ(ierr);
gid--; lid--;
garray[lid] = gid;
}
ierr = PetscSortInt(ec,garray);CHKERRQ(ierr);
ierr = PetscTableRemoveAll(gid1_lid1);CHKERRQ(ierr);
for (i=0; i<ec; i++) {
ierr = PetscTableAdd(gid1_lid1,garray[i]+1,i+1,INSERT_VALUES);CHKERRQ(ierr);
}
/* compact out the extra columns in B */
for (i=0; i<B->mbs; i++) {
for (j=0; j<B->ilen[i]; j++) {
PetscInt gid1 = aj[B->i[i] + j] + 1;
ierr = PetscTableFind(gid1_lid1,gid1,&lid);CHKERRQ(ierr);
lid--;
aj[B->i[i]+j] = lid;
}
}
B->nbs = ec;
baij->B->cmap->n = baij->B->cmap->N = ec*mat->rmap->bs;
ierr = PetscLayoutSetUp((baij->B->cmap));CHKERRQ(ierr);
ierr = PetscTableDestroy(&gid1_lid1);CHKERRQ(ierr);
#else
/* Make an array as long as the number of columns */
/* mark those columns that are in baij->B */
ierr = PetscMalloc((Nbs+1)*sizeof(PetscInt),&indices);CHKERRQ(ierr);
ierr = PetscMemzero(indices,Nbs*sizeof(PetscInt));CHKERRQ(ierr);
for (i=0; i<B->mbs; i++) {
for (j=0; j<B->ilen[i]; j++) {
if (!indices[aj[B->i[i] + j]]) ec++;
indices[aj[B->i[i] + j]] = 1;
}
}
/* form array of columns we need */
ierr = PetscMalloc((ec+1)*sizeof(PetscInt),&garray);CHKERRQ(ierr);
ec = 0;
for (i=0; i<Nbs; i++) {
if (indices[i]) {
garray[ec++] = i;
}
}
/* make indices now point into garray */
for (i=0; i<ec; i++) {
indices[garray[i]] = i;
}
/* compact out the extra columns in B */
for (i=0; i<B->mbs; i++) {
for (j=0; j<B->ilen[i]; j++) {
aj[B->i[i] + j] = indices[aj[B->i[i] + j]];
}
}
B->nbs = ec;
baij->B->cmap->n = baij->B->cmap->N = ec*mat->rmap->bs;
ierr = PetscLayoutSetUp((baij->B->cmap));CHKERRQ(ierr);
ierr = PetscFree(indices);CHKERRQ(ierr);
#endif
/* create local vector that is used to scatter into */
ierr = VecCreateSeq(PETSC_COMM_SELF,ec*bs,&baij->lvec);CHKERRQ(ierr);
/* create two temporary index sets for building scatter-gather */
ierr = ISCreateBlock(PETSC_COMM_SELF,bs,ec,garray,PETSC_COPY_VALUES,&from);CHKERRQ(ierr);
ierr = PetscMalloc((ec+1)*sizeof(PetscInt),&stmp);CHKERRQ(ierr);
for (i=0; i<ec; i++) stmp[i] = i;
ierr = ISCreateBlock(PETSC_COMM_SELF,bs,ec,stmp,PETSC_OWN_POINTER,&to);CHKERRQ(ierr);
/* create temporary global vector to generate scatter context */
ierr = VecCreateMPIWithArray(PetscObjectComm((PetscObject)mat),1,mat->cmap->n,mat->cmap->N,NULL,&gvec);CHKERRQ(ierr);
ierr = VecScatterCreate(gvec,from,baij->lvec,to,&baij->Mvctx);CHKERRQ(ierr);
ierr = PetscLogObjectParent(mat,baij->Mvctx);CHKERRQ(ierr);
ierr = PetscLogObjectParent(mat,baij->lvec);CHKERRQ(ierr);
ierr = PetscLogObjectParent(mat,from);CHKERRQ(ierr);
ierr = PetscLogObjectParent(mat,to);CHKERRQ(ierr);
baij->garray = garray;
ierr = PetscLogObjectMemory(mat,(ec+1)*sizeof(PetscInt));CHKERRQ(ierr);
ierr = ISDestroy(&from);CHKERRQ(ierr);
ierr = ISDestroy(&to);CHKERRQ(ierr);
ierr = VecDestroy(&gvec);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
uses block index sets\n\n";
#include <petscvec.h>
#undef __FUNCT__
#define __FUNCT__ "main"
int main(int argc,char **argv)
{
PetscErrorCode ierr;
PetscInt bs = 1,n = 5,ix0[3] = {5,7,9},ix1[3] = {2,3,4},i,iy0[3] = {1,2,4},iy1[3] = {0,1,3};
PetscMPIInt size,rank;
PetscScalar value;
Vec x,y;
IS isx,isy;
VecScatter ctx = 0,newctx;
ierr = PetscInitialize(&argc,&argv,(char*)0,help);CHKERRQ(ierr);
ierr = MPI_Comm_size(PETSC_COMM_WORLD,&size);CHKERRQ(ierr);
ierr = MPI_Comm_rank(PETSC_COMM_WORLD,&rank);CHKERRQ(ierr);
if (size != 2) SETERRQ(PETSC_COMM_SELF,1,"Must run with 2 processors");
ierr = PetscOptionsGetInt(PETSC_NULL,"-bs",&bs,PETSC_NULL);CHKERRQ(ierr);
n = bs*n;
/* create two vectors */
ierr = VecCreate(PETSC_COMM_WORLD,&x);CHKERRQ(ierr);
ierr = VecSetSizes(x,PETSC_DECIDE,size*n);CHKERRQ(ierr);
ierr = VecSetFromOptions(x);CHKERRQ(ierr);
ierr = VecCreateSeq(PETSC_COMM_SELF,n,&y);CHKERRQ(ierr);
/* create two index sets */
if (!rank) {
ierr = ISCreateBlock(PETSC_COMM_SELF,bs,3,ix0,PETSC_COPY_VALUES,&isx);CHKERRQ(ierr);
ierr = ISCreateBlock(PETSC_COMM_SELF,bs,3,iy0,PETSC_COPY_VALUES,&isy);CHKERRQ(ierr);
} else {
ierr = ISCreateBlock(PETSC_COMM_SELF,bs,3,ix1,PETSC_COPY_VALUES,&isx);CHKERRQ(ierr);
ierr = ISCreateBlock(PETSC_COMM_SELF,bs,3,iy1,PETSC_COPY_VALUES,&isy);CHKERRQ(ierr);
}
/* fill local part of parallel vector */
for (i=n*rank; i<n*(rank+1); i++) {
value = (PetscScalar) i;
ierr = VecSetValues(x,1,&i,&value,INSERT_VALUES);CHKERRQ(ierr);
}
ierr = VecAssemblyBegin(x);CHKERRQ(ierr);
ierr = VecAssemblyEnd(x);CHKERRQ(ierr);
ierr = VecView(x,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
/* fill local part of parallel vector */
for (i=0; i<n; i++) {
value = -(PetscScalar) (i + 100*rank);
ierr = VecSetValues(y,1,&i,&value,INSERT_VALUES);CHKERRQ(ierr);
}
ierr = VecAssemblyBegin(y);CHKERRQ(ierr);
ierr = VecAssemblyEnd(y);CHKERRQ(ierr);
ierr = VecScatterCreate(x,isx,y,isy,&ctx);CHKERRQ(ierr);
ierr = VecScatterCopy(ctx,&newctx);CHKERRQ(ierr);
ierr = VecScatterDestroy(&ctx);CHKERRQ(ierr);
ierr = VecScatterBegin(newctx,y,x,INSERT_VALUES,SCATTER_REVERSE);CHKERRQ(ierr);
ierr = VecScatterEnd(newctx,y,x,INSERT_VALUES,SCATTER_REVERSE);CHKERRQ(ierr);
ierr = VecScatterDestroy(&newctx);CHKERRQ(ierr);
ierr = VecView(x,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
ierr = ISDestroy(&isx);CHKERRQ(ierr);
ierr = ISDestroy(&isy);CHKERRQ(ierr);
ierr = VecDestroy(&x);CHKERRQ(ierr);
ierr = VecDestroy(&y);CHKERRQ(ierr);
ierr = PetscFinalize();
return 0;
}
int main(int argc,char **argv)
{
PetscErrorCode ierr;
PetscMPIInt size,rank;
PetscInt n = 5,i,*blks,bs = 1,m = 2;
PetscScalar value;
Vec x,y;
IS is1,is2;
VecScatter ctx = 0;
PetscViewer sviewer;
ierr = PetscInitialize(&argc,&argv,(char*)0,help);if (ierr) return ierr;
ierr = PetscOptionsGetInt(NULL,NULL,"-n",&n,NULL);CHKERRQ(ierr);
ierr = PetscOptionsGetInt(NULL,NULL,"-bs",&bs,NULL);CHKERRQ(ierr);
ierr = MPI_Comm_size(PETSC_COMM_WORLD,&size);CHKERRQ(ierr);
ierr = MPI_Comm_rank(PETSC_COMM_WORLD,&rank);CHKERRQ(ierr);
/* create two vectors */
ierr = VecCreate(PETSC_COMM_WORLD,&x);CHKERRQ(ierr);
ierr = VecSetSizes(x,PETSC_DECIDE,size*bs*n);CHKERRQ(ierr);
ierr = VecSetFromOptions(x);CHKERRQ(ierr);
/* create two index sets */
if (rank < size-1) m = n + 2;
else m = n;
ierr = PetscMalloc1(m,&blks);CHKERRQ(ierr);
blks[0] = n*rank;
for (i=1; i<m; i++) blks[i] = blks[i-1] + 1;
ierr = ISCreateBlock(PETSC_COMM_SELF,bs,m,blks,PETSC_COPY_VALUES,&is1);CHKERRQ(ierr);
ierr = PetscFree(blks);CHKERRQ(ierr);
ierr = VecCreateSeq(PETSC_COMM_SELF,bs*m,&y);CHKERRQ(ierr);
ierr = ISCreateStride(PETSC_COMM_SELF,bs*m,0,1,&is2);CHKERRQ(ierr);
/* each processor inserts the entire vector */
/* this is redundant but tests assembly */
for (i=0; i<bs*n*size; i++) {
value = (PetscScalar) i;
ierr = VecSetValues(x,1,&i,&value,INSERT_VALUES);CHKERRQ(ierr);
}
ierr = VecAssemblyBegin(x);CHKERRQ(ierr);
ierr = VecAssemblyEnd(x);CHKERRQ(ierr);
ierr = VecView(x,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
ierr = VecScatterCreate(x,is1,y,is2,&ctx);CHKERRQ(ierr);
ierr = VecScatterBegin(ctx,x,y,INSERT_VALUES,SCATTER_FORWARD);CHKERRQ(ierr);
ierr = VecScatterEnd(ctx,x,y,INSERT_VALUES,SCATTER_FORWARD);CHKERRQ(ierr);
ierr = PetscViewerASCIIPushSynchronized(PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
ierr = PetscViewerASCIISynchronizedPrintf(PETSC_VIEWER_STDOUT_WORLD,"----\n");CHKERRQ(ierr);
ierr = PetscViewerGetSubViewer(PETSC_VIEWER_STDOUT_WORLD,PETSC_COMM_SELF,&sviewer);CHKERRQ(ierr);
ierr = VecView(y,sviewer);CHKERRQ(ierr); fflush(stdout);
ierr = PetscViewerRestoreSubViewer(PETSC_VIEWER_STDOUT_WORLD,PETSC_COMM_SELF,&sviewer);CHKERRQ(ierr);
ierr = PetscViewerFlush(PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
ierr = PetscViewerASCIIPopSynchronized(PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
ierr = VecScatterDestroy(&ctx);CHKERRQ(ierr);
ierr = VecDestroy(&x);CHKERRQ(ierr);
ierr = VecDestroy(&y);CHKERRQ(ierr);
ierr = ISDestroy(&is1);CHKERRQ(ierr);
ierr = ISDestroy(&is2);CHKERRQ(ierr);
ierr = PetscFinalize();
return ierr;
}
int main(int argc,char **args)
{
PetscInt rank,size,npt;
PetscErrorCode ierr;
Vec x,y0,tempvec, *vinda,*vindb,*vindc;
PetscInt i,j,k,l,n,p,m,m2,pmax,puse,Istart,Iend,localsize,niter;
PetscScalar dx,dy,dx2,dy2;
PetscScalar *Mixnorm;
PetscInt iter,*iterind,*nind;
FILE *fidoutput;
char fname[50];
PetscViewer socketviewer;
PetscInt withMatlab;
PetscTruth Matlabflag;
PetscLogDouble v1,v2,elapsed_time;
PetscInitialize(&argc,&args,(char *)0,help);
MPI_Comm_size(PETSC_COMM_WORLD,&size);
MPI_Comm_rank(PETSC_COMM_WORLD,&rank);
ierr = PetscPrintf(PETSC_COMM_WORLD,"\nPETSC: Petsc Initializes successfully! \n");
ierr = PetscPrintf(PETSC_COMM_WORLD,"PETSC: comm_size is %d \n", size);
ierr = PetscOptionsGetInt(PETSC_NULL,"-withMatlab",&withMatlab,&Matlabflag);CHKERRQ(ierr);
if (Matlabflag == PETSC_FALSE){withMatlab = 0;}else{withMatlab = 1;}
if(withMatlab==1){
// Rank 0 connects to socket, use default socket
PetscViewerSocketOpen(PETSC_COMM_WORLD,0,PETSC_DEFAULT,&socketviewer);
ierr = PetscPrintf(PETSC_COMM_WORLD,"PETSC: socket opened! \n");CHKERRQ(ierr);
// Receive n from Matlab
IntReceive(socketviewer, &nind);
n = *nind;
// Receive iter from Matlab
IntReceive(socketviewer, &iterind);
iter = *iterind;
}else{
ierr = PetscOptionsGetInt(PETSC_NULL,"-ngrid",&n,PETSC_NULL);CHKERRQ(ierr);
ierr = PetscOptionsGetInt(PETSC_NULL,"-niter",&iter,PETSC_NULL);CHKERRQ(ierr);
}
/////////////////////////////////////////////////////////////////////////////////////
ierr = PetscPrintf(PETSC_COMM_WORLD,"PETSC: number of grid is %d \n", n);
ierr = PetscPrintf(PETSC_COMM_WORLD,"PETSC: number of iteration is %d \n", iter);
Mixnorm = malloc(iter*sizeof(PetscScalar));
dx = 1.0/n;
dy = 1.0/n;
dx2 = dx/2-dx/1e6;
dy2 = dy/2-dy/1e6;
npt = 5;
pmax = 4e6;
puse = pmax;
ierr = PetscPrintf(PETSC_COMM_WORLD,"PETSC: estimated buffer size (per processer) %f Mbytes \n", pmax*1.0/1e6*8*16 );
ierr = PetscPrintf(PETSC_COMM_WORLD,"PETSC: estimated variable size %f Mbytes\n", 1.0*n*n/1e6*8*2);
/////////////////////////////////////////////////////////////////////////////////////
ierr = VecCreateMPI(PETSC_COMM_WORLD,PETSC_DECIDE ,n,&tempvec);CHKERRQ(ierr);
ierr = VecGetOwnershipRange(tempvec,&Istart,&Iend);CHKERRQ(ierr);
localsize = Iend-Istart;
ierr = VecDestroy(tempvec);CHKERRQ(ierr);
/////////////////////////////////////////////////////////////////////////////////////
// Create initial vector
Vec x0;
PetscScalar *x0array;
x0array = malloc((localsize)*n*sizeof(PetscScalar));
k = 0;
for(i=Istart;i<Iend;i++){
for(j=0;j<n;j++){
*(x0array+k) = cos(2*M_PI*(dx/2+i*dx));
//*(x0array+k) = cos(2*M_PI*(dy/2+j*dy));
k++;
}
}
ierr = VecCreateMPIWithArray(PETSC_COMM_WORLD,n*localsize,PETSC_DECIDE,x0array,&x0);CHKERRQ(ierr);
ierr = VecDuplicate(x0,&x);CHKERRQ(ierr);
ierr = VecCreateSeq(PETSC_COMM_SELF,pmax*npt,&y0);CHKERRQ(ierr);
ierr = VecNorm(x0,NORM_2,Mixnorm); CHKERRQ(ierr);
PetscPrintf(PETSC_COMM_WORLD,"PETSC: initial norm= %f \n",*(Mixnorm+0)/n );
///////////////////////////////////////////////////////////////////////////
// Map Center Points
PetscInt *NzindJ,*idx,*idy,*idp;
PetscScalar *CenterX,*CenterY,*VecVal,*pty;
PetscScalar *ShiftX,*ShiftY,CX,CY, *yarray;
IS isx,isy;
VecScatter ctx;
CenterX = malloc(npt*sizeof(PetscScalar));
CenterY = malloc(npt*sizeof(PetscScalar));
ShiftX = malloc(npt*sizeof(PetscScalar));
ShiftY = malloc(npt*sizeof(PetscScalar));
VecVal = malloc(npt*sizeof(PetscScalar));
yarray = malloc(pmax*sizeof(PetscScalar));
NzindJ = malloc(pmax*npt*sizeof(PetscInt));
idx = malloc(pmax*npt*sizeof(PetscInt));
idy = malloc(pmax*npt*sizeof(PetscInt));
idp = malloc(pmax*sizeof(PetscInt));
*(ShiftX+0) = 0;
*(ShiftY+0) = 0;
*(ShiftX+1) = -dx2;
*(ShiftY+1) = -dy2;
*(ShiftX+2) = dx2;
*(ShiftY+2) = -dy2;
*(ShiftX+3) = -dx2;
*(ShiftY+3) = dy2;
*(ShiftX+4) = dy2;
*(ShiftY+4) = dx2;
//*(ShiftX+5) = 0;
//*(ShiftY+5) = -dy2;
//*(ShiftX+6) = -dx2;
//*(ShiftY+6) = 0;
//*(ShiftX+7) = dx2;
//*(ShiftY+7) = 0;
//*(ShiftX+8) = 0;
//*(ShiftY+9) = dy2;
for(i=0;i<npt*pmax;i++){ *(idy+i)=i; }
ISCreateGeneralWithArray(PETSC_COMM_SELF,npt*pmax,idy,&isy);
vinda = &x0;
vindb = &x;
sprintf(fname, "mixnorm_%d_%d",n,iter);
ierr =PetscPrintf(PETSC_COMM_WORLD,"\n iter norm time unit time\n");CHKERRQ(ierr);
ierr =PetscFOpen(PETSC_COMM_WORLD,fname,"w",&fidoutput);CHKERRQ(ierr);
for(niter=0;niter<iter;niter++){
ierr = PetscGetTime(&v1);CHKERRQ(ierr);
l = 0; p = 0;
if (n*localsize-l<=pmax){puse = n*localsize-l;}else{puse=pmax;}
for(i=Istart;i<Iend;i++){
for(j=0;j<n;j++){
CX = dx2+i*dx;
CY = dy2+j*dy;
for(k=0;k<npt;k++){
*(CenterX+k) = CX + *(ShiftX+k);
*(CenterY+k) = CY + *(ShiftY+k);
InverseStandardMap((CenterX+k),(CenterY+k));
*(NzindJ+p*npt +k) = floor(*(CenterX+k)*n)*n + floor(*(CenterY+k)*n);
}
*(idp+p) = Istart*n+ l;
if(p>=puse-1){
ierr = ISCreateGeneralWithArray(PETSC_COMM_WORLD,npt*puse,NzindJ,&isx);CHKERRQ(ierr);
for(m=0;m<npt*puse;m++){ *(idy+m)=m; }
ierr = ISCreateGeneralWithArray(PETSC_COMM_SELF,npt*puse,idy,&isy);CHKERRQ(ierr);
ierr = VecScatterCreate(*vinda,isx,y0,isy,&ctx);CHKERRQ(ierr);
ierr = VecScatterBegin(*vinda,y0,INSERT_VALUES,SCATTER_FORWARD,ctx);CHKERRQ(ierr);
ierr = VecScatterEnd(*vinda,y0,INSERT_VALUES,SCATTER_FORWARD,ctx);CHKERRQ(ierr);
ierr = VecScatterDestroy(ctx);
ierr = VecGetArray(y0,&pty);CHKERRQ(ierr);
for(m=0;m<puse;m++){
for(m2=0;m2<npt;m2++){
*(yarray+m) = *(yarray+m)+*(pty+m*npt+m2);
}
*(yarray+m) = *(yarray+m)/npt;
}
VecRestoreArray(y0,&pty);
VecSetValues(*vindb,puse,idp,yarray,INSERT_VALUES);
for(m=0;m<pmax;m++){*(yarray+m) = 0; }
p = 0;
if (n*localsize-l<=pmax){puse = n*localsize-l-1;}else{puse=pmax;}
}else{p++;}
l++;
}
}
VecAssemblyBegin(*vindb);
VecAssemblyEnd(*vindb);
vindc = vindb;
vindb = vinda;
vinda = vindc;
//ierr = VecCopy(x,x0);CHKERRQ(ierr);
ierr = VecNorm(*vinda,NORM_2,Mixnorm+niter); CHKERRQ(ierr);
*(Mixnorm+niter) = *(Mixnorm+niter)/n;
ierr = PetscGetTime(&v2);CHKERRQ(ierr);
elapsed_time = v2 - v1;
PetscPrintf(PETSC_COMM_WORLD," %d %f %f %f \n",niter,*(Mixnorm+niter),elapsed_time,elapsed_time/n/n*1e6 );
PetscFPrintf(PETSC_COMM_WORLD,fidoutput," %d %f %f %f\n"
,niter,*(Mixnorm+niter),elapsed_time,elapsed_time/n/n*1e6 );
}
PetscFClose(PETSC_COMM_WORLD,fidoutput);
///////////////////////////////////////////////////////////////////////////
if(withMatlab==1){
VecView(x0,socketviewer);
PetscScalarView(iter,Mixnorm,socketviewer);
}
free(CenterX);
free(CenterY);
free(ShiftX);
free(ShiftY);
free(x0array);
free(idx);
free(idy);
free(idp);
free(yarray);
free(NzindJ);
free(Mixnorm);
ierr = VecDestroy(x0);CHKERRQ(ierr);
ierr = VecDestroy(x);CHKERRQ(ierr);
ierr = VecDestroy(y0);CHKERRQ(ierr);
PetscPrintf(PETSC_COMM_WORLD,"Done!");
//////////////////////////////////////////////////////////////////////////////////////
ierr = PetscFinalize();CHKERRQ(ierr);
return 0;
}
uses block index sets\n\n";
/* 'mpiexec -n 3 ./ex2 -vecscatter_type mpi3node' might give incorrect solution due to multiple cores write to the same variable */
#include <petscvec.h>
int main(int argc,char **argv)
{
PetscErrorCode ierr;
PetscInt bs=1,n=5,i,low;
PetscInt ix0[3] = {5,7,9},iy0[3] = {1,2,4},ix1[3] = {2,3,4},iy1[3] = {0,1,3};
PetscMPIInt size,rank;
PetscScalar *array;
Vec x,y;
IS isx,isy;
VecScatter ctx;
ierr = PetscInitialize(&argc,&argv,(char*)0,help);if (ierr) return ierr;
ierr = MPI_Comm_size(PETSC_COMM_WORLD,&size);CHKERRQ(ierr);
ierr = MPI_Comm_rank(PETSC_COMM_WORLD,&rank);CHKERRQ(ierr);
if (size <2) SETERRQ(PETSC_COMM_SELF,1,"Must run more than one processor");
ierr = PetscOptionsGetInt(NULL,NULL,"-bs",&bs,NULL);CHKERRQ(ierr);
n = bs*n;
/* Create vector x over shared memory */
ierr = VecCreate(PETSC_COMM_WORLD,&x);CHKERRQ(ierr);
ierr = VecSetSizes(x,n,PETSC_DECIDE);CHKERRQ(ierr);
ierr = VecSetType(x,VECNODE);CHKERRQ(ierr);
ierr = VecSetFromOptions(x);CHKERRQ(ierr);
ierr = VecGetOwnershipRange(x,&low,NULL);CHKERRQ(ierr);
ierr = VecGetArray(x,&array);CHKERRQ(ierr);
for (i=0; i<n; i++) {
array[i] = (PetscScalar)(i + low);
}
ierr = VecRestoreArray(x,&array);CHKERRQ(ierr);
/* Create a sequential vector y */
ierr = VecCreateSeq(PETSC_COMM_SELF,n,&y);CHKERRQ(ierr);
ierr = VecSet(y,0.0);CHKERRQ(ierr);
/* Create two index sets */
if (!rank) {
ierr = ISCreateBlock(PETSC_COMM_SELF,bs,3,ix0,PETSC_COPY_VALUES,&isx);CHKERRQ(ierr);
ierr = ISCreateBlock(PETSC_COMM_SELF,bs,3,iy0,PETSC_COPY_VALUES,&isy);CHKERRQ(ierr);
} else {
ierr = ISCreateBlock(PETSC_COMM_SELF,bs,3,ix1,PETSC_COPY_VALUES,&isx);CHKERRQ(ierr);
ierr = ISCreateBlock(PETSC_COMM_SELF,bs,3,iy1,PETSC_COPY_VALUES,&isy);CHKERRQ(ierr);
}
if (rank == 10) {
ierr = PetscPrintf(PETSC_COMM_SELF,"\n[%d] isx:\n",rank);CHKERRQ(ierr);
ierr = ISView(isx,PETSC_VIEWER_STDOUT_SELF);CHKERRQ(ierr);
}
ierr = VecScatterCreateWithData(x,isx,y,isy,&ctx);CHKERRQ(ierr);
ierr = VecScatterSetFromOptions(ctx);CHKERRQ(ierr);
/* Test forward vecscatter */
ierr = VecScatterBegin(ctx,x,y,ADD_VALUES,SCATTER_FORWARD);CHKERRQ(ierr);
ierr = VecScatterEnd(ctx,x,y,ADD_VALUES,SCATTER_FORWARD);CHKERRQ(ierr);
if (rank == 0) {
ierr = PetscPrintf(PETSC_COMM_SELF,"[%d] y:\n",rank);CHKERRQ(ierr);
ierr = VecView(y,PETSC_VIEWER_STDOUT_SELF);CHKERRQ(ierr);
}
/* Test reverse vecscatter */
ierr = VecScale(y,-1.0);CHKERRQ(ierr);
if (rank) {
ierr = VecScale(y,1.0/(size - 1));CHKERRQ(ierr);
}
ierr = VecScatterBegin(ctx,y,x,ADD_VALUES,SCATTER_REVERSE);CHKERRQ(ierr);
ierr = VecScatterEnd(ctx,y,x,ADD_VALUES,SCATTER_REVERSE);CHKERRQ(ierr);
ierr = VecView(x,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
/* Free spaces */
ierr = VecScatterDestroy(&ctx);CHKERRQ(ierr);
ierr = ISDestroy(&isx);CHKERRQ(ierr);
ierr = ISDestroy(&isy);CHKERRQ(ierr);
ierr = VecDestroy(&x);CHKERRQ(ierr);
ierr = VecDestroy(&y);CHKERRQ(ierr);
ierr = PetscFinalize();
return ierr;
}
int main(int argc,char **args)
{
PetscMPIInt size;
PetscErrorCode ierr;
Vec x,y,b,s1,s2;
Mat A; /* linear system matrix */
Mat sA,sB,sC; /* symmetric part of the matrices */
PetscInt n,mbs=16,bs=1,nz=3,prob=1,i,j,k1,k2,col[3],lf,block, row,Ii,J,n1,inc;
PetscReal norm1,norm2,rnorm,tol=PETSC_SMALL;
PetscScalar neg_one = -1.0,four=4.0,value[3];
IS perm, iscol;
PetscRandom rdm;
PetscBool doIcc=PETSC_TRUE,equal;
MatInfo minfo1,minfo2;
MatFactorInfo factinfo;
MatType type;
PetscInitialize(&argc,&args,(char*)0,help);
ierr = MPI_Comm_size(PETSC_COMM_WORLD,&size);CHKERRQ(ierr);
if (size != 1) SETERRQ(PETSC_COMM_WORLD,PETSC_ERR_SUP,"This is a uniprocessor example only!");
ierr = PetscOptionsGetInt(NULL,"-bs",&bs,NULL);CHKERRQ(ierr);
ierr = PetscOptionsGetInt(NULL,"-mbs",&mbs,NULL);CHKERRQ(ierr);
n = mbs*bs;
ierr = MatCreate(PETSC_COMM_SELF,&A);CHKERRQ(ierr);
ierr = MatSetSizes(A,n,n,PETSC_DETERMINE,PETSC_DETERMINE);CHKERRQ(ierr);
ierr = MatSetType(A,MATSEQBAIJ);CHKERRQ(ierr);
ierr = MatSetFromOptions(A);CHKERRQ(ierr);
ierr = MatSeqBAIJSetPreallocation(A,bs,nz,NULL);CHKERRQ(ierr);
ierr = MatCreate(PETSC_COMM_SELF,&sA);CHKERRQ(ierr);
ierr = MatSetSizes(sA,n,n,PETSC_DETERMINE,PETSC_DETERMINE);CHKERRQ(ierr);
ierr = MatSetType(sA,MATSEQSBAIJ);CHKERRQ(ierr);
ierr = MatSetFromOptions(sA);CHKERRQ(ierr);
ierr = MatGetType(sA,&type);CHKERRQ(ierr);
ierr = PetscObjectTypeCompare((PetscObject)sA,MATSEQSBAIJ,&doIcc);CHKERRQ(ierr);
ierr = MatSeqSBAIJSetPreallocation(sA,bs,nz,NULL);CHKERRQ(ierr);
ierr = MatSetOption(sA,MAT_IGNORE_LOWER_TRIANGULAR,PETSC_TRUE);CHKERRQ(ierr);
/* Test MatGetOwnershipRange() */
ierr = MatGetOwnershipRange(A,&Ii,&J);CHKERRQ(ierr);
ierr = MatGetOwnershipRange(sA,&i,&j);CHKERRQ(ierr);
if (i-Ii || j-J) {
ierr = PetscPrintf(PETSC_COMM_SELF,"Error: MatGetOwnershipRange() in MatSBAIJ format\n");CHKERRQ(ierr);
}
/* Assemble matrix */
if (bs == 1) {
ierr = PetscOptionsGetInt(NULL,"-test_problem",&prob,NULL);CHKERRQ(ierr);
if (prob == 1) { /* tridiagonal matrix */
value[0] = -1.0; value[1] = 2.0; value[2] = -1.0;
for (i=1; i<n-1; i++) {
col[0] = i-1; col[1] = i; col[2] = i+1;
ierr = MatSetValues(A,1,&i,3,col,value,INSERT_VALUES);CHKERRQ(ierr);
ierr = MatSetValues(sA,1,&i,3,col,value,INSERT_VALUES);CHKERRQ(ierr);
}
i = n - 1; col[0]=0; col[1] = n - 2; col[2] = n - 1;
value[0]= 0.1; value[1]=-1; value[2]=2;
ierr = MatSetValues(A,1,&i,3,col,value,INSERT_VALUES);CHKERRQ(ierr);
ierr = MatSetValues(sA,1,&i,3,col,value,INSERT_VALUES);CHKERRQ(ierr);
i = 0;
col[0] = n-1; col[1] = 1; col[2] = 0;
value[0] = 0.1; value[1] = -1.0; value[2] = 2;
ierr = MatSetValues(A,1,&i,3,col,value,INSERT_VALUES);CHKERRQ(ierr);
ierr = MatSetValues(sA,1,&i,3,col,value,INSERT_VALUES);CHKERRQ(ierr);
} else if (prob ==2) { /* matrix for the five point stencil */
n1 = (PetscInt) (PetscSqrtReal((PetscReal)n) + 0.001);
if (n1*n1 - n) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONG,"sqrt(n) must be a positive interger!");
for (i=0; i<n1; i++) {
for (j=0; j<n1; j++) {
Ii = j + n1*i;
if (i>0) {
J = Ii - n1;
ierr = MatSetValues(A,1,&Ii,1,&J,&neg_one,INSERT_VALUES);CHKERRQ(ierr);
ierr = MatSetValues(sA,1,&Ii,1,&J,&neg_one,INSERT_VALUES);CHKERRQ(ierr);
}
if (i<n1-1) {
J = Ii + n1;
ierr = MatSetValues(A,1,&Ii,1,&J,&neg_one,INSERT_VALUES);CHKERRQ(ierr);
ierr = MatSetValues(sA,1,&Ii,1,&J,&neg_one,INSERT_VALUES);CHKERRQ(ierr);
}
if (j>0) {
J = Ii - 1;
ierr = MatSetValues(A,1,&Ii,1,&J,&neg_one,INSERT_VALUES);CHKERRQ(ierr);
ierr = MatSetValues(sA,1,&Ii,1,&J,&neg_one,INSERT_VALUES);CHKERRQ(ierr);
}
if (j<n1-1) {
J = Ii + 1;
ierr = MatSetValues(A,1,&Ii,1,&J,&neg_one,INSERT_VALUES);CHKERRQ(ierr);
ierr = MatSetValues(sA,1,&Ii,1,&J,&neg_one,INSERT_VALUES);CHKERRQ(ierr);
}
ierr = MatSetValues(A,1,&Ii,1,&Ii,&four,INSERT_VALUES);CHKERRQ(ierr);
ierr = MatSetValues(sA,1,&Ii,1,&Ii,&four,INSERT_VALUES);CHKERRQ(ierr);
}
}
}
} else { /* bs > 1 */
for (block=0; block<n/bs; block++) {
/* diagonal blocks */
value[0] = -1.0; value[1] = 4.0; value[2] = -1.0;
for (i=1+block*bs; i<bs-1+block*bs; i++) {
col[0] = i-1; col[1] = i; col[2] = i+1;
ierr = MatSetValues(A,1,&i,3,col,value,INSERT_VALUES);CHKERRQ(ierr);
ierr = MatSetValues(sA,1,&i,3,col,value,INSERT_VALUES);CHKERRQ(ierr);
}
i = bs - 1+block*bs; col[0] = bs - 2+block*bs; col[1] = bs - 1+block*bs;
value[0]=-1.0; value[1]=4.0;
ierr = MatSetValues(A,1,&i,2,col,value,INSERT_VALUES);CHKERRQ(ierr);
ierr = MatSetValues(sA,1,&i,2,col,value,INSERT_VALUES);CHKERRQ(ierr);
i = 0+block*bs; col[0] = 0+block*bs; col[1] = 1+block*bs;
value[0]=4.0; value[1] = -1.0;
ierr = MatSetValues(A,1,&i,2,col,value,INSERT_VALUES);CHKERRQ(ierr);
ierr = MatSetValues(sA,1,&i,2,col,value,INSERT_VALUES);CHKERRQ(ierr);
}
/* off-diagonal blocks */
value[0]=-1.0;
for (i=0; i<(n/bs-1)*bs; i++) {
col[0]=i+bs;
ierr = MatSetValues(A,1,&i,1,col,value,INSERT_VALUES);CHKERRQ(ierr);
ierr = MatSetValues(sA,1,&i,1,col,value,INSERT_VALUES);CHKERRQ(ierr);
col[0]=i; row=i+bs;
ierr = MatSetValues(A,1,&row,1,col,value,INSERT_VALUES);CHKERRQ(ierr);
ierr = MatSetValues(sA,1,&row,1,col,value,INSERT_VALUES);CHKERRQ(ierr);
}
}
ierr = MatAssemblyBegin(A,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
ierr = MatAssemblyEnd(A,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
ierr = MatAssemblyBegin(sA,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
ierr = MatAssemblyEnd(sA,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
/* Test MatGetInfo() of A and sA */
ierr = MatGetInfo(A,MAT_LOCAL,&minfo1);CHKERRQ(ierr);
ierr = MatGetInfo(sA,MAT_LOCAL,&minfo2);CHKERRQ(ierr);
/*
printf("A matrix nonzeros (BAIJ format) = %d, allocated nonzeros= %d\n", (int)minfo1.nz_used,(int)minfo1.nz_allocated);
printf("sA matrix nonzeros(SBAIJ format) = %d, allocated nonzeros= %d\n", (int)minfo2.nz_used,(int)minfo2.nz_allocated);
*/
i = (int) (minfo1.nz_used - minfo2.nz_used);
j = (int) (minfo1.nz_allocated - minfo2.nz_allocated);
k1 = (int) (minfo1.nz_allocated - minfo1.nz_used);
k2 = (int) (minfo2.nz_allocated - minfo2.nz_used);
if (i < 0 || j < 0 || k1 < 0 || k2 < 0) {
ierr = PetscPrintf(PETSC_COMM_SELF,"Error (compare A and sA): MatGetInfo()\n");CHKERRQ(ierr);
}
/* Test MatDuplicate() */
ierr = MatNorm(A,NORM_FROBENIUS,&norm1);CHKERRQ(ierr);
ierr = MatDuplicate(sA,MAT_COPY_VALUES,&sB);CHKERRQ(ierr);
ierr = MatEqual(sA,sB,&equal);CHKERRQ(ierr);
if (!equal) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_NOTSAMETYPE,"Error in MatDuplicate()");
/* Test MatNorm() */
ierr = MatNorm(A,NORM_FROBENIUS,&norm1);CHKERRQ(ierr);
ierr = MatNorm(sB,NORM_FROBENIUS,&norm2);CHKERRQ(ierr);
rnorm = PetscAbsReal(norm1-norm2)/norm2;
if (rnorm > tol) {
ierr = PetscPrintf(PETSC_COMM_SELF,"Error: MatNorm_FROBENIUS, NormA=%16.14e NormsB=%16.14e\n",norm1,norm2);CHKERRQ(ierr);
}
ierr = MatNorm(A,NORM_INFINITY,&norm1);CHKERRQ(ierr);
ierr = MatNorm(sB,NORM_INFINITY,&norm2);CHKERRQ(ierr);
rnorm = PetscAbsReal(norm1-norm2)/norm2;
if (rnorm > tol) {
ierr = PetscPrintf(PETSC_COMM_SELF,"Error: MatNorm_INFINITY(), NormA=%16.14e NormsB=%16.14e\n",norm1,norm2);CHKERRQ(ierr);
}
ierr = MatNorm(A,NORM_1,&norm1);CHKERRQ(ierr);
ierr = MatNorm(sB,NORM_1,&norm2);CHKERRQ(ierr);
rnorm = PetscAbsReal(norm1-norm2)/norm2;
if (rnorm > tol) {
ierr = PetscPrintf(PETSC_COMM_SELF,"Error: MatNorm_INFINITY(), NormA=%16.14e NormsB=%16.14e\n",norm1,norm2);CHKERRQ(ierr);
}
/* Test MatGetInfo(), MatGetSize(), MatGetBlockSize() */
ierr = MatGetInfo(A,MAT_LOCAL,&minfo1);CHKERRQ(ierr);
ierr = MatGetInfo(sB,MAT_LOCAL,&minfo2);CHKERRQ(ierr);
/*
printf("matrix nonzeros (BAIJ format) = %d, allocated nonzeros= %d\n", (int)minfo1.nz_used,(int)minfo1.nz_allocated);
printf("matrix nonzeros(SBAIJ format) = %d, allocated nonzeros= %d\n", (int)minfo2.nz_used,(int)minfo2.nz_allocated);
*/
i = (int) (minfo1.nz_used - minfo2.nz_used);
j = (int) (minfo1.nz_allocated - minfo2.nz_allocated);
k1 = (int) (minfo1.nz_allocated - minfo1.nz_used);
k2 = (int) (minfo2.nz_allocated - minfo2.nz_used);
if (i < 0 || j < 0 || k1 < 0 || k2 < 0) {
ierr = PetscPrintf(PETSC_COMM_SELF,"Error(compare A and sB): MatGetInfo()\n");CHKERRQ(ierr);
}
ierr = MatGetSize(A,&Ii,&J);CHKERRQ(ierr);
ierr = MatGetSize(sB,&i,&j);CHKERRQ(ierr);
if (i-Ii || j-J) {
PetscPrintf(PETSC_COMM_SELF,"Error: MatGetSize()\n");CHKERRQ(ierr);
}
ierr = MatGetBlockSize(A, &Ii);CHKERRQ(ierr);
ierr = MatGetBlockSize(sB, &i);CHKERRQ(ierr);
if (i-Ii) {
ierr = PetscPrintf(PETSC_COMM_SELF,"Error: MatGetBlockSize()\n");CHKERRQ(ierr);
}
ierr = PetscRandomCreate(PETSC_COMM_SELF,&rdm);CHKERRQ(ierr);
ierr = PetscRandomSetFromOptions(rdm);CHKERRQ(ierr);
ierr = VecCreateSeq(PETSC_COMM_SELF,n,&x);CHKERRQ(ierr);
ierr = VecDuplicate(x,&s1);CHKERRQ(ierr);
ierr = VecDuplicate(x,&s2);CHKERRQ(ierr);
ierr = VecDuplicate(x,&y);CHKERRQ(ierr);
ierr = VecDuplicate(x,&b);CHKERRQ(ierr);
ierr = VecSetRandom(x,rdm);CHKERRQ(ierr);
/* Test MatDiagonalScale(), MatGetDiagonal(), MatScale() */
#if !defined(PETSC_USE_COMPLEX)
/* Scaling matrix with complex numbers results non-spd matrix,
causing crash of MatForwardSolve() and MatBackwardSolve() */
ierr = MatDiagonalScale(A,x,x);CHKERRQ(ierr);
ierr = MatDiagonalScale(sB,x,x);CHKERRQ(ierr);
ierr = MatMultEqual(A,sB,10,&equal);CHKERRQ(ierr);
if (!equal) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_NOTSAMETYPE,"Error in MatDiagonalScale");
ierr = MatGetDiagonal(A,s1);CHKERRQ(ierr);
ierr = MatGetDiagonal(sB,s2);CHKERRQ(ierr);
ierr = VecAXPY(s2,neg_one,s1);CHKERRQ(ierr);
ierr = VecNorm(s2,NORM_1,&norm1);CHKERRQ(ierr);
if (norm1>tol) {
ierr = PetscPrintf(PETSC_COMM_SELF,"Error:MatGetDiagonal(), ||s1-s2||=%G\n",norm1);CHKERRQ(ierr);
}
{
PetscScalar alpha=0.1;
ierr = MatScale(A,alpha);CHKERRQ(ierr);
ierr = MatScale(sB,alpha);CHKERRQ(ierr);
}
#endif
/* Test MatGetRowMaxAbs() */
ierr = MatGetRowMaxAbs(A,s1,NULL);CHKERRQ(ierr);
ierr = MatGetRowMaxAbs(sB,s2,NULL);CHKERRQ(ierr);
ierr = VecNorm(s1,NORM_1,&norm1);CHKERRQ(ierr);
ierr = VecNorm(s2,NORM_1,&norm2);CHKERRQ(ierr);
norm1 -= norm2;
if (norm1<-tol || norm1>tol) {
ierr = PetscPrintf(PETSC_COMM_SELF,"Error:MatGetRowMaxAbs() \n");CHKERRQ(ierr);
}
/* Test MatMult() */
for (i=0; i<40; i++) {
ierr = VecSetRandom(x,rdm);CHKERRQ(ierr);
ierr = MatMult(A,x,s1);CHKERRQ(ierr);
ierr = MatMult(sB,x,s2);CHKERRQ(ierr);
ierr = VecNorm(s1,NORM_1,&norm1);CHKERRQ(ierr);
ierr = VecNorm(s2,NORM_1,&norm2);CHKERRQ(ierr);
norm1 -= norm2;
if (norm1<-tol || norm1>tol) {
ierr = PetscPrintf(PETSC_COMM_SELF,"Error: MatMult(), norm1-norm2: %G\n",norm1);CHKERRQ(ierr);
}
}
/* MatMultAdd() */
for (i=0; i<40; i++) {
ierr = VecSetRandom(x,rdm);CHKERRQ(ierr);
ierr = VecSetRandom(y,rdm);CHKERRQ(ierr);
ierr = MatMultAdd(A,x,y,s1);CHKERRQ(ierr);
ierr = MatMultAdd(sB,x,y,s2);CHKERRQ(ierr);
ierr = VecNorm(s1,NORM_1,&norm1);CHKERRQ(ierr);
ierr = VecNorm(s2,NORM_1,&norm2);CHKERRQ(ierr);
norm1 -= norm2;
if (norm1<-tol || norm1>tol) {
ierr = PetscPrintf(PETSC_COMM_SELF,"Error:MatMultAdd(), norm1-norm2: %G\n",norm1);CHKERRQ(ierr);
}
}
/* Test MatCholeskyFactor(), MatICCFactor() with natural ordering */
ierr = MatGetOrdering(A,MATORDERINGNATURAL,&perm,&iscol);CHKERRQ(ierr);
ierr = ISDestroy(&iscol);CHKERRQ(ierr);
norm1 = tol;
inc = bs;
/* initialize factinfo */
ierr = PetscMemzero(&factinfo,sizeof(MatFactorInfo));CHKERRQ(ierr);
for (lf=-1; lf<10; lf += inc) {
if (lf==-1) { /* Cholesky factor of sB (duplicate sA) */
factinfo.fill = 5.0;
ierr = MatGetFactor(sB,MATSOLVERPETSC,MAT_FACTOR_CHOLESKY,&sC);CHKERRQ(ierr);
ierr = MatCholeskyFactorSymbolic(sC,sB,perm,&factinfo);CHKERRQ(ierr);
} else if (!doIcc) break;
else { /* incomplete Cholesky factor */
factinfo.fill = 5.0;
factinfo.levels = lf;
ierr = MatGetFactor(sB,MATSOLVERPETSC,MAT_FACTOR_ICC,&sC);CHKERRQ(ierr);
ierr = MatICCFactorSymbolic(sC,sB,perm,&factinfo);CHKERRQ(ierr);
}
ierr = MatCholeskyFactorNumeric(sC,sB,&factinfo);CHKERRQ(ierr);
/* MatView(sC, PETSC_VIEWER_DRAW_WORLD); */
/* test MatGetDiagonal on numeric factor */
/*
if (lf == -1) {
ierr = MatGetDiagonal(sC,s1);CHKERRQ(ierr);
printf(" in ex74.c, diag: \n");
ierr = VecView(s1,PETSC_VIEWER_STDOUT_SELF);CHKERRQ(ierr);
}
*/
ierr = MatMult(sB,x,b);CHKERRQ(ierr);
/* test MatForwardSolve() and MatBackwardSolve() */
if (lf == -1) {
ierr = MatForwardSolve(sC,b,s1);CHKERRQ(ierr);
ierr = MatBackwardSolve(sC,s1,s2);CHKERRQ(ierr);
ierr = VecAXPY(s2,neg_one,x);CHKERRQ(ierr);
ierr = VecNorm(s2,NORM_2,&norm2);CHKERRQ(ierr);
if (10*norm1 < norm2) {
ierr = PetscPrintf(PETSC_COMM_SELF,"MatForwardSolve and BackwardSolve: Norm of error=%G, bs=%d\n",norm2,bs);CHKERRQ(ierr);
}
}
/* test MatSolve() */
ierr = MatSolve(sC,b,y);CHKERRQ(ierr);
ierr = MatDestroy(&sC);CHKERRQ(ierr);
/* Check the error */
ierr = VecAXPY(y,neg_one,x);CHKERRQ(ierr);
ierr = VecNorm(y,NORM_2,&norm2);CHKERRQ(ierr);
/* printf("lf: %d, error: %G\n", lf,norm2); */
if (10*norm1 < norm2 && lf-inc != -1) {
ierr = PetscPrintf(PETSC_COMM_SELF,"lf=%D, %D, Norm of error=%G, %G\n",lf-inc,lf,norm1,norm2);CHKERRQ(ierr);
}
norm1 = norm2;
if (norm2 < tol && lf != -1) break;
}
ierr = ISDestroy(&perm);CHKERRQ(ierr);
ierr = MatDestroy(&A);CHKERRQ(ierr);
ierr = MatDestroy(&sB);CHKERRQ(ierr);
ierr = MatDestroy(&sA);CHKERRQ(ierr);
ierr = VecDestroy(&x);CHKERRQ(ierr);
ierr = VecDestroy(&y);CHKERRQ(ierr);
ierr = VecDestroy(&s1);CHKERRQ(ierr);
ierr = VecDestroy(&s2);CHKERRQ(ierr);
ierr = VecDestroy(&b);CHKERRQ(ierr);
ierr = PetscRandomDestroy(&rdm);CHKERRQ(ierr);
ierr = PetscFinalize();
return 0;
}
int main(int argc,char **args)
{
Mat A,B;
Vec xx,s1,s2,yy;
PetscErrorCode ierr;
PetscInt m=45,rows[2],cols[2],bs=1,i,row,col,*idx,M;
PetscScalar rval,vals1[4],vals2[4];
PetscRandom rdm;
IS is1,is2;
PetscReal s1norm,s2norm,rnorm,tol = 1.e-4;
PetscTruth flg;
MatFactorInfo info;
PetscInitialize(&argc,&args,(char *)0,help);
/* Test MatSetValues() and MatGetValues() */
ierr = PetscOptionsGetInt(PETSC_NULL,"-mat_block_size",&bs,PETSC_NULL);CHKERRQ(ierr);
ierr = PetscOptionsGetInt(PETSC_NULL,"-mat_size",&m,PETSC_NULL);CHKERRQ(ierr);
M = m*bs;
ierr = MatCreateSeqBAIJ(PETSC_COMM_SELF,bs,M,M,1,PETSC_NULL,&A);CHKERRQ(ierr);
ierr = MatCreateSeqAIJ(PETSC_COMM_SELF,M,M,15,PETSC_NULL,&B);CHKERRQ(ierr);
ierr = PetscRandomCreate(PETSC_COMM_SELF,&rdm);CHKERRQ(ierr);
ierr = PetscRandomSetFromOptions(rdm);CHKERRQ(ierr);
ierr = VecCreateSeq(PETSC_COMM_SELF,M,&xx);CHKERRQ(ierr);
ierr = VecDuplicate(xx,&s1);CHKERRQ(ierr);
ierr = VecDuplicate(xx,&s2);CHKERRQ(ierr);
ierr = VecDuplicate(xx,&yy);CHKERRQ(ierr);
/* For each row add atleast 15 elements */
for (row=0; row<M; row++) {
for (i=0; i<25*bs; i++) {
ierr = PetscRandomGetValue(rdm,&rval);CHKERRQ(ierr);
col = (PetscInt)(PetscRealPart(rval)*M);
ierr = MatSetValues(A,1,&row,1,&col,&rval,INSERT_VALUES);CHKERRQ(ierr);
ierr = MatSetValues(B,1,&row,1,&col,&rval,INSERT_VALUES);CHKERRQ(ierr);
}
}
/* Now set blocks of values */
for (i=0; i<20*bs; i++) {
ierr = PetscRandomGetValue(rdm,&rval);CHKERRQ(ierr);
cols[0] = (PetscInt)(PetscRealPart(rval)*M);
vals1[0] = rval;
ierr = PetscRandomGetValue(rdm,&rval);CHKERRQ(ierr);
cols[1] = (PetscInt)(PetscRealPart(rval)*M);
vals1[1] = rval;
ierr = PetscRandomGetValue(rdm,&rval);CHKERRQ(ierr);
rows[0] = (PetscInt)(PetscRealPart(rval)*M);
vals1[2] = rval;
ierr = PetscRandomGetValue(rdm,&rval);CHKERRQ(ierr);
rows[1] = (PetscInt)(PetscRealPart(rval)*M);
vals1[3] = rval;
ierr = MatSetValues(A,2,rows,2,cols,vals1,INSERT_VALUES);CHKERRQ(ierr);
ierr = MatSetValues(B,2,rows,2,cols,vals1,INSERT_VALUES);CHKERRQ(ierr);
}
ierr = MatAssemblyBegin(A,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
ierr = MatAssemblyEnd(A,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
ierr = MatAssemblyBegin(B,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
ierr = MatAssemblyEnd(B,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
/* Test MatNorm() */
ierr = MatNorm(A,NORM_FROBENIUS,&s1norm);CHKERRQ(ierr);
ierr = MatNorm(B,NORM_FROBENIUS,&s2norm);CHKERRQ(ierr);
rnorm = PetscAbsScalar(s2norm-s1norm)/s2norm;
if ( rnorm>tol ) {
ierr = PetscPrintf(PETSC_COMM_SELF,"Error: MatNorm_FROBENIUS()- NormA=%16.14e NormB=%16.14e bs = %D\n",s1norm,s2norm,bs);CHKERRQ(ierr);
}
ierr = MatNorm(A,NORM_INFINITY,&s1norm);CHKERRQ(ierr);
ierr = MatNorm(B,NORM_INFINITY,&s2norm);CHKERRQ(ierr);
rnorm = PetscAbsScalar(s2norm-s1norm)/s2norm;
if ( rnorm>tol ) {
ierr = PetscPrintf(PETSC_COMM_SELF,"Error: MatNorm_INFINITY()- NormA=%16.14e NormB=%16.14e bs = %D\n",s1norm,s2norm,bs);CHKERRQ(ierr);
}
ierr = MatNorm(A,NORM_1,&s1norm);CHKERRQ(ierr);
ierr = MatNorm(B,NORM_1,&s2norm);CHKERRQ(ierr);
rnorm = PetscAbsScalar(s2norm-s1norm)/s2norm;
if ( rnorm>tol ) {
ierr = PetscPrintf(PETSC_COMM_SELF,"Error: MatNorm_NORM_1()- NormA=%16.14e NormB=%16.14e bs = %D\n",s1norm,s2norm,bs);CHKERRQ(ierr);
}
/* MatShift() */
rval = 10*s1norm;
ierr = MatShift(A,rval);CHKERRQ(ierr);
ierr = MatShift(B,rval);CHKERRQ(ierr);
/* Test MatTranspose() */
ierr = MatTranspose(A,MAT_REUSE_MATRIX,&A);CHKERRQ(ierr);
ierr = MatTranspose(B,MAT_REUSE_MATRIX,&B);CHKERRQ(ierr);
/* Now do MatGetValues() */
for (i=0; i<30; i++) {
ierr = PetscRandomGetValue(rdm,&rval);CHKERRQ(ierr);
cols[0] = (PetscInt)(PetscRealPart(rval)*M);
ierr = PetscRandomGetValue(rdm,&rval);CHKERRQ(ierr);
cols[1] = (PetscInt)(PetscRealPart(rval)*M);
ierr = PetscRandomGetValue(rdm,&rval);CHKERRQ(ierr);
rows[0] = (PetscInt)(PetscRealPart(rval)*M);
ierr = PetscRandomGetValue(rdm,&rval);CHKERRQ(ierr);
rows[1] = (PetscInt)(PetscRealPart(rval)*M);
ierr = MatGetValues(A,2,rows,2,cols,vals1);CHKERRQ(ierr);
ierr = MatGetValues(B,2,rows,2,cols,vals2);CHKERRQ(ierr);
ierr = PetscMemcmp(vals1,vals2,4*sizeof(PetscScalar),&flg);CHKERRQ(ierr);
if (!flg) {
ierr = PetscPrintf(PETSC_COMM_SELF,"Error: MatGetValues bs = %D\n",bs);CHKERRQ(ierr);
}
}
/* Test MatMult(), MatMultAdd() */
for (i=0; i<40; i++) {
ierr = VecSetRandom(xx,rdm);CHKERRQ(ierr);
ierr = VecSet(s2,0.0);CHKERRQ(ierr);
ierr = MatMult(A,xx,s1);CHKERRQ(ierr);
ierr = MatMultAdd(A,xx,s2,s2);CHKERRQ(ierr);
ierr = VecNorm(s1,NORM_2,&s1norm);CHKERRQ(ierr);
ierr = VecNorm(s2,NORM_2,&s2norm);CHKERRQ(ierr);
rnorm = s2norm-s1norm;
if (rnorm<-tol || rnorm>tol) {
ierr = PetscPrintf(PETSC_COMM_SELF,"MatMult not equal to MatMultAdd Norm1=%e Norm2=%e bs = %D\n",s1norm,s2norm,bs);CHKERRQ(ierr);
}
}
/* Test MatMult() */
ierr = MatMultEqual(A,B,10,&flg);CHKERRQ(ierr);
if (!flg){
ierr = PetscPrintf(PETSC_COMM_SELF,"Error: MatMult()\n");CHKERRQ(ierr);
}
/* Test MatMultAdd() */
ierr = MatMultAddEqual(A,B,10,&flg);CHKERRQ(ierr);
if (!flg){
ierr = PetscPrintf(PETSC_COMM_SELF,"Error: MatMultAdd()\n");CHKERRQ(ierr);
}
/* Test MatMultTranspose() */
ierr = MatMultTransposeEqual(A,B,10,&flg);CHKERRQ(ierr);
if (!flg){
ierr = PetscPrintf(PETSC_COMM_SELF,"Error: MatMultTranspose()\n");CHKERRQ(ierr);
}
/* Test MatMultTransposeAdd() */
ierr = MatMultTransposeAddEqual(A,B,10,&flg);CHKERRQ(ierr);
if (!flg){
ierr = PetscPrintf(PETSC_COMM_SELF,"Error: MatMultTransposeAdd()\n");CHKERRQ(ierr);
}
/* Do LUFactor() on both the matrices */
ierr = PetscMalloc(M*sizeof(PetscInt),&idx);CHKERRQ(ierr);
for (i=0; i<M; i++) idx[i] = i;
ierr = ISCreateGeneral(PETSC_COMM_SELF,M,idx,&is1);CHKERRQ(ierr);
ierr = ISCreateGeneral(PETSC_COMM_SELF,M,idx,&is2);CHKERRQ(ierr);
ierr = PetscFree(idx);CHKERRQ(ierr);
ierr = ISSetPermutation(is1);CHKERRQ(ierr);
ierr = ISSetPermutation(is2);CHKERRQ(ierr);
ierr = MatFactorInfoInitialize(&info);CHKERRQ(ierr);
info.fill = 2.0;
info.dtcol = 0.0;
info.zeropivot = 1.e-14;
info.pivotinblocks = 1.0;
ierr = MatLUFactor(B,is1,is2,&info);CHKERRQ(ierr);
ierr = MatLUFactor(A,is1,is2,&info);CHKERRQ(ierr);
/* Test MatSolveAdd() */
for (i=0; i<10; i++) {
ierr = VecSetRandom(xx,rdm);CHKERRQ(ierr);
ierr = VecSetRandom(yy,rdm);CHKERRQ(ierr);
ierr = MatSolveAdd(B,xx,yy,s2);CHKERRQ(ierr);
ierr = MatSolveAdd(A,xx,yy,s1);CHKERRQ(ierr);
ierr = VecNorm(s1,NORM_2,&s1norm);CHKERRQ(ierr);
ierr = VecNorm(s2,NORM_2,&s2norm);CHKERRQ(ierr);
rnorm = s2norm-s1norm;
if (rnorm<-tol || rnorm>tol) {
ierr = PetscPrintf(PETSC_COMM_SELF,"Error:MatSolveAdd - Norm1=%16.14e Norm2=%16.14e bs = %D\n",s1norm,s2norm,bs);CHKERRQ(ierr);
}
}
/* Test MatSolveAdd() when x = A'b +x */
for (i=0; i<10; i++) {
ierr = VecSetRandom(xx,rdm);CHKERRQ(ierr);
ierr = VecSetRandom(s1,rdm);CHKERRQ(ierr);
ierr = VecCopy(s2,s1);CHKERRQ(ierr);
ierr = MatSolveAdd(B,xx,s2,s2);CHKERRQ(ierr);
ierr = MatSolveAdd(A,xx,s1,s1);CHKERRQ(ierr);
ierr = VecNorm(s1,NORM_2,&s1norm);CHKERRQ(ierr);
ierr = VecNorm(s2,NORM_2,&s2norm);CHKERRQ(ierr);
rnorm = s2norm-s1norm;
if (rnorm<-tol || rnorm>tol) {
ierr = PetscPrintf(PETSC_COMM_SELF,"Error:MatSolveAdd(same) - Norm1=%16.14e Norm2=%16.14e bs = %D\n",s1norm,s2norm,bs);CHKERRQ(ierr);
}
}
/* Test MatSolve() */
for (i=0; i<10; i++) {
ierr = VecSetRandom(xx,rdm);CHKERRQ(ierr);
ierr = MatSolve(B,xx,s2);CHKERRQ(ierr);
ierr = MatSolve(A,xx,s1);CHKERRQ(ierr);
ierr = VecNorm(s1,NORM_2,&s1norm);CHKERRQ(ierr);
ierr = VecNorm(s2,NORM_2,&s2norm);CHKERRQ(ierr);
rnorm = s2norm-s1norm;
if (rnorm<-tol || rnorm>tol) {
ierr = PetscPrintf(PETSC_COMM_SELF,"Error:MatSolve - Norm1=%16.14e Norm2=%16.14e bs = %D\n",s1norm,s2norm,bs);CHKERRQ(ierr);
}
}
/* Test MatSolveTranspose() */
if (bs < 8) {
for (i=0; i<10; i++) {
ierr = VecSetRandom(xx,rdm);CHKERRQ(ierr);
ierr = MatSolveTranspose(B,xx,s2);CHKERRQ(ierr);
ierr = MatSolveTranspose(A,xx,s1);CHKERRQ(ierr);
ierr = VecNorm(s1,NORM_2,&s1norm);CHKERRQ(ierr);
ierr = VecNorm(s2,NORM_2,&s2norm);CHKERRQ(ierr);
rnorm = s2norm-s1norm;
if (rnorm<-tol || rnorm>tol) {
ierr = PetscPrintf(PETSC_COMM_SELF,"Error:MatSolveTranspose - Norm1=%16.14e Norm2=%16.14e bs = %D\n",s1norm,s2norm,bs);CHKERRQ(ierr);
}
}
}
ierr = MatDestroy(A);CHKERRQ(ierr);
ierr = MatDestroy(B);CHKERRQ(ierr);
ierr = VecDestroy(xx);CHKERRQ(ierr);
ierr = VecDestroy(s1);CHKERRQ(ierr);
ierr = VecDestroy(s2);CHKERRQ(ierr);
ierr = VecDestroy(yy);CHKERRQ(ierr);
ierr = ISDestroy(is1);CHKERRQ(ierr);
ierr = ISDestroy(is2);CHKERRQ(ierr);
ierr = PetscRandomDestroy(rdm);CHKERRQ(ierr);
ierr = PetscFinalize();CHKERRQ(ierr);
return 0;
}
int main(int argc,char **argv)
{
PetscErrorCode ierr; /* used to check for functions returning nonzeros */
PetscReal zero=0.0;
Vec x; /* solution vector */
Mat H;
Tao tao; /* Tao solver context */
PetscBool flg, test_lmvm = PETSC_FALSE;
PetscMPIInt size,rank; /* number of processes running */
AppCtx user; /* user-defined application context */
TaoConvergedReason reason;
PetscInt its, recycled_its=0, oneshot_its=0;
/* Initialize TAO and PETSc */
ierr = PetscInitialize(&argc,&argv,(char*)0,help);if (ierr) return ierr;
ierr = MPI_Comm_size(PETSC_COMM_WORLD,&size);CHKERRQ(ierr);
ierr = MPI_Comm_rank(PETSC_COMM_WORLD,&rank);CHKERRQ(ierr);
if (size >1) SETERRQ(PETSC_COMM_SELF,1,"Incorrect number of processors");
/* Initialize problem parameters */
user.n = 2; user.alpha = 99.0; user.chained = PETSC_FALSE;
/* Check for command line arguments to override defaults */
ierr = PetscOptionsGetInt(NULL,NULL,"-n",&user.n,&flg);CHKERRQ(ierr);
ierr = PetscOptionsGetReal(NULL,NULL,"-alpha",&user.alpha,&flg);CHKERRQ(ierr);
ierr = PetscOptionsGetBool(NULL,NULL,"-chained",&user.chained,&flg);CHKERRQ(ierr);
ierr = PetscOptionsGetBool(NULL,NULL,"-test_lmvm",&test_lmvm,&flg);CHKERRQ(ierr);
/* Allocate vectors for the solution and gradient */
ierr = VecCreateSeq(PETSC_COMM_SELF,user.n,&x);CHKERRQ(ierr);
ierr = MatCreateSeqBAIJ(PETSC_COMM_SELF,2,user.n,user.n,1,NULL,&H);CHKERRQ(ierr);
/* The TAO code begins here */
/* Create TAO solver with desired solution method */
ierr = TaoCreate(PETSC_COMM_SELF,&tao);CHKERRQ(ierr);
ierr = TaoSetType(tao,TAOLMVM);CHKERRQ(ierr);
/* Set solution vec and an initial guess */
ierr = VecSet(x, zero);CHKERRQ(ierr);
ierr = TaoSetInitialVector(tao,x);CHKERRQ(ierr);
/* Set routines for function, gradient, hessian evaluation */
ierr = TaoSetObjectiveAndGradientRoutine(tao,FormFunctionGradient,&user);CHKERRQ(ierr);
ierr = TaoSetHessianRoutine(tao,H,H,FormHessian,&user);CHKERRQ(ierr);
/* Check for TAO command line options */
ierr = TaoSetFromOptions(tao);CHKERRQ(ierr);
/* Solve the problem */
ierr = TaoSetTolerances(tao, 1.e-5, 0.0, 0.0);CHKERRQ(ierr);
ierr = TaoSetMaximumIterations(tao, 5);CHKERRQ(ierr);
ierr = TaoLMVMRecycle(tao, PETSC_TRUE);CHKERRQ(ierr);
reason = TAO_CONTINUE_ITERATING;
while (reason != TAO_CONVERGED_GATOL) {
ierr = TaoSolve(tao);CHKERRQ(ierr);
ierr = TaoGetConvergedReason(tao, &reason);CHKERRQ(ierr);
ierr = TaoGetIterationNumber(tao, &its);CHKERRQ(ierr);
recycled_its += its;
ierr = PetscPrintf(PETSC_COMM_SELF, "-----------------------\n");CHKERRQ(ierr);
}
/* Disable recycling and solve again! */
ierr = TaoSetMaximumIterations(tao, 100);CHKERRQ(ierr);
ierr = TaoLMVMRecycle(tao, PETSC_FALSE);CHKERRQ(ierr);
ierr = VecSet(x, zero);CHKERRQ(ierr);
ierr = TaoSolve(tao);CHKERRQ(ierr);
ierr = TaoGetConvergedReason(tao, &reason);CHKERRQ(ierr);
if (reason != TAO_CONVERGED_GATOL) SETERRQ(PETSC_COMM_SELF, PETSC_ERR_NOT_CONVERGED, "Solution failed to converge!");
ierr = TaoGetIterationNumber(tao, &oneshot_its);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_SELF, "-----------------------\n");CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_SELF, "recycled its: %D | oneshot its: %D\n", recycled_its, oneshot_its);CHKERRQ(ierr);
if (recycled_its != oneshot_its) SETERRQ(PETSC_COMM_SELF, PETSC_ERR_NOT_CONVERGED, "LMVM recycling does not work!");
ierr = TaoDestroy(&tao);CHKERRQ(ierr);
ierr = VecDestroy(&x);CHKERRQ(ierr);
ierr = MatDestroy(&H);CHKERRQ(ierr);
ierr = PetscFinalize();
return ierr;
}
int main(int argc, char **argv)
{
/* -------Initialize and Get the parameters from command line ------*/
PetscInitialize(&argc, &argv, PETSC_NULL, PETSC_NULL);
PetscPrintf(PETSC_COMM_WORLD,"--------Initializing------ \n");
PetscErrorCode ierr;
PetscBool flg;
int myrank;
MPI_Comm_rank(MPI_COMM_WORLD,&myrank);
if(myrank==0)
mma_verbose=1;
/*-------------------------------------------------*/
int Mx,My,Mz,Mzslab, Npmlx,Npmly,Npmlz,DegFree, anisotropic;
PetscOptionsGetInt(PETSC_NULL,"-Nx",&Nx,&flg); MyCheckAndOutputInt(flg,Nx,"Nx","Nx");
PetscOptionsGetInt(PETSC_NULL,"-Ny",&Ny,&flg); MyCheckAndOutputInt(flg,Ny,"Ny","Nx");
PetscOptionsGetInt(PETSC_NULL,"-Nz",&Nz,&flg); MyCheckAndOutputInt(flg,Nz,"Nz","Nz");
PetscOptionsGetInt(PETSC_NULL,"-Mx",&Mx,&flg); MyCheckAndOutputInt(flg,Mx,"Mx","Mx");
PetscOptionsGetInt(PETSC_NULL,"-My",&My,&flg); MyCheckAndOutputInt(flg,My,"My","My");
PetscOptionsGetInt(PETSC_NULL,"-Mz",&Mz,&flg); MyCheckAndOutputInt(flg,Mz,"Mz","Mz");
PetscOptionsGetInt(PETSC_NULL,"-Mzslab",&Mzslab,&flg); MyCheckAndOutputInt(flg,Mzslab,"Mzslab","Mzslab");
PetscOptionsGetInt(PETSC_NULL,"-Npmlx",&Npmlx,&flg); MyCheckAndOutputInt(flg,Npmlx,"Npmlx","Npmlx");
PetscOptionsGetInt(PETSC_NULL,"-Npmly",&Npmly,&flg); MyCheckAndOutputInt(flg,Npmly,"Npmly","Npmly");
PetscOptionsGetInt(PETSC_NULL,"-Npmlz",&Npmlz,&flg); MyCheckAndOutputInt(flg,Npmlz,"Npmlz","Npmlz");
Nxyz = Nx*Ny*Nz;
// if anisotropic !=0, Degree of Freedom = 3*Mx*My*Mz; else DegFree = Mx*My*Mz;
PetscOptionsGetInt(PETSC_NULL,"-anisotropic",&anisotropic,&flg);
if(!flg) anisotropic = 0; // by default, it is isotropc.
DegFree = (anisotropic ? 3 : 1 )*Mx*My*((Mzslab==0)?Mz:1);
PetscPrintf(PETSC_COMM_WORLD," the Degree of Freedoms is %d \n ", DegFree);
int DegFreeAll=DegFree+1;
PetscPrintf(PETSC_COMM_WORLD," the Degree of Freedoms ALL is %d \n ", DegFreeAll);
int BCPeriod, Jdirection, Jdirectiontwo, LowerPML;
int bx[2], by[2], bz[2];
PetscOptionsGetInt(PETSC_NULL,"-BCPeriod",&BCPeriod,&flg); MyCheckAndOutputInt(flg,BCPeriod,"BCPeriod","BCPeriod given");
PetscOptionsGetInt(PETSC_NULL,"-Jdirection",&Jdirection,&flg); MyCheckAndOutputInt(flg,Jdirection,"Jdirection","Diapole current direction");
PetscOptionsGetInt(PETSC_NULL,"-Jdirectiontwo",&Jdirectiontwo,&flg); MyCheckAndOutputInt(flg,Jdirectiontwo,"Jdirectiontwo","Diapole current direction for source two");
PetscOptionsGetInt(PETSC_NULL,"-LowerPML",&LowerPML,&flg); MyCheckAndOutputInt(flg,LowerPML,"LowerPML","PML in the lower xyz boundary");
PetscOptionsGetInt(PETSC_NULL,"-bxl",bx,&flg); MyCheckAndOutputInt(flg,bx[0],"bxl","BC at x lower");
PetscOptionsGetInt(PETSC_NULL,"-bxu",bx+1,&flg); MyCheckAndOutputInt(flg,bx[1],"bxu","BC at x upper");
PetscOptionsGetInt(PETSC_NULL,"-byl",by,&flg); MyCheckAndOutputInt(flg,by[0],"byl","BC at y lower");
PetscOptionsGetInt(PETSC_NULL,"-byu",by+1,&flg); MyCheckAndOutputInt(flg,by[1],"byu","BC at y upper");
PetscOptionsGetInt(PETSC_NULL,"-bzl",bz,&flg); MyCheckAndOutputInt(flg,bz[0],"bzl","BC at z lower");
PetscOptionsGetInt(PETSC_NULL,"-bzu",bz+1,&flg); MyCheckAndOutputInt(flg,bz[1],"bzu","BC at z upper");
double epssub, RRT, sigmax, sigmay, sigmaz ;
PetscOptionsGetReal(PETSC_NULL,"-hx",&hx,&flg); MyCheckAndOutputDouble(flg,hx,"hx","hx");
hy = hx;
hz = hx;
hxyz = (Nz==1)*hx*hy + (Nz>1)*hx*hy*hz;
double omega, omegaone, omegatwo, wratio;
PetscOptionsGetReal(PETSC_NULL,"-omega",&omega,&flg); MyCheckAndOutputDouble(flg,omega,"omega","omega");
PetscOptionsGetReal(PETSC_NULL,"-wratio",&wratio,&flg); MyCheckAndOutputDouble(flg,wratio,"wratio","wratio");
omegaone=omega;
omegatwo=wratio*omega;
PetscPrintf(PETSC_COMM_WORLD,"---omegaone is %.16e and omegatwo is %.16e ---\n",omegaone, omegatwo);
PetscOptionsGetReal(PETSC_NULL,"-Qabs",&Qabs,&flg);
if (flg && Qabs>1e+15)
Qabs=1.0/0.0;
MyCheckAndOutputDouble(flg,Qabs,"Qabs","Qabs");
PetscOptionsGetReal(PETSC_NULL,"-epsair",&epsair,&flg); MyCheckAndOutputDouble(flg,epsair,"epsair","epsair");
PetscOptionsGetReal(PETSC_NULL,"-epssub",&epssub,&flg); MyCheckAndOutputDouble(flg,epssub,"epssub","epssub");
PetscOptionsGetReal(PETSC_NULL,"-RRT",&RRT,&flg); MyCheckAndOutputDouble(flg,RRT,"RRT","RRT given");
sigmax = pmlsigma(RRT,Npmlx*hx);
sigmay = pmlsigma(RRT,Npmly*hy);
sigmaz = pmlsigma(RRT,Npmlz*hz);
PetscPrintf(PETSC_COMM_WORLD,"----sigmax is %.12e \n",sigmax);
PetscPrintf(PETSC_COMM_WORLD,"----sigmay is %.12e \n",sigmay);
PetscPrintf(PETSC_COMM_WORLD,"----sigmaz is %.12e \n",sigmaz);
char initialdata[PETSC_MAX_PATH_LEN]; //filenameComm[PETSC_MAX_PATH_LEN];
PetscOptionsGetString(PETSC_NULL,"-initialdata",initialdata,PETSC_MAX_PATH_LEN,&flg); MyCheckAndOutputChar(flg,initialdata,"initialdata","Inputdata file");
PetscOptionsGetString(PETSC_NULL,"-filenameComm",filenameComm,PETSC_MAX_PATH_LEN,&flg); MyCheckAndOutputChar(flg,filenameComm,"filenameComm","Output filenameComm");
// add cx, cy, cz to indicate where the diapole current is;
int cx, cy, cz;
PetscOptionsGetInt(PETSC_NULL,"-cx",&cx,&flg);
if (!flg)
{cx=(LowerPML)*floor(Nx/2); PetscPrintf(PETSC_COMM_WORLD,"cx is %d by default \n",cx);}
else
{PetscPrintf(PETSC_COMM_WORLD,"the current poisiont cx is %d \n",cx);}
PetscOptionsGetInt(PETSC_NULL,"-cy",&cy,&flg);
if (!flg)
{cy=(LowerPML)*floor(Ny/2); PetscPrintf(PETSC_COMM_WORLD,"cy is %d by default \n",cy);}
else
{PetscPrintf(PETSC_COMM_WORLD,"the current poisiont cy is %d \n",cy);}
PetscOptionsGetInt(PETSC_NULL,"-cz",&cz,&flg);
if (!flg)
{cz=(LowerPML)*floor(Nz/2); PetscPrintf(PETSC_COMM_WORLD,"cz is %d by default \n",cz);}
else
{PetscPrintf(PETSC_COMM_WORLD,"the current poisiont cz is %d \n",cz);}
posj = (cx*Ny+ cy)*Nz + cz;
PetscPrintf(PETSC_COMM_WORLD,"the posj is %d \n. ", posj);
int fixpteps;
PetscOptionsGetInt(PETSC_NULL,"-fixpteps",&fixpteps,&flg); MyCheckAndOutputInt(flg,fixpteps,"fixpteps","fixpteps");
// Get minapproach;
PetscOptionsGetInt(PETSC_NULL,"-minapproach",&minapproach,&flg); MyCheckAndOutputInt(flg,minapproach,"minapproach","minapproach");
// Get withepsinldos;
PetscOptionsGetInt(PETSC_NULL,"-withepsinldos",&withepsinldos,&flg); MyCheckAndOutputInt(flg,withepsinldos,"withepsinldos","withepsinldos");
// Get outputbase;
PetscOptionsGetInt(PETSC_NULL,"-outputbase",&outputbase,&flg); MyCheckAndOutputInt(flg,outputbase,"outputbase","outputbase");
// Get cavityverbose;
PetscOptionsGetInt(PETSC_NULL,"-cavityverbose",&cavityverbose,&flg);
if(!flg) cavityverbose=0;
PetscPrintf(PETSC_COMM_WORLD,"the cavity verbose is set as %d \n", cavityverbose);
// Get refinedldos;
PetscOptionsGetInt(PETSC_NULL,"-refinedldos",&refinedldos,&flg);
if(!flg) refinedldos=0;
PetscPrintf(PETSC_COMM_WORLD,"the refinedldos is set as %d \n", refinedldos);
// Get cmpwrhs;
int cmpwrhs;
PetscOptionsGetInt(PETSC_NULL,"-cmpwrhs",&cmpwrhs,&flg);
if(!flg) cmpwrhs=0;
PetscPrintf(PETSC_COMM_WORLD,"the cmpwrhs is set as %d \n", cmpwrhs);
// Get lrzsqr;
PetscOptionsGetInt(PETSC_NULL,"-lrzsqr",&lrzsqr,&flg);
if(!flg) lrzsqr=0;
PetscPrintf(PETSC_COMM_WORLD,"the lrzsqr is set as %d \n", lrzsqr);
// Get newQdef;
PetscOptionsGetInt(PETSC_NULL,"-newQdef",&newQdef,&flg);
if(!flg) newQdef=0;
PetscPrintf(PETSC_COMM_WORLD,"the newQdef is set as %d \n", newQdef);
/*--------------------------------------------------------*/
/*--------------------------------------------------------*/
/*---------- Set the current source---------*/
//Mat D; //ImaginaryIMatrix;
ImagIMat(PETSC_COMM_WORLD, &D,6*Nxyz);
Vec J;
ierr = VecCreateMPI(PETSC_COMM_WORLD, PETSC_DECIDE, 6*Nxyz, &J);CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) J, "Source");CHKERRQ(ierr);
VecSet(J,0.0); //initialization;
if (Jdirection == 1)
SourceSingleSetX(PETSC_COMM_WORLD, J, Nx, Ny, Nz, cx, cy, cz,1.0/hxyz);
else if (Jdirection ==2)
SourceSingleSetY(PETSC_COMM_WORLD, J, Nx, Ny, Nz, cx, cy, cz,1.0/hxyz);
else if (Jdirection == 3)
SourceSingleSetZ(PETSC_COMM_WORLD, J, Nx, Ny, Nz, cx, cy, cz,1.0/hxyz);
else
PetscPrintf(PETSC_COMM_WORLD," Please specify correct direction of current: x (1) , y (2) or z (3)\n ");
Vec Jtwo;
ierr = VecDuplicate(J, &Jtwo);CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) Jtwo, "Sourcetwo");CHKERRQ(ierr);
VecSet(Jtwo,0.0); //initialization;
if (Jdirectiontwo == 1)
SourceSingleSetX(PETSC_COMM_WORLD, Jtwo, Nx, Ny, Nz, cx, cy, cz,1.0/hxyz);
else if (Jdirectiontwo ==2)
SourceSingleSetY(PETSC_COMM_WORLD, Jtwo, Nx, Ny, Nz, cx, cy, cz,1.0/hxyz);
else if (Jdirectiontwo == 3)
SourceSingleSetZ(PETSC_COMM_WORLD, Jtwo, Nx, Ny, Nz, cx, cy, cz,1.0/hxyz);
else
PetscPrintf(PETSC_COMM_WORLD," Please specify correct direction of current two: x (1) , y (2) or z (3)\n ");
//Vec b; // b= i*omega*J;
Vec bone, btwo;
ierr = VecDuplicate(J,&b);CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) b, "rhsone");CHKERRQ(ierr);
ierr = VecDuplicate(J,&bone);CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) bone, "rhsone");CHKERRQ(ierr);
ierr = VecDuplicate(Jtwo,&btwo);CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) btwo, "rhstwo");CHKERRQ(ierr);
if (cmpwrhs==0)
{
ierr = MatMult(D,J,b);CHKERRQ(ierr);
ierr = MatMult(D,Jtwo,btwo);CHKERRQ(ierr);
VecCopy(b,bone);
VecScale(bone,omegaone);
VecScale(btwo,omegatwo);
VecScale(b,omega);
}
else
{
double complex cmpiomega;
cmpiomega = cpow(1+I/Qabs,newQdef+1);
double sqrtiomegaR = -omega*cimag(csqrt(cmpiomega));
double sqrtiomegaI = omega*creal(csqrt(cmpiomega));
PetscPrintf(PETSC_COMM_WORLD,"the real part of sqrt cmpomega is %g and imag sqrt is % g ", sqrtiomegaR, sqrtiomegaI);
Vec tmpi;
ierr = VecDuplicate(J,&tmpi);
VecSet(b,0.0);
VecSet(tmpi,0.0);
CmpVecScale(J,b,sqrtiomegaR,sqrtiomegaI,D,tmpi);
VecDestroy(&tmpi);
}
/*-------Get the weight vector ------------------*/
//Vec weight;
ierr = VecDuplicate(J,&weight); CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) weight, "weight");CHKERRQ(ierr);
if(LowerPML==0)
GetWeightVec(weight, Nx, Ny,Nz); // new code handles both 3D and 2D;
else
VecSet(weight,1.0);
Vec weightedJ;
ierr = VecDuplicate(J,&weightedJ); CHKERRQ(ierr);
ierr = VecPointwiseMult(weightedJ,J,weight);
ierr = PetscObjectSetName((PetscObject) weightedJ, "weightedJ");CHKERRQ(ierr);
Vec weightedJtwo;
ierr = VecDuplicate(Jtwo,&weightedJtwo); CHKERRQ(ierr);
ierr = VecPointwiseMult(weightedJtwo,Jtwo,weight);
ierr = PetscObjectSetName((PetscObject) weightedJtwo, "weightedJtwo");CHKERRQ(ierr);
//Vec vR;
ierr = VecDuplicate(J,&vR); CHKERRQ(ierr);
GetRealPartVec(vR, 6*Nxyz);
// VecFReal;
if (lrzsqr)
{ ierr = VecDuplicate(J,&epsFReal); CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) epsFReal, "epsFReal");CHKERRQ(ierr);
if (newQdef==0)
{
sqrtomegaI = omega*cimag(csqrt(1+I/Qabs));
PetscPrintf(PETSC_COMM_WORLD,"the real part of sqrt cmpomega is %g and imag sqrt is % g ", omega*creal(csqrt(1+I/Qabs)), sqrtomegaI);
betar = 2*sqrtomegaI;
betai = betar/Qabs;
}
else
{
double gamma;
gamma = omega/Qabs;
betar = 2*gamma*(1-1.0/pow(Qabs,2));
betai = 2*gamma*(2.0/Qabs);
}
ierr = VecDuplicate(J,&nb); CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) nb, "nb"); CHKERRQ(ierr);
ierr = VecDuplicate(J,&y); CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) y, "y"); CHKERRQ(ierr);
ierr = VecDuplicate(J,&xsqr); CHKERRQ(ierr); // xsqr = x*x;
ierr = PetscObjectSetName((PetscObject) xsqr, "xsqr"); CHKERRQ(ierr);
CongMat(PETSC_COMM_WORLD, &C, 6*Nxyz);
}
/*----------- Define PML muinv vectors */
Vec muinvpml;
MuinvPMLFull(PETSC_COMM_SELF, &muinvpml,Nx,Ny,Nz,Npmlx,Npmly,Npmlz,sigmax,sigmay,sigmaz,omega, LowerPML);
//double *muinv;
muinv = (double *) malloc(sizeof(double)*6*Nxyz);
int add=0;
AddMuAbsorption(muinv,muinvpml,Qabs,add);
ierr = VecDestroy(&muinvpml); CHKERRQ(ierr);
/*---------- Define PML eps vectors: epspml---------- */
Vec epspml; //epspmlQ, epscoef;
ierr = VecDuplicate(J,&epspml);CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) epspml,"EpsPMLFull"); CHKERRQ(ierr);
EpsPMLFull(PETSC_COMM_WORLD, epspml,Nx,Ny,Nz,Npmlx,Npmly,Npmlz,sigmax,sigmay,sigmaz,omega, LowerPML);
ierr = VecDuplicate(J,&epspmlQ);CHKERRQ(ierr);
Vec epscoefone, epscoeftwo;
ierr = VecDuplicate(J,&epscoefone);CHKERRQ(ierr);
ierr = VecDuplicate(J,&epscoeftwo);CHKERRQ(ierr);
// compute epspmlQ,epscoef;
EpsCombine(D, weight, epspml, epspmlQ, epscoefone, Qabs, omegaone);
EpsCombine(D, weight, epspml, epspmlQ, epscoeftwo, Qabs, omegatwo);
/*--------- Setup the interp matrix ----------------------- */
/* for a samll eps block, interp it into yee-lattice. The interp matrix A and PML epspml only need to generated once;*/
//Mat A;
//new routine for myinterp;
myinterp(PETSC_COMM_WORLD, &A, Nx,Ny,Nz, LowerPML*floor((Nx-Mx)/2),LowerPML*floor((Ny-My)/2),LowerPML*floor((Nz-Mz)/2), Mx,My,Mz,Mzslab, anisotropic); // LoweerPML*Npmlx,..,.., specify where the interp starts;
//Vec epsSReal, epsgrad, vgrad; // create compatiable vectors with A.
ierr = MatGetVecs(A,&epsSReal, &epsgrad); CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) epsgrad, "epsgrad");CHKERRQ(ierr);
ierr = VecDuplicate(epsSReal, &vgrad); CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) epsSReal, "epsSReal");CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) vgrad, "vgrad");CHKERRQ(ierr);
/*---------Setup the epsmedium vector----------------*/
//Vec epsmedium;
ierr = VecDuplicate(J,&epsmedium); CHKERRQ(ierr);
GetMediumVec(epsmedium,Nz,Mz,epsair,epssub);
/*--------- Setup the finitie difference matrix-------------*/
//Mat M;
MoperatorGeneral(PETSC_COMM_WORLD, &M, Nx,Ny,Nz,hx,hy,hz, bx, by, bz,muinv,BCPeriod);
free(muinv);
/*--------Setup the KSP variables ---------------*/
KSP kspone;
PC pcone;
ierr = KSPCreate(PETSC_COMM_WORLD,&kspone);CHKERRQ(ierr);
//ierr = KSPSetType(ksp, KSPPREONLY);CHKERRQ(ierr);
ierr = KSPSetType(kspone, KSPGMRES);CHKERRQ(ierr);
ierr = KSPGetPC(kspone,&pcone);CHKERRQ(ierr);
ierr = PCSetType(pcone,PCLU);CHKERRQ(ierr);
ierr = PCFactorSetMatSolverPackage(pcone,MATSOLVERPASTIX);CHKERRQ(ierr);
ierr = PCSetFromOptions(pcone);
int maxkspit = 20;
ierr = KSPSetTolerances(kspone,1e-14,PETSC_DEFAULT,PETSC_DEFAULT,maxkspit);CHKERRQ(ierr);
ierr = KSPSetFromOptions(kspone);CHKERRQ(ierr);
KSP ksptwo;
PC pctwo;
ierr = KSPCreate(PETSC_COMM_WORLD,&ksptwo);CHKERRQ(ierr);
//ierr = KSPSetType(ksp, KSPPREONLY);CHKERRQ(ierr);
ierr = KSPSetType(ksptwo, KSPGMRES);CHKERRQ(ierr);
ierr = KSPGetPC(ksptwo,&pctwo);CHKERRQ(ierr);
ierr = PCSetType(pctwo,PCLU);CHKERRQ(ierr);
ierr = PCFactorSetMatSolverPackage(pctwo,MATSOLVERPASTIX);CHKERRQ(ierr);
ierr = PCSetFromOptions(pctwo);
ierr = KSPSetTolerances(ksptwo,1e-14,PETSC_DEFAULT,PETSC_DEFAULT,maxkspit);CHKERRQ(ierr);
ierr = KSPSetFromOptions(ksptwo);CHKERRQ(ierr);
/*--------- Create the space for solution vector -------------*/
//Vec x;
ierr = VecDuplicate(J,&x);CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) x, "Solution");CHKERRQ(ierr);
/*----------- Create the space for final eps -------------*/
//Vec epsC, epsCi, epsP;
ierr = VecDuplicate(J,&epsC);CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) epsC, "EpsC");CHKERRQ(ierr);
ierr = VecDuplicate(J,&epsCi);CHKERRQ(ierr);
ierr = VecDuplicate(J,&epsP);CHKERRQ(ierr);
ierr = VecSet(epsP,0.0); CHKERRQ(ierr);
ierr = VecAssemblyBegin(epsP); CHKERRQ(ierr);
ierr = VecAssemblyEnd(epsP); CHKERRQ(ierr);
/*------------ Create space used in the solver ------------*/
//Vec vgradlocal,tmp, tmpa,tmpb;
ierr = VecCreateSeq(PETSC_COMM_SELF, DegFree, &vgradlocal); CHKERRQ(ierr);
ierr = VecDuplicate(J,&tmp); CHKERRQ(ierr);
ierr = VecDuplicate(J,&tmpa); CHKERRQ(ierr);
ierr = VecDuplicate(J,&tmpb); CHKERRQ(ierr);
// Vec pickposvec; this vector is zero except that first entry is one;
if (withepsinldos)
{ ierr = VecDuplicate(J,&pickposvec); CHKERRQ(ierr);
ierr = VecSet(pickposvec,0.0); CHKERRQ(ierr);
ierr = VecSetValue(pickposvec,posj+Jdirection*Nxyz,1.0,INSERT_VALUES);
VecAssemblyBegin(pickposvec);
VecAssemblyEnd(pickposvec);
}
/*------------ Create scatter used in the solver -----------*/
//VecScatter scatter;
//IS from, to;
ierr =ISCreateStride(PETSC_COMM_SELF,DegFree,0,1,&from); CHKERRQ(ierr);
ierr =ISCreateStride(PETSC_COMM_SELF,DegFree,0,1,&to); CHKERRQ(ierr);
/*-------------Read the input file -------------------------*/
double *epsoptAll;
epsoptAll = (double *) malloc(DegFreeAll*sizeof(double));
FILE *ptf;
ptf = fopen(initialdata,"r");
PetscPrintf(PETSC_COMM_WORLD,"reading from input files \n");
int i;
// set the dielectric at the center is fixed, and alwyas high
//epsopt[0]=myub; is defined below near lb and ub;
for (i=0;i<DegFree;i++)
{ //PetscPrintf(PETSC_COMM_WORLD,"current eps reading is %lf \n",epsopt[i]);
fscanf(ptf,"%lf",&epsoptAll[i]);
}
epsoptAll[DegFreeAll-1]=0; //initialize auxiliary variable;
fclose(ptf);
/*----declare these data types, althought they may not be used for job 2 -----------------*/
double mylb,myub, *lb=NULL, *ub=NULL;
int maxeval, maxtime, mynloptalg;
double maxf;
nlopt_opt opt;
nlopt_result result;
/*--------------------------------------------------------------*/
/*----Now based on Command Line, Do the corresponding job----*/
/*----------------------------------------------------------------*/
//int Job; set Job to be gloabl variables;
PetscOptionsGetInt(PETSC_NULL,"-Job",&Job,&flg); MyCheckAndOutputInt(flg,Job,"Job","The Job indicator you set");
int numofvar=(Job==1)*DegFreeAll + (Job==3);
/*-------- convert the epsopt array to epsSReal (if job!=optmization) --------*/
if (Job==2 || Job ==3)
{
// copy epsilon from file to epsSReal; (different from FindOpt.c, because epsilon is not degree-of-freedoms in computeQ.
// i) create a array to read file (done above in epsopt); ii) convert the array to epsSReal;
int ns, ne;
ierr = VecGetOwnershipRange(epsSReal,&ns,&ne);
for(i=ns;i<ne;i++)
{ ierr=VecSetValue(epsSReal,i,epsoptAll[i],INSERT_VALUES);
CHKERRQ(ierr); }
if(withepsinldos)
{ epsatinterest = epsoptAll[cx*Ny*Nz + cy*Nz + cz] + epsair;
PetscPrintf(PETSC_COMM_WORLD, " the relative permitivity at the point of current is %.16e \n ",epsatinterest);}
ierr = VecAssemblyBegin(epsSReal); CHKERRQ(ierr);
ierr = VecAssemblyEnd(epsSReal); CHKERRQ(ierr);
}
if (Job==1 || Job==3) // optimization bounds setup;
{
PetscOptionsGetInt(PETSC_NULL,"-maxeval",&maxeval,&flg); MyCheckAndOutputInt(flg,maxeval,"maxeval","max number of evaluation");
PetscOptionsGetInt(PETSC_NULL,"-maxtime",&maxtime,&flg); MyCheckAndOutputInt(flg,maxtime,"maxtime","max time of evaluation");
PetscOptionsGetInt(PETSC_NULL,"-mynloptalg",&mynloptalg,&flg); MyCheckAndOutputInt(flg,mynloptalg,"mynloptalg","The algorithm used ");
PetscOptionsGetReal(PETSC_NULL,"-mylb",&mylb,&flg); MyCheckAndOutputDouble(flg,mylb,"mylb","optimization lb");
PetscOptionsGetReal(PETSC_NULL,"-myub",&myub,&flg); MyCheckAndOutputDouble(flg,myub,"myub","optimization ub");
lb = (double *) malloc(numofvar*sizeof(double));
ub = (double *) malloc(numofvar*sizeof(double));
// the dielectric constant at center is fixed!
for(i=0;i<numofvar;i++)
{
lb[i] = mylb;
ub[i] = myub;
} //initial guess, lower bounds, upper bounds;
// set lower and upper bounds for auxiliary variable;
lb[numofvar-1]=0;
ub[numofvar-1]=1.0/0.0;
//fix the dielectric at the center to be high for topology optimization;
if (Job==1 && fixpteps==1)
{
epsoptAll[0]=myub;
lb[0]=myub;
ub[0]=myub;
}
opt = nlopt_create(mynloptalg, numofvar);
myfundatatypeshg data[2] = {{omegaone, bone, weightedJ, epscoefone,kspone},{omegatwo, btwo, weightedJtwo, epscoeftwo,ksptwo}};
nlopt_add_inequality_constraint(opt,ldosconstraint, &data[0], 1e-8);
nlopt_add_inequality_constraint(opt,ldosconstraint, &data[1], 1e-8);
nlopt_set_lower_bounds(opt,lb);
nlopt_set_upper_bounds(opt,ub);
nlopt_set_maxeval(opt,maxeval);
nlopt_set_maxtime(opt,maxtime);
/*add functionality to choose local optimizer; */
int mynloptlocalalg;
nlopt_opt local_opt;
PetscOptionsGetInt(PETSC_NULL,"-mynloptlocalalg",&mynloptlocalalg,&flg); MyCheckAndOutputInt(flg,mynloptlocalalg,"mynloptlocalalg","The local optimization algorithm used ");
if (mynloptlocalalg)
{
local_opt=nlopt_create(mynloptlocalalg,numofvar);
nlopt_set_ftol_rel(local_opt, 1e-14);
nlopt_set_maxeval(local_opt,100000);
nlopt_set_local_optimizer(opt,local_opt);
}
}
switch (Job)
{
case 1:
{
if (minapproach)
nlopt_set_min_objective(opt,maxminobjfun,NULL);// NULL: no data to be passed because of global variables;
else
nlopt_set_max_objective(opt,maxminobjfun,NULL);
result = nlopt_optimize(opt,epsoptAll,&maxf);
}
break;
case 2 : //AnalyzeStructure
{
int Linear, Eig, maxeigit;
PetscOptionsGetInt(PETSC_NULL,"-Linear",&Linear,&flg); MyCheckAndOutputInt(flg,Linear,"Linear","Linear solver indicator");
PetscOptionsGetInt(PETSC_NULL,"-Eig",&Eig,&flg); MyCheckAndOutputInt(flg,Eig,"Eig","Eig solver indicator");
PetscOptionsGetInt(PETSC_NULL,"-maxeigit",&maxeigit,&flg); MyCheckAndOutputInt(flg,maxeigit,"maxeigit","maximum number of Eig solver iterations is");
/*----------------------------------*/
//EigenSolver(Linear, Eig, maxeigit);
/*----------------------------------*/
OutputVec(PETSC_COMM_WORLD, weight,filenameComm, "weight.m");
}
break;
default:
PetscPrintf(PETSC_COMM_WORLD,"--------Interesting! You're doing nothing!--------\n ");
}
if(Job==1 || Job==3)
{
/* print the optimization parameters */
#if 0
double xrel, frel, fabs;
// double *xabs;
frel=nlopt_get_ftol_rel(opt);
fabs=nlopt_get_ftol_abs(opt);
xrel=nlopt_get_xtol_rel(opt);
PetscPrintf(PETSC_COMM_WORLD,"nlopt frel is %g \n",frel);
PetscPrintf(PETSC_COMM_WORLD,"nlopt fabs is %g \n",fabs);
PetscPrintf(PETSC_COMM_WORLD,"nlopt xrel is %g \n",xrel);
//nlopt_result nlopt_get_xtol_abs(const nlopt_opt opt, double *tol);
#endif
/*--------------*/
if (result < 0) {
PetscPrintf(PETSC_COMM_WORLD,"nlopt failed! \n", result);
}
else {
PetscPrintf(PETSC_COMM_WORLD,"found extremum %0.16e\n", minapproach?1.0/maxf:maxf);
}
PetscPrintf(PETSC_COMM_WORLD,"nlopt returned value is %d \n", result);
if(Job==1)
{ //OutputVec(PETSC_COMM_WORLD, epsopt,filenameComm, "epsopt.m");
//OutputVec(PETSC_COMM_WORLD, epsgrad,filenameComm, "epsgrad.m");
//OutputVec(PETSC_COMM_WORLD, vgrad,filenameComm, "vgrad.m");
//OutputVec(PETSC_COMM_WORLD, x,filenameComm, "x.m");
int rankA;
MPI_Comm_rank(PETSC_COMM_WORLD, &rankA);
if(rankA==0)
{
ptf = fopen(strcat(filenameComm,"epsopt.txt"),"w");
for (i=0;i<DegFree;i++)
fprintf(ptf,"%0.16e \n",epsoptAll[i]);
fclose(ptf);
PetscPrintf(PETSC_COMM_WORLD,"the t parameter is %.8e \n",epsoptAll[DegFreeAll-1]);
}
}
nlopt_destroy(opt);
}
ierr = PetscPrintf(PETSC_COMM_WORLD,"--------Done!--------\n ");CHKERRQ(ierr);
/*------------------------------------*/
/* ----------------------Destroy Vecs and Mats----------------------------*/
free(epsoptAll);
free(lb);
free(ub);
ierr = VecDestroy(&J); CHKERRQ(ierr);
ierr = VecDestroy(&b); CHKERRQ(ierr);
ierr = VecDestroy(&weight); CHKERRQ(ierr);
ierr = VecDestroy(&weightedJ); CHKERRQ(ierr);
ierr = VecDestroy(&vR); CHKERRQ(ierr);
ierr = VecDestroy(&epspml); CHKERRQ(ierr);
ierr = VecDestroy(&epspmlQ); CHKERRQ(ierr);
ierr = VecDestroy(&epsSReal); CHKERRQ(ierr);
ierr = VecDestroy(&epsgrad); CHKERRQ(ierr);
ierr = VecDestroy(&vgrad); CHKERRQ(ierr);
ierr = VecDestroy(&epsmedium); CHKERRQ(ierr);
ierr = VecDestroy(&epsC); CHKERRQ(ierr);
ierr = VecDestroy(&epsCi); CHKERRQ(ierr);
ierr = VecDestroy(&epsP); CHKERRQ(ierr);
ierr = VecDestroy(&x); CHKERRQ(ierr);
ierr = VecDestroy(&vgradlocal);CHKERRQ(ierr);
ierr = VecDestroy(&tmp); CHKERRQ(ierr);
ierr = VecDestroy(&tmpa); CHKERRQ(ierr);
ierr = VecDestroy(&tmpb); CHKERRQ(ierr);
ierr = MatDestroy(&A); CHKERRQ(ierr);
ierr = MatDestroy(&D); CHKERRQ(ierr);
ierr = MatDestroy(&M); CHKERRQ(ierr);
ierr = VecDestroy(&epscoefone); CHKERRQ(ierr);
ierr = VecDestroy(&epscoeftwo); CHKERRQ(ierr);
ierr = KSPDestroy(&kspone);CHKERRQ(ierr);
ierr = KSPDestroy(&ksptwo);CHKERRQ(ierr);
ISDestroy(&from);
ISDestroy(&to);
if (withepsinldos)
{ierr=VecDestroy(&pickposvec); CHKERRQ(ierr);}
if (lrzsqr)
{
ierr=VecDestroy(&epsFReal); CHKERRQ(ierr);
ierr=VecDestroy(&xsqr); CHKERRQ(ierr);
ierr=VecDestroy(&y); CHKERRQ(ierr);
ierr=VecDestroy(&nb); CHKERRQ(ierr);
ierr=MatDestroy(&C); CHKERRQ(ierr);
}
ierr = VecDestroy(&bone); CHKERRQ(ierr);
ierr = VecDestroy(&btwo); CHKERRQ(ierr);
ierr = VecDestroy(&Jtwo); CHKERRQ(ierr);
/*------------ finalize the program -------------*/
{
int rank;
MPI_Comm_rank(PETSC_COMM_WORLD, &rank);
//if (rank == 0) fgetc(stdin);
MPI_Barrier(PETSC_COMM_WORLD);
}
ierr = PetscFinalize(); CHKERRQ(ierr);
return 0;
}
int main(int argc,char **argv)
{
Vec V,W;
MPI_Comm comm;
PetscScalar one=1,e=2.7181;
PetscReal nrm1,nrm2,nrm3,nrm4;
PetscInt ione=1;
PetscErrorCode ierr;
PetscFunctionBegin;
ierr = PetscInitialize(&argc,&argv,0,help);CHKERRQ(ierr);
comm = MPI_COMM_SELF;
ierr = VecCreateSeq(comm,10,&V);CHKERRQ(ierr);
ierr = VecSetRandom(V,NULL);CHKERRQ(ierr);
ierr = VecAssemblyBegin(V);CHKERRQ(ierr);
ierr = VecAssemblyEnd(V);CHKERRQ(ierr);
/*
* Initial
*/
/* display norm 1 & 2 */
ierr = VecNorm(V,NORM_1,&nrm1);CHKERRQ(ierr);
ierr = VecNorm(V,NORM_2,&nrm2);CHKERRQ(ierr);
ierr = PetscPrintf(comm,"Original: norm1=%e,norm2=%e\n",(double)nrm1,(double)nrm2);CHKERRQ(ierr);
/* display cached norm 1 & 2 */
ierr = VecNorm(V,NORM_1,&nrm1);CHKERRQ(ierr);
ierr = VecNorm(V,NORM_2,&nrm2);CHKERRQ(ierr);
ierr = PetscPrintf(comm,"cached: norm1=%e,norm2=%e\n",(double)nrm1,(double)nrm2);CHKERRQ(ierr);
/*
* Alter an element
*/
ierr = VecSetValues(V,1,&ione,&one,INSERT_VALUES);CHKERRQ(ierr);
/* display norm 1 & 2 */
ierr = VecNorm(V,NORM_1,&nrm1);CHKERRQ(ierr);
ierr = VecNorm(V,NORM_2,&nrm2);CHKERRQ(ierr);
ierr = PetscPrintf(comm,"Altered: norm1=%e,norm2=%e\n",(double)nrm1,(double)nrm2);CHKERRQ(ierr);
/* display cached norm 1 & 2 */
ierr = VecNorm(V,NORM_1,&nrm1);CHKERRQ(ierr);
ierr = VecNorm(V,NORM_2,&nrm2);CHKERRQ(ierr);
ierr = PetscPrintf(comm,"recomputed: norm1=%e,norm2=%e\n",(double)nrm1,(double)nrm2);CHKERRQ(ierr);
/*
* Scale the vector a little
*/
ierr = VecScale(V,e);CHKERRQ(ierr);
/* display updated cached norm 1 & 2 */
ierr = VecNorm(V,NORM_1,&nrm1);CHKERRQ(ierr);
ierr = VecNorm(V,NORM_2,&nrm2);CHKERRQ(ierr);
ierr = PetscPrintf(comm,"Scale: norm1=%e,norm2=%e\n",(double)nrm1,(double)nrm2);CHKERRQ(ierr);
/* display forced norm 1 & 2 */
ierr = PetscObjectStateIncrease((PetscObject)V);CHKERRQ(ierr);
ierr = VecNorm(V,NORM_1,&nrm1);CHKERRQ(ierr);
ierr = VecNorm(V,NORM_2,&nrm2);CHKERRQ(ierr);
ierr = PetscPrintf(comm,"recompute: norm1=%e,norm2=%e\n",(double)nrm1,(double)nrm2);CHKERRQ(ierr);
/*
* Normalize the vector a little
*/
ierr = VecNormalize(V,&nrm1);CHKERRQ(ierr);
/* display updated cached norm 1 & 2 */
ierr = VecNorm(V,NORM_1,&nrm1);CHKERRQ(ierr);
ierr = VecNorm(V,NORM_2,&nrm2);CHKERRQ(ierr);
ierr = PetscPrintf(comm,"Normalize: norm1=%e,norm2=%e\n",(double)nrm1,(double)nrm2);CHKERRQ(ierr);
/* display forced norm 1 & 2 */
ierr = PetscObjectStateIncrease((PetscObject)V);CHKERRQ(ierr);
ierr = VecNorm(V,NORM_1,&nrm1);CHKERRQ(ierr);
ierr = VecNorm(V,NORM_2,&nrm2);CHKERRQ(ierr);
ierr = PetscPrintf(comm,"recompute: norm1=%e,norm2=%e\n",(double)nrm1,(double)nrm2);CHKERRQ(ierr);
/*
* Copy to another vector
*/
ierr = VecDuplicate(V,&W);CHKERRQ(ierr);
ierr = VecCopy(V,W);CHKERRQ(ierr);
/* display norm 1 & 2 */
ierr = VecNorm(V,NORM_1,&nrm1);CHKERRQ(ierr);
ierr = VecNorm(V,NORM_2,&nrm2);CHKERRQ(ierr);
ierr = PetscPrintf(comm,"Original: norm1=%e,norm2=%e\n",(double)nrm1,(double)nrm2);CHKERRQ(ierr);
/* display cached norm 1 & 2 */
ierr = VecNorm(W,NORM_1,&nrm1);CHKERRQ(ierr);
ierr = VecNorm(W,NORM_2,&nrm2);CHKERRQ(ierr);
ierr = PetscPrintf(comm,"copied: norm1=%e,norm2=%e\n",(double)nrm1,(double)nrm2);CHKERRQ(ierr);
/*
* Copy while data is invalid
*/
ierr = VecSetValues(V,1,&ione,&one,INSERT_VALUES);CHKERRQ(ierr);
ierr = VecCopy(V,W);CHKERRQ(ierr);
/* display norm 1 & 2 */
ierr = VecNorm(V,NORM_1,&nrm1);CHKERRQ(ierr);
ierr = VecNorm(V,NORM_2,&nrm2);CHKERRQ(ierr);
ierr = PetscPrintf(comm,"Invalidated: norm1=%e,norm2=%e\n",(double)nrm1,(double)nrm2);CHKERRQ(ierr);
/* display norm 1 & 2 */
ierr = VecNorm(W,NORM_1,&nrm1);CHKERRQ(ierr);
ierr = VecNorm(W,NORM_2,&nrm2);CHKERRQ(ierr);
ierr = PetscPrintf(comm,"copied: norm1=%e,norm2=%e\n",(double)nrm1,(double)nrm2);CHKERRQ(ierr);
/*
* Constant vector
*/
ierr = VecSet(V,e);CHKERRQ(ierr);
/* display updated cached norm 1 & 2 */
ierr = VecNorm(V,NORM_1,&nrm1);CHKERRQ(ierr);
ierr = VecNorm(V,NORM_2,&nrm2);CHKERRQ(ierr);
ierr = PetscPrintf(comm,"Constant: norm1=%e,norm2=%e\n",(double)nrm1,(double)nrm2);CHKERRQ(ierr);
/* display forced norm 1 & 2 */
ierr = PetscObjectStateIncrease((PetscObject)V);CHKERRQ(ierr);
ierr = VecNorm(V,NORM_1,&nrm1);CHKERRQ(ierr);
ierr = VecNorm(V,NORM_2,&nrm2);CHKERRQ(ierr);
ierr = PetscPrintf(comm,"recomputed: norm1=%e,norm2=%e\n",(double)nrm1,(double)nrm2);CHKERRQ(ierr);
/*
* Swap vectors
*/
ierr = VecNorm(V,NORM_1,&nrm1);CHKERRQ(ierr);
ierr = VecNorm(W,NORM_1,&nrm2);CHKERRQ(ierr);
ierr = PetscPrintf(comm,"Orig: norm_V=%e,norm_W=%e\n",(double)nrm1,(double)nrm2);CHKERRQ(ierr);
/* store inf norm */
ierr = VecNorm(V,NORM_INFINITY,&nrm3);CHKERRQ(ierr);
ierr = VecNorm(W,NORM_INFINITY,&nrm4);CHKERRQ(ierr);
ierr = VecSwap(V,W);CHKERRQ(ierr);
ierr = PetscObjectStateIncrease((PetscObject)V);CHKERRQ(ierr);
ierr = PetscObjectStateIncrease((PetscObject)W);CHKERRQ(ierr);
ierr = VecNorm(V,NORM_1,&nrm1);CHKERRQ(ierr);
ierr = VecNorm(W,NORM_1,&nrm2);CHKERRQ(ierr);
ierr = PetscPrintf(comm,"swapped: norm_V=%e,norm_W=%e\n",(double)nrm2,(double)nrm1);CHKERRQ(ierr);
ierr = PetscPrintf(comm,"orig: F-norm_V=%e,F-norm_W=%e\n",(double)nrm3,(double)nrm4);CHKERRQ(ierr);
ierr = VecNorm(V,NORM_INFINITY,&nrm3);CHKERRQ(ierr);
ierr = VecNorm(W,NORM_INFINITY,&nrm4);CHKERRQ(ierr);
ierr = PetscPrintf(comm,"swapped: F-norm_V=%e,F-norm_W=%e\n",(double)nrm4,(double)nrm3);CHKERRQ(ierr);
ierr = VecDestroy(&V);CHKERRQ(ierr);
ierr = VecDestroy(&W);CHKERRQ(ierr);
PetscFinalize();
PetscFunctionReturn(0);
}
int main(int argc,char **args)
{
Mat C;
PetscErrorCode ierr;
PetscInt i,m = 2,N,M,its,idx[4],count,*rows;
PetscScalar val,Ke[16],r[4];
PetscReal x,y,h,norm,tol=1.e-14;
Vec u,ustar,b;
KSP ksp;
PetscInitialize(&argc,&args,(char*)0,help);
ierr = PetscOptionsGetInt(NULL,"-m",&m,NULL);CHKERRQ(ierr);
N = (m+1)*(m+1); /* dimension of matrix */
M = m*m; /* number of elements */
h = 1.0/m; /* mesh width */
/* create stiffness matrix */
ierr = MatCreateSeqAIJ(PETSC_COMM_SELF,N,N,9,NULL,&C);CHKERRQ(ierr);
ierr = MatSetUp(C);CHKERRQ(ierr);
/* forms the element stiffness for the Laplacian */
ierr = FormElementStiffness(h*h,Ke);CHKERRQ(ierr);
for (i=0; i<M; i++) {
/* location of lower left corner of element */
x = h*(i % m); y = h*(i/m);
/* node numbers for the four corners of element */
idx[0] = (m+1)*(i/m) + (i % m);
idx[1] = idx[0]+1; idx[2] = idx[1] + m + 1; idx[3] = idx[2] - 1;
ierr = MatSetValues(C,4,idx,4,idx,Ke,ADD_VALUES);CHKERRQ(ierr);
}
ierr = MatAssemblyBegin(C,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
ierr = MatAssemblyEnd(C,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
/* create right hand side and solution */
ierr = VecCreateSeq(PETSC_COMM_SELF,N,&u);CHKERRQ(ierr);
ierr = VecDuplicate(u,&b);CHKERRQ(ierr);
ierr = VecDuplicate(b,&ustar);CHKERRQ(ierr);
ierr = VecSet(u,0.0);CHKERRQ(ierr);
ierr = VecSet(b,0.0);CHKERRQ(ierr);
for (i=0; i<M; i++) {
/* location of lower left corner of element */
x = h*(i % m); y = h*(i/m);
/* node numbers for the four corners of element */
idx[0] = (m+1)*(i/m) + (i % m);
idx[1] = idx[0]+1; idx[2] = idx[1] + m + 1; idx[3] = idx[2] - 1;
ierr = FormElementRhs(x,y,h*h,r);CHKERRQ(ierr);
ierr = VecSetValues(b,4,idx,r,ADD_VALUES);CHKERRQ(ierr);
}
ierr = VecAssemblyBegin(b);CHKERRQ(ierr);
ierr = VecAssemblyEnd(b);CHKERRQ(ierr);
/* modify matrix and rhs for Dirichlet boundary conditions */
ierr = PetscMalloc1((4*m+1),&rows);CHKERRQ(ierr);
for (i=0; i<m+1; i++) {
rows[i] = i; /* bottom */
rows[3*m - 1 +i] = m*(m+1) + i; /* top */
}
count = m+1; /* left side */
for (i=m+1; i<m*(m+1); i+= m+1) rows[count++] = i;
count = 2*m; /* left side */
for (i=2*m+1; i<m*(m+1); i+= m+1) rows[count++] = i;
for (i=0; i<4*m; i++) {
x = h*(rows[i] % (m+1)); y = h*(rows[i]/(m+1));
val = y;
ierr = VecSetValues(u,1,&rows[i],&val,INSERT_VALUES);CHKERRQ(ierr);
ierr = VecSetValues(b,1,&rows[i],&val,INSERT_VALUES);CHKERRQ(ierr);
}
ierr = MatZeroRows(C,4*m,rows,1.0,0,0);CHKERRQ(ierr);
ierr = PetscFree(rows);CHKERRQ(ierr);
ierr = VecAssemblyBegin(u);CHKERRQ(ierr);
ierr = VecAssemblyEnd(u);CHKERRQ(ierr);
ierr = VecAssemblyBegin(b);CHKERRQ(ierr);
ierr = VecAssemblyEnd(b);CHKERRQ(ierr);
/* solve linear system */
ierr = KSPCreate(PETSC_COMM_WORLD,&ksp);CHKERRQ(ierr);
ierr = KSPSetOperators(ksp,C,C,DIFFERENT_NONZERO_PATTERN);CHKERRQ(ierr);
ierr = KSPSetFromOptions(ksp);CHKERRQ(ierr);
ierr = KSPSetInitialGuessNonzero(ksp,PETSC_TRUE);CHKERRQ(ierr);
ierr = KSPSolve(ksp,b,u);CHKERRQ(ierr);
/* check error */
for (i=0; i<N; i++) {
x = h*(i % (m+1)); y = h*(i/(m+1));
val = y;
ierr = VecSetValues(ustar,1,&i,&val,INSERT_VALUES);CHKERRQ(ierr);
}
ierr = VecAssemblyBegin(ustar);CHKERRQ(ierr);
ierr = VecAssemblyEnd(ustar);CHKERRQ(ierr);
ierr = VecAXPY(u,-1.0,ustar);CHKERRQ(ierr);
ierr = VecNorm(u,NORM_2,&norm);CHKERRQ(ierr);
ierr = KSPGetIterationNumber(ksp,&its);CHKERRQ(ierr);
if (norm > tol) {
ierr = PetscPrintf(PETSC_COMM_WORLD,"Norm of error %G Iterations %D\n",norm*h,its);CHKERRQ(ierr);
}
ierr = KSPDestroy(&ksp);CHKERRQ(ierr);
ierr = VecDestroy(&ustar);CHKERRQ(ierr);
ierr = VecDestroy(&u);CHKERRQ(ierr);
ierr = VecDestroy(&b);CHKERRQ(ierr);
ierr = MatDestroy(&C);CHKERRQ(ierr);
ierr = PetscFinalize();
return 0;
}
int main(int Argc,char **Args)
{
PetscInt x_mesh = 15,levels = 3,cycles = 1,use_jacobi = 0;
PetscInt i,smooths = 1,*N,its;
PetscErrorCode ierr;
PCMGType am = PC_MG_MULTIPLICATIVE;
Mat cmat,mat[20],fmat;
KSP cksp,ksp[20],kspmg;
PetscReal e[3]; /* l_2 error,max error, residual */
const char *shellname;
Vec x,solution,X[20],R[20],B[20];
PC pcmg,pc;
PetscBool flg;
PetscInitialize(&Argc,&Args,(char*)0,help);
ierr = PetscOptionsGetInt(NULL,"-x",&x_mesh,NULL);CHKERRQ(ierr);
ierr = PetscOptionsGetInt(NULL,"-l",&levels,NULL);CHKERRQ(ierr);
ierr = PetscOptionsGetInt(NULL,"-c",&cycles,NULL);CHKERRQ(ierr);
ierr = PetscOptionsGetInt(NULL,"-smooths",&smooths,NULL);CHKERRQ(ierr);
ierr = PetscOptionsHasName(NULL,"-a",&flg);CHKERRQ(ierr);
if (flg) am = PC_MG_ADDITIVE;
ierr = PetscOptionsHasName(NULL,"-f",&flg);CHKERRQ(ierr);
if (flg) am = PC_MG_FULL;
ierr = PetscOptionsHasName(NULL,"-j",&flg);CHKERRQ(ierr);
if (flg) use_jacobi = 1;
ierr = PetscMalloc1(levels,&N);CHKERRQ(ierr);
N[0] = x_mesh;
for (i=1; i<levels; i++) {
N[i] = N[i-1]/2;
if (N[i] < 1) SETERRQ(PETSC_COMM_WORLD,1,"Too many levels");
}
ierr = Create1dLaplacian(N[levels-1],&cmat);CHKERRQ(ierr);
ierr = KSPCreate(PETSC_COMM_WORLD,&kspmg);CHKERRQ(ierr);
ierr = KSPGetPC(kspmg,&pcmg);CHKERRQ(ierr);
ierr = KSPSetFromOptions(kspmg);CHKERRQ(ierr);
ierr = PCSetType(pcmg,PCMG);CHKERRQ(ierr);
ierr = PCMGSetLevels(pcmg,levels,NULL);CHKERRQ(ierr);
ierr = PCMGSetType(pcmg,am);CHKERRQ(ierr);
ierr = PCMGGetCoarseSolve(pcmg,&cksp);CHKERRQ(ierr);
ierr = KSPSetOperators(cksp,cmat,cmat);CHKERRQ(ierr);
ierr = KSPGetPC(cksp,&pc);CHKERRQ(ierr);
ierr = PCSetType(pc,PCLU);CHKERRQ(ierr);
ierr = KSPSetType(cksp,KSPPREONLY);CHKERRQ(ierr);
/* zero is finest level */
for (i=0; i<levels-1; i++) {
ierr = PCMGSetResidual(pcmg,levels - 1 - i,residual,(Mat)0);CHKERRQ(ierr);
ierr = MatCreateShell(PETSC_COMM_WORLD,N[i+1],N[i],N[i+1],N[i],(void*)0,&mat[i]);CHKERRQ(ierr);
ierr = MatShellSetOperation(mat[i],MATOP_MULT,(void (*)(void))restrct);CHKERRQ(ierr);
ierr = MatShellSetOperation(mat[i],MATOP_MULT_TRANSPOSE_ADD,(void (*)(void))interpolate);CHKERRQ(ierr);
ierr = PCMGSetInterpolation(pcmg,levels - 1 - i,mat[i]);CHKERRQ(ierr);
ierr = PCMGSetRestriction(pcmg,levels - 1 - i,mat[i]);CHKERRQ(ierr);
ierr = PCMGSetCyclesOnLevel(pcmg,levels - 1 - i,cycles);CHKERRQ(ierr);
/* set smoother */
ierr = PCMGGetSmoother(pcmg,levels - 1 - i,&ksp[i]);CHKERRQ(ierr);
ierr = KSPGetPC(ksp[i],&pc);CHKERRQ(ierr);
ierr = PCSetType(pc,PCSHELL);CHKERRQ(ierr);
ierr = PCShellSetName(pc,"user_precond");CHKERRQ(ierr);
ierr = PCShellGetName(pc,&shellname);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"level=%D, PCShell name is %s\n",i,shellname);CHKERRQ(ierr);
/* this is a dummy! since KSP requires a matrix passed in */
ierr = KSPSetOperators(ksp[i],mat[i],mat[i]);CHKERRQ(ierr);
/*
We override the matrix passed in by forcing it to use Richardson with
a user provided application. This is non-standard and this practice
should be avoided.
*/
ierr = PCShellSetApplyRichardson(pc,gauss_seidel);CHKERRQ(ierr);
if (use_jacobi) {
ierr = PCShellSetApplyRichardson(pc,jacobi);CHKERRQ(ierr);
}
ierr = KSPSetType(ksp[i],KSPRICHARDSON);CHKERRQ(ierr);
ierr = KSPSetInitialGuessNonzero(ksp[i],PETSC_TRUE);CHKERRQ(ierr);
ierr = KSPSetTolerances(ksp[i],PETSC_DEFAULT,PETSC_DEFAULT,PETSC_DEFAULT,smooths);CHKERRQ(ierr);
ierr = VecCreateSeq(PETSC_COMM_SELF,N[i],&x);CHKERRQ(ierr);
X[levels - 1 - i] = x;
if (i > 0) {
ierr = PCMGSetX(pcmg,levels - 1 - i,x);CHKERRQ(ierr);
}
ierr = VecCreateSeq(PETSC_COMM_SELF,N[i],&x);CHKERRQ(ierr);
B[levels -1 - i] = x;
if (i > 0) {
ierr = PCMGSetRhs(pcmg,levels - 1 - i,x);CHKERRQ(ierr);
}
ierr = VecCreateSeq(PETSC_COMM_SELF,N[i],&x);CHKERRQ(ierr);
R[levels - 1 - i] = x;
ierr = PCMGSetR(pcmg,levels - 1 - i,x);CHKERRQ(ierr);
}
/* create coarse level vectors */
ierr = VecCreateSeq(PETSC_COMM_SELF,N[levels-1],&x);CHKERRQ(ierr);
ierr = PCMGSetX(pcmg,0,x);CHKERRQ(ierr); X[0] = x;
ierr = VecCreateSeq(PETSC_COMM_SELF,N[levels-1],&x);CHKERRQ(ierr);
ierr = PCMGSetRhs(pcmg,0,x);CHKERRQ(ierr); B[0] = x;
/* create matrix multiply for finest level */
ierr = MatCreateShell(PETSC_COMM_WORLD,N[0],N[0],N[0],N[0],(void*)0,&fmat);CHKERRQ(ierr);
ierr = MatShellSetOperation(fmat,MATOP_MULT,(void (*)(void))amult);CHKERRQ(ierr);
ierr = KSPSetOperators(kspmg,fmat,fmat);CHKERRQ(ierr);
ierr = CalculateSolution(N[0],&solution);CHKERRQ(ierr);
ierr = CalculateRhs(B[levels-1]);CHKERRQ(ierr);
ierr = VecSet(X[levels-1],0.0);CHKERRQ(ierr);
ierr = residual((Mat)0,B[levels-1],X[levels-1],R[levels-1]);CHKERRQ(ierr);
ierr = CalculateError(solution,X[levels-1],R[levels-1],e);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_SELF,"l_2 error %g max error %g resi %g\n",(double)e[0],(double)e[1],(double)e[2]);CHKERRQ(ierr);
ierr = KSPSolve(kspmg,B[levels-1],X[levels-1]);CHKERRQ(ierr);
ierr = KSPGetIterationNumber(kspmg,&its);CHKERRQ(ierr);
ierr = residual((Mat)0,B[levels-1],X[levels-1],R[levels-1]);CHKERRQ(ierr);
ierr = CalculateError(solution,X[levels-1],R[levels-1],e);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_SELF,"its %D l_2 error %g max error %g resi %g\n",its,(double)e[0],(double)e[1],(double)e[2]);CHKERRQ(ierr);
ierr = PetscFree(N);CHKERRQ(ierr);
ierr = VecDestroy(&solution);CHKERRQ(ierr);
/* note we have to keep a list of all vectors allocated, this is
not ideal, but putting it in MGDestroy is not so good either*/
for (i=0; i<levels; i++) {
ierr = VecDestroy(&X[i]);CHKERRQ(ierr);
ierr = VecDestroy(&B[i]);CHKERRQ(ierr);
if (i) {ierr = VecDestroy(&R[i]);CHKERRQ(ierr);}
}
for (i=0; i<levels-1; i++) {
ierr = MatDestroy(&mat[i]);CHKERRQ(ierr);
}
ierr = MatDestroy(&cmat);CHKERRQ(ierr);
ierr = MatDestroy(&fmat);CHKERRQ(ierr);
ierr = KSPDestroy(&kspmg);CHKERRQ(ierr);
ierr = PetscFinalize();
return 0;
}
PetscErrorCode PCISSetUp(PC pc)
{
PC_IS *pcis = (PC_IS*)(pc->data);
Mat_IS *matis;
PetscErrorCode ierr;
PetscBool flg,issbaij;
Vec counter;
PetscFunctionBegin;
ierr = PetscObjectTypeCompare((PetscObject)pc->pmat,MATIS,&flg);CHKERRQ(ierr);
if (!flg) SETERRQ(PetscObjectComm((PetscObject)pc),PETSC_ERR_ARG_WRONG,"Preconditioner type of Neumann Neumman requires matrix of type MATIS");
matis = (Mat_IS*)pc->pmat->data;
pcis->pure_neumann = matis->pure_neumann;
/* get info on mapping */
ierr = PetscObjectReference((PetscObject)matis->mapping);CHKERRQ(ierr);
ierr = ISLocalToGlobalMappingDestroy(&pcis->mapping);CHKERRQ(ierr);
pcis->mapping = matis->mapping;
ierr = ISLocalToGlobalMappingGetSize(pcis->mapping,&pcis->n);CHKERRQ(ierr);
ierr = ISLocalToGlobalMappingGetInfo(pcis->mapping,&(pcis->n_neigh),&(pcis->neigh),&(pcis->n_shared),&(pcis->shared));CHKERRQ(ierr);
/* Creating local and global index sets for interior and inteface nodes. */
{
PetscInt n_I;
PetscInt *idx_I_local,*idx_B_local,*idx_I_global,*idx_B_global;
PetscInt *array;
PetscInt i,j;
/* Identifying interior and interface nodes, in local numbering */
ierr = PetscMalloc1(pcis->n,&array);CHKERRQ(ierr);
ierr = PetscMemzero(array,pcis->n*sizeof(PetscInt));CHKERRQ(ierr);
for (i=0;i<pcis->n_neigh;i++)
for (j=0;j<pcis->n_shared[i];j++)
array[pcis->shared[i][j]] += 1;
ierr = PetscMalloc1(pcis->n,&idx_I_local);CHKERRQ(ierr);
ierr = PetscMalloc1(pcis->n,&idx_B_local);CHKERRQ(ierr);
for (i=0, pcis->n_B=0, n_I=0; i<pcis->n; i++) {
if (!array[i]) {
idx_I_local[n_I] = i;
n_I++;
} else {
idx_B_local[pcis->n_B] = i;
pcis->n_B++;
}
}
/* Getting the global numbering */
idx_B_global = idx_I_local + n_I; /* Just avoiding allocating extra memory, since we have vacant space */
idx_I_global = idx_B_local + pcis->n_B;
ierr = ISLocalToGlobalMappingApply(pcis->mapping,pcis->n_B,idx_B_local,idx_B_global);CHKERRQ(ierr);
ierr = ISLocalToGlobalMappingApply(pcis->mapping,n_I, idx_I_local,idx_I_global);CHKERRQ(ierr);
/* Creating the index sets. */
ierr = ISCreateGeneral(PETSC_COMM_SELF,pcis->n_B,idx_B_local,PETSC_COPY_VALUES, &pcis->is_B_local);CHKERRQ(ierr);
ierr = ISCreateGeneral(PETSC_COMM_SELF,pcis->n_B,idx_B_global,PETSC_COPY_VALUES,&pcis->is_B_global);CHKERRQ(ierr);
ierr = ISCreateGeneral(PETSC_COMM_SELF,n_I,idx_I_local,PETSC_COPY_VALUES, &pcis->is_I_local);CHKERRQ(ierr);
ierr = ISCreateGeneral(PETSC_COMM_SELF,n_I,idx_I_global,PETSC_COPY_VALUES,&pcis->is_I_global);CHKERRQ(ierr);
/* Freeing memory and restoring arrays */
ierr = PetscFree(idx_B_local);CHKERRQ(ierr);
ierr = PetscFree(idx_I_local);CHKERRQ(ierr);
ierr = PetscFree(array);CHKERRQ(ierr);
}
/*
Extracting the blocks A_II, A_BI, A_IB and A_BB from A. If the numbering
is such that interior nodes come first than the interface ones, we have
[ | ]
[ A_II | A_IB ]
A = [ | ]
[-----------+------]
[ A_BI | A_BB ]
*/
ierr = MatGetSubMatrix(matis->A,pcis->is_I_local,pcis->is_I_local,MAT_INITIAL_MATRIX,&pcis->A_II);CHKERRQ(ierr);
ierr = MatGetSubMatrix(matis->A,pcis->is_B_local,pcis->is_B_local,MAT_INITIAL_MATRIX,&pcis->A_BB);CHKERRQ(ierr);
ierr = PetscObjectTypeCompare((PetscObject)matis->A,MATSEQSBAIJ,&issbaij);CHKERRQ(ierr);
if (!issbaij) {
ierr = MatGetSubMatrix(matis->A,pcis->is_I_local,pcis->is_B_local,MAT_INITIAL_MATRIX,&pcis->A_IB);CHKERRQ(ierr);
ierr = MatGetSubMatrix(matis->A,pcis->is_B_local,pcis->is_I_local,MAT_INITIAL_MATRIX,&pcis->A_BI);CHKERRQ(ierr);
} else {
Mat newmat;
ierr = MatConvert(matis->A,MATSEQBAIJ,MAT_INITIAL_MATRIX,&newmat);CHKERRQ(ierr);
ierr = MatGetSubMatrix(newmat,pcis->is_I_local,pcis->is_B_local,MAT_INITIAL_MATRIX,&pcis->A_IB);CHKERRQ(ierr);
ierr = MatGetSubMatrix(newmat,pcis->is_B_local,pcis->is_I_local,MAT_INITIAL_MATRIX,&pcis->A_BI);CHKERRQ(ierr);
ierr = MatDestroy(&newmat);CHKERRQ(ierr);
}
/*
Creating work vectors and arrays
*/
ierr = VecDuplicate(matis->x,&pcis->vec1_N);CHKERRQ(ierr);
ierr = VecDuplicate(pcis->vec1_N,&pcis->vec2_N);CHKERRQ(ierr);
ierr = VecCreateSeq(PETSC_COMM_SELF,pcis->n-pcis->n_B,&pcis->vec1_D);CHKERRQ(ierr);
ierr = VecDuplicate(pcis->vec1_D,&pcis->vec2_D);CHKERRQ(ierr);
ierr = VecDuplicate(pcis->vec1_D,&pcis->vec3_D);CHKERRQ(ierr);
ierr = VecDuplicate(pcis->vec1_D,&pcis->vec4_D);CHKERRQ(ierr);
ierr = VecCreateSeq(PETSC_COMM_SELF,pcis->n_B,&pcis->vec1_B);CHKERRQ(ierr);
ierr = VecDuplicate(pcis->vec1_B,&pcis->vec2_B);CHKERRQ(ierr);
ierr = VecDuplicate(pcis->vec1_B,&pcis->vec3_B);CHKERRQ(ierr);
ierr = MatCreateVecs(pc->pmat,&pcis->vec1_global,0);CHKERRQ(ierr);
ierr = PetscMalloc1(pcis->n,&pcis->work_N);CHKERRQ(ierr);
/* Creating the scatter contexts */
ierr = VecScatterCreate(pcis->vec1_global,pcis->is_I_global,pcis->vec1_D,(IS)0,&pcis->global_to_D);CHKERRQ(ierr);
ierr = VecScatterCreate(pcis->vec1_N,pcis->is_B_local,pcis->vec1_B,(IS)0,&pcis->N_to_B);CHKERRQ(ierr);
ierr = VecScatterCreate(pcis->vec1_global,pcis->is_B_global,pcis->vec1_B,(IS)0,&pcis->global_to_B);CHKERRQ(ierr);
/* Creating scaling "matrix" D */
ierr = PetscOptionsGetBool(((PetscObject)pc)->prefix,"-pc_is_use_stiffness_scaling",&pcis->use_stiffness_scaling,NULL);CHKERRQ(ierr);
if (!pcis->D) {
ierr = VecDuplicate(pcis->vec1_B,&pcis->D);CHKERRQ(ierr);
if (!pcis->use_stiffness_scaling) {
ierr = VecSet(pcis->D,pcis->scaling_factor);CHKERRQ(ierr);
} else {
ierr = MatGetDiagonal(matis->A,pcis->vec1_N);CHKERRQ(ierr);
ierr = VecScatterBegin(pcis->N_to_B,pcis->vec1_N,pcis->D,INSERT_VALUES,SCATTER_FORWARD);CHKERRQ(ierr);
ierr = VecScatterEnd (pcis->N_to_B,pcis->vec1_N,pcis->D,INSERT_VALUES,SCATTER_FORWARD);CHKERRQ(ierr);
}
}
ierr = VecCopy(pcis->D,pcis->vec1_B);CHKERRQ(ierr);
ierr = MatCreateVecs(pc->pmat,&counter,0);CHKERRQ(ierr); /* temporary auxiliar vector */
ierr = VecSet(counter,0.0);CHKERRQ(ierr);
ierr = VecScatterBegin(pcis->global_to_B,pcis->vec1_B,counter,ADD_VALUES,SCATTER_REVERSE);CHKERRQ(ierr);
ierr = VecScatterEnd (pcis->global_to_B,pcis->vec1_B,counter,ADD_VALUES,SCATTER_REVERSE);CHKERRQ(ierr);
ierr = VecScatterBegin(pcis->global_to_B,counter,pcis->vec1_B,INSERT_VALUES,SCATTER_FORWARD);CHKERRQ(ierr);
ierr = VecScatterEnd (pcis->global_to_B,counter,pcis->vec1_B,INSERT_VALUES,SCATTER_FORWARD);CHKERRQ(ierr);
ierr = VecPointwiseDivide(pcis->D,pcis->D,pcis->vec1_B);CHKERRQ(ierr);
ierr = VecDestroy(&counter);CHKERRQ(ierr);
/* See historical note 01, at the bottom of this file. */
/*
Creating the KSP contexts for the local Dirichlet and Neumann problems.
*/
if (pcis->computesolvers) {
PC pc_ctx;
/* Dirichlet */
ierr = KSPCreate(PETSC_COMM_SELF,&pcis->ksp_D);CHKERRQ(ierr);
ierr = PetscObjectIncrementTabLevel((PetscObject)pcis->ksp_D,(PetscObject)pc,1);CHKERRQ(ierr);
ierr = KSPSetOperators(pcis->ksp_D,pcis->A_II,pcis->A_II);CHKERRQ(ierr);
ierr = KSPSetOptionsPrefix(pcis->ksp_D,"is_localD_");CHKERRQ(ierr);
ierr = KSPGetPC(pcis->ksp_D,&pc_ctx);CHKERRQ(ierr);
ierr = PCSetType(pc_ctx,PCLU);CHKERRQ(ierr);
ierr = KSPSetType(pcis->ksp_D,KSPPREONLY);CHKERRQ(ierr);
ierr = KSPSetFromOptions(pcis->ksp_D);CHKERRQ(ierr);
/* the vectors in the following line are dummy arguments, just telling the KSP the vector size. Values are not used */
ierr = KSPSetUp(pcis->ksp_D);CHKERRQ(ierr);
/* Neumann */
ierr = KSPCreate(PETSC_COMM_SELF,&pcis->ksp_N);CHKERRQ(ierr);
ierr = PetscObjectIncrementTabLevel((PetscObject)pcis->ksp_N,(PetscObject)pc,1);CHKERRQ(ierr);
ierr = KSPSetOperators(pcis->ksp_N,matis->A,matis->A);CHKERRQ(ierr);
ierr = KSPSetOptionsPrefix(pcis->ksp_N,"is_localN_");CHKERRQ(ierr);
ierr = KSPGetPC(pcis->ksp_N,&pc_ctx);CHKERRQ(ierr);
ierr = PCSetType(pc_ctx,PCLU);CHKERRQ(ierr);
ierr = KSPSetType(pcis->ksp_N,KSPPREONLY);CHKERRQ(ierr);
ierr = KSPSetFromOptions(pcis->ksp_N);CHKERRQ(ierr);
{
PetscBool damp_fixed = PETSC_FALSE,
remove_nullspace_fixed = PETSC_FALSE,
set_damping_factor_floating = PETSC_FALSE,
not_damp_floating = PETSC_FALSE,
not_remove_nullspace_floating = PETSC_FALSE;
PetscReal fixed_factor,
floating_factor;
ierr = PetscOptionsGetReal(((PetscObject)pc_ctx)->prefix,"-pc_is_damp_fixed",&fixed_factor,&damp_fixed);CHKERRQ(ierr);
if (!damp_fixed) fixed_factor = 0.0;
ierr = PetscOptionsGetBool(((PetscObject)pc_ctx)->prefix,"-pc_is_damp_fixed",&damp_fixed,NULL);CHKERRQ(ierr);
ierr = PetscOptionsGetBool(((PetscObject)pc_ctx)->prefix,"-pc_is_remove_nullspace_fixed",&remove_nullspace_fixed,NULL);CHKERRQ(ierr);
ierr = PetscOptionsGetReal(((PetscObject)pc_ctx)->prefix,"-pc_is_set_damping_factor_floating",
&floating_factor,&set_damping_factor_floating);CHKERRQ(ierr);
if (!set_damping_factor_floating) floating_factor = 0.0;
ierr = PetscOptionsGetBool(((PetscObject)pc_ctx)->prefix,"-pc_is_set_damping_factor_floating",&set_damping_factor_floating,NULL);CHKERRQ(ierr);
if (!set_damping_factor_floating) floating_factor = 1.e-12;
ierr = PetscOptionsGetBool(((PetscObject)pc_ctx)->prefix,"-pc_is_not_damp_floating",¬_damp_floating,NULL);CHKERRQ(ierr);
ierr = PetscOptionsGetBool(((PetscObject)pc_ctx)->prefix,"-pc_is_not_remove_nullspace_floating",¬_remove_nullspace_floating,NULL);CHKERRQ(ierr);
if (pcis->pure_neumann) { /* floating subdomain */
if (!(not_damp_floating)) {
ierr = PCFactorSetShiftType(pc_ctx,MAT_SHIFT_NONZERO);CHKERRQ(ierr);
ierr = PCFactorSetShiftAmount(pc_ctx,floating_factor);CHKERRQ(ierr);
}
if (!(not_remove_nullspace_floating)) {
MatNullSpace nullsp;
ierr = MatNullSpaceCreate(PETSC_COMM_SELF,PETSC_TRUE,0,NULL,&nullsp);CHKERRQ(ierr);
ierr = KSPSetNullSpace(pcis->ksp_N,nullsp);CHKERRQ(ierr);
ierr = MatNullSpaceDestroy(&nullsp);CHKERRQ(ierr);
}
} else { /* fixed subdomain */
if (damp_fixed) {
ierr = PCFactorSetShiftType(pc_ctx,MAT_SHIFT_NONZERO);CHKERRQ(ierr);
ierr = PCFactorSetShiftAmount(pc_ctx,floating_factor);CHKERRQ(ierr);
}
if (remove_nullspace_fixed) {
MatNullSpace nullsp;
ierr = MatNullSpaceCreate(PETSC_COMM_SELF,PETSC_TRUE,0,NULL,&nullsp);CHKERRQ(ierr);
ierr = KSPSetNullSpace(pcis->ksp_N,nullsp);CHKERRQ(ierr);
ierr = MatNullSpaceDestroy(&nullsp);CHKERRQ(ierr);
}
}
}
/* the vectors in the following line are dummy arguments, just telling the KSP the vector size. Values are not used */
ierr = KSPSetUp(pcis->ksp_N);CHKERRQ(ierr);
}
PetscFunctionReturn(0);
}