PetscErrorCode CalcMat(FEMInf fem, int L, Mat *H, Mat *S) {
PetscErrorCode ierr;
char label[10]; sprintf(label, "L+%d", L);
PrintTimeStamp(fem->comm, label, NULL);
FEMInfCreateMat(fem, 1, H);
FEMInfCreateMat(fem, 1, S);
PetscBool s_is_id; FEMInfGetOverlapIsId(fem, &s_is_id);
if(s_is_id)
S = NULL;
else {
ierr = FEMInfSR1Mat(fem, *S); CHKERRQ(ierr); CHKERRQ(ierr);
}
ierr = FEMInfD2R1Mat(fem, *H); CHKERRQ(ierr);
MatScale(*H, -0.5);
if(L != 0) {
Mat A;
FEMInfCreateMat(fem, 1, &A);
ierr = FEMInfR2invR1Mat(fem, A); CHKERRQ(ierr);
MatAXPY(*H, 0.5*L*(L+1), A, DIFFERENT_NONZERO_PATTERN);
}
Mat V;
FEMInfCreateMat(fem, 1, &V);
FEMInfENR1Mat(fem, 0, 0.0, V);
MatAXPY(*H, -1.0, V, DIFFERENT_NONZERO_PATTERN);
return 0;
}
void Field_solver::construct_equation_matrix_in_full_domain( Mat *A,
int nx, int ny, int nz,
double dx, double dy, double dz,
PetscInt nlocal, PetscInt rstart, PetscInt rend )
{
PetscErrorCode ierr;
Mat d2dy2, d2dz2;
int nrow = ( nx - 2 ) * ( ny - 2 ) * ( nz - 2 );
int ncol = nrow;
PetscInt nonzero_per_row = 7; // approx
construct_d2dx2_in_3d( A, nx, ny, nz, rstart, rend );
ierr = MatScale( *A, dy * dy * dz * dz ); CHKERRXX( ierr );
alloc_petsc_matrix( &d2dy2, nlocal, nlocal, nrow, ncol, nonzero_per_row );
construct_d2dy2_in_3d( &d2dy2, nx, ny, nz, rstart, rend );
ierr = MatAXPY( *A, dx * dx * dz * dz, d2dy2, DIFFERENT_NONZERO_PATTERN ); CHKERRXX( ierr );
ierr = MatDestroy( &d2dy2 ); CHKERRXX( ierr );
alloc_petsc_matrix( &d2dz2, nlocal, nlocal, nrow, ncol, nonzero_per_row );
construct_d2dz2_in_3d( &d2dz2, nx, ny, nz, rstart, rend );
ierr = MatAXPY( *A, dx * dx * dy * dy, d2dz2, DIFFERENT_NONZERO_PATTERN ); CHKERRXX( ierr );
ierr = MatDestroy( &d2dz2 ); CHKERRXX( ierr );
return;
}
int main(int argc,char **args)
{
PetscErrorCode ierr;
Mat A,B,C;
PetscBool different=PETSC_FALSE,skip=PETSC_FALSE;
PetscInt m0,m1,n=128,i;
PetscInitialize(&argc,&args,(char*)0,help);
ierr = PetscOptionsGetBool(NULL,"-different",&different,NULL);CHKERRQ(ierr);
ierr = PetscOptionsGetBool(NULL,"-skip",&skip,NULL);CHKERRQ(ierr);
/*
Create matrices
A = tridiag(1,-2,1) and B = diag(7);
*/
ierr = MatCreate(PETSC_COMM_WORLD,&A);CHKERRQ(ierr);
ierr = MatCreate(PETSC_COMM_WORLD,&B);CHKERRQ(ierr);
ierr = MatSetSizes(A,PETSC_DECIDE,PETSC_DECIDE,n,n);CHKERRQ(ierr);
ierr = MatSetSizes(B,PETSC_DECIDE,PETSC_DECIDE,n,n);CHKERRQ(ierr);
ierr = MatSetFromOptions(A);CHKERRQ(ierr);
ierr = MatSetFromOptions(B);CHKERRQ(ierr);
ierr = MatSetUp(A);CHKERRQ(ierr);
ierr = MatSetUp(B);CHKERRQ(ierr);
ierr = MatGetOwnershipRange(A,&m0,&m1);CHKERRQ(ierr);
for (i=m0;i<m1;i++) {
if (i>0) { ierr = MatSetValue(A,i,i-1,-1.0,INSERT_VALUES);CHKERRQ(ierr); }
if (i<n-1) { ierr = MatSetValue(A,i,i+1,-1.0,INSERT_VALUES);CHKERRQ(ierr); }
ierr = MatSetValue(A,i,i,2.0,INSERT_VALUES);CHKERRQ(ierr);
ierr = MatSetValue(B,i,i,7.0,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);
ierr = MatDuplicate(A,MAT_COPY_VALUES,&C);CHKERRQ(ierr);
/* Add B */
ierr = MatAXPY(C,1.0,B,(different)?DIFFERENT_NONZERO_PATTERN:SUBSET_NONZERO_PATTERN);CHKERRQ(ierr);
/* Add A */
if (!skip) { ierr = MatAXPY(C,1.0,A,SUBSET_NONZERO_PATTERN);CHKERRQ(ierr); }
/*
Free memory
*/
ierr = MatDestroy(&A);CHKERRQ(ierr);
ierr = MatDestroy(&B);CHKERRQ(ierr);
ierr = MatDestroy(&C);CHKERRQ(ierr);
ierr = PetscFinalize();
return 0;
}
int testBSplinePot2() {
PrintTimeStamp(PETSC_COMM_SELF, "pot2", NULL);
MPI_Comm comm = PETSC_COMM_SELF;
BPS bps; BPSCreate(comm, &bps); BPSSetLine(bps, 5.0, 8);
int order = 3;
BSS bss; BSSCreate(comm, &bss); BSSSetKnots(bss, order, bps); BSSSetUp(bss);
Pot pot; PotCreate(comm, &pot); PotSetCoulombNE(pot, 2, 1.5, 1.0);
// POTView(pot);
Mat V; BSSCreateR1Mat(bss, &V);
Mat U; BSSCreateR1Mat(bss, &U);
BSSENR1Mat(bss, 2, 1.5, V);
BSSPotR1Mat(bss, pot, U);
MatAXPY(V, -1.0, U, SAME_NONZERO_PATTERN);
PetscReal v;
MatNorm(V, NORM_1, &v);
ASSERT_DOUBLE_EQ(0.0, v);
BSSDestroy(&bss);
MatDestroy(&V);
MatDestroy(&U);
PFDestroy(&pot);
return 0;
}
PetscErrorCode SNESMonitorJacUpdateSpectrum(SNES snes,PetscInt it,PetscReal fnorm,void *ctx)
{
#if defined(PETSC_MISSING_LAPACK_GEEV)
SETERRQ(PetscObjectComm((PetscObject)snes),PETSC_ERR_SUP,"GEEV - Lapack routine is unavailable\nNot able to provide eigen values.");
#elif defined(PETSC_HAVE_ESSL)
SETERRQ(PetscObjectComm((PetscObject)snes),PETSC_ERR_SUP,"GEEV - No support for ESSL Lapack Routines");
#else
Vec X;
Mat J,dJ,dJdense;
PetscErrorCode ierr;
PetscErrorCode (*func)(SNES,Vec,Mat*,Mat*,MatStructure*,void*);
PetscInt n,i;
PetscBLASInt nb,lwork;
PetscReal *eigr,*eigi;
MatStructure flg = DIFFERENT_NONZERO_PATTERN;
PetscScalar *work;
PetscScalar *a;
PetscFunctionBegin;
if (it == 0) PetscFunctionReturn(0);
/* create the difference between the current update and the current jacobian */
ierr = SNESGetSolution(snes,&X);CHKERRQ(ierr);
ierr = SNESGetJacobian(snes,&J,NULL,&func,NULL);CHKERRQ(ierr);
ierr = MatDuplicate(J,MAT_COPY_VALUES,&dJ);CHKERRQ(ierr);
ierr = SNESComputeJacobian(snes,X,&dJ,&dJ,&flg);CHKERRQ(ierr);
ierr = MatAXPY(dJ,-1.0,J,SAME_NONZERO_PATTERN);CHKERRQ(ierr);
/* compute the spectrum directly */
ierr = MatConvert(dJ,MATSEQDENSE,MAT_INITIAL_MATRIX,&dJdense);CHKERRQ(ierr);
ierr = MatGetSize(dJ,&n,NULL);CHKERRQ(ierr);
ierr = PetscBLASIntCast(n,&nb);CHKERRQ(ierr);
lwork = 3*nb;
ierr = PetscMalloc(n*sizeof(PetscReal),&eigr);CHKERRQ(ierr);
ierr = PetscMalloc(n*sizeof(PetscReal),&eigi);CHKERRQ(ierr);
ierr = PetscMalloc(lwork*sizeof(PetscScalar),&work);CHKERRQ(ierr);
ierr = MatDenseGetArray(dJdense,&a);CHKERRQ(ierr);
#if !defined(PETSC_USE_COMPLEX)
{
PetscBLASInt lierr;
ierr = PetscFPTrapPush(PETSC_FP_TRAP_OFF);CHKERRQ(ierr);
PetscStackCall("LAPACKgeev",LAPACKgeev_("N","N",&nb,a,&nb,eigr,eigi,NULL,&nb,NULL,&nb,work,&lwork,&lierr));
if (lierr) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_LIB,"geev() error %d",lierr);
ierr = PetscFPTrapPop();CHKERRQ(ierr);
}
#else
SETERRQ(PETSC_COMM_SELF,PETSC_ERR_SUP,"Not coded for complex");
#endif
PetscPrintf(PetscObjectComm((PetscObject)snes),"Eigenvalues of J_%d - J_%d:\n",it,it-1);CHKERRQ(ierr);
for (i=0;i<n;i++) {
PetscPrintf(PetscObjectComm((PetscObject)snes),"%5d: %20.5g + %20.5gi\n",i,eigr[i],eigi[i]);CHKERRQ(ierr);
}
ierr = MatDenseRestoreArray(dJdense,&a);CHKERRQ(ierr);
ierr = MatDestroy(&dJ);CHKERRQ(ierr);
ierr = MatDestroy(&dJdense);CHKERRQ(ierr);
ierr = PetscFree(eigr);CHKERRQ(ierr);
ierr = PetscFree(eigi);CHKERRQ(ierr);
ierr = PetscFree(work);CHKERRQ(ierr);
PetscFunctionReturn(0);
#endif
}
TEST_F(TestOp, D2) {
PetscErrorCode ierr;
Op d2;
ierr = OpCreate(comm, &d2); ASSERT_EQ(0, ierr);
ierr = OpSetD2(d2); ASSERT_EQ(0, ierr);
if(getenv("SHOW_DEBUG")) {
ierr = OpView(d2, PETSC_VIEWER_STDOUT_SELF); ASSERT_EQ(0, ierr);
}
Mat M1;
ierr = BSSCreateR1Mat(this->bss, &M1); ASSERT_EQ(0, ierr);
ierr = BSSD2R1Mat(bss, M1); ASSERT_EQ(0, ierr);
Mat M2;
ierr = BSSCreateR1Mat(bss, &M2); ASSERT_EQ(0, ierr);
ierr = BSSOpMat(bss, d2, M2); ASSERT_EQ(0, ierr);
MatAXPY(M1, -1.0, M2, DIFFERENT_NONZERO_PATTERN);
PetscReal a;
MatNorm(M1, NORM_1, &a);
ASSERT_DOUBLE_EQ(0.0, a);
OpDestroy(&d2);
MatDestroy(&M1);
MatDestroy(&M2);
}
-fA <input_file> -fB <input_file> \n\n";
#include <petscmat.h>
#undef WRITEFILE
#undef __FUNCT__
#define __FUNCT__ "main"
PetscInt main(PetscInt argc,char **args)
{
Mat A,B;
PetscViewer fd;
char file[2][PETSC_MAX_PATH_LEN];
PetscBool flg;
PetscErrorCode ierr;
PetscMPIInt size;
PetscInt ma,na,mb,nb;
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,PETSC_ERR_SUP,"This is a uniprocessor example only!");
/* read the two matrices, A and B */
ierr = PetscOptionsGetString(NULL,NULL,"-fA",file[0],PETSC_MAX_PATH_LEN,&flg);CHKERRQ(ierr);
if (!flg) SETERRQ(PETSC_COMM_WORLD,PETSC_ERR_USER,"Must indicate binary file with the -fA options");
ierr = PetscOptionsGetString(NULL,NULL,"-fB",file[1],PETSC_MAX_PATH_LEN,&flg);CHKERRQ(ierr);
if (!flg) SETERRQ(PETSC_COMM_WORLD,PETSC_ERR_USER,"Must indicate binary file with the -fP options");
/* Load matrices */
ierr = PetscViewerBinaryOpen(PETSC_COMM_WORLD,file[0],FILE_MODE_READ,&fd);CHKERRQ(ierr);
ierr = MatCreate(PETSC_COMM_WORLD,&A);CHKERRQ(ierr);
ierr = MatLoad(A,fd);CHKERRQ(ierr);
ierr = PetscViewerDestroy(&fd);CHKERRQ(ierr);
printf("\n A:\n");
printf("----------------------\n");
ierr = MatView(A,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
ierr = MatGetSize(A,&ma,&na);CHKERRQ(ierr);
ierr = PetscViewerBinaryOpen(PETSC_COMM_WORLD,file[1],FILE_MODE_READ,&fd);CHKERRQ(ierr);
ierr = MatCreate(PETSC_COMM_WORLD,&B);CHKERRQ(ierr);
ierr = MatLoad(B,fd);CHKERRQ(ierr);
ierr = PetscViewerDestroy(&fd);CHKERRQ(ierr);
printf("\n B:\n");
printf("----------------------\n");
ierr = MatView(B,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
ierr = MatGetSize(B,&mb,&nb);CHKERRQ(ierr);
/* Compute B = -A + B */
if (ma != mb || na != nb) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_SIZ,"nonconforming matrix size");
ierr = MatAXPY(B,-1.0,A,DIFFERENT_NONZERO_PATTERN);CHKERRQ(ierr);
printf("\n B - A:\n");
printf("----------------------\n");
ierr = MatView(B,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
ierr = MatDestroy(&B);CHKERRQ(ierr);
ierr = MatDestroy(&A);CHKERRQ(ierr);
ierr = PetscFinalize();
return ierr;
}
PetscErrorCode NEPSolve_Interpol(NEP nep)
{
PetscErrorCode ierr;
NEP_INTERPOL *ctx = (NEP_INTERPOL*)nep->data;
Mat *A; /*T=nep->function,Tp=nep->jacobian;*/
PetscScalar *x,*fx,t;
PetscReal *cs,a,b,s;
PetscInt i,j,k,deg=ctx->deg;
PetscFunctionBegin;
ierr = PetscMalloc4(deg+1,&A,(deg+1)*(deg+1),&cs,deg+1,&x,(deg+1)*nep->nt,&fx);CHKERRQ(ierr);
ierr = RGIntervalGetEndpoints(nep->rg,&a,&b,NULL,NULL);CHKERRQ(ierr);
ierr = ChebyshevNodes(deg,a,b,x,cs);CHKERRQ(ierr);
for (j=0;j<nep->nt;j++) {
for (i=0;i<=deg;i++) {
ierr = FNEvaluateFunction(nep->f[j],x[i],&fx[i+j*(deg+1)]);CHKERRQ(ierr);
}
}
/* Polynomial coefficients */
for (k=0;k<=deg;k++) {
ierr = MatDuplicate(nep->A[0],MAT_COPY_VALUES,&A[k]);CHKERRQ(ierr);
t = 0.0;
for (i=0;i<deg+1;i++) t += fx[i]*cs[i*(deg+1)+k];
t *= 2.0/(deg+1);
if (k==0) t /= 2.0;
ierr = MatScale(A[k],t);CHKERRQ(ierr);
for (j=1;j<nep->nt;j++) {
t = 0.0;
for (i=0;i<deg+1;i++) t += fx[i+j*(deg+1)]*cs[i*(deg+1)+k];
t *= 2.0/(deg+1);
if (k==0) t /= 2.0;
ierr = MatAXPY(A[k],t,nep->A[j],SUBSET_NONZERO_PATTERN);CHKERRQ(ierr);
}
}
ierr = PEPSetOperators(ctx->pep,deg+1,A);CHKERRQ(ierr);
for (k=0;k<=deg;k++) {
ierr = MatDestroy(&A[k]);CHKERRQ(ierr);
}
ierr = PetscFree4(A,cs,x,fx);CHKERRQ(ierr);
/* Solve polynomial eigenproblem */
ierr = PEPSolve(ctx->pep);CHKERRQ(ierr);
ierr = PEPGetConverged(ctx->pep,&nep->nconv);CHKERRQ(ierr);
ierr = PEPGetIterationNumber(ctx->pep,&nep->its);CHKERRQ(ierr);
ierr = PEPGetConvergedReason(ctx->pep,(PEPConvergedReason*)&nep->reason);CHKERRQ(ierr);
s = 2.0/(b-a);
for (i=0;i<nep->nconv;i++) {
ierr = PEPGetEigenpair(ctx->pep,i,&nep->eigr[i],&nep->eigi[i],NULL,NULL);CHKERRQ(ierr);
nep->eigr[i] /= s;
nep->eigr[i] += (a+b)/2.0;
nep->eigi[i] /= s;
}
nep->state = NEP_STATE_EIGENVECTORS;
PetscFunctionReturn(0);
}
int testSlaterPotWithECS() {
PrintTimeStamp(PETSC_COMM_SELF, "ECS", NULL);
MPI_Comm comm = PETSC_COMM_SELF;
BPS bps; BPSCreate(comm, &bps); BPSSetLine(bps, 100.0, 101);
CScaling scaler; CScalingCreate(comm, &scaler);
CScalingSetSharpECS(scaler, 60.0, 20.0*M_PI/180.0);
int order = 5;
BSS bss; BSSCreate(comm, &bss); BSSSetKnots(bss, order, bps);
BSSSetCScaling(bss, scaler); BSSSetUp(bss);
Pot slater; PotCreate(comm, &slater); PotSetSlater(slater, 7.5, 2, 1.0);
if(getenv("SHOW_DEBUG"))
BSSView(bss, PETSC_VIEWER_STDOUT_SELF);
Mat H; BSSCreateR1Mat(bss, &H);
Mat V; BSSCreateR1Mat(bss, &V); BSSPotR1Mat(bss, slater, V);
Mat S; BSSCreateR1Mat(bss, &S); BSSSR1Mat(bss, S);
BSSD2R1Mat(bss, H);
MatScale(H, -0.5);
MatAXPY(H, 1.0, V, DIFFERENT_NONZERO_PATTERN);
EEPS eps; EEPSCreate(comm, &eps);
EEPSSetOperators(eps, H, S);
EEPSSetTarget(eps, 3.4);
EPSSetDimensions(eps->eps, 10, PETSC_DEFAULT, PETSC_DEFAULT);
EPSSetTolerances(eps->eps, PETSC_DEFAULT, 1000);
// EPSSetType(eps, EPSARNOLDI);
EEPSSolve(eps);
PetscInt nconv;
PetscScalar kr;
EPSGetConverged(eps->eps, &nconv);
ASSERT_TRUE(nconv > 0);
if(getenv("SHOW_DEBUG"))
for(int i = 0; i < nconv; i++) {
EPSGetEigenpair(eps->eps, i, &kr, NULL, NULL, NULL);
PetscPrintf(comm, "%f, %f\n", PetscRealPart(kr), PetscImaginaryPart(kr));
}
EPSGetEigenpair(eps->eps, 0, &kr, NULL, NULL, NULL);
PFDestroy(&slater); BSSDestroy(&bss); EEPSDestroy(&eps);
MatDestroy(&H); MatDestroy(&V); MatDestroy(&S);
// ASSERT_DOUBLE_NEAR(-0.0127745, PetscImaginaryPart(kr), pow(10.0, -4.0));
// ASSERT_DOUBLE_NEAR(3.4263903, PetscRealPart(kr), pow(10.0, -4.0));
return 0;
}
PetscErrorCode MatAXPY_Transpose(Mat Y,PetscScalar a,Mat X,MatStructure str)
{
Mat_Transpose *Ya = (Mat_Transpose*)Y->data;
Mat_Transpose *Xa = (Mat_Transpose*)X->data;
Mat M = Ya->A;
Mat N = Xa->A;
PetscErrorCode ierr;
PetscFunctionBegin;
ierr = MatAXPY(M,a,N,str);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/*@
MatSchurComplementComputeExplicitOperator - Compute the Schur complement matrix explicitly
Collective on Mat
Input Parameter:
. M - the matrix obtained with MatCreateSchurComplement()
Output Parameter:
. S - the Schur complement matrix
Note: This can be expensive, so it is mainly for testing
Level: advanced
.seealso: MatCreateSchurComplement(), MatSchurComplementUpdate()
@*/
PetscErrorCode MatSchurComplementComputeExplicitOperator(Mat M, Mat *S)
{
Mat B, C, D;
KSP ksp;
PC pc;
PetscBool isLU, isILU;
PetscReal fill = 2.0;
PetscErrorCode ierr;
PetscFunctionBegin;
ierr = MatSchurComplementGetSubMatrices(M, NULL, NULL, &B, &C, &D);CHKERRQ(ierr);
ierr = MatSchurComplementGetKSP(M, &ksp);CHKERRQ(ierr);
ierr = KSPGetPC(ksp, &pc);CHKERRQ(ierr);
ierr = PetscObjectTypeCompare((PetscObject) pc, PCLU, &isLU);CHKERRQ(ierr);
ierr = PetscObjectTypeCompare((PetscObject) pc, PCILU, &isILU);CHKERRQ(ierr);
if (isLU || isILU) {
Mat fact, Bd, AinvB, AinvBd;
PetscReal eps = 1.0e-10;
/* This can be sped up for banded LU */
ierr = KSPSetUp(ksp);CHKERRQ(ierr);
ierr = PCFactorGetMatrix(pc, &fact);CHKERRQ(ierr);
ierr = MatConvert(B, MATDENSE, MAT_INITIAL_MATRIX, &Bd);CHKERRQ(ierr);
ierr = MatDuplicate(Bd, MAT_DO_NOT_COPY_VALUES, &AinvBd);CHKERRQ(ierr);
ierr = MatMatSolve(fact, Bd, AinvBd);CHKERRQ(ierr);
ierr = MatDestroy(&Bd);CHKERRQ(ierr);
ierr = MatChop(AinvBd, eps);CHKERRQ(ierr);
ierr = MatConvert(AinvBd, MATAIJ, MAT_INITIAL_MATRIX, &AinvB);CHKERRQ(ierr);
ierr = MatDestroy(&AinvBd);CHKERRQ(ierr);
ierr = MatMatMult(C, AinvB, MAT_INITIAL_MATRIX, fill, S);CHKERRQ(ierr);
ierr = MatDestroy(&AinvB);CHKERRQ(ierr);
} else {
Mat Ainvd, Ainv;
ierr = PCComputeExplicitOperator(pc, &Ainvd);CHKERRQ(ierr);
ierr = MatConvert(Ainvd, MATAIJ, MAT_INITIAL_MATRIX, &Ainv);CHKERRQ(ierr);
ierr = MatDestroy(&Ainvd);CHKERRQ(ierr);
#if 0
/* Symmetric version */
ierr = MatPtAP(Ainv, B, MAT_INITIAL_MATRIX, fill, S);CHKERRQ(ierr);
#else
/* Nonsymmetric version */
ierr = MatMatMatMult(C, Ainv, B, MAT_INITIAL_MATRIX, fill, S);CHKERRQ(ierr);
#endif
ierr = MatDestroy(&Ainv);CHKERRQ(ierr);
}
if (D) {
ierr = MatAXPY(*S, -1.0, D, DIFFERENT_NONZERO_PATTERN);CHKERRQ(ierr);
}
ierr = MatScale(*S,-1.0);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
PetscErrorCode CheckMat(Mat A, Mat B, PetscBool usemult, const char* func)
{
Mat Bcheck;
PetscReal error;
PetscErrorCode ierr;
PetscFunctionBeginUser;
if (!usemult) {
if (B) {
MatType Btype;
ierr = MatGetType(B,&Btype);CHKERRQ(ierr);
ierr = MatConvert(A,Btype,MAT_INITIAL_MATRIX,&Bcheck);CHKERRQ(ierr);
} else {
ierr = MatConvert(A,MATAIJ,MAT_INITIAL_MATRIX,&Bcheck);CHKERRQ(ierr);
}
if (B) { /* if B is present, subtract it */
ierr = MatAXPY(Bcheck,-1.,B,DIFFERENT_NONZERO_PATTERN);CHKERRQ(ierr);
}
ierr = MatNorm(Bcheck,NORM_INFINITY,&error);CHKERRQ(ierr);
if (error > PETSC_SQRT_MACHINE_EPSILON) {
ISLocalToGlobalMapping rl2g,cl2g;
ierr = PetscObjectSetName((PetscObject)Bcheck,"Assembled Bcheck");CHKERRQ(ierr);
ierr = MatView(Bcheck,NULL);CHKERRQ(ierr);
if (B) {
ierr = PetscObjectSetName((PetscObject)B,"Assembled AIJ");CHKERRQ(ierr);
ierr = MatView(B,NULL);CHKERRQ(ierr);
ierr = MatDestroy(&Bcheck);CHKERRQ(ierr);
ierr = MatConvert(A,MATAIJ,MAT_INITIAL_MATRIX,&Bcheck);CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject)Bcheck,"Assembled IS");CHKERRQ(ierr);
ierr = MatView(Bcheck,NULL);CHKERRQ(ierr);
}
ierr = MatDestroy(&Bcheck);CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject)A,"MatIS");CHKERRQ(ierr);
ierr = MatView(A,NULL);CHKERRQ(ierr);
ierr = MatGetLocalToGlobalMapping(A,&rl2g,&cl2g);CHKERRQ(ierr);
ierr = ISLocalToGlobalMappingView(rl2g,NULL);CHKERRQ(ierr);
ierr = ISLocalToGlobalMappingView(cl2g,NULL);CHKERRQ(ierr);
SETERRQ2(PETSC_COMM_WORLD,PETSC_ERR_PLIB,"ERROR ON %s: %g",func,error);
}
ierr = MatDestroy(&Bcheck);CHKERRQ(ierr);
} else {
PetscBool ok,okt;
ierr = MatMultEqual(A,B,3,&ok);CHKERRQ(ierr);
ierr = MatMultTransposeEqual(A,B,3,&okt);CHKERRQ(ierr);
if (!ok || !okt) SETERRQ3(PETSC_COMM_WORLD,PETSC_ERR_PLIB,"ERROR ON %s: mult ok ? %d, multtranspose ok ? %d",func,ok,okt);
}
PetscFunctionReturn(0);
}
void PetscMatrix<T>::add (const T a_in, SparseMatrix<T> &X_in)
{
libmesh_assert (this->initialized());
// sanity check. but this cannot avoid
// crash due to incompatible sparsity structure...
libmesh_assert_equal_to (this->m(), X_in.m());
libmesh_assert_equal_to (this->n(), X_in.n());
PetscScalar a = static_cast<PetscScalar> (a_in);
PetscMatrix<T>* X = libmesh_cast_ptr<PetscMatrix<T>*> (&X_in);
libmesh_assert (X);
PetscErrorCode ierr=0;
// the matrix from which we copy the values has to be assembled/closed
// X->close ();
libmesh_assert(X->closed());
semiparallel_only();
// 2.2.x & earlier style
#if PETSC_VERSION_LESS_THAN(2,3,0)
ierr = MatAXPY(&a, X->_mat, _mat, SAME_NONZERO_PATTERN);
LIBMESH_CHKERRABORT(ierr);
// 2.3.x & newer
#else
ierr = MatAXPY(_mat, a, X->_mat, DIFFERENT_NONZERO_PATTERN);
LIBMESH_CHKERRABORT(ierr);
#endif
}
/*@
MatAYPX - Computes Y = a*Y + X.
Logically on Mat
Input Parameters:
+ a - the PetscScalar multiplier
. Y - the first matrix
. X - the second matrix
- str - either SAME_NONZERO_PATTERN, DIFFERENT_NONZERO_PATTERN or SUBSET_NONZERO_PATTERN
Level: intermediate
.keywords: matrix, add
.seealso: MatAXPY()
@*/
PetscErrorCode MatAYPX(Mat Y,PetscScalar a,Mat X,MatStructure str)
{
PetscScalar one = 1.0;
PetscErrorCode ierr;
PetscInt mX,mY,nX,nY;
PetscFunctionBegin;
PetscValidHeaderSpecific(X,MAT_CLASSID,3);
PetscValidHeaderSpecific(Y,MAT_CLASSID,1);
PetscValidLogicalCollectiveScalar(Y,a,2);
ierr = MatGetSize(X,&mX,&nX);CHKERRQ(ierr);
ierr = MatGetSize(X,&mY,&nY);CHKERRQ(ierr);
if (mX != mY || nX != nY) SETERRQ4(PETSC_COMM_SELF,PETSC_ERR_ARG_SIZ,"Non conforming matrices: %D %D first %D %D second",mX,mY,nX,nY);
ierr = MatScale(Y,a);CHKERRQ(ierr);
ierr = MatAXPY(Y,one,X,str);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
PetscErrorCode SolveFinal(FEMInf fem, int L1, PetscScalar energy,
Vec x0, Vec *x1, PetscScalar *alpha) {
PetscErrorCode ierr;
Mat S, L, D;
CalcMat(fem, L1, &L, &S);
MatAXPY(L, -energy, S, DIFFERENT_NONZERO_PATTERN);
MatDestroy(&S);
PetscScalar mat_ele_cos;
// <Y_10 | P_q(cos theta) | Y_00>
mat_ele_cos = Y1ElePq(1, 1, 0,
0, 0);
if(getenv("SHOW_DEBUG"))
printf("mat_ele_cos = %f\n", PetscRealPart(mat_ele_cos));
PF dp_length; PotCreate(PETSC_COMM_SELF, &dp_length);
ierr = PotSetPower(dp_length, mat_ele_cos, 1); CHKERRQ(ierr);
ierr =FEMInfCreateMat(fem, 1, &D);
ierr = FEMInfPotR1Mat(fem, dp_length, D); CHKERRQ(ierr);
Vec driv;
MatCreateVecs(L, &driv, NULL);
ierr = MatMult(D, x0, driv); CHKERRQ(ierr);
ierr = MatDestroy(&D); CHKERRQ(ierr);
KSP ksp;
ierr = KSPCreate(fem->comm, &ksp); CHKERRQ(ierr);
ierr = KSPSetOperators(ksp, L, L); CHKERRQ(ierr);
ierr = KSPSetFromOptions(ksp); CHKERRQ(ierr);
ierr = MatCreateVecs(L, x1, NULL);
ierr = KSPSolve(ksp, driv, *x1); CHKERRQ(ierr);
ierr = VecDot(*x1, driv, alpha); CHKERRQ(ierr);
// KSPView(ksp, PETSC_VIEWER_STDOUT_SELF);
KSPDestroy(&ksp);
MatDestroy(&L);
VecDestroy(&driv);
return 0;
}
TEST_F(TestOp, Vne) {
PetscErrorCode ierr;
PF pf; PotCreate(comm, &pf); PotSetCoulombNE(pf, 1, 0.0, 1.0);
Op vne; OpCreate(comm, &vne); OpSetPF(vne, pf);
Mat M1; BSSCreateR1Mat(bss, &M1); BSSENR1Mat(bss, 1, 0.0, M1);
Mat M2; BSSCreateR1Mat(bss, &M2); BSSOpMat(bss, vne, M2);
if(getenv("SHOW_DEBUG")) {
ierr = OpView(vne, PETSC_VIEWER_STDOUT_SELF); ASSERT_EQ(0, ierr);
}
ierr = MatAXPY(M1, -1.0, M2, DIFFERENT_NONZERO_PATTERN); ASSERT_EQ(0, ierr);
PetscReal a;
ierr = MatNorm(M1, NORM_1, &a);ASSERT_EQ(0, ierr);
ASSERT_DOUBLE_EQ(0.0, a);
MatDestroy(&M1); MatDestroy(&M2);
OpDestroy(&vne);
}
/*@C
MatCompositeMerge - Given a composite matrix, replaces it with a "regular" matrix
by summing all the matrices inside the composite matrix.
Collective on MPI_Comm
Input Parameters:
. mat - the composite matrix
Options Database:
. -mat_composite_merge (you must call MatAssemblyBegin()/MatAssemblyEnd() to have this checked)
Level: advanced
Notes:
The MatType of the resulting matrix will be the same as the MatType of the FIRST
matrix in the composite matrix.
.seealso: MatDestroy(), MatMult(), MatCompositeAddMat(), MatCreateComposite(), MATCOMPOSITE
@*/
PetscErrorCode MatCompositeMerge(Mat mat)
{
Mat_Composite *shell = (Mat_Composite*)mat->data;
Mat_CompositeLink next = shell->head, prev = shell->tail;
PetscErrorCode ierr;
Mat tmat,newmat;
Vec left,right;
PetscScalar scale;
PetscFunctionBegin;
if (!next) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONGSTATE,"Must provide at least one matrix with MatCompositeAddMat()");
PetscFunctionBegin;
if (shell->type == MAT_COMPOSITE_ADDITIVE) {
ierr = MatDuplicate(next->mat,MAT_COPY_VALUES,&tmat);CHKERRQ(ierr);
while ((next = next->next)) {
ierr = MatAXPY(tmat,1.0,next->mat,DIFFERENT_NONZERO_PATTERN);CHKERRQ(ierr);
}
} else {
ierr = MatDuplicate(next->mat,MAT_COPY_VALUES,&tmat);CHKERRQ(ierr);
while ((prev = prev->prev)) {
ierr = MatMatMult(tmat,prev->mat,MAT_INITIAL_MATRIX,PETSC_DECIDE,&newmat);CHKERRQ(ierr);
ierr = MatDestroy(&tmat);CHKERRQ(ierr);
tmat = newmat;
}
}
scale = shell->scale;
if ((left = shell->left)) {ierr = PetscObjectReference((PetscObject)left);CHKERRQ(ierr);}
if ((right = shell->right)) {ierr = PetscObjectReference((PetscObject)right);CHKERRQ(ierr);}
ierr = MatHeaderReplace(mat,&tmat);CHKERRQ(ierr);
ierr = MatDiagonalScale(mat,left,right);CHKERRQ(ierr);
ierr = MatScale(mat,scale);CHKERRQ(ierr);
ierr = VecDestroy(&left);CHKERRQ(ierr);
ierr = VecDestroy(&right);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/*
K is the discretiziation of the Laplacian
G is the discretization of the gradient
Computes Jacobian of K u + diag(u) G u which is given by
K + diag(u)G + diag(Gu)
*/
PetscErrorCode RHSJacobian(TS ts,PetscReal t,Vec globalin,Mat A, Mat B,void *ctx)
{
PetscErrorCode ierr;
AppCtx *appctx = (AppCtx*)ctx;
Vec Gglobalin;
PetscFunctionBegin;
/* A = diag(u) G */
ierr = MatCopy(appctx->SEMop.grad,A,SAME_NONZERO_PATTERN);CHKERRQ(ierr);
ierr = MatDiagonalScale(A,globalin,NULL);CHKERRQ(ierr);
/* A = A + diag(Gu) */
ierr = VecDuplicate(globalin,&Gglobalin);CHKERRQ(ierr);
ierr = MatMult(appctx->SEMop.grad,globalin,Gglobalin);CHKERRQ(ierr);
ierr = MatDiagonalSet(A,Gglobalin,ADD_VALUES);CHKERRQ(ierr);
ierr = VecDestroy(&Gglobalin);CHKERRQ(ierr);
/* A = K - A */
ierr = MatScale(A,-1.0);CHKERRQ(ierr);
ierr = MatAXPY(A,0.0,appctx->SEMop.keptstiff,SAME_NONZERO_PATTERN);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
void PETSC_STDCALL mataxpy_(Mat Y,PetscScalar *a,Mat X,MatStructure *str, int *__ierr ){
*__ierr = MatAXPY(
(Mat)PetscToPointer((Y) ),*a,
(Mat)PetscToPointer((X) ),*str);
}
/*
Computes coefficients for the transformed polynomial,
and stores the result in argument S.
alpha - value of the parameter of the transformed polynomial
beta - value of the previous shift (only used in inplace mode)
k - number of A matrices involved in the computation
coeffs - coefficients of the expansion
initial - true if this is the first time (only relevant for shell mode)
*/
PetscErrorCode STMatMAXPY_Private(ST st,PetscScalar alpha,PetscScalar beta,PetscInt k,PetscScalar *coeffs,PetscBool initial,Mat *S)
{
PetscErrorCode ierr;
PetscInt *matIdx=NULL,nmat,i,ini=-1;
PetscScalar t=1.0,ta,gamma;
PetscBool nz=PETSC_FALSE;
PetscFunctionBegin;
nmat = st->nmat-k;
switch (st->shift_matrix) {
case ST_MATMODE_INPLACE:
if (st->nmat>2) SETERRQ(PetscObjectComm((PetscObject)st),PETSC_ERR_SUP,"ST_MATMODE_INPLACE not supported for polynomial eigenproblems");
if (initial) {
ierr = PetscObjectReference((PetscObject)st->A[0]);CHKERRQ(ierr);
*S = st->A[0];
gamma = alpha;
} else gamma = alpha-beta;
if (gamma != 0.0) {
if (st->nmat>1) {
ierr = MatAXPY(*S,gamma,st->A[1],st->str);CHKERRQ(ierr);
} else {
ierr = MatShift(*S,gamma);CHKERRQ(ierr);
}
}
break;
case ST_MATMODE_SHELL:
if (initial) {
if (st->nmat>2) {
ierr = PetscMalloc(nmat*sizeof(PetscInt),&matIdx);CHKERRQ(ierr);
for (i=0;i<nmat;i++) matIdx[i] = k+i;
}
ierr = STMatShellCreate(st,alpha,nmat,matIdx,coeffs,S);CHKERRQ(ierr);
ierr = PetscLogObjectParent((PetscObject)st,(PetscObject)*S);CHKERRQ(ierr);
if (st->nmat>2) { ierr = PetscFree(matIdx);CHKERRQ(ierr); }
} else {
ierr = STMatShellShift(*S,alpha);CHKERRQ(ierr);
}
break;
case ST_MATMODE_COPY:
if (coeffs) {
for (i=0;i<nmat && ini==-1;i++) {
if (coeffs[i]!=0.0) ini = i;
else t *= alpha;
}
if (coeffs[ini] != 1.0) nz = PETSC_TRUE;
for (i=ini+1;i<nmat&&!nz;i++) if (coeffs[i]!=0.0) nz = PETSC_TRUE;
} else { nz = PETSC_TRUE; ini = 0; }
if ((alpha == 0.0 || !nz) && t==1.0) {
ierr = MatDestroy(S);CHKERRQ(ierr);
ierr = PetscObjectReference((PetscObject)st->A[k+ini]);CHKERRQ(ierr);
*S = st->A[k+ini];
} else {
if (*S && *S!=st->A[k+ini]) {
ierr = MatCopy(st->A[k+ini],*S,DIFFERENT_NONZERO_PATTERN);CHKERRQ(ierr);
} else {
ierr = MatDestroy(S);CHKERRQ(ierr);
ierr = MatDuplicate(st->A[k+ini],MAT_COPY_VALUES,S);CHKERRQ(ierr);
ierr = PetscLogObjectParent((PetscObject)st,(PetscObject)*S);CHKERRQ(ierr);
}
if (coeffs && coeffs[ini]!=1.0) {
ierr = MatScale(*S,coeffs[ini]);CHKERRQ(ierr);
}
for (i=ini+k+1;i<PetscMax(2,st->nmat);i++) {
t *= alpha;
ta = t;
if (coeffs) ta *= coeffs[i-k];
if (ta!=0.0) {
if (st->nmat>1) {
ierr = MatAXPY(*S,ta,st->A[i],st->str);CHKERRQ(ierr);
} else {
ierr = MatShift(*S,ta);CHKERRQ(ierr);
}
}
}
}
}
ierr = STMatSetHermitian(st,*S);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
int main(int argc,char **argv)
{
Mat pA,P,aijP;
PetscScalar pa[]={1.,-1.,0.,0.,1.,-1.,0.,0.,1.};
PetscInt i,pij[]={0,1,2};
PetscInt aij[3][3]={{0,1,2},{3,4,5},{6,7,8}};
Mat A,mC,C;
PetscScalar one=1.;
PetscErrorCode ierr;
PetscMPIInt size;
ierr = PetscInitialize(&argc,&argv,(char*)0,help);if (ierr) return ierr;
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!");
/* Create MAIJ matrix, P */
ierr = MatCreate(PETSC_COMM_SELF,&pA);CHKERRQ(ierr);
ierr = MatSetSizes(pA,3,3,3,3);CHKERRQ(ierr);
ierr = MatSetType(pA,MATSEQAIJ);CHKERRQ(ierr);
ierr = MatSetUp(pA);CHKERRQ(ierr);
ierr = MatSetOption(pA,MAT_IGNORE_ZERO_ENTRIES,PETSC_TRUE);CHKERRQ(ierr);
ierr = MatSetValues(pA,3,pij,3,pij,pa,ADD_VALUES);CHKERRQ(ierr);
ierr = MatAssemblyBegin(pA,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
ierr = MatAssemblyEnd(pA,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
ierr = MatCreateMAIJ(pA,3,&P);CHKERRQ(ierr);
ierr = MatDestroy(&pA);CHKERRQ(ierr);
/* Create AIJ equivalent matrix, aijP, for comparison testing */
ierr = MatConvert(P,MATSEQAIJ,MAT_INITIAL_MATRIX,&aijP);CHKERRQ(ierr);
/* Create AIJ matrix, A */
ierr = MatCreate(PETSC_COMM_SELF,&A);CHKERRQ(ierr);
ierr = MatSetSizes(A,9,9,9,9);CHKERRQ(ierr);
ierr = MatSetType(A,MATSEQAIJ);CHKERRQ(ierr);
ierr = MatSetUp(A);CHKERRQ(ierr);
ierr = MatSetOption(A,MAT_IGNORE_ZERO_ENTRIES,PETSC_TRUE);CHKERRQ(ierr);
ierr = MatSetValues(A,3,aij[0],3,aij[0],pa,ADD_VALUES);CHKERRQ(ierr);
ierr = MatSetValues(A,3,aij[1],3,aij[1],pa,ADD_VALUES);CHKERRQ(ierr);
ierr = MatSetValues(A,3,aij[2],3,aij[2],pa,ADD_VALUES);CHKERRQ(ierr);
for (i=0; i<9; i++) {
ierr = MatSetValue(A,i,i,one,ADD_VALUES);CHKERRQ(ierr);
}
ierr = MatAssemblyBegin(A,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
ierr = MatAssemblyEnd(A,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
/* Perform PtAP_SeqAIJ_SeqMAIJ */
ierr = MatPtAP(A,P,MAT_INITIAL_MATRIX,1.,&mC);CHKERRQ(ierr);
ierr = MatPtAP(A,P,MAT_REUSE_MATRIX,1.,&mC);CHKERRQ(ierr);
ierr = MatView(mC,PETSC_VIEWER_STDOUT_SELF);CHKERRQ(ierr);
/* Perform PtAP_SeqAIJ_SeqAIJ for comparison testing */
ierr = MatPtAP(A,aijP,MAT_INITIAL_MATRIX,1.,&C);CHKERRQ(ierr);
ierr = MatView(C,PETSC_VIEWER_STDOUT_SELF);CHKERRQ(ierr);
/* Check mC = C */
ierr = MatAXPY(C,-1.0,mC,DIFFERENT_NONZERO_PATTERN);CHKERRQ(ierr);
/* Note: We should be able to use SAME_NONZERO_PATTERN on the line above, */
/* but don't because this flag doesn't assist testing. */
ierr = MatView(C,PETSC_VIEWER_STDOUT_SELF);CHKERRQ(ierr);
/* Cleanup */
ierr = MatDestroy(&P);CHKERRQ(ierr);
ierr = MatDestroy(&aijP);CHKERRQ(ierr);
ierr = MatDestroy(&A);CHKERRQ(ierr);
ierr = MatDestroy(&C);CHKERRQ(ierr);
ierr = MatDestroy(&mC);CHKERRQ(ierr);
ierr = PetscFinalize();
return ierr;
}
int main(int argc,char **args)
{
Mat A,B,F;
PetscErrorCode ierr;
KSP ksp;
PC pc;
PetscInt N, n=10, m, Istart, Iend, II, J, i,j;
PetscInt nneg, nzero, npos;
PetscScalar v,sigma;
PetscBool flag,loadA=PETSC_FALSE,loadB=PETSC_FALSE;
char file[2][PETSC_MAX_PATH_LEN];
PetscViewer viewer;
PetscMPIInt rank;
PetscInitialize(&argc,&args,(char *)0,help);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Compute the matrices that define the eigensystem, Ax=kBx
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
ierr = PetscOptionsGetString(PETSC_NULL,"-fA",file[0],PETSC_MAX_PATH_LEN,&loadA);CHKERRQ(ierr);
if (loadA) {
ierr = PetscViewerBinaryOpen(PETSC_COMM_WORLD,file[0],FILE_MODE_READ,&viewer);CHKERRQ(ierr);
ierr = MatCreate(PETSC_COMM_WORLD,&A);CHKERRQ(ierr);
ierr = MatSetType(A,MATSBAIJ);CHKERRQ(ierr);
ierr = MatLoad(A,viewer);CHKERRQ(ierr);
ierr = PetscViewerDestroy(&viewer);CHKERRQ(ierr);
ierr = PetscOptionsGetString(PETSC_NULL,"-fB",file[1],PETSC_MAX_PATH_LEN,&loadB);CHKERRQ(ierr);
if (loadB){
/* load B to get A = A + sigma*B */
ierr = PetscViewerBinaryOpen(PETSC_COMM_WORLD,file[1],FILE_MODE_READ,&viewer);CHKERRQ(ierr);
ierr = MatCreate(PETSC_COMM_WORLD,&B);CHKERRQ(ierr);
ierr = MatSetType(B,MATSBAIJ);CHKERRQ(ierr);
ierr = MatLoad(B,viewer);CHKERRQ(ierr);
ierr = PetscViewerDestroy(&viewer);CHKERRQ(ierr);
}
}
if (!loadA) { /* Matrix A is copied from slepc-3.0.0-p6/src/examples/ex13.c. */
ierr = PetscOptionsGetInt(PETSC_NULL,"-n",&n,PETSC_NULL);CHKERRQ(ierr);
ierr = PetscOptionsGetInt(PETSC_NULL,"-m",&m,&flag);CHKERRQ(ierr);
if( flag==PETSC_FALSE ) m=n;
N = n*m;
ierr = MatCreate(PETSC_COMM_WORLD,&A);CHKERRQ(ierr);
ierr = MatSetSizes(A,PETSC_DECIDE,PETSC_DECIDE,N,N);CHKERRQ(ierr);
ierr = MatSetType(A,MATSBAIJ);CHKERRQ(ierr);
ierr = MatSetFromOptions(A);CHKERRQ(ierr);
ierr = MatSetUp(A);CHKERRQ(ierr);
ierr = MatSetOption(A,MAT_IGNORE_LOWER_TRIANGULAR,PETSC_TRUE);CHKERRQ(ierr);
ierr = MatGetOwnershipRange(A,&Istart,&Iend);CHKERRQ(ierr);
for( II=Istart; II<Iend; II++ ) {
v = -1.0; i = II/n; j = II-i*n;
if(i>0) { J=II-n; MatSetValues(A,1,&II,1,&J,&v,INSERT_VALUES);CHKERRQ(ierr); }
if(i<m-1) { J=II+n; MatSetValues(A,1,&II,1,&J,&v,INSERT_VALUES);CHKERRQ(ierr); }
if(j>0) { J=II-1; MatSetValues(A,1,&II,1,&J,&v,INSERT_VALUES);CHKERRQ(ierr); }
if(j<n-1) { J=II+1; MatSetValues(A,1,&II,1,&J,&v,INSERT_VALUES);CHKERRQ(ierr); }
v=4.0; MatSetValues(A,1,&II,1,&II,&v,INSERT_VALUES);CHKERRQ(ierr);
}
ierr = MatAssemblyBegin(A,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
ierr = MatAssemblyEnd(A,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
}
/* ierr = MatView(A,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr); */
if (!loadB) {
ierr = MatGetLocalSize(A,&m,&n);CHKERRQ(ierr);
ierr = MatCreate(PETSC_COMM_WORLD,&B);CHKERRQ(ierr);
ierr = MatSetSizes(B,m,n,PETSC_DECIDE,PETSC_DECIDE);CHKERRQ(ierr);
ierr = MatSetType(B,MATSBAIJ);CHKERRQ(ierr);
ierr = MatSetFromOptions(B);CHKERRQ(ierr);
ierr = MatSetUp(B);CHKERRQ(ierr);
ierr = MatSetOption(B,MAT_IGNORE_LOWER_TRIANGULAR,PETSC_TRUE);CHKERRQ(ierr);
ierr = MatGetOwnershipRange(A,&Istart,&Iend);CHKERRQ(ierr);
for( II=Istart; II<Iend; II++ ) {
/* v=4.0; MatSetValues(B,1,&II,1,&II,&v,INSERT_VALUES);CHKERRQ(ierr); */
v=1.0; MatSetValues(B,1,&II,1,&II,&v,INSERT_VALUES);CHKERRQ(ierr);
}
ierr = MatAssemblyBegin(B,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
ierr = MatAssemblyEnd(B,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
}
/* ierr = MatView(B,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr); */
/* Set a shift: A = A - sigma*B */
ierr = PetscOptionsGetScalar(PETSC_NULL,"-sigma",&sigma,&flag);CHKERRQ(ierr);
if (flag){
sigma = -1.0 * sigma;
ierr = MatAXPY(A,sigma,B,DIFFERENT_NONZERO_PATTERN);CHKERRQ(ierr); /* A <- A - sigma*B */
/* ierr = MatView(A,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr); */
}
/* Test MatGetInertia() */
ierr = KSPCreate(PETSC_COMM_WORLD,&ksp);CHKERRQ(ierr);
ierr = KSPSetType(ksp,KSPPREONLY);CHKERRQ(ierr);
ierr = KSPSetOperators(ksp,A,A,DIFFERENT_NONZERO_PATTERN);CHKERRQ(ierr);
ierr = KSPGetPC(ksp,&pc);CHKERRQ(ierr);
ierr = PCSetType(pc,PCCHOLESKY);CHKERRQ(ierr);
ierr = PCSetFromOptions(pc);CHKERRQ(ierr);
ierr = PCSetUp(pc);CHKERRQ(ierr);
ierr = PCFactorGetMatrix(pc,&F);CHKERRQ(ierr);
ierr = MatGetInertia(F,&nneg,&nzero,&npos);CHKERRQ(ierr);
ierr = MPI_Comm_rank(PETSC_COMM_WORLD,&rank);CHKERRQ(ierr);
if (!rank){
ierr = PetscPrintf(PETSC_COMM_SELF," MatInertia: nneg: %D, nzero: %D, npos: %D\n",nneg,nzero,npos);CHKERRQ(ierr);
}
/* Destroy */
ierr = KSPDestroy(&ksp);CHKERRQ(ierr);
ierr = MatDestroy(&A);CHKERRQ(ierr);
ierr = MatDestroy(&B);CHKERRQ(ierr);
ierr = PetscFinalize();
return 0;
}
int main(int argc,char **argv)
{
Mat mat,tmat = 0;
PetscInt m = 7,n,i,j,rstart,rend,rect = 0;
PetscErrorCode ierr;
PetscMPIInt size,rank;
PetscBool flg;
PetscScalar v, alpha;
PetscReal normf,normi,norm1;
ierr = PetscInitialize(&argc,&argv,(char*)0,help);CHKERRQ(ierr);
ierr = PetscViewerSetFormat(PETSC_VIEWER_STDOUT_WORLD,PETSC_VIEWER_ASCII_COMMON);CHKERRQ(ierr);
ierr = PetscOptionsGetInt(NULL,"-m",&m,NULL);CHKERRQ(ierr);
ierr = MPI_Comm_rank(PETSC_COMM_WORLD,&rank);CHKERRQ(ierr);
ierr = MPI_Comm_size(PETSC_COMM_WORLD,&size);CHKERRQ(ierr);
n = m;
ierr = PetscOptionsHasName(NULL,"-rectA",&flg);CHKERRQ(ierr);
if (flg) {n += 2; rect = 1;}
ierr = PetscOptionsHasName(NULL,"-rectB",&flg);CHKERRQ(ierr);
if (flg) {n -= 2; rect = 1;}
/* ------- Assemble matrix, test MatValid() --------- */
ierr = MatCreate(PETSC_COMM_WORLD,&mat);CHKERRQ(ierr);
ierr = MatSetSizes(mat,PETSC_DECIDE,PETSC_DECIDE,m,n);CHKERRQ(ierr);
ierr = MatSetFromOptions(mat);CHKERRQ(ierr);
ierr = MatSetUp(mat);CHKERRQ(ierr);
ierr = MatGetOwnershipRange(mat,&rstart,&rend);CHKERRQ(ierr);
for (i=rstart; i<rend; i++) {
for (j=0; j<n; j++) {
v = 10.0*i+j;
ierr = MatSetValues(mat,1,&i,1,&j,&v,INSERT_VALUES);CHKERRQ(ierr);
}
}
ierr = MatAssemblyBegin(mat,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
ierr = MatAssemblyEnd(mat,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
/* ----------------- Test MatNorm() ----------------- */
ierr = MatNorm(mat,NORM_FROBENIUS,&normf);CHKERRQ(ierr);
ierr = MatNorm(mat,NORM_1,&norm1);CHKERRQ(ierr);
ierr = MatNorm(mat,NORM_INFINITY,&normi);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"original A: Frobenious norm = %G, one norm = %G, infinity norm = %G\n",
normf,norm1,normi);CHKERRQ(ierr);
ierr = MatView(mat,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
/* --------------- Test MatTranspose() -------------- */
ierr = PetscOptionsHasName(NULL,"-in_place",&flg);CHKERRQ(ierr);
if (!rect && flg) {
ierr = MatTranspose(mat,MAT_REUSE_MATRIX,&mat);CHKERRQ(ierr); /* in-place transpose */
tmat = mat; mat = 0;
} else { /* out-of-place transpose */
ierr = MatTranspose(mat,MAT_INITIAL_MATRIX,&tmat);CHKERRQ(ierr);
}
/* ----------------- Test MatNorm() ----------------- */
/* Print info about transpose matrix */
ierr = MatNorm(tmat,NORM_FROBENIUS,&normf);CHKERRQ(ierr);
ierr = MatNorm(tmat,NORM_1,&norm1);CHKERRQ(ierr);
ierr = MatNorm(tmat,NORM_INFINITY,&normi);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"B = A^T: Frobenious norm = %G, one norm = %G, infinity norm = %G\n",
normf,norm1,normi);CHKERRQ(ierr);
ierr = MatView(tmat,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
/* ----------------- Test MatAXPY(), MatAYPX() ----------------- */
if (mat && !rect) {
alpha = 1.0;
ierr = PetscOptionsGetScalar(NULL,"-alpha",&alpha,NULL);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"MatAXPY: B = B + alpha * A\n");CHKERRQ(ierr);
ierr = MatAXPY(tmat,alpha,mat,DIFFERENT_NONZERO_PATTERN);CHKERRQ(ierr);
ierr = MatView(tmat,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"MatAYPX: B = alpha*B + A\n");CHKERRQ(ierr);
ierr = MatAYPX(tmat,alpha,mat,DIFFERENT_NONZERO_PATTERN);CHKERRQ(ierr);
ierr = MatView(tmat,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
}
{
Mat C;
alpha = 1.0;
ierr = PetscPrintf(PETSC_COMM_WORLD,"MatAXPY: C = C + alpha * A, C=A, SAME_NONZERO_PATTERN\n");CHKERRQ(ierr);
ierr = MatDuplicate(mat,MAT_COPY_VALUES,&C);CHKERRQ(ierr);
ierr = MatAXPY(C,alpha,mat,SAME_NONZERO_PATTERN);CHKERRQ(ierr);
ierr = MatView(C,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
ierr = MatDestroy(&C);CHKERRQ(ierr);
}
{
Mat matB;
/* get matB that has nonzeros of mat in all even numbers of row and col */
ierr = MatCreate(PETSC_COMM_WORLD,&matB);CHKERRQ(ierr);
ierr = MatSetSizes(matB,PETSC_DECIDE,PETSC_DECIDE,m,n);CHKERRQ(ierr);
ierr = MatSetFromOptions(matB);CHKERRQ(ierr);
ierr = MatSetUp(matB);CHKERRQ(ierr);
ierr = MatGetOwnershipRange(matB,&rstart,&rend);CHKERRQ(ierr);
if (rstart % 2 != 0) rstart++;
for (i=rstart; i<rend; i += 2) {
for (j=0; j<n; j += 2) {
v = 10.0*i+j;
ierr = MatSetValues(matB,1,&i,1,&j,&v,INSERT_VALUES);CHKERRQ(ierr);
}
}
ierr = MatAssemblyBegin(matB,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
ierr = MatAssemblyEnd(matB,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
PetscPrintf(PETSC_COMM_WORLD," A: original matrix:\n");
ierr = MatView(mat,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
PetscPrintf(PETSC_COMM_WORLD," B(a subset of A):\n");
ierr = MatView(matB,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"MatAXPY: B = B + alpha * A, SUBSET_NONZERO_PATTERN\n");CHKERRQ(ierr);
ierr = MatAXPY(mat,alpha,matB,SUBSET_NONZERO_PATTERN);CHKERRQ(ierr);
ierr = MatView(mat,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
ierr = MatDestroy(&matB);CHKERRQ(ierr);
}
/* Free data structures */
if (mat) {ierr = MatDestroy(&mat);CHKERRQ(ierr);}
if (tmat) {ierr = MatDestroy(&tmat);CHKERRQ(ierr);}
ierr = PetscFinalize();
return 0;
}
PetscErrorCode BearQueryMat(PetscInt s, PetscScalar c, Mat invL1, Mat invU1, Mat invL2, Mat invU2, Mat H12, Mat H21, Vec order){
PetscErrorCode err;
PetscInt n1, n2, n, M, N;
PetscInt oseed;
PetscScalar val, one = 1.0;
PetscMPIInt size;
PetscLogDouble tic, toc;
Mat r = NULL;
Mat r1 = NULL, q1 = NULL, t1_1 = NULL, t1_2 = NULL, t1_3 = NULL, t1_4 = NULL, t1_5 = NULL; // dimension: n1
Mat r2 = NULL, q2 = NULL, q_tilda = NULL, t2_1 = NULL, t2_2 = NULL, t2_3 = NULL; // dimension: n2_idx
Vec vr=NULL, vr1=NULL, vr2=NULL;
PetscInt col = 0;
err = MPI_Comm_size(PETSC_COMM_WORLD, &size); CHKERRQ(err);
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 = MatCreateAIJ(PETSC_COMM_WORLD, PETSC_DECIDE, 1, n, size, 1, NULL, 1, NULL, &r); CHKERRQ(err);
err = MatCreateAIJ(PETSC_COMM_WORLD, PETSC_DECIDE, 1, n1, size, 1, NULL, 1, NULL, &q1); CHKERRQ(err);
err = MatCreateAIJ(PETSC_COMM_WORLD, PETSC_DECIDE, 1, n2, size, 1, NULL, 1, NULL, &q2); CHKERRQ(err);
// err = MatCreate(PETSC_COMM_WORLD, &q2); CHKERRQ(err);
// err = MatSetSizes(q2, PETSC_DECIDE, PETSC_DECIDE, n2, 1); CHKERRQ(err);
// err = MatSetType(q2, MATAIJ); CHKERRQ(err);
// err = MatSetUp(q2);
s = s - 1; // shift -1 for zero-based index
err = VecGetValues(order, 1, &s, &val); CHKERRQ(err);
oseed = (PetscInt) val;
// err = PetscPrintf(PETSC_COMM_WORLD, "Given seed: %d, Reorered seed: %d (0 ~ n-1)\n", s, oseed); CHKERRQ(err);
if(oseed < n1){
//err = MatSetValues(q1, 1, &oseed, 1, &col, &one, INSERT_VALUES); CHKERRQ(err);
err = MatSetValue(q1, oseed, col, one, INSERT_VALUES); CHKERRQ(err);
}else{
oseed = oseed - n1;
//err = MatSetValues(q2, 1, &oseed, 1, &col, &one, INSERT_VALUES); CHKERRQ(err);
err = MatSetValue(q2, oseed, col, one, INSERT_VALUES); CHKERRQ(err);
//err = printVecSum(q2);
}
err = MatAssemblyBegin(q1, MAT_FINAL_ASSEMBLY); CHKERRQ(err);
err = MatAssemblyEnd(q1, MAT_FINAL_ASSEMBLY); CHKERRQ(err);
err = MatAssemblyBegin(q2, MAT_FINAL_ASSEMBLY); CHKERRQ(err);
err = MatAssemblyEnd(q2, MAT_FINAL_ASSEMBLY); CHKERRQ(err);
err = printMatInfo("q1", q1);
err = printMatInfo("q2", q2);
//err = MatView(q1, PETSC_VIEWER_STDOUT_WORLD);
//err = MatView(q2, PETSC_VIEWER_STDOUT_WORLD);
err = MatDuplicate(q1, MAT_DO_NOT_COPY_VALUES, &r1); CHKERRQ(err);
err = MatDuplicate(q1, MAT_DO_NOT_COPY_VALUES, &t1_1); CHKERRQ(err);
err = MatDuplicate(q1, MAT_DO_NOT_COPY_VALUES, &t1_2); CHKERRQ(err);
err = MatDuplicate(q1, MAT_DO_NOT_COPY_VALUES, &t1_3); CHKERRQ(err);
err = MatDuplicate(q1, MAT_DO_NOT_COPY_VALUES, &t1_4); CHKERRQ(err);
err = MatDuplicate(q1, MAT_DO_NOT_COPY_VALUES, &t1_5); CHKERRQ(err);
err = MatDuplicate(q2, MAT_DO_NOT_COPY_VALUES, &r2); CHKERRQ(err);
err = MatDuplicate(q2, MAT_DO_NOT_COPY_VALUES, &q_tilda); CHKERRQ(err);
err = MatDuplicate(q2, MAT_DO_NOT_COPY_VALUES, &t2_1); CHKERRQ(err);
err = MatDuplicate(q2, MAT_DO_NOT_COPY_VALUES, &t2_2); CHKERRQ(err);
err = MatDuplicate(q2, MAT_DO_NOT_COPY_VALUES, &t2_3); CHKERRQ(err);
err = MatMatMult(invL1, q1, MAT_INITIAL_MATRIX, PETSC_DEFAULT, &t1_1); CHKERRQ(err);
err = MatMatMult(invU1, t1_1, MAT_INITIAL_MATRIX, PETSC_DEFAULT, &t1_2); CHKERRQ(err);
err = MatMatMult(H21, t1_2, MAT_INITIAL_MATRIX, PETSC_DEFAULT, &t2_1); CHKERRQ(err);
err = MatScale(t2_1, -1.0); CHKERRQ(err);
err = MatAXPY(t2_1, 1.0, q2, DIFFERENT_NONZERO_PATTERN); CHKERRQ(err);
//MatView(t1_1, PETSC_VIEWER_STDOUT_WORLD);
err = PetscTime(&tic);
err = MatMatMult(invL2, t2_1, MAT_INITIAL_MATRIX, PETSC_DEFAULT, &t2_2); CHKERRQ(err);
err = MatMatMult(invU2, t2_2, MAT_INITIAL_MATRIX, PETSC_DEFAULT, &r2); CHKERRQ(err);
err = PetscTime(&toc);
err = PetscPrintf(PETSC_COMM_WORLD, "running time: %f sec\n", toc-tic); CHKERRQ(err);
err = MatMatMult(H12, r2, MAT_INITIAL_MATRIX, PETSC_DEFAULT, &t1_3); CHKERRQ(err);
err = MatScale(t1_3, -1.0); CHKERRQ(err);
err = MatAXPY(t1_3, 1.0, q1, DIFFERENT_NONZERO_PATTERN); CHKERRQ(err);
err = MatMatMult(invL1, t1_3, MAT_INITIAL_MATRIX, PETSC_DEFAULT, &t1_5); CHKERRQ(err);
err = MatMatMult(invU1, t1_5, MAT_INITIAL_MATRIX, PETSC_DEFAULT, &r1); CHKERRQ(err);
//MatView(r1, PETSC_VIEWER_STDOUT_WORLD);
MatGetSize(r1, &M, &N);
PetscPrintf(PETSC_COMM_WORLD, "%d %d\n", M, N);
err = VecCreateMPI(PETSC_COMM_WORLD, PETSC_DECIDE, n1, &vr1);
err = MatGetColumnVector(r1, vr1, 0);
err = VecCreateMPI(PETSC_COMM_WORLD, PETSC_DECIDE, n2, &vr2);
err = MatGetColumnVector(r2, vr2, 0);
err = printMatInfo("r2", r2);
/*
// Start matrix-vec multiplications
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);
*/
err = MatDestroy(&r); CHKERRQ(err);
err = MatDestroy(&r1); CHKERRQ(err);
err = MatDestroy(&q1); CHKERRQ(err);
err = MatDestroy(&t1_1); CHKERRQ(err);
err = MatDestroy(&t1_2); CHKERRQ(err);
err = MatDestroy(&t1_3); CHKERRQ(err);
err = MatDestroy(&t1_4); CHKERRQ(err);
err = MatDestroy(&t1_5); CHKERRQ(err);
err = MatDestroy(&r2); CHKERRQ(err);
err = MatDestroy(&q2); CHKERRQ(err);
err = MatDestroy(&q_tilda); CHKERRQ(err);
err = MatDestroy(&t2_1); CHKERRQ(err);
err = MatDestroy(&t2_2); CHKERRQ(err);
err = MatDestroy(&t2_3); CHKERRQ(err);
return err;
}
int main(int argc,char **argv)
{
PetscErrorCode ierr;
KSP ksp;
PC pc;
Vec x,b;
DM da;
Mat A,Atrans;
PetscInt dof=1,M=8;
PetscBool flg,trans=PETSC_FALSE;
ierr = PetscInitialize(&argc,&argv,(char*)0,help);if (ierr) return ierr;
ierr = PetscOptionsGetInt(NULL,NULL,"-dof",&dof,NULL);CHKERRQ(ierr);
ierr = PetscOptionsGetInt(NULL,NULL,"-M",&M,NULL);CHKERRQ(ierr);
ierr = PetscOptionsGetBool(NULL,NULL,"-trans",&trans,NULL);CHKERRQ(ierr);
ierr = DMDACreate(PETSC_COMM_WORLD,&da);CHKERRQ(ierr);
ierr = DMSetDimension(da,3);CHKERRQ(ierr);
ierr = DMDASetBoundaryType(da,DM_BOUNDARY_NONE,DM_BOUNDARY_NONE,DM_BOUNDARY_NONE);CHKERRQ(ierr);
ierr = DMDASetStencilType(da,DMDA_STENCIL_STAR);CHKERRQ(ierr);
ierr = DMDASetSizes(da,M,M,M);CHKERRQ(ierr);
ierr = DMDASetNumProcs(da,PETSC_DECIDE,PETSC_DECIDE,PETSC_DECIDE);CHKERRQ(ierr);
ierr = DMDASetDof(da,dof);CHKERRQ(ierr);
ierr = DMDASetStencilWidth(da,1);CHKERRQ(ierr);
ierr = DMDASetOwnershipRanges(da,NULL,NULL,NULL);CHKERRQ(ierr);
ierr = DMSetFromOptions(da);CHKERRQ(ierr);
ierr = DMSetUp(da);CHKERRQ(ierr);
ierr = DMCreateGlobalVector(da,&x);CHKERRQ(ierr);
ierr = DMCreateGlobalVector(da,&b);CHKERRQ(ierr);
ierr = ComputeRHS(da,b);CHKERRQ(ierr);
ierr = DMSetMatType(da,MATBAIJ);CHKERRQ(ierr);
ierr = DMSetFromOptions(da);CHKERRQ(ierr);
ierr = DMCreateMatrix(da,&A);CHKERRQ(ierr);
ierr = ComputeMatrix(da,A);CHKERRQ(ierr);
/* A is non-symmetric. Make A = 0.5*(A + Atrans) symmetric for testing icc and cholesky */
ierr = MatTranspose(A,MAT_INITIAL_MATRIX,&Atrans);CHKERRQ(ierr);
ierr = MatAXPY(A,1.0,Atrans,DIFFERENT_NONZERO_PATTERN);CHKERRQ(ierr);
ierr = MatScale(A,0.5);CHKERRQ(ierr);
ierr = MatDestroy(&Atrans);CHKERRQ(ierr);
/* Test sbaij matrix */
flg = PETSC_FALSE;
ierr = PetscOptionsGetBool(NULL,NULL, "-test_sbaij1", &flg,NULL);CHKERRQ(ierr);
if (flg) {
Mat sA;
PetscBool issymm;
ierr = MatIsTranspose(A,A,0.0,&issymm);CHKERRQ(ierr);
if (issymm) {
ierr = MatSetOption(A,MAT_SYMMETRIC,PETSC_TRUE);CHKERRQ(ierr);
} else {ierr = PetscPrintf(PETSC_COMM_WORLD,"Warning: A is non-symmetric\n");CHKERRQ(ierr);}
ierr = MatConvert(A,MATSBAIJ,MAT_INITIAL_MATRIX,&sA);CHKERRQ(ierr);
ierr = MatDestroy(&A);CHKERRQ(ierr);
A = sA;
}
ierr = KSPCreate(PETSC_COMM_WORLD,&ksp);CHKERRQ(ierr);
ierr = KSPSetFromOptions(ksp);CHKERRQ(ierr);
ierr = KSPSetOperators(ksp,A,A);CHKERRQ(ierr);
ierr = KSPGetPC(ksp,&pc);CHKERRQ(ierr);
ierr = PCSetDM(pc,(DM)da);CHKERRQ(ierr);
if (trans) {
ierr = KSPSolveTranspose(ksp,b,x);CHKERRQ(ierr);
} else {
ierr = KSPSolve(ksp,b,x);CHKERRQ(ierr);
}
/* check final residual */
flg = PETSC_FALSE;
ierr = PetscOptionsGetBool(NULL,NULL, "-check_final_residual", &flg,NULL);CHKERRQ(ierr);
if (flg) {
Vec b1;
PetscReal norm;
ierr = KSPGetSolution(ksp,&x);CHKERRQ(ierr);
ierr = VecDuplicate(b,&b1);CHKERRQ(ierr);
ierr = MatMult(A,x,b1);CHKERRQ(ierr);
ierr = VecAXPY(b1,-1.0,b);CHKERRQ(ierr);
ierr = VecNorm(b1,NORM_2,&norm);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"Final residual %g\n",norm);CHKERRQ(ierr);
ierr = VecDestroy(&b1);CHKERRQ(ierr);
}
ierr = KSPDestroy(&ksp);CHKERRQ(ierr);
ierr = VecDestroy(&x);CHKERRQ(ierr);
ierr = VecDestroy(&b);CHKERRQ(ierr);
ierr = MatDestroy(&A);CHKERRQ(ierr);
ierr = DMDestroy(&da);CHKERRQ(ierr);
ierr = PetscFinalize();
return ierr;
}
int main(int argc,char **argv)
{
PetscErrorCode ierr;
KSP ksp;
PC pc;
Vec x,b;
DA da;
Mat A,Atrans;
PetscInt dof=1,M=-8;
PetscTruth flg,trans=PETSC_FALSE;
PetscInitialize(&argc,&argv,(char *)0,help);
ierr = PetscOptionsGetInt(PETSC_NULL,"-dof",&dof,PETSC_NULL);CHKERRQ(ierr);
ierr = PetscOptionsGetInt(PETSC_NULL,"-M",&M,PETSC_NULL);CHKERRQ(ierr);
ierr = PetscOptionsGetTruth(PETSC_NULL,"-trans",&trans,PETSC_NULL);CHKERRQ(ierr);
ierr = DACreate(PETSC_COMM_WORLD,&da);CHKERRQ(ierr);
ierr = DASetDim(da,3);CHKERRQ(ierr);
ierr = DASetPeriodicity(da,DA_NONPERIODIC);CHKERRQ(ierr);
ierr = DASetStencilType(da,DA_STENCIL_STAR);CHKERRQ(ierr);
ierr = DASetSizes(da,M,M,M);CHKERRQ(ierr);
ierr = DASetNumProcs(da,PETSC_DECIDE,PETSC_DECIDE,PETSC_DECIDE);CHKERRQ(ierr);
ierr = DASetDof(da,dof);CHKERRQ(ierr);
ierr = DASetStencilWidth(da,1);CHKERRQ(ierr);
ierr = DASetVertexDivision(da,PETSC_NULL,PETSC_NULL,PETSC_NULL);CHKERRQ(ierr);
ierr = DASetFromOptions(da);CHKERRQ(ierr);
ierr = DACreateGlobalVector(da,&x);CHKERRQ(ierr);
ierr = DACreateGlobalVector(da,&b);CHKERRQ(ierr);
ierr = ComputeRHS(da,b);CHKERRQ(ierr);
ierr = DAGetMatrix(da,MATBAIJ,&A);CHKERRQ(ierr);
ierr = ComputeMatrix(da,A);CHKERRQ(ierr);
/* A is non-symmetric. Make A = 0.5*(A + Atrans) symmetric for testing icc and cholesky */
ierr = MatTranspose(A,MAT_INITIAL_MATRIX,&Atrans);CHKERRQ(ierr);
ierr = MatAXPY(A,1.0,Atrans,DIFFERENT_NONZERO_PATTERN);CHKERRQ(ierr);
ierr = MatScale(A,0.5);CHKERRQ(ierr);
ierr = MatDestroy(Atrans);CHKERRQ(ierr);
/* Test sbaij matrix */
flg = PETSC_FALSE;
ierr = PetscOptionsGetTruth(PETSC_NULL, "-test_sbaij1", &flg,PETSC_NULL);CHKERRQ(ierr);
if (flg){
Mat sA;
ierr = MatConvert(A,MATSBAIJ,MAT_INITIAL_MATRIX,&sA);CHKERRQ(ierr);
ierr = MatDestroy(A);CHKERRQ(ierr);
A = sA;
}
ierr = KSPCreate(PETSC_COMM_WORLD,&ksp);CHKERRQ(ierr);
ierr = KSPSetFromOptions(ksp);CHKERRQ(ierr);
ierr = KSPSetOperators(ksp,A,A,SAME_NONZERO_PATTERN);CHKERRQ(ierr);
ierr = KSPGetPC(ksp,&pc);CHKERRQ(ierr);
ierr = PCSetDA(pc,da);CHKERRQ(ierr);
if (trans) {
ierr = KSPSolveTranspose(ksp,b,x);CHKERRQ(ierr);
} else {
ierr = KSPSolve(ksp,b,x);CHKERRQ(ierr);
}
/* check final residual */
flg = PETSC_FALSE;
ierr = PetscOptionsGetTruth(PETSC_NULL, "-check_final_residual", &flg,PETSC_NULL);CHKERRQ(ierr);
if (flg){
Vec b1;
PetscReal norm;
ierr = KSPGetSolution(ksp,&x);CHKERRQ(ierr);
ierr = VecDuplicate(b,&b1);CHKERRQ(ierr);
ierr = MatMult(A,x,b1);CHKERRQ(ierr);
ierr = VecAXPY(b1,-1.0,b);CHKERRQ(ierr);
ierr = VecNorm(b1,NORM_2,&norm);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"Final residual %g\n",norm);CHKERRQ(ierr);
ierr = VecDestroy(b1);CHKERRQ(ierr);
}
ierr = KSPDestroy(ksp);CHKERRQ(ierr);
ierr = VecDestroy(x);CHKERRQ(ierr);
ierr = VecDestroy(b);CHKERRQ(ierr);
ierr = MatDestroy(A);CHKERRQ(ierr);
ierr = DADestroy(da);CHKERRQ(ierr);
ierr = PetscFinalize();CHKERRQ(ierr);
return 0;
}
int main(int argc,char **argv) {
Mat A,B,C,D;
PetscScalar a[]= {1.,1.,0.,0.,1.,1.,0.,0.,1.};
PetscInt ij[]= {0,1,2};
PetscScalar none=-1.;
PetscErrorCode ierr;
PetscReal fill=4;
PetscReal norm;
PetscInitialize(&argc,&argv,(char *)0,help);
ierr = MatCreate(PETSC_COMM_SELF,&A);
CHKERRQ(ierr);
ierr = MatSetSizes(A,3,3,3,3);
CHKERRQ(ierr);
ierr = MatSetType(A,MATSEQAIJ);
CHKERRQ(ierr);
ierr = MatSetUp(A);
CHKERRQ(ierr);
ierr = MatSetOption(A,MAT_IGNORE_ZERO_ENTRIES,PETSC_TRUE);
CHKERRQ(ierr);
ierr = MatSetValues(A,3,ij,3,ij,a,ADD_VALUES);
CHKERRQ(ierr);
ierr = MatAssemblyBegin(A,MAT_FINAL_ASSEMBLY);
CHKERRQ(ierr);
ierr = MatAssemblyEnd(A,MAT_FINAL_ASSEMBLY);
CHKERRQ(ierr);
ierr = MatSetOptionsPrefix(A,"A_");
CHKERRQ(ierr);
ierr = MatView(A,PETSC_VIEWER_STDOUT_WORLD);
CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_SELF,"\n");
CHKERRQ(ierr);
/* Test MatMatMult() */
ierr = MatTranspose(A,MAT_INITIAL_MATRIX,&B);
CHKERRQ(ierr); /* B = A^T */
ierr = MatMatMult(B,A,MAT_INITIAL_MATRIX,fill,&C);
CHKERRQ(ierr); /* C = B*A */
ierr = MatSetOptionsPrefix(C,"C=B*A=A^T*A_");
CHKERRQ(ierr);
ierr = MatView(C,PETSC_VIEWER_STDOUT_WORLD);
CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_SELF,"\n");
CHKERRQ(ierr);
ierr = MatMatMultSymbolic(C,A,fill,&D);
CHKERRQ(ierr);
ierr = MatMatMultNumeric(C,A,D);
CHKERRQ(ierr); /* D = C*A = (A^T*A)*A */
ierr = MatSetOptionsPrefix(D,"D=C*A=(A^T*A)*A_");
CHKERRQ(ierr);
ierr = MatView(D,PETSC_VIEWER_STDOUT_WORLD);
CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_SELF,"\n");
CHKERRQ(ierr);
/* Repeat the numeric product to test reuse of the previous symbolic product */
ierr = MatMatMultNumeric(C,A,D);
CHKERRQ(ierr);
ierr = MatView(D,PETSC_VIEWER_STDOUT_WORLD);
CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_SELF,"\n");
CHKERRQ(ierr);
ierr = MatDestroy(&B);
CHKERRQ(ierr);
ierr = MatDestroy(&C);
CHKERRQ(ierr);
/* Test PtAP routine. */
ierr = MatDuplicate(A,MAT_COPY_VALUES,&B);
CHKERRQ(ierr); /* B = A */
ierr = MatPtAP(A,B,MAT_INITIAL_MATRIX,fill,&C);
CHKERRQ(ierr); /* C = B^T*A*B */
ierr = MatAXPY(D,none,C,DIFFERENT_NONZERO_PATTERN);
CHKERRQ(ierr);
ierr = MatNorm(D,NORM_FROBENIUS,&norm);
if (norm > 1.e-15) {
ierr = PetscPrintf(PETSC_COMM_SELF,"Error in MatPtAP: %g\n",norm);
}
ierr = MatDestroy(&C);
CHKERRQ(ierr);
ierr = MatDestroy(&D);
CHKERRQ(ierr);
/* Repeat PtAP to test symbolic/numeric separation for reuse of the symbolic product */
ierr = MatPtAP(A,B,MAT_INITIAL_MATRIX,fill,&C);
CHKERRQ(ierr);
ierr = MatSetOptionsPrefix(C,"C=BtAB_");
CHKERRQ(ierr);
ierr = MatView(C,PETSC_VIEWER_STDOUT_WORLD);
CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_SELF,"\n");
CHKERRQ(ierr);
ierr = MatPtAPSymbolic(A,B,fill,&D);
CHKERRQ(ierr);
ierr = MatPtAPNumeric(A,B,D);
CHKERRQ(ierr);
ierr = MatSetOptionsPrefix(D,"D=BtAB_");
CHKERRQ(ierr);
ierr = MatView(D,PETSC_VIEWER_STDOUT_WORLD);
CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_SELF,"\n");
CHKERRQ(ierr);
/* Repeat numeric product to test reuse of the previous symbolic product */
ierr = MatPtAPNumeric(A,B,D);
CHKERRQ(ierr);
ierr = MatAXPY(D,none,C,DIFFERENT_NONZERO_PATTERN);
CHKERRQ(ierr);
ierr = MatNorm(D,NORM_FROBENIUS,&norm);
if (norm > 1.e-15) {
ierr = PetscPrintf(PETSC_COMM_SELF,"Error in symbolic/numeric MatPtAP: %g\n",norm);
}
ierr = MatDestroy(&B);
ierr = MatDestroy(&C);
ierr = MatDestroy(&D);
/* A test contributed by Tobias Neckel <*****@*****.**> */
ierr = testPTAPRectangular();
CHKERRQ(ierr);
/* test MatMatTransposeMult(): A*B^T */
ierr = MatMatTransposeMult(A,A,MAT_INITIAL_MATRIX,fill,&D);
CHKERRQ(ierr); /* D = A*A^T */
ierr = MatSetOptionsPrefix(D,"D=A*A^T_");
CHKERRQ(ierr);
ierr = MatView(D,PETSC_VIEWER_STDOUT_WORLD);
CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_SELF,"\n");
CHKERRQ(ierr);
ierr = MatTranspose(A,MAT_INITIAL_MATRIX,&B);
CHKERRQ(ierr); /* B = A^T */
ierr = MatMatMult(A,B,MAT_INITIAL_MATRIX,fill,&C);
CHKERRQ(ierr); /* C=A*B */
ierr = MatSetOptionsPrefix(C,"D=A*B=A*A^T_");
CHKERRQ(ierr);
ierr = MatView(C,PETSC_VIEWER_STDOUT_WORLD);
CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_SELF,"\n");
CHKERRQ(ierr);
ierr = MatDestroy(&A);
ierr = MatDestroy(&B);
ierr = MatDestroy(&C);
ierr = MatDestroy(&D);
PetscFinalize();
return(0);
}
void _Stokes_SLE_PenaltySolver_Solve( void* solver,void* stokesSLE ) {
Stokes_SLE_PenaltySolver* self = (Stokes_SLE_PenaltySolver*)solver;
Stokes_SLE* sle = (Stokes_SLE*)stokesSLE;
/* Create shortcuts to stuff needed on sle */
Mat kMatrix = sle->kStiffMat->matrix;
Mat gradMat = sle->gStiffMat->matrix;
Mat divMat = NULL;
Mat C_Mat = sle->cStiffMat->matrix;
Vec uVec = sle->uSolnVec->vector;
Vec pVec = sle->pSolnVec->vector;
Vec fVec = sle->fForceVec->vector;
Vec hVec = sle->hForceVec->vector;
Vec hTempVec;
Vec fTempVec;
Vec penalty;
Mat GTrans, kHat;
KSP ksp_v;
double negOne=-1.0;
double one=1.0;
Mat C_InvMat;
Vec diagC;
PC pc;
int rank;
MPI_Comm_rank( MPI_COMM_WORLD, &rank );
Journal_DPrintf( self->debug, "In %s():\n", __func__ );
VecDuplicate( hVec, &hTempVec );
VecDuplicate( fVec, &fTempVec );
VecDuplicate( pVec, &diagC );
if( sle->dStiffMat == NULL ) {
Journal_DPrintf( self->debug, "Div matrix == NULL : Problem is assumed to be symmetric. ie Div = GTrans \n");
#if( PETSC_VERSION_MAJOR <= 2 )
MatTranspose( gradMat, >rans );
#else
MatTranspose( gradMat, MAT_INITIAL_MATRIX, >rans );
#endif
divMat = GTrans;
}
else {
MatType type;
PetscInt size[2];
MatGetType( sle->dStiffMat->matrix, &type );
MatGetLocalSize( sle->dStiffMat->matrix, size + 0, size + 1 );
/* make a copy we can play with */
MatCreate( sle->comm, >rans );
MatSetSizes( GTrans, size[0], size[1], PETSC_DECIDE, PETSC_DECIDE );
MatSetType( GTrans, type );
#if (((PETSC_VERSION_MAJOR==3) && (PETSC_VERSION_MINOR>=3)) || (PETSC_VERSION_MAJOR>3) )
MatSetUp(GTrans);
#endif
MatCopy( sle->dStiffMat->matrix, GTrans, DIFFERENT_NONZERO_PATTERN );
divMat = GTrans;
}
Stokes_SLE_PenaltySolver_MakePenalty( self, sle, &penalty );
/* Create CInv */
MatGetDiagonal( C_Mat, diagC );
VecReciprocal( diagC );
VecPointwiseMult( diagC, penalty, diagC );
{ /* Print the maximum and minimum penalties in my system. */
PetscInt idx;
PetscReal min, max;
VecMin( diagC, &idx, &min );
VecMax( diagC, &idx, &max );
if( rank == 0 ) {
printf( "PENALTY RANGE:\n" );
printf( " MIN: %e\n", min );
printf( " MAX: %e\n", max );
}
}
MatDiagonalSet( C_Mat, diagC, INSERT_VALUES );
C_InvMat = C_Mat; /* Use pointer CInv since C has been inverted */
/* Build RHS : rhs = f - GCInv h */
MatMult( C_InvMat, hVec, hTempVec ); /* hTempVec = C_InvMat * hVec */
VecScale( hTempVec, -1.0 );
MatMult( gradMat, hTempVec, fTempVec );
#if 0
VecPointwiseMult( fTempVec, penalty, fTempVec );
{ /* Print the maximum and minimum penalties in my system. */
PetscInt idx;
PetscReal min, max;
VecMin( fTempVec, &idx, &min );
VecMax( fTempVec, &idx, &max );
printf( "PENALTY RANGE:\n" );
printf( " MIN: %e\n", min );
printf( " MAX: %e\n", max );
}
#endif
VecAXPY( fTempVec, 1.0, fVec );
/*MatMultAdd( gradMat, hTempVec, fVec, fTempVec );*/
/* Build G CInv GTrans */
/* MatTranspose( gradMat, >rans ); */
/* since CInv is diagonal we can just scale mat entries by the diag vector */
MatDiagonalScale( divMat, diagC, PETSC_NULL ); /* Div = CInve Div */
MatMatMult( gradMat, divMat, MAT_INITIAL_MATRIX, PETSC_DEFAULT, &kHat );
/*MatDiagonalScale( kHat, penalty, PETSC_NULL );*/
MatScale( kHat, -1.0 );
MatAXPY( kMatrix, 1.0, kHat, SAME_NONZERO_PATTERN );
/* Setup solver context and make sure that it uses a direct solver */
KSPCreate( sle->comm, &ksp_v );
Stg_KSPSetOperators( ksp_v, kMatrix, kMatrix, DIFFERENT_NONZERO_PATTERN );
KSPSetType( ksp_v, KSPPREONLY );
KSPGetPC( ksp_v, &pc );
PCSetType( pc, PCLU );
KSPSetFromOptions( ksp_v );
KSPSolve( ksp_v, fTempVec, uVec );
/* Recover p */
if( sle->dStiffMat == NULL ) {
/* since Div was modified when C is diagonal, re build the transpose */
if( GTrans != PETSC_NULL )
Stg_MatDestroy(>rans );
#if( PETSC_VERSION_MAJOR <= 2 )
MatTranspose( gradMat, >rans );
#else
MatTranspose( gradMat, MAT_INITIAL_MATRIX, >rans );
#endif
divMat = GTrans;
}
else {
/* never modified Div_null so set divMat to point back to it */
divMat = sle->dStiffMat->matrix;
}
MatMult( divMat, uVec, hTempVec ); /* hTemp = Div v */
VecAYPX( hTempVec, negOne, hVec ); /* hTemp = H - hTemp : hTemp = H - Div v */
MatMult( C_InvMat, hTempVec, pVec ); /* p = CInv hTemp : p = CInv ( H - Div v ) */
Stg_MatDestroy(&kHat );
if( fTempVec != PETSC_NULL ) Stg_VecDestroy(&fTempVec );
if( hTempVec != PETSC_NULL ) Stg_VecDestroy(&hTempVec );
if( diagC != PETSC_NULL ) Stg_VecDestroy(&diagC );
if( ksp_v != PETSC_NULL ) Stg_KSPDestroy(&ksp_v );
if( GTrans != PETSC_NULL ) Stg_MatDestroy(>rans );
}
/*
PEPBuildDiagonalScaling - compute two diagonal matrices to be applied for balancing
in polynomial eigenproblems.
*/
PetscErrorCode PEPBuildDiagonalScaling(PEP pep)
{
PetscErrorCode ierr;
PetscInt it,i,j,k,nmat,nr,e,nz,lst,lend,nc=0,*cols,emax,emin,emaxl,eminl;
const PetscInt *cidx,*ridx;
Mat M,*T,A;
PetscMPIInt n;
PetscBool cont=PETSC_TRUE,flg=PETSC_FALSE;
PetscScalar *array,*Dr,*Dl,t;
PetscReal l2,d,*rsum,*aux,*csum,w=1.0;
MatStructure str;
MatInfo info;
PetscFunctionBegin;
l2 = 2*PetscLogReal(2.0);
nmat = pep->nmat;
ierr = PetscMPIIntCast(pep->n,&n);
ierr = STGetMatStructure(pep->st,&str);CHKERRQ(ierr);
ierr = PetscMalloc1(nmat,&T);CHKERRQ(ierr);
for (k=0;k<nmat;k++) {
ierr = STGetTOperators(pep->st,k,&T[k]);CHKERRQ(ierr);
}
/* Form local auxiliar matrix M */
ierr = PetscObjectTypeCompareAny((PetscObject)T[0],&cont,MATMPIAIJ,MATSEQAIJ);CHKERRQ(ierr);
if (!cont) SETERRQ(PetscObjectComm((PetscObject)T[0]),PETSC_ERR_SUP,"Only for MPIAIJ or SEQAIJ matrix types");
ierr = PetscObjectTypeCompare((PetscObject)T[0],MATMPIAIJ,&cont);CHKERRQ(ierr);
if (cont) {
ierr = MatMPIAIJGetLocalMat(T[0],MAT_INITIAL_MATRIX,&M);CHKERRQ(ierr);
flg = PETSC_TRUE;
} else {
ierr = MatDuplicate(T[0],MAT_COPY_VALUES,&M);CHKERRQ(ierr);
}
ierr = MatGetInfo(M,MAT_LOCAL,&info);CHKERRQ(ierr);
nz = info.nz_used;
ierr = MatSeqAIJGetArray(M,&array);CHKERRQ(ierr);
for (i=0;i<nz;i++) {
t = PetscAbsScalar(array[i]);
array[i] = t*t;
}
ierr = MatSeqAIJRestoreArray(M,&array);CHKERRQ(ierr);
for (k=1;k<nmat;k++) {
if (flg) {
ierr = MatMPIAIJGetLocalMat(T[k],MAT_INITIAL_MATRIX,&A);CHKERRQ(ierr);
} else {
if (str==SAME_NONZERO_PATTERN) {
ierr = MatCopy(T[k],A,SAME_NONZERO_PATTERN);CHKERRQ(ierr);
} else {
ierr = MatDuplicate(T[k],MAT_COPY_VALUES,&A);CHKERRQ(ierr);
}
}
ierr = MatGetInfo(A,MAT_LOCAL,&info);CHKERRQ(ierr);
nz = info.nz_used;
ierr = MatSeqAIJGetArray(A,&array);CHKERRQ(ierr);
for (i=0;i<nz;i++) {
t = PetscAbsScalar(array[i]);
array[i] = t*t;
}
ierr = MatSeqAIJRestoreArray(A,&array);CHKERRQ(ierr);
w *= pep->slambda*pep->slambda*pep->sfactor;
ierr = MatAXPY(M,w,A,str);CHKERRQ(ierr);
if (flg || str!=SAME_NONZERO_PATTERN || k==nmat-2) {
ierr = MatDestroy(&A);CHKERRQ(ierr);
}
}
ierr = MatGetRowIJ(M,0,PETSC_FALSE,PETSC_FALSE,&nr,&ridx,&cidx,&cont);CHKERRQ(ierr);
if (!cont) SETERRQ(PetscObjectComm((PetscObject)T[0]), PETSC_ERR_SUP,"It is not possible to compute scaling diagonals for these PEP matrices");
ierr = MatGetInfo(M,MAT_LOCAL,&info);CHKERRQ(ierr);
nz = info.nz_used;
ierr = VecGetOwnershipRange(pep->Dl,&lst,&lend);CHKERRQ(ierr);
ierr = PetscMalloc4(nr,&rsum,pep->n,&csum,pep->n,&aux,PetscMin(pep->n-lend+lst,nz),&cols);CHKERRQ(ierr);
ierr = VecSet(pep->Dr,1.0);CHKERRQ(ierr);
ierr = VecSet(pep->Dl,1.0);CHKERRQ(ierr);
ierr = VecGetArray(pep->Dl,&Dl);CHKERRQ(ierr);
ierr = VecGetArray(pep->Dr,&Dr);CHKERRQ(ierr);
ierr = MatSeqAIJGetArray(M,&array);CHKERRQ(ierr);
ierr = PetscMemzero(aux,pep->n*sizeof(PetscReal));CHKERRQ(ierr);
for (j=0;j<nz;j++) {
/* Search non-zero columns outsize lst-lend */
if (aux[cidx[j]]==0 && (cidx[j]<lst || lend<=cidx[j])) cols[nc++] = cidx[j];
/* Local column sums */
aux[cidx[j]] += PetscAbsScalar(array[j]);
}
for (it=0;it<pep->sits && cont;it++) {
emaxl = 0; eminl = 0;
/* Column sum */
if (it>0) { /* it=0 has been already done*/
ierr = MatSeqAIJGetArray(M,&array);CHKERRQ(ierr);
ierr = PetscMemzero(aux,pep->n*sizeof(PetscReal));CHKERRQ(ierr);
for (j=0;j<nz;j++) aux[cidx[j]] += PetscAbsScalar(array[j]);
ierr = MatSeqAIJRestoreArray(M,&array);CHKERRQ(ierr);
}
ierr = MPI_Allreduce(aux,csum,n,MPIU_REAL,MPIU_SUM,PetscObjectComm((PetscObject)pep->Dr));
/* Update Dr */
for (j=lst;j<lend;j++) {
d = PetscLogReal(csum[j])/l2;
e = -(PetscInt)((d < 0)?(d-0.5):(d+0.5));
d = PetscPowReal(2.0,e);
Dr[j-lst] *= d;
aux[j] = d*d;
emaxl = PetscMax(emaxl,e);
eminl = PetscMin(eminl,e);
}
for (j=0;j<nc;j++) {
d = PetscLogReal(csum[cols[j]])/l2;
e = -(PetscInt)((d < 0)?(d-0.5):(d+0.5));
d = PetscPowReal(2.0,e);
aux[cols[j]] = d*d;
emaxl = PetscMax(emaxl,e);
eminl = PetscMin(eminl,e);
}
/* Scale M */
ierr = MatSeqAIJGetArray(M,&array);CHKERRQ(ierr);
for (j=0;j<nz;j++) {
array[j] *= aux[cidx[j]];
}
ierr = MatSeqAIJRestoreArray(M,&array);CHKERRQ(ierr);
/* Row sum */
ierr = PetscMemzero(rsum,nr*sizeof(PetscReal));CHKERRQ(ierr);
ierr = MatSeqAIJGetArray(M,&array);CHKERRQ(ierr);
for (i=0;i<nr;i++) {
for (j=ridx[i];j<ridx[i+1];j++) rsum[i] += PetscAbsScalar(array[j]);
/* Update Dl */
d = PetscLogReal(rsum[i])/l2;
e = -(PetscInt)((d < 0)?(d-0.5):(d+0.5));
d = PetscPowReal(2.0,e);
Dl[i] *= d;
/* Scale M */
for (j=ridx[i];j<ridx[i+1];j++) array[j] *= d*d;
emaxl = PetscMax(emaxl,e);
eminl = PetscMin(eminl,e);
}
ierr = MatSeqAIJRestoreArray(M,&array);CHKERRQ(ierr);
/* Compute global max and min */
ierr = MPI_Allreduce(&emaxl,&emax,1,MPIU_INT,MPIU_MAX,PetscObjectComm((PetscObject)pep->Dl));
ierr = MPI_Allreduce(&eminl,&emin,1,MPIU_INT,MPIU_MIN,PetscObjectComm((PetscObject)pep->Dl));
if (emax<=emin+2) cont = PETSC_FALSE;
}
ierr = VecRestoreArray(pep->Dr,&Dr);CHKERRQ(ierr);
ierr = VecRestoreArray(pep->Dl,&Dl);CHKERRQ(ierr);
/* Free memory*/
ierr = MatDestroy(&M);CHKERRQ(ierr);
ierr = PetscFree4(rsum,csum,aux,cols);CHKERRQ(ierr);
ierr = PetscFree(T);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
int main(int argc,char **args)
{
Mat A,Atrans,sA,*submatA,*submatsA;
PetscErrorCode ierr;
PetscMPIInt size,rank;
PetscInt bs=1,mbs=10,ov=1,i,j,k,*rows,*cols,nd=2,*idx,rstart,rend,sz,M,N,Mbs;
PetscScalar *vals,rval,one=1.0;
IS *is1,*is2;
PetscRandom rand;
PetscBool flg,TestOverlap,TestSubMat,TestAllcols,test_sorted=PETSC_FALSE;
PetscInt vid = -1;
#if defined(PETSC_USE_LOG)
PetscLogStage stages[2];
#endif
ierr = PetscInitialize(&argc,&args,(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);
ierr = PetscOptionsGetInt(NULL,NULL,"-mat_block_size",&bs,NULL);CHKERRQ(ierr);
ierr = PetscOptionsGetInt(NULL,NULL,"-mat_mbs",&mbs,NULL);CHKERRQ(ierr);
ierr = PetscOptionsGetInt(NULL,NULL,"-ov",&ov,NULL);CHKERRQ(ierr);
ierr = PetscOptionsGetInt(NULL,NULL,"-nd",&nd,NULL);CHKERRQ(ierr);
ierr = PetscOptionsGetInt(NULL,NULL,"-view_id",&vid,NULL);CHKERRQ(ierr);
ierr = PetscOptionsHasName(NULL,NULL, "-test_overlap", &TestOverlap);CHKERRQ(ierr);
ierr = PetscOptionsHasName(NULL,NULL, "-test_submat", &TestSubMat);CHKERRQ(ierr);
ierr = PetscOptionsHasName(NULL,NULL, "-test_allcols", &TestAllcols);CHKERRQ(ierr);
ierr = PetscOptionsGetBool(NULL,NULL,"-test_sorted",&test_sorted,NULL);CHKERRQ(ierr);
ierr = MatCreate(PETSC_COMM_WORLD,&A);CHKERRQ(ierr);
ierr = MatSetSizes(A,mbs*bs,mbs*bs,PETSC_DECIDE,PETSC_DECIDE);CHKERRQ(ierr);
ierr = MatSetType(A,MATBAIJ);CHKERRQ(ierr);
ierr = MatSeqBAIJSetPreallocation(A,bs,PETSC_DEFAULT,NULL);CHKERRQ(ierr);
ierr = MatMPIBAIJSetPreallocation(A,bs,PETSC_DEFAULT,NULL,PETSC_DEFAULT,NULL);CHKERRQ(ierr);
ierr = PetscRandomCreate(PETSC_COMM_WORLD,&rand);CHKERRQ(ierr);
ierr = PetscRandomSetFromOptions(rand);CHKERRQ(ierr);
ierr = MatGetOwnershipRange(A,&rstart,&rend);CHKERRQ(ierr);
ierr = MatGetSize(A,&M,&N);CHKERRQ(ierr);
Mbs = M/bs;
ierr = PetscMalloc1(bs,&rows);CHKERRQ(ierr);
ierr = PetscMalloc1(bs,&cols);CHKERRQ(ierr);
ierr = PetscMalloc1(bs*bs,&vals);CHKERRQ(ierr);
ierr = PetscMalloc1(M,&idx);CHKERRQ(ierr);
/* Now set blocks of values */
for (j=0; j<bs*bs; j++) vals[j] = 0.0;
for (i=0; i<Mbs; i++) {
cols[0] = i*bs; rows[0] = i*bs;
for (j=1; j<bs; j++) {
rows[j] = rows[j-1]+1;
cols[j] = cols[j-1]+1;
}
ierr = MatSetValues(A,bs,rows,bs,cols,vals,ADD_VALUES);CHKERRQ(ierr);
}
/* second, add random blocks */
for (i=0; i<20*bs; i++) {
ierr = PetscRandomGetValue(rand,&rval);CHKERRQ(ierr);
cols[0] = bs*(PetscInt)(PetscRealPart(rval)*Mbs);
ierr = PetscRandomGetValue(rand,&rval);CHKERRQ(ierr);
rows[0] = rstart + bs*(PetscInt)(PetscRealPart(rval)*mbs);
for (j=1; j<bs; j++) {
rows[j] = rows[j-1]+1;
cols[j] = cols[j-1]+1;
}
for (j=0; j<bs*bs; j++) {
ierr = PetscRandomGetValue(rand,&rval);CHKERRQ(ierr);
vals[j] = rval;
}
ierr = MatSetValues(A,bs,rows,bs,cols,vals,ADD_VALUES);CHKERRQ(ierr);
}
ierr = MatAssemblyBegin(A,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
ierr = MatAssemblyEnd(A,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
/* make A a symmetric matrix: A <- A^T + A */
ierr = MatTranspose(A,MAT_INITIAL_MATRIX, &Atrans);CHKERRQ(ierr);
ierr = MatAXPY(A,one,Atrans,DIFFERENT_NONZERO_PATTERN);CHKERRQ(ierr);
ierr = MatDestroy(&Atrans);CHKERRQ(ierr);
ierr = MatTranspose(A,MAT_INITIAL_MATRIX, &Atrans);CHKERRQ(ierr);
ierr = MatEqual(A, Atrans, &flg);CHKERRQ(ierr);
if (flg) {
ierr = MatSetOption(A,MAT_SYMMETRIC,PETSC_TRUE);CHKERRQ(ierr);
} else SETERRQ(PETSC_COMM_SELF,1,"A+A^T is non-symmetric");
ierr = MatDestroy(&Atrans);CHKERRQ(ierr);
/* create a SeqSBAIJ matrix sA (= A) */
ierr = MatConvert(A,MATSBAIJ,MAT_INITIAL_MATRIX,&sA);CHKERRQ(ierr);
if (vid >= 0 && vid < size) {
if (!rank) printf("A: \n");
ierr = MatView(A,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
if (!rank) printf("sA: \n");
ierr = MatView(sA,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
}
/* Test sA==A through MatMult() */
ierr = MatMultEqual(A,sA,10,&flg);CHKERRQ(ierr);
if (!flg) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONG,"Error in MatConvert(): A != sA");
/* Test MatIncreaseOverlap() */
ierr = PetscMalloc1(nd,&is1);CHKERRQ(ierr);
ierr = PetscMalloc1(nd,&is2);CHKERRQ(ierr);
for (i=0; i<nd; i++) {
if (!TestAllcols) {
ierr = PetscRandomGetValue(rand,&rval);CHKERRQ(ierr);
sz = (PetscInt)((0.5+0.2*PetscRealPart(rval))*mbs); /* 0.5*mbs < sz < 0.7*mbs */
for (j=0; j<sz; j++) {
ierr = PetscRandomGetValue(rand,&rval);CHKERRQ(ierr);
idx[j*bs] = bs*(PetscInt)(PetscRealPart(rval)*Mbs);
for (k=1; k<bs; k++) idx[j*bs+k] = idx[j*bs]+k;
}
ierr = ISCreateGeneral(PETSC_COMM_SELF,sz*bs,idx,PETSC_COPY_VALUES,is1+i);CHKERRQ(ierr);
ierr = ISCreateGeneral(PETSC_COMM_SELF,sz*bs,idx,PETSC_COPY_VALUES,is2+i);CHKERRQ(ierr);
if (rank == vid) {
ierr = PetscPrintf(PETSC_COMM_SELF," [%d] IS sz[%d]: %d\n",rank,i,sz);CHKERRQ(ierr);
ierr = ISView(is2[i],PETSC_VIEWER_STDOUT_SELF);CHKERRQ(ierr);
}
} else { /* Test all rows and colums */
sz = M;
ierr = ISCreateStride(PETSC_COMM_SELF,sz,0,1,is1+i);CHKERRQ(ierr);
ierr = ISCreateStride(PETSC_COMM_SELF,sz,0,1,is2+i);CHKERRQ(ierr);
if (rank == vid) {
PetscBool colflag;
ierr = ISIdentity(is2[i],&colflag);CHKERRQ(ierr);
printf("[%d] is2[%d], colflag %d\n",rank,(int)i,(int)colflag);
ierr = ISView(is2[i],PETSC_VIEWER_STDOUT_SELF);CHKERRQ(ierr);
}
}
}
ierr = PetscLogStageRegister("MatOv_SBAIJ",&stages[0]);CHKERRQ(ierr);
ierr = PetscLogStageRegister("MatOv_BAIJ",&stages[1]);CHKERRQ(ierr);
/* Test MatIncreaseOverlap */
if (TestOverlap) {
ierr = PetscLogStagePush(stages[0]);CHKERRQ(ierr);
ierr = MatIncreaseOverlap(sA,nd,is2,ov);CHKERRQ(ierr);
ierr = PetscLogStagePop();CHKERRQ(ierr);
ierr = PetscLogStagePush(stages[1]);CHKERRQ(ierr);
ierr = MatIncreaseOverlap(A,nd,is1,ov);CHKERRQ(ierr);
ierr = PetscLogStagePop();CHKERRQ(ierr);
if (rank == vid) {
printf("\n[%d] IS from BAIJ:\n",rank);
ierr = ISView(is1[0],PETSC_VIEWER_STDOUT_SELF);CHKERRQ(ierr);
printf("\n[%d] IS from SBAIJ:\n",rank);
ierr = ISView(is2[0],PETSC_VIEWER_STDOUT_SELF);CHKERRQ(ierr);
}
for (i=0; i<nd; ++i) {
ierr = ISEqual(is1[i],is2[i],&flg);CHKERRQ(ierr);
if (!flg) {
if (!rank) {
ierr = ISSort(is1[i]);CHKERRQ(ierr);
/* ISView(is1[i],PETSC_VIEWER_STDOUT_SELF);CHKERRQ(ierr); */
ierr = ISSort(is2[i]);CHKERRQ(ierr);
/* ISView(is2[i],PETSC_VIEWER_STDOUT_SELF);CHKERRQ(ierr); */
}
SETERRQ1(PETSC_COMM_SELF,1,"i=%D, is1 != is2",i);
}
}
}
/* Test MatCreateSubmatrices */
if (TestSubMat) {
if (test_sorted) {
for (i = 0; i < nd; ++i) {
ierr = ISSort(is1[i]);CHKERRQ(ierr);
}
}
ierr = MatCreateSubMatrices(A,nd,is1,is1,MAT_INITIAL_MATRIX,&submatA);CHKERRQ(ierr);
ierr = MatCreateSubMatrices(sA,nd,is1,is1,MAT_INITIAL_MATRIX,&submatsA);CHKERRQ(ierr);
ierr = MatMultEqual(A,sA,10,&flg);CHKERRQ(ierr);
if (!flg) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONGSTATE,"A != sA");
/* Now test MatCreateSubmatrices with MAT_REUSE_MATRIX option */
ierr = MatCreateSubMatrices(A,nd,is1,is1,MAT_REUSE_MATRIX,&submatA);CHKERRQ(ierr);
ierr = MatCreateSubMatrices(sA,nd,is1,is1,MAT_REUSE_MATRIX,&submatsA);CHKERRQ(ierr);
ierr = MatMultEqual(A,sA,10,&flg);CHKERRQ(ierr);
if (!flg) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONGSTATE,"MatCreateSubmatrices(): A != sA");
ierr = MatDestroySubMatrices(nd,&submatA);CHKERRQ(ierr);
ierr = MatDestroySubMatrices(nd,&submatsA);CHKERRQ(ierr);
}
/* Free allocated memory */
for (i=0; i<nd; ++i) {
ierr = ISDestroy(&is1[i]);CHKERRQ(ierr);
ierr = ISDestroy(&is2[i]);CHKERRQ(ierr);
}
ierr = PetscFree(is1);CHKERRQ(ierr);
ierr = PetscFree(is2);CHKERRQ(ierr);
ierr = PetscFree(idx);CHKERRQ(ierr);
ierr = PetscFree(rows);CHKERRQ(ierr);
ierr = PetscFree(cols);CHKERRQ(ierr);
ierr = PetscFree(vals);CHKERRQ(ierr);
ierr = MatDestroy(&A);CHKERRQ(ierr);
ierr = MatDestroy(&sA);CHKERRQ(ierr);
ierr = PetscRandomDestroy(&rand);CHKERRQ(ierr);
ierr = PetscFinalize();
return ierr;
}