int main(int argc, char **argv){
SlepcInitialize(&argc, &argv, PETSC_NULL, PETSC_NULL);
int N[3] = {20, 25, 1}, Npml[3] = {5, 7, 0}, Nc = 2,
b[3][2] = {{-1, 0}, {1, 0}, {0, 0}}, LowerPML = 0, BCPeriod = 3;
double h[3] = {0.2, 0.3, 0.1};
int i, Nxyzr = 2*N[0]*N[1]*N[2];
double sigma[3], *muinv;
Vec muinvpml;
muinv = (double *) malloc(sizeof(double)*3*Nxyzr );
for(i=0; i<3; i++) sigma[i] = pmlsigma(1e-25, Npml[i]*h[i]);
MuinvPMLFull(PETSC_COMM_SELF, &muinvpml, N[0], N[1], N[2], Npml[0],
Npml[1], Npml[2], sigma[0], sigma[1], sigma[2], 1.0, LowerPML);
AddMuAbsorption(muinv, muinvpml, 1e25, 0);
VecDestroy(&muinvpml);
Mat Moperator;
MatCreateAIJ(PETSC_COMM_WORLD, PETSC_DECIDE, PETSC_DECIDE, Nc*Nxyzr,
Nc*Nxyzr, 26, NULL, 26, NULL, &Moperator);
MoperatorGeneralFill(Moperator, N[0], N[1], N[2], h[0], h[1], h[2],
b[0], b[1], b[2], muinv, BCPeriod, 0, Nc);
Assemble(Moperator);
PetscObjectSetName((PetscObject) Moperator, "M");
OutputMat(PETSC_COMM_WORLD, Moperator, filenameComm, "M.m");
SlepcFinalize();
return 0;
}
int main(int argc, char **args) {
SlepcInitialize(&argc, &args, (char*)0, help);
testNumBSpline();
testCalcBSpline();
testCalcBSplineECS();
testNon0QuadIndex();
testNon0QuadIndex2();
// testBSplineECS();
testBSplineSetBasic();
testBSplinePsi();
testBSplineSetSR1Mat();
testBSplineSetD2R1Mat();
testBSplineSetENMatR1Mat();
testBSplineSetEE();
testBSplineSetEE_time();
testBSplineSetNE_time();
testBSplineHAtom();
testBSplinePot();
testBSplinePot2();
testSlaterPotWithECS();
SlepcFinalize();
return 0;
}
int main(int argc, char *argv[])
{
PetscErrorCode ierr;
params params;
Mat H;
SlepcInitialize(&argc,&argv,(char*)0,help);
ierr = PetscPrintf(PETSC_COMM_WORLD,"--------------------------------------------------------------------------------------\n");CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD," _______ __ __ _______ _______ ______ _______ \n");CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD," |__ __| \\/ |/ ____\\ \\ / /_ _| ____|__ __| \n");CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD," | | | \\ / | (___ \\ \\ /\\ / / | | | |__ | | \n");CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD," | | | |\\/| |\\___ \\ \\ \\/ \\/ / | | | __| | | \n");CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD," | | | | | |____) | \\ /\\ / _| |_| | | | \n");CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD," |_| |_| |_|_____/ \\/ \\/ |_____|_| |_| \n");CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD," True Muonium Solver with Iterative Front-Form Techniques \n");CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD," \n");CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"--------------------------------------------------------------------------------------\n");CHKERRQ(ierr);
read_input(ierr,argv,¶ms);
print_input(ierr,¶ms);
if(check_file(params.hfile))
{
PetscViewer viewer_H;
PetscViewerBinaryOpen(PETSC_COMM_WORLD,params.hfile.c_str(),FILE_MODE_READ,&viewer_H);
MatCreate(PETSC_COMM_WORLD,&H);
MatSetFromOptions(H);
MatLoad(H,viewer_H);
PetscViewerDestroy(&viewer_H);
}else
{
discretize(ierr,¶ms);
// ierr = VecView(params.mu,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
// ierr = VecView(params.theta,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
write_output(ierr,¶ms);
coulomb_trick(ierr,¶ms);
// ierr = VecView(params.CT,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
ct_discrete(ierr,¶ms);
// ierr = VecView(params.CT,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
hamiltonian(ierr,¶ms,H);
// ierr = PetscViewerSetFormat(PETSC_VIEWER_STDOUT_WORLD,PETSC_VIEWER_ASCII_DENSE);//DENSE<-->COMMON
// MatView(H,PETSC_VIEWER_STDOUT_WORLD);
}
cleanup(ierr,¶ms);
eigensolver(ierr,¶ms,H,argc,argv);
ierr = MatDestroy(&H);CHKERRQ(ierr);
ierr = SlepcFinalize();
return 0;
}
int main(int argc,char **argv)
{
PetscErrorCode ierr;
DS ds;
PetscScalar *A;
PetscInt i,j,n=10,ld;
PetscViewer viewer;
PetscBool verbose;
SlepcInitialize(&argc,&argv,(char*)0,help);
ierr = PetscOptionsGetInt(NULL,"-n",&n,NULL);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"Compute symmetric matrix exponential - dimension %D.\n",n);CHKERRQ(ierr);
ierr = PetscOptionsHasName(NULL,"-verbose",&verbose);CHKERRQ(ierr);
/* Create DS object */
ierr = DSCreate(PETSC_COMM_WORLD,&ds);CHKERRQ(ierr);
ierr = DSSetType(ds,DSHEP);CHKERRQ(ierr);
ierr = DSSetFromOptions(ds);CHKERRQ(ierr);
ld = n+2; /* test leading dimension larger than n */
ierr = DSAllocate(ds,ld);CHKERRQ(ierr);
ierr = DSSetDimensions(ds,n,0,0,0);CHKERRQ(ierr);
/* Set up viewer */
ierr = PetscViewerASCIIGetStdout(PETSC_COMM_WORLD,&viewer);CHKERRQ(ierr);
ierr = PetscViewerPushFormat(viewer,PETSC_VIEWER_ASCII_INFO_DETAIL);CHKERRQ(ierr);
ierr = DSView(ds,viewer);CHKERRQ(ierr);
ierr = PetscViewerPopFormat(viewer);CHKERRQ(ierr);
if (verbose) {
ierr = PetscViewerPushFormat(viewer,PETSC_VIEWER_ASCII_MATLAB);CHKERRQ(ierr);
}
/* Fill with a symmetric Toeplitz matrix */
ierr = DSGetArray(ds,DS_MAT_A,&A);CHKERRQ(ierr);
for (i=0;i<n;i++) A[i+i*ld]=2.0;
for (j=1;j<3;j++) {
for (i=0;i<n-j;i++) { A[i+(i+j)*ld]=1.0; A[(i+j)+i*ld]=1.0; }
}
ierr = DSRestoreArray(ds,DS_MAT_A,&A);CHKERRQ(ierr);
ierr = DSSetState(ds,DS_STATE_RAW);CHKERRQ(ierr);
if (verbose) {
ierr = PetscPrintf(PETSC_COMM_WORLD,"Matrix A - - - - - - - -\n");CHKERRQ(ierr);
ierr = DSView(ds,viewer);CHKERRQ(ierr);
}
/* Compute matrix exponential */
ierr = DSComputeFunction(ds,SLEPC_FUNCTION_EXP);CHKERRQ(ierr);
if (verbose) {
ierr = PetscPrintf(PETSC_COMM_WORLD,"Computed f(A) - - - - - - -\n");CHKERRQ(ierr);
ierr = DSViewMat(ds,viewer,DS_MAT_F);CHKERRQ(ierr);
}
ierr = DSDestroy(&ds);CHKERRQ(ierr);
ierr = SlepcFinalize();
return 0;
}
int main(int argc, char **args) {
PetscErrorCode ierr;
MPI_Comm comm = MPI_COMM_SELF;
FEMInf fem;
ViewerFunc viewer;
int n;
ierr = SlepcInitialize(&argc, &args, (char*)0, help); CHKERRQ(ierr);
// ==== Initialize ====
PrintTimeStamp(comm, "Init", NULL);
ierr = FEMInfCreate(comm, &fem); CHKERRQ(ierr);
ierr = ViewerFuncCreate(comm, &viewer); CHKERRQ(ierr);
// ==== Set values ====
PrintTimeStamp(comm, "Set", NULL);
PetscOptionsBegin(comm, "", "plot_basis.c options", "none");
ierr = FEMInfSetFromOptions(fem); CHKERRQ(ierr);
ierr = ViewerFuncSetFromOptions(viewer); CHKERRQ(ierr);
ierr = PetscOptionsGetInt(NULL, "-n", &n, NULL); CHKERRQ(ierr);
PetscOptionsEnd();
// ==== Check input values ====
int num; FEMInfGetSize(fem, &num);
if(n < 0 || num <= n) {
SETERRQ(comm, 1, "n msut be zero or positive integer and smaller than size of FEM");
}
// ==== Calc ====
Vec c;
ierr = VecCreateSeq(comm, num, &c); CHKERRQ(ierr);
ierr = VecSet(c, 0.0); CHKERRQ(ierr);
int indices[1] = {n};
PetscScalar values[1] = {1.0};
ierr = VecSetValues(c, 1, indices, values, INSERT_VALUES); CHKERRQ(ierr);
ierr = VecAssemblyBegin(c); CHKERRQ(ierr);
ierr = VecAssemblyEnd(c); CHKERRQ(ierr);
FEMInfViewFunc(fem, c, viewer);
// ==== Finalize ====
ierr = SlepcFinalize(); CHKERRQ(ierr);
return 0;
}
int main(int argc, char** argv){
SlepcInitialize(&argc, &argv, PETSC_NULL, PETSC_NULL);
thing t;
PetscPrintf(PETSC_COMM_WORLD, "x before everything = %i\n", t.x);
t = thing(2);
PetscPrintf(PETSC_COMM_WORLD, "x after everything = %i\n", t.x);
// int N;
// VecGetSize(t.x, &N);
SlepcFinalize();
}
void Msg::Init(int argc, char **argv)
{
#if defined(HAVE_MPI)
int flag;
MPI_Initialized(&flag);
if(!flag) MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &_commRank);
MPI_Comm_size(MPI_COMM_WORLD, &_commSize);
MPI_Errhandler_set(MPI_COMM_WORLD, MPI_ERRORS_RETURN);
#endif
#if defined(HAVE_PETSC)
int sargc = 0;
char **sargv = new char*[argc + 1];
// prune argv from gmsh-specific options that make PETSc verbose
for(int i = 0; i < argc; i++){
std::string val(argv[i]);
if(val != "-info" && val != "-help" && val != "-v")
sargv[sargc++] = argv[i];
}
PetscInitialize(&sargc, &sargv, PETSC_NULL, PETSC_NULL);
PetscPopSignalHandler();
#if defined(HAVE_SLEPC)
SlepcInitialize(&sargc, &sargv, PETSC_NULL, PETSC_NULL);
#endif
delete [] sargv;
#endif
time_t now;
time(&now);
_launchDate = ctime(&now);
_launchDate.resize(_launchDate.size() - 1);
_commandLine.clear();
for(int i = 0; i < argc; i++){
if(i) _commandLine += " ";
_commandLine += argv[i];
}
if(argc && argv){
CTX::instance()->argv0 = std::string(argv[0]);
// add the directory where the binary is installed to the path where Python
// looks for modules, and to the path for executables (this allows us to
// find the onelab.py module or subclients automatically)
addGmshPathToEnvironmentVar("PYTHONPATH");
addGmshPathToEnvironmentVar("PATH");
}
InitializeOnelab("Gmsh");
}
int main(int argc, char **args) {
PetscErrorCode ierr;
MPI_Comm comm = PETSC_COMM_SELF;
FEMInf fem; FEMInfCreate(comm, &fem);
ViewerFunc viewer; ViewerFuncCreate(comm, &viewer);
PetscReal w = 1.0;
int L0 = 0;
int L1 = 1;
ierr = SlepcInitialize(&argc, &args, (char*)0, help); CHKERRQ(ierr);
PrintTimeStamp(comm, "Init", NULL);
PetscOptionsBegin(comm, "", "h_pi.c options", "none");
ierr = PetscOptionsGetInt(NULL, "-L0", &L0, NULL); CHKERRQ(ierr);
ierr = PetscOptionsGetInt(NULL, "-L1", &L1, NULL); CHKERRQ(ierr);
ierr = PetscOptionsGetReal(NULL, "-w", &w, NULL); CHKERRQ(ierr);
ierr = FEMInfSetFromOptions(fem); CHKERRQ(ierr);
ierr = ViewerFuncSetFromOptions(viewer); CHKERRQ(ierr);
PetscOptionsEnd();
Vec x0, x1;
PetscScalar e0, alpha;
ierr = SolveInit(fem, L0, &e0, &x0); CHKERRQ(ierr);
if(getenv("SHOW_DEBUG")) {
printf("E0=%f\n", PetscRealPart(e0));
}
ierr = SolveFinal(fem, L1, e0+w, x0, &x1, &alpha); CHKERRQ(ierr);
FEMInfView(fem, PETSC_VIEWER_STDOUT_SELF);
PetscPrintf(comm, "alpha: %f, %f\n",
PetscRealPart(alpha),
PetscImaginaryPart(alpha));
// ierr = PetscFOpen(comm, "tmp/h_pi_psi.dat", "w", &fp); CHKERRQ(ierr);
ierr = FEMInfViewFunc(fem, x1, viewer); CHKERRQ(ierr);
// ierr = PetscFClose(comm, fp); CHKERRQ(ierr);
// ierr = FEMInfDestroy(&fem); CHKERRQ(ierr);
return 0;
}
int main(int argc,char **args){
PetscErrorCode ierr;
SlepcInitialize(&argc,&args,(char*)0,help);
ierr = PetscPrintf(PETSC_COMM_WORLD,
"======================================================================\n"
"The purpose of this program is to study the steady state solution of\n"
" quantum master equation, that governs the laser assisted SOC system.\n"
"Motivated, proposed, designed, implemented and researched \n"
"by Lin Dong at Rice University. \n"
"at " __TIME__ ", on " __DATE__ "\n"
"Petsc is initialized and program starts from \n"
__FILE__ "\n"
"======================================================================\n");CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Compute the matrix and right-hand-side vector that define
the linear system, Gx = b.
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
cMasterMatrix GMatrix;
GMatrix.initialize();
GMatrix.construction();
GMatrix.seek_steady_state();
GMatrix.viewMatrix();
cMasterObservables DensityOps;
DensityOps.initialize(GMatrix);
DensityOps.photon(GMatrix);
DensityOps.oscillator(GMatrix);
DensityOps.ReshapeRho(GMatrix);
DensityOps.negativity();
DensityOps.checkODT(GMatrix);
DensityOps.spin_density(GMatrix);
/*
Always call PetscFinalize() before exiting a program. This routine
- finalizes the PETSc libraries as well as MPI
- provides summary and diagnostic information if certain runtime
options are chosen (e.g., -log_summary).
*/
DensityOps.destruction();
GMatrix.destruction();
ierr = SlepcFinalize();
return 0;
}
int main(int argc, char **args) {
PetscErrorCode ierr;
MPI_Comm comm = PETSC_COMM_SELF;
H2 h2;
ierr = SlepcInitialize(&argc, &args, (char*)0, help); CHKERRQ(ierr);
#if defined(PETSC_USE_COMPLEX)
PetscPrintf(comm, "Scalar: complex\n");
#else
PetscPrintf(comm, "Scalar: real\n");
#endif
PrintTimeStamp(comm, "Create", NULL);
ierr = H2Create(&h2); CHKERRQ(ierr);
PrintTimeStamp(comm, "Set", NULL);
ierr = H2SetFromOptions(h2); CHKERRQ(ierr);
PrintTimeStamp(comm, "View", NULL);
OCE2View(h2->oce, h2->viewer);
if(h2->init_view)
PetscViewerView(h2->init_view, h2->viewer);
for(int i = 0; i < h2->num_bondlength; i++) {
PrintTimeStamp(comm, "Set H", NULL);
PetscPrintf(comm, "bond_length = %f\n", h2->bondlength);
ierr = H2SetH(h2); CHKERRQ(ierr);
PrintTimeStamp(comm, "eps", NULL);
ierr = H2Solve(h2); CHKERRQ(ierr);
h2->bondlength += h2->d_bondlength;
}
PrintTimeStamp(comm, "Finalize", NULL);
ierr = H2Destroy(&h2); CHKERRQ(ierr);
ierr = SlepcFinalize(); CHKERRQ(ierr);
return 0;
}
int main(int argc,char **argv)
{
PetscErrorCode ierr;
DS ds;
SlepcSC sc;
PetscScalar *A,*eig;
PetscInt i,j,n,ld,bs,maxbw=3,nblks=8;
PetscViewer viewer;
PetscBool verbose;
SlepcInitialize(&argc,&argv,(char*)0,help);
ierr = PetscOptionsGetInt(NULL,"-maxbw",&maxbw,NULL);CHKERRQ(ierr);
ierr = PetscOptionsGetInt(NULL,"-nblks",&nblks,NULL);CHKERRQ(ierr);
n = maxbw*nblks;
bs = maxbw;
ierr = PetscPrintf(PETSC_COMM_WORLD,"Solve a block HEP Dense System - dimension %D (bandwidth=%D, blocks=%D).\n",n,maxbw,nblks);CHKERRQ(ierr);
ierr = PetscOptionsHasName(NULL,"-verbose",&verbose);CHKERRQ(ierr);
/* Create DS object */
ierr = DSCreate(PETSC_COMM_WORLD,&ds);CHKERRQ(ierr);
ierr = DSSetType(ds,DSHEP);CHKERRQ(ierr);
ierr = DSSetMethod(ds,3);CHKERRQ(ierr); /* Select block divide-and-conquer */
ierr = DSSetBlockSize(ds,bs);CHKERRQ(ierr);
ierr = DSSetFromOptions(ds);CHKERRQ(ierr);
ld = n;
ierr = DSAllocate(ds,ld);CHKERRQ(ierr);
ierr = DSSetDimensions(ds,n,0,0,0);CHKERRQ(ierr);
/* Set up viewer */
ierr = PetscViewerASCIIGetStdout(PETSC_COMM_WORLD,&viewer);CHKERRQ(ierr);
ierr = PetscViewerPushFormat(viewer,PETSC_VIEWER_ASCII_INFO_DETAIL);CHKERRQ(ierr);
ierr = DSView(ds,viewer);CHKERRQ(ierr);
ierr = PetscViewerPopFormat(viewer);CHKERRQ(ierr);
if (verbose) {
ierr = PetscViewerPushFormat(viewer,PETSC_VIEWER_ASCII_MATLAB);CHKERRQ(ierr);
}
/* Fill with a symmetric band Toeplitz matrix */
ierr = DSGetArray(ds,DS_MAT_A,&A);CHKERRQ(ierr);
for (i=0;i<n;i++) A[i+i*ld]=2.0;
for (j=1;j<=bs;j++) {
for (i=0;i<n-j;i++) { A[i+(i+j)*ld]=1.0; A[(i+j)+i*ld]=1.0; }
}
ierr = DSRestoreArray(ds,DS_MAT_A,&A);CHKERRQ(ierr);
ierr = DSSetState(ds,DS_STATE_RAW);CHKERRQ(ierr);
if (verbose) {
ierr = PetscPrintf(PETSC_COMM_WORLD,"Initial - - - - - - - - -\n");CHKERRQ(ierr);
ierr = DSView(ds,viewer);CHKERRQ(ierr);
}
/* Solve */
ierr = PetscMalloc1(n,&eig);CHKERRQ(ierr);
ierr = DSGetSlepcSC(ds,&sc);CHKERRQ(ierr);
sc->comparison = SlepcCompareSmallestReal;
sc->comparisonctx = NULL;
sc->map = NULL;
sc->mapobj = NULL;
ierr = DSSolve(ds,eig,NULL);CHKERRQ(ierr);
ierr = DSSort(ds,eig,NULL,NULL,NULL,NULL);CHKERRQ(ierr);
if (verbose) {
ierr = PetscPrintf(PETSC_COMM_WORLD,"After solve - - - - - - - - -\n");CHKERRQ(ierr);
ierr = DSView(ds,viewer);CHKERRQ(ierr);
}
/* Print eigenvalues */
ierr = PetscPrintf(PETSC_COMM_WORLD,"Computed eigenvalues =\n",n);CHKERRQ(ierr);
for (i=0;i<n;i++) {
ierr = PetscViewerASCIIPrintf(viewer," %.5f\n",(double)PetscRealPart(eig[i]));CHKERRQ(ierr);
}
ierr = PetscFree(eig);CHKERRQ(ierr);
ierr = DSDestroy(&ds);CHKERRQ(ierr);
ierr = SlepcFinalize();
return 0;
}
int main(int argc,char **argv)
{
Mat A[NMAT]; /* problem matrices */
FN f[NMAT]; /* functions to define the nonlinear operator */
NEP nep; /* nonlinear eigensolver context */
PetscInt n=20,Istart,Iend,i,nconv;
PetscReal kappa=1.0,m=1.0,re,im,norm;
PetscScalar kr,ki,sigma,numer[2],denom[2];
PetscErrorCode ierr;
SlepcInitialize(&argc,&argv,(char*)0,help);
ierr = PetscOptionsGetInt(NULL,"-n",&n,NULL);CHKERRQ(ierr);
ierr = PetscOptionsGetReal(NULL,"-kappa",&kappa,NULL);CHKERRQ(ierr);
ierr = PetscOptionsGetReal(NULL,"-mass",&m,NULL);CHKERRQ(ierr);
sigma = kappa/m;
ierr = PetscPrintf(PETSC_COMM_WORLD,"Loaded vibrating string, n=%D kappa=%g m=%g\n\n",n,(double)kappa,(double)m);CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Build the problem matrices
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
/* initialize matrices */
for (i=0;i<NMAT;i++) {
ierr = MatCreate(PETSC_COMM_WORLD,&A[i]);CHKERRQ(ierr);
ierr = MatSetSizes(A[i],PETSC_DECIDE,PETSC_DECIDE,n,n);CHKERRQ(ierr);
ierr = MatSetFromOptions(A[i]);CHKERRQ(ierr);
ierr = MatSetUp(A[i]);CHKERRQ(ierr);
}
ierr = MatGetOwnershipRange(A[0],&Istart,&Iend);CHKERRQ(ierr);
/* A0 */
for (i=Istart;i<Iend;i++) {
ierr = MatSetValue(A[0],i,i,(i==n-1)?1.0*n:2.0*n,INSERT_VALUES);CHKERRQ(ierr);
if (i>0) { ierr = MatSetValue(A[0],i,i-1,-1.0*n,INSERT_VALUES);CHKERRQ(ierr); }
if (i<n-1) { ierr = MatSetValue(A[0],i,i+1,-1.0*n,INSERT_VALUES);CHKERRQ(ierr); }
}
/* A1 */
for (i=Istart;i<Iend;i++) {
ierr = MatSetValue(A[1],i,i,(i==n-1)?2.0/(6.0*n):4.0/(6.0*n),INSERT_VALUES);CHKERRQ(ierr);
if (i>0) { ierr = MatSetValue(A[1],i,i-1,1.0/(6.0*n),INSERT_VALUES);CHKERRQ(ierr); }
if (i<n-1) { ierr = MatSetValue(A[1],i,i+1,1.0/(6.0*n),INSERT_VALUES);CHKERRQ(ierr); }
}
/* A2 */
if (Istart<=n-1 && n-1<Iend) {
ierr = MatSetValue(A[2],n-1,n-1,kappa,INSERT_VALUES); CHKERRQ(ierr);
}
/* assemble matrices */
for (i=0;i<NMAT;i++) {
ierr = MatAssemblyBegin(A[i],MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
}
for (i=0;i<NMAT;i++) {
ierr = MatAssemblyEnd(A[i],MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
}
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Create the problem functions
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
/* f1=1 */
ierr = FNCreate(PETSC_COMM_WORLD,&f[0]);CHKERRQ(ierr);
ierr = FNSetType(f[0],FNRATIONAL);CHKERRQ(ierr);
numer[0] = 1.0;
ierr = FNSetParameters(f[0],1,numer,0,NULL);CHKERRQ(ierr);
/* f2=-lambda */
ierr = FNCreate(PETSC_COMM_WORLD,&f[1]);CHKERRQ(ierr);
ierr = FNSetType(f[1],FNRATIONAL);CHKERRQ(ierr);
numer[0] = -1.0; numer[1] = 0.0;
ierr = FNSetParameters(f[1],2,numer,0,NULL);CHKERRQ(ierr);
/* f3=lambda/(lambda-sigma) */
ierr = FNCreate(PETSC_COMM_WORLD,&f[2]);CHKERRQ(ierr);
ierr = FNSetType(f[2],FNRATIONAL);CHKERRQ(ierr);
numer[0] = 1.0; numer[1] = 0.0;
denom[0] = 1.0; denom[1] = -sigma;
ierr = FNSetParameters(f[2],2,numer,2,denom);CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Create the eigensolver and solve the problem
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
ierr = NEPCreate(PETSC_COMM_WORLD,&nep);CHKERRQ(ierr);
ierr = NEPSetSplitOperator(nep,3,A,f,SUBSET_NONZERO_PATTERN);CHKERRQ(ierr);
ierr = NEPSetFromOptions(nep);CHKERRQ(ierr);
ierr = NEPSolve(nep);CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Display solution and clean up
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
/*
Get number of converged approximate eigenpairs
*/
ierr = NEPGetConverged(nep,&nconv);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD," Number of converged approximate eigenpairs: %D\n\n",nconv);CHKERRQ(ierr);
if (nconv>0) {
/*
Display eigenvalues and relative errors
*/
ierr = PetscPrintf(PETSC_COMM_WORLD,
" k ||T(k)x||\n"
" ----------------- ------------------\n");CHKERRQ(ierr);
for (i=0;i<nconv;i++) {
ierr = NEPGetEigenpair(nep,i,&kr,&ki,NULL,NULL);CHKERRQ(ierr);
ierr = NEPComputeRelativeError(nep,i,&norm);CHKERRQ(ierr);
#if defined(PETSC_USE_COMPLEX)
re = PetscRealPart(kr);
im = PetscImaginaryPart(kr);
#else
re = kr;
im = ki;
#endif
if (im!=0.0) {
ierr = PetscPrintf(PETSC_COMM_WORLD," %9f%+9f j %12g\n",(double)re,(double)im,(double)norm);CHKERRQ(ierr);
} else {
ierr = PetscPrintf(PETSC_COMM_WORLD," %12f %12g\n",(double)re,(double)norm);CHKERRQ(ierr);
}
}
ierr = PetscPrintf(PETSC_COMM_WORLD,"\n");CHKERRQ(ierr);
}
ierr = NEPDestroy(&nep);CHKERRQ(ierr);
for (i=0;i<NMAT;i++) {
ierr = MatDestroy(&A[i]);CHKERRQ(ierr);
ierr = FNDestroy(&f[i]);CHKERRQ(ierr);
}
ierr = SlepcFinalize();CHKERRQ(ierr);
return 0;
}
int main(int argc,char **argv)
{
Mat A; /* operator matrix */
EPS eps; /* eigenproblem solver context */
EPSType type;
PetscMPIInt nproc, myproc;
PetscInt nev;
PetscErrorCode ierr;
SlepcInitialize(&argc, &argv, (char*)0, 0);
ierr = MPI_Comm_size(PETSC_COMM_WORLD,&nproc); CHKERRQ(ierr);
ierr = MPI_Comm_rank(PETSC_COMM_WORLD,&myproc); CHKERRQ(ierr);
int L = 8;
ierr = PetscOptionsGetInt(NULL,"-L", &L, NULL); CHKERRQ(ierr);
PetscInt N_global = 1 << L;
PetscInt N_local = N_global / nproc;
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Compute the operator matrix that defines the eigensystem, Ax=kx
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
model m;
m.comm = PETSC_COMM_WORLD;
m.L = L;
m.buffer = new double[N_local];
if (m.buffer == 0) {
MPI_Abort(MPI_COMM_WORLD, 4);
}
for (int i=0; i<L; ++i) {
m.lattice.push_back(std::make_pair(i, (i+1)%L));
}
ierr = MatCreateShell(PETSC_COMM_WORLD, N_local, N_local, N_global, N_global, &m, &A); CHKERRQ(ierr);
ierr = MatSetFromOptions(A); CHKERRQ(ierr);
ierr = MatShellSetOperation(A,MATOP_MULT,(void(*)())MatMult_myMat); CHKERRQ(ierr);
ierr = MatShellSetOperation(A,MATOP_MULT_TRANSPOSE,(void(*)())MatMult_myMat); CHKERRQ(ierr);
ierr = MatShellSetOperation(A,MATOP_GET_DIAGONAL,(void(*)())MatGetDiagonal_myMat); CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Create the eigensolver and set various options
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
/*
Create eigensolver context
*/
ierr = EPSCreate(PETSC_COMM_WORLD,&eps); CHKERRQ(ierr);
/*
Set operators. In this case, it is a standard eigenvalue problem
*/
ierr = EPSSetOperators(eps,A,NULL); CHKERRQ(ierr);
ierr = EPSSetProblemType(eps,EPS_HEP); CHKERRQ(ierr);
ierr = EPSSetDimensions(eps, 5, 100, 100); CHKERRQ(ierr);
ierr = EPSSetTolerances(eps, (PetscScalar) 1e-1, (PetscInt) 100); CHKERRQ(ierr);
//Vec v0;
//MatGetVecs(A, &v0, NULL);
//VecSet(v0,1.0);
//EPSSetInitialSpace(eps,1,&v0);
/*
Set solver parameters at runtime
*/
ierr = EPSSetFromOptions(eps); CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Solve the eigensystem
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
ierr = EPSSolve(eps);CHKERRQ(ierr);
/*
Optional: Get some information from the solver and display it
*/
ierr = EPSGetType(eps,&type); CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD," Solution method: %s\n\n",type); CHKERRQ(ierr);
ierr = EPSGetDimensions(eps,&nev,NULL,NULL); CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD," Number of requested eigenvalues: %D\n",nev); CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Display solution and clean up
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
ierr = EPSPrintSolution(eps,NULL); CHKERRQ(ierr);
ierr = EPSDestroy(&eps); CHKERRQ(ierr);
ierr = MatDestroy(&A); CHKERRQ(ierr);
ierr = SlepcFinalize();
return 0;
}
int main(int argc,char **argv)
{
Mat M,C,K,A[3]; /* problem matrices */
PEP pep; /* polynomial eigenproblem solver context */
PetscInt m=6,n,II,Istart,Iend,i,j;
PetscScalar z=1.0;
PetscReal h;
char str[50];
PetscErrorCode ierr;
SlepcInitialize(&argc,&argv,(char*)0,help);
ierr = PetscOptionsGetInt(NULL,"-m",&m,NULL);CHKERRQ(ierr);
if (m<2) SETERRQ(PETSC_COMM_SELF,1,"m must be at least 2");
ierr = PetscOptionsGetScalar(NULL,"-z",&z,NULL);CHKERRQ(ierr);
h = 1.0/m;
n = m*(m-1);
ierr = SlepcSNPrintfScalar(str,50,z,PETSC_FALSE);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"\nAcoustic wave 2-D, n=%D (m=%D), z=%s\n\n",n,m,str);CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Compute the matrices that define the eigensystem, (k^2*M+k*C+K)x=0
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
/* K has a pattern similar to the 2D Laplacian */
ierr = MatCreate(PETSC_COMM_WORLD,&K);CHKERRQ(ierr);
ierr = MatSetSizes(K,PETSC_DECIDE,PETSC_DECIDE,n,n);CHKERRQ(ierr);
ierr = MatSetFromOptions(K);CHKERRQ(ierr);
ierr = MatSetUp(K);CHKERRQ(ierr);
ierr = MatGetOwnershipRange(K,&Istart,&Iend);CHKERRQ(ierr);
for (II=Istart;II<Iend;II++) {
i = II/m; j = II-i*m;
if (i>0) { ierr = MatSetValue(K,II,II-m,(j==m-1)?-0.5:-1.0,INSERT_VALUES);CHKERRQ(ierr); }
if (i<m-2) { ierr = MatSetValue(K,II,II+m,(j==m-1)?-0.5:-1.0,INSERT_VALUES);CHKERRQ(ierr); }
if (j>0) { ierr = MatSetValue(K,II,II-1,-1.0,INSERT_VALUES);CHKERRQ(ierr); }
if (j<m-1) { ierr = MatSetValue(K,II,II+1,-1.0,INSERT_VALUES);CHKERRQ(ierr); }
ierr = MatSetValue(K,II,II,(j==m-1)?2.0:4.0,INSERT_VALUES);CHKERRQ(ierr);
}
ierr = MatAssemblyBegin(K,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
ierr = MatAssemblyEnd(K,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
/* C is the zero matrix except for a few nonzero elements on the diagonal */
ierr = MatCreate(PETSC_COMM_WORLD,&C);CHKERRQ(ierr);
ierr = MatSetSizes(C,PETSC_DECIDE,PETSC_DECIDE,n,n);CHKERRQ(ierr);
ierr = MatSetFromOptions(C);CHKERRQ(ierr);
ierr = MatSetUp(C);CHKERRQ(ierr);
ierr = MatGetOwnershipRange(C,&Istart,&Iend);CHKERRQ(ierr);
for (i=Istart;i<Iend;i++) {
if (i%m==m-1) {
ierr = MatSetValue(C,i,i,-2*PETSC_PI*h/z,INSERT_VALUES);CHKERRQ(ierr);
}
}
ierr = MatAssemblyBegin(C,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
ierr = MatAssemblyEnd(C,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
/* M is a diagonal matrix */
ierr = MatCreate(PETSC_COMM_WORLD,&M);CHKERRQ(ierr);
ierr = MatSetSizes(M,PETSC_DECIDE,PETSC_DECIDE,n,n);CHKERRQ(ierr);
ierr = MatSetFromOptions(M);CHKERRQ(ierr);
ierr = MatSetUp(M);CHKERRQ(ierr);
ierr = MatGetOwnershipRange(M,&Istart,&Iend);CHKERRQ(ierr);
for (i=Istart;i<Iend;i++) {
if (i%m==m-1) {
ierr = MatSetValue(M,i,i,2*PETSC_PI*PETSC_PI*h*h,INSERT_VALUES);CHKERRQ(ierr);
} else {
ierr = MatSetValue(M,i,i,4*PETSC_PI*PETSC_PI*h*h,INSERT_VALUES);CHKERRQ(ierr);
}
}
ierr = MatAssemblyBegin(M,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
ierr = MatAssemblyEnd(M,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Create the eigensolver and solve the problem
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
ierr = PEPCreate(PETSC_COMM_WORLD,&pep);CHKERRQ(ierr);
A[0] = K; A[1] = C; A[2] = M;
ierr = PEPSetOperators(pep,3,A);CHKERRQ(ierr);
ierr = PEPSetFromOptions(pep);CHKERRQ(ierr);
ierr = PEPSolve(pep);CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Display solution and clean up
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
ierr = PEPPrintSolution(pep,NULL);CHKERRQ(ierr);
ierr = PEPDestroy(&pep);CHKERRQ(ierr);
ierr = MatDestroy(&M);CHKERRQ(ierr);
ierr = MatDestroy(&C);CHKERRQ(ierr);
ierr = MatDestroy(&K);CHKERRQ(ierr);
ierr = SlepcFinalize();CHKERRQ(ierr);
return 0;
}
int main(int argc,char **argv)
{
Mat A[NMAT]; /* problem matrices */
PEP pep; /* polynomial eigenproblem solver context */
PetscInt n,m=8,k,II,Istart,Iend,i,j;
PetscReal c[10] = { 0.6, 1.3, 1.3, 0.1, 0.1, 1.2, 1.0, 1.0, 1.2, 1.0 };
PetscBool flg;
PetscErrorCode ierr;
SlepcInitialize(&argc,&argv,(char*)0,help);
ierr = PetscOptionsGetInt(NULL,"-m",&m,NULL);CHKERRQ(ierr);
n = m*m;
k = 10;
ierr = PetscOptionsGetRealArray(NULL,"-c",c,&k,&flg);CHKERRQ(ierr);
if (flg && k!=10) SETERRQ1(PETSC_COMM_WORLD,1,"The number of parameters -c should be 10, you provided %D",k);
ierr = PetscPrintf(PETSC_COMM_WORLD,"\nButterfly problem, n=%D (m=%D)\n\n",n,m);CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Compute the polynomial matrices
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
/* initialize matrices */
for (i=0;i<NMAT;i++) {
ierr = MatCreate(PETSC_COMM_WORLD,&A[i]);CHKERRQ(ierr);
ierr = MatSetSizes(A[i],PETSC_DECIDE,PETSC_DECIDE,n,n);CHKERRQ(ierr);
ierr = MatSetFromOptions(A[i]);CHKERRQ(ierr);
ierr = MatSetUp(A[i]);CHKERRQ(ierr);
}
ierr = MatGetOwnershipRange(A[0],&Istart,&Iend);CHKERRQ(ierr);
/* A0 */
for (II=Istart;II<Iend;II++) {
i = II/m; j = II-i*m;
ierr = MatSetValue(A[0],II,II,4.0*c[0]/6.0+4.0*c[1]/6.0,INSERT_VALUES);CHKERRQ(ierr);
if (j>0) { ierr = MatSetValue(A[0],II,II-1,c[0]/6.0,INSERT_VALUES);CHKERRQ(ierr); }
if (j<m-1) { ierr = MatSetValue(A[0],II,II+1,c[0]/6.0,INSERT_VALUES);CHKERRQ(ierr); }
if (i>0) { ierr = MatSetValue(A[0],II,II-m,c[1]/6.0,INSERT_VALUES);CHKERRQ(ierr); }
if (i<m-1) { ierr = MatSetValue(A[0],II,II+m,c[1]/6.0,INSERT_VALUES);CHKERRQ(ierr); }
}
/* A1 */
for (II=Istart;II<Iend;II++) {
i = II/m; j = II-i*m;
if (j>0) { ierr = MatSetValue(A[1],II,II-1,c[2],INSERT_VALUES);CHKERRQ(ierr); }
if (j<m-1) { ierr = MatSetValue(A[1],II,II+1,-c[2],INSERT_VALUES);CHKERRQ(ierr); }
if (i>0) { ierr = MatSetValue(A[1],II,II-m,c[3],INSERT_VALUES);CHKERRQ(ierr); }
if (i<m-1) { ierr = MatSetValue(A[1],II,II+m,-c[3],INSERT_VALUES);CHKERRQ(ierr); }
}
/* A2 */
for (II=Istart;II<Iend;II++) {
i = II/m; j = II-i*m;
ierr = MatSetValue(A[2],II,II,-2.0*c[4]-2.0*c[5],INSERT_VALUES);CHKERRQ(ierr);
if (j>0) { ierr = MatSetValue(A[2],II,II-1,c[4],INSERT_VALUES);CHKERRQ(ierr); }
if (j<m-1) { ierr = MatSetValue(A[2],II,II+1,c[4],INSERT_VALUES);CHKERRQ(ierr); }
if (i>0) { ierr = MatSetValue(A[2],II,II-m,c[5],INSERT_VALUES);CHKERRQ(ierr); }
if (i<m-1) { ierr = MatSetValue(A[2],II,II+m,c[5],INSERT_VALUES);CHKERRQ(ierr); }
}
/* A3 */
for (II=Istart;II<Iend;II++) {
i = II/m; j = II-i*m;
if (j>0) { ierr = MatSetValue(A[3],II,II-1,c[6],INSERT_VALUES);CHKERRQ(ierr); }
if (j<m-1) { ierr = MatSetValue(A[3],II,II+1,-c[6],INSERT_VALUES);CHKERRQ(ierr); }
if (i>0) { ierr = MatSetValue(A[3],II,II-m,c[7],INSERT_VALUES);CHKERRQ(ierr); }
if (i<m-1) { ierr = MatSetValue(A[3],II,II+m,-c[7],INSERT_VALUES);CHKERRQ(ierr); }
}
/* A4 */
for (II=Istart;II<Iend;II++) {
i = II/m; j = II-i*m;
ierr = MatSetValue(A[4],II,II,2.0*c[8]+2.0*c[9],INSERT_VALUES);CHKERRQ(ierr);
if (j>0) { ierr = MatSetValue(A[4],II,II-1,-c[8],INSERT_VALUES);CHKERRQ(ierr); }
if (j<m-1) { ierr = MatSetValue(A[4],II,II+1,-c[8],INSERT_VALUES);CHKERRQ(ierr); }
if (i>0) { ierr = MatSetValue(A[4],II,II-m,-c[9],INSERT_VALUES);CHKERRQ(ierr); }
if (i<m-1) { ierr = MatSetValue(A[4],II,II+m,-c[9],INSERT_VALUES);CHKERRQ(ierr); }
}
/* assemble matrices */
for (i=0;i<NMAT;i++) {
ierr = MatAssemblyBegin(A[i],MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
}
for (i=0;i<NMAT;i++) {
ierr = MatAssemblyEnd(A[i],MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
}
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Create the eigensolver and solve the problem
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
ierr = PEPCreate(PETSC_COMM_WORLD,&pep);CHKERRQ(ierr);
ierr = PEPSetOperators(pep,NMAT,A);CHKERRQ(ierr);
ierr = PEPSetFromOptions(pep);CHKERRQ(ierr);
ierr = PEPSolve(pep);CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Display solution and clean up
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
ierr = PEPPrintSolution(pep,NULL);CHKERRQ(ierr);
ierr = PEPDestroy(&pep);CHKERRQ(ierr);
for (i=0;i<NMAT;i++) {
ierr = MatDestroy(&A[i]);CHKERRQ(ierr);
}
ierr = SlepcFinalize();CHKERRQ(ierr);
return 0;
}
int main( int argc, char **argv )
{
Mat A; /* operator matrix */
Vec x;
EPS eps; /* eigenproblem solver context */
const EPSType type;
PetscReal error, tol, re, im;
PetscScalar kr, ki;
PetscErrorCode ierr;
PetscInt N, n=10, m, i, j, II, Istart, Iend, nev, maxit, its, nconv;
PetscScalar w;
PetscBool flag;
SlepcInitialize(&argc,&argv,(char*)0,help);
ierr = PetscOptionsGetInt(PETSC_NULL,"-n",&n,PETSC_NULL);CHKERRQ(ierr);
ierr = PetscOptionsGetInt(PETSC_NULL,"-m",&m,&flag);CHKERRQ(ierr);
if(!flag) m=n;
N = n*m;
ierr = PetscPrintf(PETSC_COMM_WORLD,"\nFiedler vector of a 2-D regular mesh, N=%d (%dx%d grid)\n\n",N,n,m);CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Compute the operator matrix that defines the eigensystem, Ax=kx
In this example, A = L(G), where L is the Laplacian of graph G, i.e.
Lii = degree of node i, Lij = -1 if edge (i,j) exists in G
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
ierr = MatCreate(PETSC_COMM_WORLD,&A);CHKERRQ(ierr);
ierr = MatSetSizes(A,PETSC_DECIDE,PETSC_DECIDE,N,N);CHKERRQ(ierr);
ierr = MatSetFromOptions(A);CHKERRQ(ierr);
ierr = MatGetOwnershipRange(A,&Istart,&Iend);CHKERRQ(ierr);
for( II=Istart; II<Iend; II++ ) {
i = II/n; j = II-i*n;
w = 0.0;
if(i>0) { ierr = MatSetValue(A,II,II-n,-1.0,INSERT_VALUES);CHKERRQ(ierr); w=w+1.0; }
if(i<m-1) { ierr = MatSetValue(A,II,II+n,-1.0,INSERT_VALUES);CHKERRQ(ierr); w=w+1.0; }
if(j>0) { ierr = MatSetValue(A,II,II-1,-1.0,INSERT_VALUES);CHKERRQ(ierr); w=w+1.0; }
if(j<n-1) { ierr = MatSetValue(A,II,II+1,-1.0,INSERT_VALUES);CHKERRQ(ierr); w=w+1.0; }
ierr = MatSetValue(A,II,II,w,INSERT_VALUES);CHKERRQ(ierr);
}
ierr = MatAssemblyBegin(A,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
ierr = MatAssemblyEnd(A,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Create the eigensolver and set various options
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
/*
Create eigensolver context
*/
ierr = EPSCreate(PETSC_COMM_WORLD,&eps);CHKERRQ(ierr);
/*
Set operators. In this case, it is a standard eigenvalue problem
*/
ierr = EPSSetOperators(eps,A,PETSC_NULL);CHKERRQ(ierr);
ierr = EPSSetProblemType(eps,EPS_HEP);CHKERRQ(ierr);
/*
Select portion of spectrum
*/
ierr = EPSSetWhichEigenpairs(eps,EPS_SMALLEST_REAL);CHKERRQ(ierr);
/*
Set solver parameters at runtime
*/
ierr = EPSSetFromOptions(eps);CHKERRQ(ierr);
/*
Attach deflation space: in this case, the matrix has a constant
nullspace, [1 1 ... 1]^T is the eigenvector of the zero eigenvalue
*/
ierr = MatGetVecs(A,&x,PETSC_NULL);CHKERRQ(ierr);
ierr = VecSet(x,1.0);CHKERRQ(ierr);
ierr = EPSSetDeflationSpace(eps,1,&x);CHKERRQ(ierr);
ierr = VecDestroy(x);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Solve the eigensystem
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
ierr = EPSSolve(eps);CHKERRQ(ierr);
ierr = EPSGetIterationNumber(eps, &its);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD," Number of iterations of the method: %d\n",its);CHKERRQ(ierr);
/*
Optional: Get some information from the solver and display it
*/
ierr = EPSGetType(eps,&type);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD," Solution method: %s\n\n",type);CHKERRQ(ierr);
ierr = EPSGetDimensions(eps,&nev,PETSC_NULL,PETSC_NULL);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD," Number of requested eigenvalues: %d\n",nev);CHKERRQ(ierr);
ierr = EPSGetTolerances(eps,&tol,&maxit);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD," Stopping condition: tol=%.4g, maxit=%d\n",tol,maxit);CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Display solution and clean up
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
/*
Get number of converged approximate eigenpairs
*/
ierr = EPSGetConverged(eps,&nconv);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD," Number of converged approximate eigenpairs: %d\n\n",nconv);
CHKERRQ(ierr);
if (nconv>0) {
/*
Display eigenvalues and relative errors
*/
ierr = PetscPrintf(PETSC_COMM_WORLD,
" k ||Ax-kx||/||kx||\n"
" ----------------- ------------------\n" );CHKERRQ(ierr);
for( i=0; i<nconv; i++ ) {
/*
Get converged eigenpairs: i-th eigenvalue is stored in kr (real part) and
ki (imaginary part)
*/
ierr = EPSGetEigenpair(eps,i,&kr,&ki,PETSC_NULL,PETSC_NULL);CHKERRQ(ierr);
/*
Compute the relative error associated to each eigenpair
*/
ierr = EPSComputeRelativeError(eps,i,&error);CHKERRQ(ierr);
#ifdef PETSC_USE_COMPLEX
re = PetscRealPart(kr);
im = PetscImaginaryPart(kr);
#else
re = kr;
im = ki;
#endif
if (im!=0.0) {
ierr = PetscPrintf(PETSC_COMM_WORLD," %9f%+9f j %12g\n",re,im,error);CHKERRQ(ierr);
} else {
ierr = PetscPrintf(PETSC_COMM_WORLD," %12f %12g\n",re,error);CHKERRQ(ierr);
}
}
ierr = PetscPrintf(PETSC_COMM_WORLD,"\n" );CHKERRQ(ierr);
}
/*
Free work space
*/
ierr = EPSDestroy(eps);CHKERRQ(ierr);
ierr = MatDestroy(A);CHKERRQ(ierr);
ierr = SlepcFinalize();CHKERRQ(ierr);
return 0;
}
int main(int argc,char **argv)
{
PetscErrorCode ierr;
DS ds;
SlepcSC sc;
PetscScalar *A,*B,*wr,*wi;
PetscReal re,im;
PetscInt i,j,n=10,ld;
PetscViewer viewer;
PetscBool verbose;
SlepcInitialize(&argc,&argv,(char*)0,help);
ierr = PetscOptionsGetInt(NULL,"-n",&n,NULL);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"Solve a Dense System of type GNHEP - dimension %D.\n",n);CHKERRQ(ierr);
ierr = PetscOptionsHasName(NULL,"-verbose",&verbose);CHKERRQ(ierr);
/* Create DS object */
ierr = DSCreate(PETSC_COMM_WORLD,&ds);CHKERRQ(ierr);
ierr = DSSetType(ds,DSGNHEP);CHKERRQ(ierr);
ierr = DSSetFromOptions(ds);CHKERRQ(ierr);
ld = n+2; /* test leading dimension larger than n */
ierr = DSAllocate(ds,ld);CHKERRQ(ierr);
ierr = DSSetDimensions(ds,n,0,0,0);CHKERRQ(ierr);
/* Set up viewer */
ierr = PetscViewerASCIIGetStdout(PETSC_COMM_WORLD,&viewer);CHKERRQ(ierr);
ierr = PetscViewerPushFormat(viewer,PETSC_VIEWER_ASCII_INFO_DETAIL);CHKERRQ(ierr);
ierr = DSView(ds,viewer);CHKERRQ(ierr);
ierr = PetscViewerPopFormat(viewer);CHKERRQ(ierr);
if (verbose) {
ierr = PetscViewerPushFormat(viewer,PETSC_VIEWER_ASCII_MATLAB);CHKERRQ(ierr);
}
/* Fill A with Grcar matrix */
ierr = DSGetArray(ds,DS_MAT_A,&A);CHKERRQ(ierr);
ierr = PetscMemzero(A,sizeof(PetscScalar)*ld*n);CHKERRQ(ierr);
for (i=1;i<n;i++) A[i+(i-1)*ld]=-1.0;
for (j=0;j<4;j++) {
for (i=0;i<n-j;i++) A[i+(i+j)*ld]=1.0;
}
ierr = DSRestoreArray(ds,DS_MAT_A,&A);CHKERRQ(ierr);
/* Fill B with an identity matrix */
ierr = DSGetArray(ds,DS_MAT_B,&B);CHKERRQ(ierr);
ierr = PetscMemzero(B,sizeof(PetscScalar)*ld*n);CHKERRQ(ierr);
for (i=0;i<n;i++) B[i+i*ld]=1.0;
ierr = DSRestoreArray(ds,DS_MAT_B,&B);CHKERRQ(ierr);
if (verbose) {
ierr = PetscPrintf(PETSC_COMM_WORLD,"Initial - - - - - - - - -\n");CHKERRQ(ierr);
ierr = DSView(ds,viewer);CHKERRQ(ierr);
}
/* Solve */
ierr = PetscMalloc2(n,&wr,n,&wi);CHKERRQ(ierr);
ierr = DSGetSlepcSC(ds,&sc);CHKERRQ(ierr);
sc->comparison = SlepcCompareLargestMagnitude;
sc->comparisonctx = NULL;
sc->map = NULL;
sc->mapobj = NULL;
ierr = DSSolve(ds,wr,wi);CHKERRQ(ierr);
ierr = DSSort(ds,wr,wi,NULL,NULL,NULL);CHKERRQ(ierr);
if (verbose) {
ierr = PetscPrintf(PETSC_COMM_WORLD,"After solve - - - - - - - - -\n");CHKERRQ(ierr);
ierr = DSView(ds,viewer);CHKERRQ(ierr);
}
/* Print eigenvalues */
ierr = PetscPrintf(PETSC_COMM_WORLD,"Computed eigenvalues =\n",n);CHKERRQ(ierr);
for (i=0;i<n;i++) {
#if defined(PETSC_USE_COMPLEX)
re = PetscRealPart(wr[i]);
im = PetscImaginaryPart(wr[i]);
#else
re = wr[i];
im = wi[i];
#endif
if (PetscAbs(im)<1e-10) {
ierr = PetscViewerASCIIPrintf(viewer," %.5f\n",(double)re);CHKERRQ(ierr);
} else {
ierr = PetscViewerASCIIPrintf(viewer," %.5f%+.5fi\n",(double)re,(double)im);CHKERRQ(ierr);
}
}
ierr = PetscFree2(wr,wi);CHKERRQ(ierr);
ierr = DSDestroy(&ds);CHKERRQ(ierr);
ierr = SlepcFinalize();
return 0;
}
LibMeshInit::LibMeshInit (int argc, const char* const* argv,
MPI_Comm COMM_WORLD_IN)
#endif
{
// should _not_ be initialized already.
libmesh_assert (!libMesh::initialized());
// Build a command-line parser.
command_line.reset (new GetPot (argc, argv));
// Disable performance logging upon request
{
if (libMesh::on_command_line ("--disable-perflog"))
libMesh::perflog.disable_logging();
}
// Build a task scheduler
{
// Get the requested number of threads, defaults to 1 to avoid MPI and
// multithreading competition. If you would like to use MPI and multithreading
// at the same time then (n_mpi_processes_per_node)x(n_threads) should be the
// number of processing cores per node.
std::vector<std::string> n_threads(2);
n_threads[0] = "--n_threads";
n_threads[1] = "--n-threads";
libMesh::libMeshPrivateData::_n_threads =
libMesh::command_line_value (n_threads, 1);
// Set the number of OpenMP threads to the same as the number of threads libMesh is going to use
#ifdef LIBMESH_HAVE_OPENMP
omp_set_num_threads(libMesh::libMeshPrivateData::_n_threads);
#endif
task_scheduler.reset (new Threads::task_scheduler_init(libMesh::n_threads()));
}
// Construct singletons who may be at risk of the
// "static initialization order fiasco"
Singleton::setup();
// Make sure the construction worked
libmesh_assert(remote_elem);
#if defined(LIBMESH_HAVE_MPI)
// Allow the user to bypass MPI initialization
if (!libMesh::on_command_line ("--disable-mpi"))
{
// Check whether the calling program has already initialized
// MPI, and avoid duplicate Init/Finalize
int flag;
MPI_Initialized (&flag);
if (!flag)
{
#if MPI_VERSION > 1
int mpi_thread_provided;
const int mpi_thread_requested = libMesh::n_threads() > 1 ?
MPI_THREAD_FUNNELED :
MPI_THREAD_SINGLE;
MPI_Init_thread (&argc, const_cast<char***>(&argv),
mpi_thread_requested, &mpi_thread_provided);
if ((libMesh::n_threads() > 1) &&
(mpi_thread_provided < MPI_THREAD_FUNNELED))
{
libmesh_warning("Warning: MPI failed to guarantee MPI_THREAD_FUNNELED\n" <<
"for a threaded run.\n" <<
"Be sure your library is funneled-thread-safe..." <<
std::endl);
// Ideally, if an MPI stack tells us it's unsafe for us
// to use threads, we shouldn't use threads.
// In practice, we've encountered one MPI stack (an
// mvapich2 configuration) that returned
// MPI_THREAD_SINGLE as a proper warning, two stacks
// that handle MPI_THREAD_FUNNELED properly, and two
// current stacks plus a couple old stacks that return
// MPI_THREAD_SINGLE but support libMesh threaded runs
// anyway.
// libMesh::libMeshPrivateData::_n_threads = 1;
// task_scheduler.reset (new Threads::task_scheduler_init(libMesh::n_threads()));
}
#else
if (libMesh::libMeshPrivateData::_n_threads > 1)
{
libmesh_warning("Warning: using MPI1 for threaded code.\n" <<
"Be sure your library is funneled-thread-safe..." <<
std::endl);
}
MPI_Init (&argc, const_cast<char***>(&argv));
#endif
libmesh_initialized_mpi = true;
}
// Duplicate the input communicator for internal use
// And get a Parallel::Communicator copy too, to use
// as a default for that API
this->_comm = COMM_WORLD_IN;
libMesh::GLOBAL_COMM_WORLD = COMM_WORLD_IN;
#ifndef LIBMESH_DISABLE_COMMWORLD
libMesh::COMM_WORLD = COMM_WORLD_IN;
Parallel::Communicator_World = COMM_WORLD_IN;
#endif
//MPI_Comm_set_name not supported in at least SGI MPT's MPI implementation
//MPI_Comm_set_name (libMesh::COMM_WORLD, "libMesh::COMM_WORLD");
libMeshPrivateData::_processor_id =
libmesh_cast_int<processor_id_type>(this->comm().rank());
libMeshPrivateData::_n_processors =
libmesh_cast_int<processor_id_type>(this->comm().size());
// Set up an MPI error handler if requested. This helps us get
// into a debugger with a proper stack when an MPI error occurs.
if (libMesh::on_command_line ("--handle-mpi-errors"))
{
#if MPI_VERSION > 1
MPI_Comm_create_errhandler(libMesh_MPI_Handler, &libmesh_errhandler);
MPI_Comm_set_errhandler(libMesh::GLOBAL_COMM_WORLD, libmesh_errhandler);
MPI_Comm_set_errhandler(MPI_COMM_WORLD, libmesh_errhandler);
#else
MPI_Errhandler_create(libMesh_MPI_Handler, &libmesh_errhandler);
MPI_Errhandler_set(libMesh::GLOBAL_COMM_WORLD, libmesh_errhandler);
MPI_Errhandler_set(MPI_COMM_WORLD, libmesh_errhandler);
#endif // #if MPI_VERSION > 1
}
}
// Could we have gotten bad values from the above calls?
libmesh_assert_greater (libMeshPrivateData::_n_processors, 0);
// The libmesh_cast_int already tested _processor_id>=0
// libmesh_assert_greater_equal (libMeshPrivateData::_processor_id, 0);
// Let's be sure we properly initialize on every processor at once:
libmesh_parallel_only(this->comm());
#endif
#if defined(LIBMESH_HAVE_PETSC)
// Allow the user to bypass PETSc initialization
if (!libMesh::on_command_line ("--disable-petsc")
#if defined(LIBMESH_HAVE_MPI)
// If the user bypassed MPI, we'd better be safe and assume that
// PETSc was built to require it; otherwise PETSc initialization
// dies.
&& !libMesh::on_command_line ("--disable-mpi")
#endif
)
{
int ierr=0;
PETSC_COMM_WORLD = libMesh::GLOBAL_COMM_WORLD;
// Check whether the calling program has already initialized
// PETSc, and avoid duplicate Initialize/Finalize
PetscBool petsc_already_initialized;
ierr = PetscInitialized(&petsc_already_initialized);
CHKERRABORT(libMesh::GLOBAL_COMM_WORLD,ierr);
if (petsc_already_initialized != PETSC_TRUE)
libmesh_initialized_petsc = true;
# if defined(LIBMESH_HAVE_SLEPC)
// If SLEPc allows us to check whether the calling program
// has already initialized it, we do that, and avoid
// duplicate Initialize/Finalize.
// We assume that SLEPc will handle PETSc appropriately,
// which it does in the versions we've checked.
# if !SLEPC_VERSION_LESS_THAN(2,3,3)
if (!SlepcInitializeCalled)
# endif
{
ierr = SlepcInitialize (&argc, const_cast<char***>(&argv), NULL, NULL);
CHKERRABORT(libMesh::GLOBAL_COMM_WORLD,ierr);
libmesh_initialized_slepc = true;
}
# else
if (libmesh_initialized_petsc)
{
ierr = PetscInitialize (&argc, const_cast<char***>(&argv), NULL, NULL);
CHKERRABORT(libMesh::GLOBAL_COMM_WORLD,ierr);
}
# endif
}
#endif
// Re-parse the command-line arguments. Note that PETSc and MPI
// initialization above may have removed command line arguments
// that are not relevant to this application in the above calls.
// We don't want a false-positive by detecting those arguments.
command_line->parse_command_line (argc, argv);
// The following line is an optimization when simultaneous
// C and C++ style access to output streams is not required.
// The amount of benefit which occurs is probably implementation
// defined, and may be nothing. On the other hand, I have seen
// some IO tests where IO peformance improves by a factor of two.
if (!libMesh::on_command_line ("--sync-with-stdio"))
std::ios::sync_with_stdio(false);
// Honor the --separate-libmeshout command-line option.
// When this is specified, the library uses an independent ostream
// for libMesh::out/libMesh::err messages, and
// std::cout and std::cerr are untouched by any other options
if (libMesh::on_command_line ("--separate-libmeshout"))
{
// Redirect. We'll share streambufs with cout/cerr for now, but
// presumably anyone using this option will want to replace the
// bufs later.
std::ostream* newout = new std::ostream(std::cout.rdbuf());
libMesh::out = *newout;
std::ostream* newerr = new std::ostream(std::cerr.rdbuf());
libMesh::err = *newerr;
}
// Honor the --redirect-stdout command-line option.
// When this is specified each processor sends
// libMesh::out/libMesh::err messages to
// stdout.processor.####
if (libMesh::on_command_line ("--redirect-stdout"))
{
std::ostringstream filename;
filename << "stdout.processor." << libMesh::global_processor_id();
_ofstream.reset (new std::ofstream (filename.str().c_str()));
// Redirect, saving the original streambufs!
out_buf = libMesh::out.rdbuf (_ofstream->rdbuf());
err_buf = libMesh::err.rdbuf (_ofstream->rdbuf());
}
// redirect libMesh::out to nothing on all
// other processors unless explicitly told
// not to via the --keep-cout command-line argument.
if (libMesh::global_processor_id() != 0)
if (!libMesh::on_command_line ("--keep-cout"))
libMesh::out.rdbuf (NULL);
// Check command line to override printing
// of reference count information.
if(libMesh::on_command_line("--disable-refcount-printing") )
ReferenceCounter::disable_print_counter_info();
#ifdef LIBMESH_ENABLE_EXCEPTIONS
// Set our terminate handler to write stack traces in the event of a
// crash
old_terminate_handler = std::set_terminate(libmesh_terminate_handler);
#endif
if (libMesh::on_command_line("--enable-fpe"))
libMesh::enableFPE(true);
// The library is now ready for use
libMeshPrivateData::_is_initialized = true;
// Make sure these work. Library methods
// depend on these being implemented properly,
// so this is a good time to test them!
libmesh_assert (libMesh::initialized());
libmesh_assert (!libMesh::closed());
}
int main(int argc,char **argv)
{
Mat A; /* problem matrix */
EPS eps; /* eigenproblem solver context */
ST st;
PetscReal tol=PetscMax(1000*PETSC_MACHINE_EPSILON,1e-9);
PetscScalar value[3];
PetscInt n=30,i,Istart,Iend,col[3];
PetscBool FirstBlock=PETSC_FALSE,LastBlock=PETSC_FALSE,flg;
PetscErrorCode ierr;
SlepcInitialize(&argc,&argv,(char*)0,help);
ierr = PetscOptionsGetInt(NULL,"-n",&n,NULL);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"\n1-D Laplacian Eigenproblem, n=%D\n\n",n);CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Compute the operator matrix that defines the eigensystem, Ax=kx
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
ierr = MatCreate(PETSC_COMM_WORLD,&A);CHKERRQ(ierr);
ierr = MatSetSizes(A,PETSC_DECIDE,PETSC_DECIDE,n,n);CHKERRQ(ierr);
ierr = MatSetFromOptions(A);CHKERRQ(ierr);
ierr = MatSetUp(A);CHKERRQ(ierr);
ierr = MatGetOwnershipRange(A,&Istart,&Iend);CHKERRQ(ierr);
if (Istart==0) FirstBlock=PETSC_TRUE;
if (Iend==n) LastBlock=PETSC_TRUE;
value[0]=-1.0; value[1]=2.0; value[2]=-1.0;
for (i=(FirstBlock? Istart+1: Istart); i<(LastBlock? Iend-1: Iend); i++) {
col[0]=i-1; col[1]=i; col[2]=i+1;
ierr = MatSetValues(A,1,&i,3,col,value,INSERT_VALUES);CHKERRQ(ierr);
}
if (LastBlock) {
i=n-1; col[0]=n-2; col[1]=n-1;
ierr = MatSetValues(A,1,&i,2,col,value,INSERT_VALUES);CHKERRQ(ierr);
}
if (FirstBlock) {
i=0; col[0]=0; col[1]=1; value[0]=2.0; value[1]=-1.0;
ierr = MatSetValues(A,1,&i,2,col,value,INSERT_VALUES);CHKERRQ(ierr);
}
ierr = MatAssemblyBegin(A,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
ierr = MatAssemblyEnd(A,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Create the eigensolver
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
ierr = EPSCreate(PETSC_COMM_WORLD,&eps);CHKERRQ(ierr);
ierr = EPSSetOperators(eps,A,NULL);CHKERRQ(ierr);
ierr = EPSSetProblemType(eps,EPS_HEP);CHKERRQ(ierr);
ierr = EPSSetTolerances(eps,tol,PETSC_DEFAULT);CHKERRQ(ierr);
ierr = EPSSetFromOptions(eps);CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Solve for largest eigenvalues
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
ierr = EPSSetWhichEigenpairs(eps,EPS_LARGEST_REAL);CHKERRQ(ierr);
ierr = EPSSolve(eps);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD," - - - Largest eigenvalues - - -\n");CHKERRQ(ierr);
ierr = EPSPrintSolution(eps,NULL);CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Solve for smallest eigenvalues
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
ierr = EPSSetWhichEigenpairs(eps,EPS_SMALLEST_REAL);CHKERRQ(ierr);
ierr = EPSSolve(eps);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD," - - - Smallest eigenvalues - - -\n");CHKERRQ(ierr);
ierr = EPSPrintSolution(eps,NULL);CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Solve for interior eigenvalues (target=2.1)
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
ierr = EPSSetWhichEigenpairs(eps,EPS_TARGET_MAGNITUDE);CHKERRQ(ierr);
ierr = EPSSetTarget(eps,2.1);CHKERRQ(ierr);
ierr = PetscObjectTypeCompare((PetscObject)eps,EPSLANCZOS,&flg);CHKERRQ(ierr);
if (flg) {
ierr = EPSGetST(eps,&st);CHKERRQ(ierr);
ierr = STSetType(st,STSINVERT);CHKERRQ(ierr);
} else {
ierr = PetscObjectTypeCompare((PetscObject)eps,EPSKRYLOVSCHUR,&flg);CHKERRQ(ierr);
if (!flg) {
ierr = PetscObjectTypeCompare((PetscObject)eps,EPSARNOLDI,&flg);CHKERRQ(ierr);
}
if (flg) {
ierr = EPSSetExtraction(eps,EPS_HARMONIC);CHKERRQ(ierr);
}
}
ierr = EPSSolve(eps);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD," - - - Interior eigenvalues - - -\n");CHKERRQ(ierr);
ierr = EPSPrintSolution(eps,NULL);CHKERRQ(ierr);
ierr = EPSDestroy(&eps);CHKERRQ(ierr);
ierr = MatDestroy(&A);CHKERRQ(ierr);
ierr = SlepcFinalize();
return 0;
}
int main( int argc, char **argv )
{
int ierr,i,j;
char infilename[PETSC_MAX_PATH_LEN]="", temporary[PETSC_MAX_PATH_LEN]="", path[PETSC_MAX_PATH_LEN]="";
PetscViewer viewer;
PetscBool isTail=PETSC_FALSE,isRight=PETSC_FALSE;
Mat mat;
PetscInt idxn[DIM], idxm[DIM], m, n, windowX=0, windowY=0;
PetscScalar values[DIM*DIM];
SlepcInitialize(&argc,&argv,(char*)0,help);
ierr = PetscOptionsGetString(PETSC_NULL,"-file",infilename,PETSC_MAX_PATH_LEN-1,PETSC_NULL);CHKERRQ(ierr);
ierr = PetscOptionsGetBool(PETSC_NULL, "-tail", &isTail, NULL);
ierr = PetscOptionsGetBool(PETSC_NULL, "-right", &isRight, NULL);
ierr = PetscGetWorkingDirectory(path,PETSC_MAX_PATH_LEN);
// concat filename
strcat(temporary, path); strcat(temporary, "/"); strcat(temporary, infilename); strcpy(infilename, temporary);
if ( strcmp(infilename, "") == 0 ){
SETERRQ(PETSC_COMM_WORLD,1,"Specifiy the filename!\nExample call: ./inspectBinary -file matrix.dat");
}
ierr = PetscViewerBinaryOpen(PETSC_COMM_WORLD,infilename,FILE_MODE_READ,&viewer);CHKERRQ(ierr);
ierr = MatCreate(PETSC_COMM_WORLD,&mat);CHKERRQ(ierr);
ierr = MatSetFromOptions(mat);CHKERRQ(ierr);
ierr = MatLoad(mat,viewer);CHKERRQ(ierr);
ierr = PetscViewerDestroy(&viewer);CHKERRQ(ierr);
MatGetSize(mat,&m,&n);
if ( isTail == PETSC_TRUE ){
windowY = m - DIM;
}
if ( isRight == PETSC_TRUE ){
windowX = n - DIM;
}
for ( i = 0 ; i < DIM ; ++i ){
idxm[i] = i + windowY; idxn[i] = i + windowX;
}
MatGetValues(mat,DIM,idxm,DIM,idxn,values);
ierr = PetscPrintf(PETSC_COMM_WORLD,"Dimension: %d rows x %d columns:\n", m, n);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"row index idxm:");CHKERRQ(ierr);
for ( i = 0 ; i < DIM ; ++i ){
ierr = PetscPrintf(PETSC_COMM_WORLD,"%d, ", idxm[i]);CHKERRQ(ierr);
}
ierr = PetscPrintf(PETSC_COMM_WORLD,"\ncol index idxn:");CHKERRQ(ierr);
for ( i = 0 ; i < DIM ; ++i ){
ierr = PetscPrintf(PETSC_COMM_WORLD,"%d, ", idxn[i]);CHKERRQ(ierr);
}
ierr = PetscPrintf(PETSC_COMM_WORLD,"\n\n\n");CHKERRQ(ierr);
for ( i = 0 ; i < DIM ; ++i ){
for ( j = 0 ; j < DIM ; ++j ){
ierr = PetscPrintf(PETSC_COMM_WORLD,"(%2.10e/ %2.10e) ", PetscRealPart(values[i*DIM + j]), PetscImaginaryPart(values[i*DIM + j]) );CHKERRQ(ierr);
}
ierr = PetscPrintf(PETSC_COMM_WORLD,"\n");CHKERRQ(ierr);
}
ierr = SlepcFinalize();CHKERRQ(ierr);
return 0;
}
int main(int argc,char **argv)
{
Mat A,B,C,D,mat[4];
ST st;
Vec v,w;
STType type;
PetscScalar value[3],sigma;
PetscInt n=10,i,Istart,Iend,col[3];
PetscBool FirstBlock=PETSC_FALSE,LastBlock=PETSC_FALSE;
PetscErrorCode ierr;
SlepcInitialize(&argc,&argv,(char*)0,help);
ierr = PetscOptionsGetInt(NULL,"-n",&n,NULL);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"\n1-D Laplacian plus diagonal, n=%D\n\n",n);CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Compute the operator matrix for the 1-D Laplacian
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
ierr = MatCreate(PETSC_COMM_WORLD,&A);CHKERRQ(ierr);
ierr = MatSetSizes(A,PETSC_DECIDE,PETSC_DECIDE,n,n);CHKERRQ(ierr);
ierr = MatSetFromOptions(A);CHKERRQ(ierr);
ierr = MatSetUp(A);CHKERRQ(ierr);
ierr = MatCreate(PETSC_COMM_WORLD,&B);CHKERRQ(ierr);
ierr = MatSetSizes(B,PETSC_DECIDE,PETSC_DECIDE,n,n);CHKERRQ(ierr);
ierr = MatSetFromOptions(B);CHKERRQ(ierr);
ierr = MatSetUp(B);CHKERRQ(ierr);
ierr = MatCreate(PETSC_COMM_WORLD,&C);CHKERRQ(ierr);
ierr = MatSetSizes(C,PETSC_DECIDE,PETSC_DECIDE,n,n);CHKERRQ(ierr);
ierr = MatSetFromOptions(C);CHKERRQ(ierr);
ierr = MatSetUp(C);CHKERRQ(ierr);
ierr = MatCreate(PETSC_COMM_WORLD,&D);CHKERRQ(ierr);
ierr = MatSetSizes(D,PETSC_DECIDE,PETSC_DECIDE,n,n);CHKERRQ(ierr);
ierr = MatSetFromOptions(D);CHKERRQ(ierr);
ierr = MatSetUp(D);CHKERRQ(ierr);
ierr = MatGetOwnershipRange(A,&Istart,&Iend);CHKERRQ(ierr);
if (Istart==0) FirstBlock=PETSC_TRUE;
if (Iend==n) LastBlock=PETSC_TRUE;
value[0]=-1.0; value[1]=2.0; value[2]=-1.0;
for (i=(FirstBlock? Istart+1: Istart); i<(LastBlock? Iend-1: Iend); 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 = MatSetValue(B,i,i,(PetscScalar)i,INSERT_VALUES);CHKERRQ(ierr);
}
if (LastBlock) {
i=n-1; col[0]=n-2; col[1]=n-1;
ierr = MatSetValues(A,1,&i,2,col,value,INSERT_VALUES);CHKERRQ(ierr);
ierr = MatSetValue(B,i,i,(PetscScalar)i,INSERT_VALUES);CHKERRQ(ierr);
}
if (FirstBlock) {
i=0; col[0]=0; col[1]=1; value[0]=2.0; value[1]=-1.0;
ierr = MatSetValues(A,1,&i,2,col,value,INSERT_VALUES);CHKERRQ(ierr);
ierr = MatSetValue(B,i,i,-1.0,INSERT_VALUES);CHKERRQ(ierr);
}
for (i=Istart;i<Iend;i++) {
ierr = MatSetValue(C,i,n-i-1,1.0,INSERT_VALUES);CHKERRQ(ierr);
ierr = MatSetValue(D,i,i,i*.1,INSERT_VALUES);CHKERRQ(ierr);
if (i==0) {
ierr = MatSetValue(D,0,n-1,1.0,INSERT_VALUES);CHKERRQ(ierr);
}
if (i==n-1) {
ierr = MatSetValue(D,n-1,0,1.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 = MatAssemblyBegin(C,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
ierr = MatAssemblyEnd(C,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
ierr = MatAssemblyBegin(D,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
ierr = MatAssemblyEnd(D,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
ierr = MatGetVecs(A,&v,&w);CHKERRQ(ierr);
ierr = VecSet(v,1.0);CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Create the spectral transformation object
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
ierr = STCreate(PETSC_COMM_WORLD,&st);CHKERRQ(ierr);
mat[0] = A;
mat[1] = B;
mat[2] = C;
mat[3] = D;
ierr = STSetOperators(st,4,mat);CHKERRQ(ierr);
ierr = STSetFromOptions(st);CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Apply the transformed operator for several ST's
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
/* shift, sigma=0.0 */
ierr = STSetUp(st);CHKERRQ(ierr);
ierr = STGetType(st,&type);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"ST type %s\n",type);CHKERRQ(ierr);
for (i=0;i<4;i++) {
ierr = STMatMult(st,i,v,w);
ierr = PetscPrintf(PETSC_COMM_WORLD,"k= %D\n",i);CHKERRQ(ierr);
ierr = VecView(w,NULL);CHKERRQ(ierr);
}
ierr = STMatSolve(st,v,w);
ierr = PetscPrintf(PETSC_COMM_WORLD,"solve\n");CHKERRQ(ierr);
ierr = VecView(w,NULL);CHKERRQ(ierr);
/* shift, sigma=0.1 */
sigma = 0.1;
ierr = STSetShift(st,sigma);CHKERRQ(ierr);
ierr = STGetShift(st,&sigma);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"With shift=%g\n",(double)PetscRealPart(sigma));CHKERRQ(ierr);
for (i=0;i<4;i++) {
ierr = STMatMult(st,i,v,w);
ierr = PetscPrintf(PETSC_COMM_WORLD,"k= %D\n",i);CHKERRQ(ierr);
ierr = VecView(w,NULL);CHKERRQ(ierr);
}
ierr = STMatSolve(st,v,w);
ierr = PetscPrintf(PETSC_COMM_WORLD,"solve\n");CHKERRQ(ierr);
ierr = VecView(w,NULL);CHKERRQ(ierr);
/* sinvert, sigma=0.1 */
ierr = STPostSolve(st);CHKERRQ(ierr);
ierr = STSetType(st,STSINVERT);CHKERRQ(ierr);
ierr = STGetType(st,&type);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"ST type %s\n",type);CHKERRQ(ierr);
ierr = STGetShift(st,&sigma);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"With shift=%g\n",(double)PetscRealPart(sigma));CHKERRQ(ierr);
for (i=0;i<4;i++) {
ierr = STMatMult(st,i,v,w);
ierr = PetscPrintf(PETSC_COMM_WORLD,"k= %D\n",i);CHKERRQ(ierr);
ierr = VecView(w,NULL);CHKERRQ(ierr);
}
ierr = STMatSolve(st,v,w);
ierr = PetscPrintf(PETSC_COMM_WORLD,"solve\n");CHKERRQ(ierr);
ierr = VecView(w,NULL);CHKERRQ(ierr);
/* sinvert, sigma=-0.5 */
sigma = -0.5;
ierr = STSetShift(st,sigma);CHKERRQ(ierr);
ierr = STGetShift(st,&sigma);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"With shift=%g\n",(double)PetscRealPart(sigma));CHKERRQ(ierr);
for (i=0;i<4;i++) {
ierr = STMatMult(st,i,v,w);
ierr = PetscPrintf(PETSC_COMM_WORLD,"k= %D\n",i);CHKERRQ(ierr);
ierr = VecView(w,NULL);CHKERRQ(ierr);
}
ierr = STMatSolve(st,v,w);
ierr = PetscPrintf(PETSC_COMM_WORLD,"solve\n");CHKERRQ(ierr);
ierr = VecView(w,NULL);CHKERRQ(ierr);
ierr = STDestroy(&st);CHKERRQ(ierr);
ierr = MatDestroy(&A);CHKERRQ(ierr);
ierr = MatDestroy(&B);CHKERRQ(ierr);
ierr = MatDestroy(&C);CHKERRQ(ierr);
ierr = MatDestroy(&D);CHKERRQ(ierr);
ierr = VecDestroy(&v);CHKERRQ(ierr);
ierr = VecDestroy(&w);CHKERRQ(ierr);
ierr = SlepcFinalize();
return 0;
}
int main(int argc, char **args) {
PetscErrorCode ierr;
ierr = SlepcInitialize(&argc, &args, (char*)0, help); CHKERRQ(ierr);
MPI_Comm comm = PETSC_COMM_SELF;
PetscBool find;
PetscViewer v = PETSC_VIEWER_STDOUT_SELF;
PetscPrintf(comm, "\n");
PetscPrintf(comm, ">>>> fit_oce1 program >>>>\n");
PetscPrintf(comm, "Fit L=0 radial function in OCE1\n");
OCE1 oce;
Pot pot;
KSP ksp;
Vec c;
char path_out[100];
PetscViewerFormat format;
PetscBool set;
// -- create --
PrintTimeStamp(comm, "Init", NULL);
ierr = OCE1Create(comm, &oce); CHKERRQ(ierr);
ierr = PotCreate(comm, &pot); CHKERRQ(ierr);
ierr = KSPCreate(comm, &ksp); CHKERRQ(ierr);
// -- read options --
PrintTimeStamp(comm, "Set", NULL);
PetscOptionsBegin(comm, "", "fit_oce1.c options", "none");
ierr = OCE1SetFromOptions(oce); CHKERRQ(ierr);
ierr = PotSetFromOptions2(pot, "v_", &find); CHKERRQ(ierr);
ierr = PetscOptionsGetString(NULL, NULL, "-out", path_out,
100, &set); CHKERRQ(ierr);
CHKERRQ(ierr);
ierr = PetscOptionsEnd(); CHKERRQ(ierr);
// -- input error --
if(pot == NULL) {
SETERRQ(comm, 1, "-v_pot option is necessary");
}
// -- print in --
PrintTimeStamp(comm, "PrintIn", NULL);
ierr = PetscPrintf(comm, "OCE1: "); CHKERRQ(ierr);
ierr = OCE1View(oce, v); CHKERRQ(ierr);
ierr = PetscPrintf(comm, "POT: "); CHKERRQ(ierr);
ierr = PFView(pot, v); CHKERRQ(ierr);
ierr = PetscPrintf(comm, "out: %s\n", path_out);
// -- calculation --
PrintTimeStamp(comm, "Calc", NULL);
ierr = OCE1CreateVec(oce, &c); CHKERRQ(ierr);
ierr = OCE1Fit(oce, pot, 0, ksp, c); CHKERRQ(ierr);
// -- write --
PetscViewer v_out;
ierr = PetscViewerBinaryOpen(comm, path_out, FILE_MODE_WRITE, &v_out); CHKERRQ(ierr);
ierr = VecView(c, v_out); CHKERRQ(ierr);
PetscViewerDestroy(&v_out);
PetscPrintf(comm, "<<<< fit_oce1 program <<<<\n\n");
// -- finalize --
OCE1Destroy(&oce); PFDestroy(&pot); KSPDestroy(&ksp); VecDestroy(&c);
SlepcFinalize();
return 0;
}
int main(int argc,char **args)
{
Mat A;
PetscInt i;
PetscErrorCode ierr;
char file[PETSC_MAX_PATH_LEN];
PetscLogDouble numberOfFlops, tsolve1, tsolve2;
EPS eps; /* eigenproblem solver context */
const EPSType type;
PetscReal error,tol,re,im;
PetscScalar kr,ki;
Vec xr=0,xi=0;
PetscInt nev,maxit,its,nconv;
EPSWhich which;
EPSProblemType problemType;
PetscMPIInt rank;
PetscMPIInt numberOfProcessors;
PetscBool flg;
PetscBool isComplex;
PetscViewer fd;
SlepcInitialize(&argc,&args,(char*)0,help);
ierr = MPI_Comm_rank(PETSC_COMM_WORLD,&rank);CHKERRQ(ierr);
ierr = MPI_Comm_size(PETSC_COMM_WORLD,&numberOfProcessors);CHKERRQ(ierr);
ierr = PetscOptionsGetString(PETSC_NULL,"-fin",file,PETSC_MAX_PATH_LEN,&flg);CHKERRQ(ierr);
if (!flg) {
SETERRQ(PETSC_COMM_WORLD,1,"Must indicate matrix file with the -fin option");
}
/* Read file */
ierr = PetscViewerBinaryOpen(PETSC_COMM_WORLD,file,FILE_MODE_READ,&fd);CHKERRQ(ierr);
// Create matrix
ierr = MatCreate(PETSC_COMM_WORLD,&A);CHKERRQ(ierr);
ierr = MatSetFromOptions(A);CHKERRQ(ierr);
// Load matrix from file
ierr = MatLoad(A,fd);CHKERRQ(ierr);
// Destroy viewer
ierr = PetscViewerDestroy(&fd);CHKERRQ(ierr);
// Assemble matrix
ierr = MatAssemblyBegin(A,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
ierr = MatAssemblyEnd(A,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
//ierr = PetscPrintf(PETSC_COMM_SELF,"Reading matrix completes.\n");CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Create the eigensolver and set various options
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
/*
Create eigensolver context
*/
ierr = EPSCreate(PETSC_COMM_WORLD,&eps);CHKERRQ(ierr);
/*
Set operators. In this case, it is a standard eigenvalue problem
*/
ierr = EPSSetOperators(eps,A,PETSC_NULL);CHKERRQ(ierr);
//ierr = EPSSetProblemType(eps,EPS_HEP);CHKERRQ(ierr);
/*
Set solver parameters at runtime
*/
ierr = EPSSetFromOptions(eps);CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Solve the eigensystem
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
PetscTime(tsolve1);
ierr = EPSSolve(eps);CHKERRQ(ierr);
PetscTime(tsolve2);
/*
Optional: Get some information from the solver and display it
*/
ierr = EPSGetProblemType(eps, &problemType);CHKERRQ(ierr);
ierr = EPSGetWhichEigenpairs(eps, &which);CHKERRQ(ierr);
ierr = EPSGetDimensions(eps,&nev,PETSC_NULL,PETSC_NULL);CHKERRQ(ierr);
ierr = EPSGetType(eps,&type);CHKERRQ(ierr);
ierr = EPSGetTolerances(eps,&tol,&maxit);CHKERRQ(ierr);
ierr = EPSGetConverged(eps,&nconv);CHKERRQ(ierr);
ierr = EPSGetIterationNumber(eps,&its);CHKERRQ(ierr);
ierr = PetscGetFlops(&numberOfFlops);CHKERRQ(ierr);
#if defined(PETSC_USE_COMPLEX)
isComplex = 1;
#else
isComplex = 0;
#endif
//Print output:
ierr = PetscPrintf(PETSC_COMM_WORLD,"%D\t %D\t %D\t %D\t %D\t %.4G\t %s\t %D\t %D\t %F\t %2.1e\t",isComplex, numberOfProcessors, problemType, which, nev, tol, type, nconv, its, numberOfFlops, (tsolve2-tsolve1));CHKERRQ(ierr);
if (nconv>0) {
for (i=0;i<nconv;i++) {
/*
Get converged eigenpairs: i-th eigenvalue is stored in kr (real part) and
ki (imaginary part)
*/
ierr = EPSGetEigenpair(eps,i,&kr,&ki,xr,xi);CHKERRQ(ierr);
/*
Compute the relative error associated to each eigenpair
*/
ierr = EPSComputeRelativeError(eps,i,&error);CHKERRQ(ierr);
#if defined(PETSC_USE_COMPLEX)
re = PetscRealPart(kr);
im = PetscImaginaryPart(kr);
#else
re = kr;
im = ki;
#endif
if (im!=0.0) {
// ierr = PetscPrintf(PETSC_COMM_WORLD," %9F%+9F j %12G\n",re,im,error);CHKERRQ(ierr);
} else {
// ierr = PetscPrintf(PETSC_COMM_WORLD," %12F %12G\n",re,error);CHKERRQ(ierr);
}
ierr = PetscPrintf(PETSC_COMM_WORLD,"%12G\t", error);CHKERRQ(ierr);
}
}
ierr = PetscPrintf(PETSC_COMM_WORLD,"\n");CHKERRQ(ierr);
//Destructors
ierr = MatDestroy(&A);CHKERRQ(ierr);
//ierr = PetscFinalize();
ierr = SlepcFinalize();CHKERRQ(ierr);
return 0;
}
int main(int argc,char **argv)
{
PetscErrorCode ierr;
FN fn;
PetscInt na,nb;
PetscScalar x,y,yp,p[10],q[10],five=5.0;
char strx[50],str[50];
SlepcInitialize(&argc,&argv,(char*)0,help);
ierr = FNCreate(PETSC_COMM_WORLD,&fn);CHKERRQ(ierr);
/* polynomial p(x) */
na = 5;
p[0] = -3.1; p[1] = 1.1; p[2] = 1.0; p[3] = -2.0; p[4] = 3.5;
ierr = FNSetType(fn,FNRATIONAL);CHKERRQ(ierr);
ierr = FNSetParameters(fn,na,p,0,NULL);CHKERRQ(ierr);
ierr = FNView(fn,NULL);CHKERRQ(ierr);
x = 2.2;
ierr = SlepcSNPrintfScalar(strx,50,x,PETSC_FALSE);CHKERRQ(ierr);
ierr = FNEvaluateFunction(fn,x,&y);CHKERRQ(ierr);
ierr = FNEvaluateDerivative(fn,x,&yp);CHKERRQ(ierr);
ierr = SlepcSNPrintfScalar(str,50,y,PETSC_FALSE);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD," f(%s)=%s\n",strx,str);CHKERRQ(ierr);
ierr = SlepcSNPrintfScalar(str,50,yp,PETSC_FALSE);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD," f'(%s)=%s\n",strx,str);CHKERRQ(ierr);
/* inverse of polynomial 1/q(x) */
nb = 3;
q[0] = -3.1; q[1] = 1.1; q[2] = 1.0;
ierr = FNSetType(fn,FNRATIONAL);CHKERRQ(ierr);
ierr = FNSetParameters(fn,0,NULL,nb,q);CHKERRQ(ierr);
ierr = FNView(fn,NULL);CHKERRQ(ierr);
x = 2.2;
ierr = SlepcSNPrintfScalar(strx,50,x,PETSC_FALSE);CHKERRQ(ierr);
ierr = FNEvaluateFunction(fn,x,&y);CHKERRQ(ierr);
ierr = FNEvaluateDerivative(fn,x,&yp);CHKERRQ(ierr);
ierr = SlepcSNPrintfScalar(str,50,y,PETSC_FALSE);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD," f(%s)=%s\n",strx,str);CHKERRQ(ierr);
ierr = SlepcSNPrintfScalar(str,50,yp,PETSC_FALSE);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD," f'(%s)=%s\n",strx,str);CHKERRQ(ierr);
/* rational p(x)/q(x) */
na = 2; nb = 3;
p[0] = -3.1; p[1] = 1.1;
q[0] = 1.0; q[1] = -2.0; q[2] = 3.5;
ierr = FNSetType(fn,FNRATIONAL);CHKERRQ(ierr);
ierr = FNSetParameters(fn,na,p,nb,q);CHKERRQ(ierr);
ierr = FNView(fn,NULL);CHKERRQ(ierr);
x = 2.2;
ierr = SlepcSNPrintfScalar(strx,50,x,PETSC_FALSE);CHKERRQ(ierr);
ierr = FNEvaluateFunction(fn,x,&y);CHKERRQ(ierr);
ierr = FNEvaluateDerivative(fn,x,&yp);CHKERRQ(ierr);
ierr = SlepcSNPrintfScalar(str,50,y,PETSC_FALSE);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD," f(%s)=%s\n",strx,str);CHKERRQ(ierr);
ierr = SlepcSNPrintfScalar(str,50,yp,PETSC_FALSE);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD," f'(%s)=%s\n",strx,str);CHKERRQ(ierr);
/* constant */
ierr = FNSetType(fn,FNRATIONAL);CHKERRQ(ierr);
ierr = FNSetParameters(fn,1,&five,0,NULL);CHKERRQ(ierr);
ierr = FNView(fn,NULL);CHKERRQ(ierr);
x = 2.2;
ierr = SlepcSNPrintfScalar(strx,50,x,PETSC_FALSE);CHKERRQ(ierr);
ierr = FNEvaluateFunction(fn,x,&y);CHKERRQ(ierr);
ierr = FNEvaluateDerivative(fn,x,&yp);CHKERRQ(ierr);
ierr = SlepcSNPrintfScalar(str,50,y,PETSC_FALSE);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD," f(%s)=%s\n",strx,str);CHKERRQ(ierr);
ierr = SlepcSNPrintfScalar(str,50,yp,PETSC_FALSE);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD," f'(%s)=%s\n",strx,str);CHKERRQ(ierr);
ierr = FNDestroy(&fn);CHKERRQ(ierr);
ierr = SlepcFinalize();
return 0;
}
int main(int argc,char **argv)
{
Mat A[NMAT]; /* problem matrices */
PEP pep; /* polynomial eigenproblem solver context */
PetscInt m=15,n,II,Istart,Iend,i,j,k;
PetscReal h,xi,xj,c[7] = { 2, .3, -2, .2, -2, -.3, -PETSC_PI/2 };
PetscScalar alpha,beta,gamma;
PetscBool flg;
PetscErrorCode ierr;
SlepcInitialize(&argc,&argv,(char*)0,help);
#if !defined(PETSC_USE_COMPLEX)
SETERRQ(PETSC_COMM_WORLD,PETSC_ERR_SUP, "This example requires complex scalars");
#endif
ierr = PetscOptionsGetInt(NULL,"-m",&m,NULL);CHKERRQ(ierr);
n = m*m;
h = PETSC_PI/(m+1);
gamma = PetscExpScalar(PETSC_i*c[6]);
gamma = gamma/PetscAbsScalar(gamma);
k = 7;
ierr = PetscOptionsGetRealArray(NULL,"-c",c,&k,&flg);CHKERRQ(ierr);
if (flg && k!=7) SETERRQ1(PETSC_COMM_WORLD,1,"The number of parameters -c should be 7, you provided %D",k);
ierr = PetscPrintf(PETSC_COMM_WORLD,"\nPDDE stability, n=%D (m=%D)\n\n",n,m);CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Compute the polynomial matrices
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
/* initialize matrices */
for (i=0;i<NMAT;i++) {
ierr = MatCreate(PETSC_COMM_WORLD,&A[i]);CHKERRQ(ierr);
ierr = MatSetSizes(A[i],PETSC_DECIDE,PETSC_DECIDE,n,n);CHKERRQ(ierr);
ierr = MatSetFromOptions(A[i]);CHKERRQ(ierr);
ierr = MatSetUp(A[i]);CHKERRQ(ierr);
}
ierr = MatGetOwnershipRange(A[0],&Istart,&Iend);CHKERRQ(ierr);
/* A[1] has a pattern similar to the 2D Laplacian */
for (II=Istart;II<Iend;II++) {
i = II/m; j = II-i*m;
xi = (i+1)*h; xj = (j+1)*h;
alpha = c[0]+c[1]*PetscSinReal(xi)+gamma*(c[2]+c[3]*xi*(1.0-PetscExpReal(xi-PETSC_PI)));
beta = c[0]+c[1]*PetscSinReal(xj)-gamma*(c[2]+c[3]*xj*(1.0-PetscExpReal(xj-PETSC_PI)));
ierr = MatSetValue(A[1],II,II,alpha+beta-4.0/(h*h),INSERT_VALUES);CHKERRQ(ierr);
if (j>0) { ierr = MatSetValue(A[1],II,II-1,1.0/(h*h),INSERT_VALUES);CHKERRQ(ierr); }
if (j<m-1) { ierr = MatSetValue(A[1],II,II+1,1.0/(h*h),INSERT_VALUES);CHKERRQ(ierr); }
if (i>0) { ierr = MatSetValue(A[1],II,II-m,1.0/(h*h),INSERT_VALUES);CHKERRQ(ierr); }
if (i<m-1) { ierr = MatSetValue(A[1],II,II+m,1.0/(h*h),INSERT_VALUES);CHKERRQ(ierr); }
}
/* A[0] and A[2] are diagonal */
for (II=Istart;II<Iend;II++) {
i = II/m; j = II-i*m;
xi = (i+1)*h; xj = (j+1)*h;
alpha = c[4]+c[5]*xi*(PETSC_PI-xi);
beta = c[4]+c[5]*xj*(PETSC_PI-xj);
ierr = MatSetValue(A[0],II,II,alpha,INSERT_VALUES);CHKERRQ(ierr);
ierr = MatSetValue(A[2],II,II,beta,INSERT_VALUES);CHKERRQ(ierr);
}
/* assemble matrices */
for (i=0;i<NMAT;i++) {
ierr = MatAssemblyBegin(A[i],MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
}
for (i=0;i<NMAT;i++) {
ierr = MatAssemblyEnd(A[i],MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
}
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Create the eigensolver and solve the problem
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
ierr = PEPCreate(PETSC_COMM_WORLD,&pep);CHKERRQ(ierr);
ierr = PEPSetOperators(pep,NMAT,A);CHKERRQ(ierr);
ierr = PEPSetFromOptions(pep);CHKERRQ(ierr);
ierr = PEPSolve(pep);CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Display solution and clean up
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
ierr = PEPPrintSolution(pep,NULL);CHKERRQ(ierr);
ierr = PEPDestroy(&pep);CHKERRQ(ierr);
for (i=0;i<NMAT;i++) {
ierr = MatDestroy(&A[i]);CHKERRQ(ierr);
}
ierr = SlepcFinalize();CHKERRQ(ierr);
return 0;
}
int main(int argc,char **argv)
{
Mat M,C,K,A[3]; /* problem matrices */
PEP pep; /* polynomial eigenproblem solver context */
PetscInt n=5,Istart,Iend,i;
PetscReal mu=1,tau=10,kappa=5;
PetscBool terse;
PetscErrorCode ierr;
PetscLogDouble time1,time2;
SlepcInitialize(&argc,&argv,(char*)0,help);
ierr = PetscOptionsGetInt(NULL,"-n",&n,NULL);CHKERRQ(ierr);
ierr = PetscOptionsGetReal(NULL,"-mu",&mu,NULL);CHKERRQ(ierr);
ierr = PetscOptionsGetReal(NULL,"-tau",&tau,NULL);CHKERRQ(ierr);
ierr = PetscOptionsGetReal(NULL,"-kappa",&kappa,NULL);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"\nDamped mass-spring system, n=%D mu=%g tau=%g kappa=%g\n\n",n,(double)mu,(double)tau,(double)kappa);CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Compute the matrices that define the eigensystem, (k^2*M+k*C+K)x=0
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
/* K is a tridiagonal */
ierr = MatCreate(PETSC_COMM_WORLD,&K);CHKERRQ(ierr);
ierr = MatSetSizes(K,PETSC_DECIDE,PETSC_DECIDE,n,n);CHKERRQ(ierr);
ierr = MatSetFromOptions(K);CHKERRQ(ierr);
ierr = MatSetUp(K);CHKERRQ(ierr);
ierr = MatGetOwnershipRange(K,&Istart,&Iend);CHKERRQ(ierr);
for (i=Istart;i<Iend;i++) {
if (i>0) {
ierr = MatSetValue(K,i,i-1,-kappa,INSERT_VALUES);CHKERRQ(ierr);
}
ierr = MatSetValue(K,i,i,kappa*3.0,INSERT_VALUES);CHKERRQ(ierr);
if (i<n-1) {
ierr = MatSetValue(K,i,i+1,-kappa,INSERT_VALUES);CHKERRQ(ierr);
}
}
ierr = MatAssemblyBegin(K,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
ierr = MatAssemblyEnd(K,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
/* C is a tridiagonal */
ierr = MatCreate(PETSC_COMM_WORLD,&C);CHKERRQ(ierr);
ierr = MatSetSizes(C,PETSC_DECIDE,PETSC_DECIDE,n,n);CHKERRQ(ierr);
ierr = MatSetFromOptions(C);CHKERRQ(ierr);
ierr = MatSetUp(C);CHKERRQ(ierr);
ierr = MatGetOwnershipRange(C,&Istart,&Iend);CHKERRQ(ierr);
for (i=Istart;i<Iend;i++) {
if (i>0) {
ierr = MatSetValue(C,i,i-1,-tau,INSERT_VALUES);CHKERRQ(ierr);
}
ierr = MatSetValue(C,i,i,tau*3.0,INSERT_VALUES);CHKERRQ(ierr);
if (i<n-1) {
ierr = MatSetValue(C,i,i+1,-tau,INSERT_VALUES);CHKERRQ(ierr);
}
}
ierr = MatAssemblyBegin(C,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
ierr = MatAssemblyEnd(C,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
/* M is a diagonal matrix */
ierr = MatCreate(PETSC_COMM_WORLD,&M);CHKERRQ(ierr);
ierr = MatSetSizes(M,PETSC_DECIDE,PETSC_DECIDE,n,n);CHKERRQ(ierr);
ierr = MatSetFromOptions(M);CHKERRQ(ierr);
ierr = MatSetUp(M);CHKERRQ(ierr);
ierr = MatGetOwnershipRange(M,&Istart,&Iend);CHKERRQ(ierr);
for (i=Istart;i<Iend;i++) {
ierr = MatSetValue(M,i,i,mu,INSERT_VALUES);CHKERRQ(ierr);
}
ierr = MatAssemblyBegin(M,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
ierr = MatAssemblyEnd(M,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Create the eigensolver and solve the problem
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
ierr = PEPCreate(PETSC_COMM_WORLD,&pep);CHKERRQ(ierr);
A[0] = K; A[1] = C; A[2] = M;
ierr = PEPSetOperators(pep,3,A);CHKERRQ(ierr);
ierr = PEPSetFromOptions(pep);CHKERRQ(ierr);
ierr = PetscTime(&time1); CHKERRQ(ierr);
ierr = PEPSolve(pep);CHKERRQ(ierr);
ierr = PetscTime(&time2); CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Display solution and clean up
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
/* show detailed info unless -terse option is given by user */
ierr = PetscOptionsHasName(NULL,"-terse",&terse);CHKERRQ(ierr);
if (terse) {
ierr = PEPErrorView(pep,PEP_ERROR_BACKWARD,NULL);CHKERRQ(ierr);
} else {
ierr = PetscViewerPushFormat(PETSC_VIEWER_STDOUT_WORLD,PETSC_VIEWER_ASCII_INFO_DETAIL);CHKERRQ(ierr);
ierr = PEPReasonView(pep,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
ierr = PEPErrorView(pep,PEP_ERROR_BACKWARD,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
ierr = PetscViewerPopFormat(PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
}
ierr = PetscPrintf(PETSC_COMM_WORLD,"Time: %g\n\n\n",time2-time1);CHKERRQ(ierr);
ierr = PEPDestroy(&pep);CHKERRQ(ierr);
ierr = MatDestroy(&M);CHKERRQ(ierr);
ierr = MatDestroy(&C);CHKERRQ(ierr);
ierr = MatDestroy(&K);CHKERRQ(ierr);
ierr = SlepcFinalize();CHKERRQ(ierr);
return 0;
}
int main(int argc,char **argv)
{
PetscErrorCode ierr;
DS ds;
FN f1,f2,f3,funs[3];
PetscScalar *Id,*A,*B,*wr,*wi,coeffs[2];
PetscReal tau=0.001,h,a=20,xi,re,im;
PetscInt i,n=10,ld,nev;
PetscViewer viewer;
PetscBool verbose;
SlepcInitialize(&argc,&argv,(char*)0,help);
ierr = PetscOptionsGetInt(NULL,"-n",&n,NULL);CHKERRQ(ierr);
ierr = PetscOptionsGetReal(NULL,"-tau",&tau,NULL);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"Solve a Dense System of type NEP - dimension %D, tau=%g.\n",n,(double)tau);CHKERRQ(ierr);
ierr = PetscOptionsHasName(NULL,"-verbose",&verbose);CHKERRQ(ierr);
/* Create DS object */
ierr = DSCreate(PETSC_COMM_WORLD,&ds);CHKERRQ(ierr);
ierr = DSSetType(ds,DSNEP);CHKERRQ(ierr);
ierr = DSSetFromOptions(ds);CHKERRQ(ierr);
/* Set functions (prior to DSAllocate) */
ierr = FNCreate(PETSC_COMM_WORLD,&f1);CHKERRQ(ierr);
ierr = FNSetType(f1,FNRATIONAL);CHKERRQ(ierr);
coeffs[0] = -1.0; coeffs[1] = 0.0;
ierr = FNSetParameters(f1,2,coeffs,0,NULL);CHKERRQ(ierr);
ierr = FNCreate(PETSC_COMM_WORLD,&f2);CHKERRQ(ierr);
ierr = FNSetType(f2,FNRATIONAL);CHKERRQ(ierr);
coeffs[0] = 1.0;
ierr = FNSetParameters(f2,1,coeffs,0,NULL);CHKERRQ(ierr);
ierr = FNCreate(PETSC_COMM_WORLD,&f3);CHKERRQ(ierr);
ierr = FNSetType(f3,FNEXP);CHKERRQ(ierr);
coeffs[0] = -tau;
ierr = FNSetParameters(f3,1,coeffs,0,NULL);CHKERRQ(ierr);
funs[0] = f1;
funs[1] = f2;
funs[2] = f3;
ierr = DSSetFN(ds,3,funs);CHKERRQ(ierr);
/* Set dimensions */
ld = n+2; /* test leading dimension larger than n */
ierr = DSAllocate(ds,ld);CHKERRQ(ierr);
ierr = DSSetDimensions(ds,n,0,0,0);CHKERRQ(ierr);
/* Set up viewer */
ierr = PetscViewerASCIIGetStdout(PETSC_COMM_WORLD,&viewer);CHKERRQ(ierr);
ierr = PetscViewerPushFormat(viewer,PETSC_VIEWER_ASCII_INFO_DETAIL);CHKERRQ(ierr);
ierr = DSView(ds,viewer);CHKERRQ(ierr);
ierr = PetscViewerPopFormat(viewer);CHKERRQ(ierr);
if (verbose) {
ierr = PetscViewerPushFormat(viewer,PETSC_VIEWER_ASCII_MATLAB);CHKERRQ(ierr);
}
/* Fill matrices */
ierr = DSGetArray(ds,DS_MAT_E0,&Id);CHKERRQ(ierr);
for (i=0;i<n;i++) Id[i+i*ld]=1.0;
ierr = DSRestoreArray(ds,DS_MAT_E0,&Id);CHKERRQ(ierr);
h = PETSC_PI/(PetscReal)(n+1);
ierr = DSGetArray(ds,DS_MAT_E1,&A);CHKERRQ(ierr);
for (i=0;i<n;i++) A[i+i*ld]=-2.0/(h*h)+a;
for (i=1;i<n;i++) {
A[i+(i-1)*ld]=1.0/(h*h);
A[(i-1)+i*ld]=1.0/(h*h);
}
ierr = DSRestoreArray(ds,DS_MAT_E1,&A);CHKERRQ(ierr);
ierr = DSGetArray(ds,DS_MAT_E2,&B);CHKERRQ(ierr);
for (i=0;i<n;i++) {
xi = (i+1)*h;
B[i+i*ld] = -4.1+xi*(1.0-PetscExpReal(xi-PETSC_PI));
}
ierr = DSRestoreArray(ds,DS_MAT_E2,&B);CHKERRQ(ierr);
if (verbose) {
ierr = PetscPrintf(PETSC_COMM_WORLD,"Initial - - - - - - - - -\n");CHKERRQ(ierr);
ierr = DSView(ds,viewer);CHKERRQ(ierr);
}
/* Solve */
ierr = PetscMalloc2(n,&wr,n,&wi);CHKERRQ(ierr);
ierr = DSSolve(ds,wr,wi);CHKERRQ(ierr);
if (verbose) {
ierr = PetscPrintf(PETSC_COMM_WORLD,"After solve - - - - - - - - -\n");CHKERRQ(ierr);
ierr = DSView(ds,viewer);CHKERRQ(ierr);
}
/* Print first eigenvalue */
ierr = PetscPrintf(PETSC_COMM_WORLD,"Computed eigenvalue =\n",n);CHKERRQ(ierr);
nev = 1;
for (i=0;i<nev;i++) {
#if defined(PETSC_USE_COMPLEX)
re = PetscRealPart(wr[i]);
im = PetscImaginaryPart(wr[i]);
#else
re = wr[i];
im = wi[i];
#endif
if (PetscAbs(im)<1e-10) {
ierr = PetscViewerASCIIPrintf(viewer," %.5f\n",(double)re);CHKERRQ(ierr);
} else {
ierr = PetscViewerASCIIPrintf(viewer," %.5f%+.5fi\n",(double)re,(double)im);CHKERRQ(ierr);
}
}
ierr = PetscFree2(wr,wi);CHKERRQ(ierr);
ierr = FNDestroy(&f1);CHKERRQ(ierr);
ierr = FNDestroy(&f2);CHKERRQ(ierr);
ierr = FNDestroy(&f3);CHKERRQ(ierr);
ierr = DSDestroy(&ds);CHKERRQ(ierr);
ierr = SlepcFinalize();
return 0;
}
int main(int argc,char **argv)
{
PetscErrorCode ierr;
DS ds;
SlepcSC sc;
PetscReal *T,*s,re,im;
PetscScalar *eigr,*eigi;
PetscInt i,n=10,l=2,k=5,ld;
PetscViewer viewer;
PetscBool verbose;
SlepcInitialize(&argc,&argv,(char*)0,help);
ierr = PetscOptionsGetInt(NULL,"-n",&n,NULL);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"Solve a Dense System of type GHIEP with compact storage - dimension %D.\n",n);CHKERRQ(ierr);
ierr = PetscOptionsGetInt(NULL,"-l",&l,NULL);CHKERRQ(ierr);
ierr = PetscOptionsGetInt(NULL,"-k",&k,NULL);CHKERRQ(ierr);
if (l>n || k>n || l>k) SETERRQ(PETSC_COMM_WORLD,1,"Wrong value of dimensions");
ierr = PetscOptionsHasName(NULL,"-verbose",&verbose);CHKERRQ(ierr);
/* Create DS object */
ierr = DSCreate(PETSC_COMM_WORLD,&ds);CHKERRQ(ierr);
ierr = DSSetType(ds,DSGHIEP);CHKERRQ(ierr);
ierr = DSSetFromOptions(ds);CHKERRQ(ierr);
ld = n+2; /* test leading dimension larger than n */
ierr = DSAllocate(ds,ld);CHKERRQ(ierr);
ierr = DSSetDimensions(ds,n,0,l,k);CHKERRQ(ierr);
ierr = DSSetCompact(ds,PETSC_TRUE);CHKERRQ(ierr);
/* Set up viewer */
ierr = PetscViewerASCIIGetStdout(PETSC_COMM_WORLD,&viewer);CHKERRQ(ierr);
ierr = PetscViewerPushFormat(viewer,PETSC_VIEWER_ASCII_INFO_DETAIL);CHKERRQ(ierr);
ierr = DSView(ds,viewer);CHKERRQ(ierr);
ierr = PetscViewerPopFormat(viewer);CHKERRQ(ierr);
if (verbose) {
ierr = PetscViewerPushFormat(viewer,PETSC_VIEWER_ASCII_MATLAB);CHKERRQ(ierr);
}
/* Fill arrow-tridiagonal matrix */
ierr = DSGetArrayReal(ds,DS_MAT_T,&T);CHKERRQ(ierr);
ierr = DSGetArrayReal(ds,DS_MAT_D,&s);CHKERRQ(ierr);
for (i=0;i<n;i++) T[i] = (PetscReal)(i+1);
for (i=k;i<n-1;i++) T[i+ld] = 1.0;
for (i=l;i<k;i++) T[i+2*ld] = 1.0;
T[2*ld+l+1] = -7; T[ld+k+1] = -7;
/* Signature matrix */
for (i=0;i<n;i++) s[i] = 1.0;
s[l+1] = -1.0;
s[k+1] = -1.0;
ierr = DSRestoreArrayReal(ds,DS_MAT_T,&T);CHKERRQ(ierr);
ierr = DSRestoreArrayReal(ds,DS_MAT_D,&s);CHKERRQ(ierr);
if (l==0 && k==0) {
ierr = DSSetState(ds,DS_STATE_INTERMEDIATE);CHKERRQ(ierr);
} else {
ierr = DSSetState(ds,DS_STATE_RAW);CHKERRQ(ierr);
}
if (verbose) {
ierr = PetscPrintf(PETSC_COMM_WORLD,"Initial - - - - - - - - -\n");CHKERRQ(ierr);
ierr = DSView(ds,viewer);CHKERRQ(ierr);
}
/* Solve */
ierr = PetscCalloc2(n,&eigr,n,&eigi);CHKERRQ(ierr);
ierr = DSGetSlepcSC(ds,&sc);CHKERRQ(ierr);
sc->comparison = SlepcCompareLargestMagnitude;
sc->comparisonctx = NULL;
sc->map = NULL;
sc->mapobj = NULL;
ierr = DSSolve(ds,eigr,eigi);CHKERRQ(ierr);
ierr = DSSort(ds,eigr,eigi,NULL,NULL,NULL);CHKERRQ(ierr);
if (verbose) {
ierr = PetscPrintf(PETSC_COMM_WORLD,"After solve - - - - - - - - -\n");CHKERRQ(ierr);
ierr = DSView(ds,viewer);CHKERRQ(ierr);
}
/* Print eigenvalues */
ierr = PetscPrintf(PETSC_COMM_WORLD,"Computed eigenvalues =\n",n);CHKERRQ(ierr);
for (i=0;i<n;i++) {
#if defined(PETSC_USE_COMPLEX)
re = PetscRealPart(eigr[i]);
im = PetscImaginaryPart(eigr[i]);
#else
re = eigr[i];
im = eigi[i];
#endif
if (PetscAbs(im)<1e-10) {
ierr = PetscViewerASCIIPrintf(viewer," %.5f\n",(double)re);CHKERRQ(ierr);
} else {
ierr = PetscViewerASCIIPrintf(viewer," %.5f%+.5fi\n",(double)re,(double)im);CHKERRQ(ierr);
}
}
ierr = PetscFree2(eigr,eigi);CHKERRQ(ierr);
ierr = DSDestroy(&ds);CHKERRQ(ierr);
ierr = SlepcFinalize();
return 0;
}
int main( int argc, char **argv )
{
PetscErrorCode ierr;
Mat A; /* Grcar matrix */
SVD svd; /* singular value solver context */
PetscInt N=30, Istart, Iend, i, col[5], nconv1, nconv2;
PetscScalar value[] = { -1, 1, 1, 1, 1 };
PetscReal sigma_1, sigma_n;
SlepcInitialize(&argc,&argv,(char*)0,help);
ierr = PetscOptionsGetInt(PETSC_NULL,"-n",&N,PETSC_NULL);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"\nEstimate the condition number of a Grcar matrix, n=%d\n\n",N);CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Generate the matrix
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
ierr = MatCreate(PETSC_COMM_WORLD,&A);CHKERRQ(ierr);
ierr = MatSetSizes(A,PETSC_DECIDE,PETSC_DECIDE,N,N);CHKERRQ(ierr);
ierr = MatSetFromOptions(A);CHKERRQ(ierr);
ierr = MatGetOwnershipRange(A,&Istart,&Iend);CHKERRQ(ierr);
for( i=Istart; i<Iend; i++ ) {
col[0]=i-1; col[1]=i; col[2]=i+1; col[3]=i+2; col[4]=i+3;
if (i==0) {
ierr = MatSetValues(A,1,&i,4,col+1,value+1,INSERT_VALUES);CHKERRQ(ierr);
}
else {
ierr = MatSetValues(A,1,&i,PetscMin(5,N-i+1),col,value,INSERT_VALUES);CHKERRQ(ierr);
}
}
ierr = MatAssemblyBegin(A,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
ierr = MatAssemblyEnd(A,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Create the singular value solver and set the solution method
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
/*
Create singular value context
*/
ierr = SVDCreate(PETSC_COMM_WORLD,&svd);CHKERRQ(ierr);
/*
Set operator
*/
ierr = SVDSetOperator(svd,A);CHKERRQ(ierr);
/*
Set solver parameters at runtime
*/
ierr = SVDSetFromOptions(svd);CHKERRQ(ierr);
ierr = SVDSetDimensions(svd,1,PETSC_IGNORE,PETSC_IGNORE);CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Solve the eigensystem
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
/*
First request an eigenvalue from one end of the spectrum
*/
ierr = SVDSetWhichSingularTriplets(svd,SVD_LARGEST);CHKERRQ(ierr);
ierr = SVDSolve(svd);CHKERRQ(ierr);
/*
Get number of converged singular values
*/
ierr = SVDGetConverged(svd,&nconv1);CHKERRQ(ierr);
/*
Get converged singular values: largest singular value is stored in sigma_1.
In this example, we are not interested in the singular vectors
*/
if (nconv1 > 0) {
ierr = SVDGetSingularTriplet(svd,0,&sigma_1,PETSC_NULL,PETSC_NULL);CHKERRQ(ierr);
} else {
ierr = PetscPrintf(PETSC_COMM_WORLD," Unable to compute large singular value!\n\n");CHKERRQ(ierr);
}
/*
Request an eigenvalue from the other end of the spectrum
*/
ierr = SVDSetWhichSingularTriplets(svd,SVD_SMALLEST);CHKERRQ(ierr);
ierr = SVDSolve(svd);CHKERRQ(ierr);
/*
Get number of converged eigenpairs
*/
ierr = SVDGetConverged(svd,&nconv2);CHKERRQ(ierr);
/*
Get converged singular values: smallest singular value is stored in sigma_n.
As before, we are not interested in the singular vectors
*/
if (nconv2 > 0) {
ierr = SVDGetSingularTriplet(svd,0,&sigma_n,PETSC_NULL,PETSC_NULL);CHKERRQ(ierr);
} else {
ierr = PetscPrintf(PETSC_COMM_WORLD," Unable to compute small singular value!\n\n");CHKERRQ(ierr);
}
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Display solution and clean up
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
if (nconv1 > 0 && nconv2 > 0) {
ierr = PetscPrintf(PETSC_COMM_WORLD," Computed singular values: sigma_1=%6f, sigma_n=%6f\n",sigma_1,sigma_n);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD," Estimated condition number: sigma_1/sigma_n=%6f\n\n",sigma_1/sigma_n);CHKERRQ(ierr);
}
/*
Free work space
*/
ierr = SVDDestroy(svd);CHKERRQ(ierr);
ierr = MatDestroy(A);CHKERRQ(ierr);
ierr = SlepcFinalize();CHKERRQ(ierr);
return 0;
}
int main(int argc,char **argv)
{
PetscErrorCode ierr;
Vec t,v;
Mat Q,M;
BV X,Y;
PetscInt i,j,n=10,kx=6,lx=3,ky=5,ly=2;
PetscScalar *q,*z;
PetscReal nrm;
PetscViewer view;
PetscBool verbose,trans;
SlepcInitialize(&argc,&argv,(char*)0,help);
ierr = PetscOptionsGetInt(NULL,"-n",&n,NULL);CHKERRQ(ierr);
ierr = PetscOptionsGetInt(NULL,"-kx",&kx,NULL);CHKERRQ(ierr);
ierr = PetscOptionsGetInt(NULL,"-lx",&lx,NULL);CHKERRQ(ierr);
ierr = PetscOptionsGetInt(NULL,"-ky",&ky,NULL);CHKERRQ(ierr);
ierr = PetscOptionsGetInt(NULL,"-ly",&ly,NULL);CHKERRQ(ierr);
ierr = PetscOptionsHasName(NULL,"-verbose",&verbose);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"First BV with %D active columns (%D leading columns) of dimension %D.\n",kx,lx,n);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"Second BV with %D active columns (%D leading columns) of dimension %D.\n",ky,ly,n);CHKERRQ(ierr);
/* Create template vector */
ierr = VecCreate(PETSC_COMM_WORLD,&t);CHKERRQ(ierr);
ierr = VecSetSizes(t,PETSC_DECIDE,n);CHKERRQ(ierr);
ierr = VecSetFromOptions(t);CHKERRQ(ierr);
/* Create BV object X */
ierr = BVCreate(PETSC_COMM_WORLD,&X);CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject)X,"X");CHKERRQ(ierr);
ierr = BVSetSizesFromVec(X,t,kx+2);CHKERRQ(ierr); /* two extra columns to test active columns */
ierr = BVSetFromOptions(X);CHKERRQ(ierr);
ierr = BVSetActiveColumns(X,lx,kx);CHKERRQ(ierr);
/* Set up viewer */
ierr = PetscViewerASCIIGetStdout(PETSC_COMM_WORLD,&view);CHKERRQ(ierr);
if (verbose) {
ierr = PetscViewerPushFormat(view,PETSC_VIEWER_ASCII_MATLAB);CHKERRQ(ierr);
}
/* Fill X entries */
for (j=0;j<kx+2;j++) {
ierr = BVGetColumn(X,j,&v);CHKERRQ(ierr);
ierr = VecZeroEntries(v);CHKERRQ(ierr);
for (i=0;i<4;i++) {
if (i+j<n) {
ierr = VecSetValue(v,i+j,(PetscScalar)(3*i+j-2),INSERT_VALUES);CHKERRQ(ierr);
}
}
ierr = VecAssemblyBegin(v);CHKERRQ(ierr);
ierr = VecAssemblyEnd(v);CHKERRQ(ierr);
ierr = BVRestoreColumn(X,j,&v);CHKERRQ(ierr);
}
if (verbose) {
ierr = BVView(X,view);CHKERRQ(ierr);
}
/* Create BV object Y */
ierr = BVCreate(PETSC_COMM_WORLD,&Y);CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject)Y,"Y");CHKERRQ(ierr);
ierr = BVSetSizesFromVec(Y,t,ky+1);CHKERRQ(ierr);
ierr = BVSetFromOptions(Y);CHKERRQ(ierr);
ierr = BVSetActiveColumns(Y,ly,ky);CHKERRQ(ierr);
/* Fill Y entries */
for (j=0;j<ky+1;j++) {
ierr = BVGetColumn(Y,j,&v);CHKERRQ(ierr);
ierr = VecSet(v,(PetscScalar)(j+1)/4.0);CHKERRQ(ierr);
ierr = BVRestoreColumn(Y,j,&v);CHKERRQ(ierr);
}
if (verbose) {
ierr = BVView(Y,view);CHKERRQ(ierr);
}
/* Create Mat */
ierr = MatCreateSeqDense(PETSC_COMM_SELF,kx,ky,NULL,&Q);CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject)Q,"Q");CHKERRQ(ierr);
ierr = MatDenseGetArray(Q,&q);CHKERRQ(ierr);
for (i=0;i<kx;i++)
for (j=0;j<ky;j++)
q[i+j*kx] = (i<j)? 2.0: -0.5;
ierr = MatDenseRestoreArray(Q,&q);CHKERRQ(ierr);
if (verbose) {
ierr = MatView(Q,NULL);CHKERRQ(ierr);
}
/* Test BVMult */
ierr = BVMult(Y,2.0,1.0,X,Q);CHKERRQ(ierr);
if (verbose) {
ierr = PetscPrintf(PETSC_COMM_WORLD,"After BVMult - - - - - - - - -\n");CHKERRQ(ierr);
ierr = BVView(Y,view);CHKERRQ(ierr);
}
/* Test BVMultVec */
ierr = BVGetColumn(Y,0,&v);CHKERRQ(ierr);
ierr = PetscMalloc1(kx-lx,&z);CHKERRQ(ierr);
z[0] = 2.0;
for (i=1;i<kx-lx;i++) z[i] = -0.5*z[i-1];
ierr = BVMultVec(X,-1.0,1.0,v,z);CHKERRQ(ierr);
ierr = PetscFree(z);CHKERRQ(ierr);
ierr = BVRestoreColumn(Y,0,&v);CHKERRQ(ierr);
if (verbose) {
ierr = PetscPrintf(PETSC_COMM_WORLD,"After BVMultVec - - - - - - -\n");CHKERRQ(ierr);
ierr = BVView(Y,view);CHKERRQ(ierr);
}
/* Test BVDot */
ierr = MatCreateSeqDense(PETSC_COMM_SELF,ky,kx,NULL,&M);CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject)M,"M");CHKERRQ(ierr);
ierr = BVDot(X,Y,M);CHKERRQ(ierr);
if (verbose) {
ierr = PetscPrintf(PETSC_COMM_WORLD,"After BVDot - - - - - - - - -\n");CHKERRQ(ierr);
ierr = MatView(M,NULL);CHKERRQ(ierr);
}
/* Test BVDotVec */
ierr = BVGetColumn(Y,0,&v);CHKERRQ(ierr);
ierr = PetscMalloc1(kx-lx,&z);CHKERRQ(ierr);
ierr = BVDotVec(X,v,z);CHKERRQ(ierr);
ierr = BVRestoreColumn(Y,0,&v);CHKERRQ(ierr);
if (verbose) {
ierr = PetscPrintf(PETSC_COMM_WORLD,"After BVDotVec - - - - - - -\n");CHKERRQ(ierr);
ierr = VecCreateSeqWithArray(PETSC_COMM_SELF,1,kx-lx,z,&v);CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject)v,"z");CHKERRQ(ierr);
ierr = VecView(v,view);CHKERRQ(ierr);
ierr = VecDestroy(&v);CHKERRQ(ierr);
}
ierr = PetscFree(z);CHKERRQ(ierr);
/* Test BVMultInPlace and BVScale */
ierr = PetscOptionsHasName(NULL,"-trans",&trans);CHKERRQ(ierr);
if (trans) {
Mat Qt;
ierr = MatTranspose(Q,MAT_INITIAL_MATRIX,&Qt);CHKERRQ(ierr);
ierr = BVMultInPlaceTranspose(X,Qt,lx+1,ky);CHKERRQ(ierr);
ierr = MatDestroy(&Qt);CHKERRQ(ierr);
} else {
ierr = BVMultInPlace(X,Q,lx+1,ky);CHKERRQ(ierr);
}
ierr = BVScale(X,2.0);CHKERRQ(ierr);
if (verbose) {
ierr = PetscPrintf(PETSC_COMM_WORLD,"After BVMultInPlace - - - - -\n");CHKERRQ(ierr);
ierr = BVView(X,view);CHKERRQ(ierr);
}
/* Test BVNorm */
ierr = BVNormColumn(X,lx,NORM_2,&nrm);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"2-Norm or X[%D] = %g\n",lx,(double)nrm);CHKERRQ(ierr);
ierr = BVNorm(X,NORM_FROBENIUS,&nrm);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"Frobenius Norm or X = %g\n",(double)nrm);CHKERRQ(ierr);
ierr = BVDestroy(&X);CHKERRQ(ierr);
ierr = BVDestroy(&Y);CHKERRQ(ierr);
ierr = MatDestroy(&Q);CHKERRQ(ierr);
ierr = MatDestroy(&M);CHKERRQ(ierr);
ierr = VecDestroy(&t);CHKERRQ(ierr);
ierr = SlepcFinalize();
return 0;
}