Actual source code: ex3.c

  1: static char help[] = "Bilinear elements on the unit square for Laplacian.  To test the parallel\n\
  2: matrix assembly, the matrix is intentionally laid out across processors\n\
  3: differently from the way it is assembled.  Input arguments are:\n\
  4:   -m <size> : problem size\n\n";

  6: /* Addendum: piggy-backing on this example to test KSPChebyshev methods */

  8: #include <petscksp.h>

 10: PetscErrorCode FormElementStiffness(PetscReal H, PetscScalar *Ke)
 11: {
 12:   PetscFunctionBeginUser;
 13:   Ke[0]  = H / 6.0;
 14:   Ke[1]  = -.125 * H;
 15:   Ke[2]  = H / 12.0;
 16:   Ke[3]  = -.125 * H;
 17:   Ke[4]  = -.125 * H;
 18:   Ke[5]  = H / 6.0;
 19:   Ke[6]  = -.125 * H;
 20:   Ke[7]  = H / 12.0;
 21:   Ke[8]  = H / 12.0;
 22:   Ke[9]  = -.125 * H;
 23:   Ke[10] = H / 6.0;
 24:   Ke[11] = -.125 * H;
 25:   Ke[12] = -.125 * H;
 26:   Ke[13] = H / 12.0;
 27:   Ke[14] = -.125 * H;
 28:   Ke[15] = H / 6.0;
 29:   PetscFunctionReturn(PETSC_SUCCESS);
 30: }

 32: PetscErrorCode FormElementRhs(PetscReal x, PetscReal y, PetscReal H, PetscScalar *r)
 33: {
 34:   PetscFunctionBeginUser;
 35:   r[0] = 0.;
 36:   r[1] = 0.;
 37:   r[2] = 0.;
 38:   r[3] = 0.0;
 39:   PetscFunctionReturn(PETSC_SUCCESS);
 40: }

 42: int main(int argc, char **args)
 43: {
 44:   Mat         C;
 45:   PetscMPIInt rank, size;
 46:   PetscInt    i, m = 5, N, start, end, M, its;
 47:   PetscScalar val, Ke[16], r[4];
 48:   PetscReal   x, y, h, norm;
 49:   PetscInt    idx[4], count, *rows;
 50:   Vec         u, ustar, b, build_sol;
 51:   KSP         ksp;
 52:   PetscBool   viewkspest = PETSC_FALSE, testbuildsolution = PETSC_FALSE, ishypre;
 53:   PC          pc;

 55:   PetscFunctionBeginUser;
 56:   PetscCall(PetscInitialize(&argc, &args, NULL, help));
 57:   PetscCall(PetscOptionsGetInt(NULL, NULL, "-m", &m, NULL));
 58:   PetscCall(PetscOptionsGetBool(NULL, NULL, "-ksp_est_view", &viewkspest, NULL));
 59:   PetscCall(PetscOptionsGetBool(NULL, NULL, "-test_build_solution", &testbuildsolution, NULL));
 60:   N = (m + 1) * (m + 1); /* dimension of matrix */
 61:   M = m * m;             /* number of elements */
 62:   h = 1.0 / m;           /* mesh width */
 63:   PetscCallMPI(MPI_Comm_rank(PETSC_COMM_WORLD, &rank));
 64:   PetscCallMPI(MPI_Comm_size(PETSC_COMM_WORLD, &size));

 66:   /* Create stiffness matrix */
 67:   PetscCall(MatCreate(PETSC_COMM_WORLD, &C));
 68:   PetscCall(MatSetSizes(C, PETSC_DECIDE, PETSC_DECIDE, N, N));
 69:   PetscCall(MatSetFromOptions(C));
 70:   PetscCall(MatSetUp(C));
 71:   start = rank * (M / size) + ((M % size) < rank ? (M % size) : rank);
 72:   end   = start + M / size + ((M % size) > rank);

 74:   /* Assemble matrix */
 75:   PetscCall(FormElementStiffness(h * h, Ke)); /* element stiffness for Laplacian */
 76:   for (i = start; i < end; i++) {
 77:     /* node numbers for the four corners of element */
 78:     idx[0] = (m + 1) * (i / m) + (i % m);
 79:     idx[1] = idx[0] + 1;
 80:     idx[2] = idx[1] + m + 1;
 81:     idx[3] = idx[2] - 1;
 82:     PetscCall(MatSetValues(C, 4, idx, 4, idx, Ke, ADD_VALUES));
 83:   }
 84:   PetscCall(MatAssemblyBegin(C, MAT_FINAL_ASSEMBLY));
 85:   PetscCall(MatAssemblyEnd(C, MAT_FINAL_ASSEMBLY));

 87:   /* Create right-hand side and solution vectors */
 88:   PetscCall(VecCreate(PETSC_COMM_WORLD, &u));
 89:   PetscCall(VecSetSizes(u, PETSC_DECIDE, N));
 90:   PetscCall(VecSetFromOptions(u));
 91:   PetscCall(PetscObjectSetName((PetscObject)u, "Approx. Solution"));
 92:   PetscCall(VecDuplicate(u, &b));
 93:   PetscCall(PetscObjectSetName((PetscObject)b, "Right hand side"));
 94:   PetscCall(VecDuplicate(b, &ustar));
 95:   PetscCall(VecSet(u, 0.0));
 96:   PetscCall(VecSet(b, 0.0));

 98:   /* Assemble right-hand-side vector */
 99:   for (i = start; i < end; i++) {
100:     /* location of lower left corner of element */
101:     x = h * (i % m);
102:     y = h * (i / m);
103:     /* node numbers for the four corners of element */
104:     idx[0] = (m + 1) * (i / m) + (i % m);
105:     idx[1] = idx[0] + 1;
106:     idx[2] = idx[1] + m + 1;
107:     idx[3] = idx[2] - 1;
108:     PetscCall(FormElementRhs(x, y, h * h, r));
109:     PetscCall(VecSetValues(b, 4, idx, r, ADD_VALUES));
110:   }
111:   PetscCall(VecAssemblyBegin(b));
112:   PetscCall(VecAssemblyEnd(b));

114:   /* Modify matrix and right-hand side for Dirichlet boundary conditions */
115:   PetscCall(PetscMalloc1(4 * m, &rows));
116:   for (i = 0; i < m + 1; i++) {
117:     rows[i]             = i;               /* bottom */
118:     rows[3 * m - 1 + i] = m * (m + 1) + i; /* top */
119:   }
120:   count = m + 1; /* left side */
121:   for (i = m + 1; i < m * (m + 1); i += m + 1) rows[count++] = i;

123:   count = 2 * m; /* left side */
124:   for (i = 2 * m + 1; i < m * (m + 1); i += m + 1) rows[count++] = i;
125:   for (i = 0; i < 4 * m; i++) {
126:     val = h * (rows[i] / (m + 1));
127:     PetscCall(VecSetValues(u, 1, &rows[i], &val, INSERT_VALUES));
128:     PetscCall(VecSetValues(b, 1, &rows[i], &val, INSERT_VALUES));
129:   }
130:   PetscCall(MatZeroRows(C, 4 * m, rows, 1.0, 0, 0));

132:   PetscCall(PetscFree(rows));
133:   PetscCall(VecAssemblyBegin(u));
134:   PetscCall(VecAssemblyEnd(u));
135:   PetscCall(VecAssemblyBegin(b));
136:   PetscCall(VecAssemblyEnd(b));

138:   {
139:     Mat A;
140:     PetscCall(MatConvert(C, MATSAME, MAT_INITIAL_MATRIX, &A));
141:     PetscCall(MatDestroy(&C));
142:     PetscCall(MatConvert(A, MATSAME, MAT_INITIAL_MATRIX, &C));
143:     PetscCall(MatDestroy(&A));
144:   }

146:   /* Solve linear system */
147:   PetscCall(KSPCreate(PETSC_COMM_WORLD, &ksp));
148:   PetscCall(KSPSetOperators(ksp, C, C));
149:   PetscCall(KSPSetFromOptions(ksp));
150:   PetscCall(KSPSetInitialGuessNonzero(ksp, PETSC_TRUE));

152:   /* verify that PCView_HYPRE() handles PETSC_DECIDE parameters correctly */
153:   PetscCall(KSPGetPC(ksp, &pc));
154:   PetscCall(PetscObjectTypeCompare((PetscObject)pc, PCHYPRE, &ishypre));
155:   if (ishypre) PetscCall(KSPView(ksp, PETSC_VIEWER_STDOUT_WORLD));

157:   PetscCall(KSPSolve(ksp, b, u));

159:   if (testbuildsolution) {
160:     PetscBool ok;

162:     PetscCall(VecDuplicate(u, &build_sol));
163:     PetscCall(KSPBuildSolution(ksp, build_sol, NULL));
164:     PetscCall(VecEqual(u, build_sol, &ok));
165:     PetscCheck(ok, PETSC_COMM_WORLD, PETSC_ERR_PLIB, "KSPBuildSolution() returned incorrect solution");
166:     PetscCall(VecDestroy(&build_sol));
167:   }

169:   if (viewkspest) {
170:     KSP kspest;

172:     PetscCall(KSPChebyshevEstEigGetKSP(ksp, &kspest));
173:     if (kspest) PetscCall(KSPView(kspest, PETSC_VIEWER_STDOUT_WORLD));
174:   }

176:   /* Check error */
177:   PetscCall(VecGetOwnershipRange(ustar, &start, &end));
178:   for (i = start; i < end; i++) {
179:     val = h * (i / (m + 1));
180:     PetscCall(VecSetValues(ustar, 1, &i, &val, INSERT_VALUES));
181:   }
182:   PetscCall(VecAssemblyBegin(ustar));
183:   PetscCall(VecAssemblyEnd(ustar));
184:   PetscCall(VecAXPY(u, -1.0, ustar));
185:   PetscCall(VecNorm(u, NORM_2, &norm));
186:   PetscCall(KSPGetIterationNumber(ksp, &its));
187:   PetscCall(PetscPrintf(PETSC_COMM_WORLD, "Norm of error %g Iterations %" PetscInt_FMT "\n", (double)(norm * h), its));

189:   /* Free work space */
190:   PetscCall(KSPDestroy(&ksp));
191:   PetscCall(VecDestroy(&ustar));
192:   PetscCall(VecDestroy(&u));
193:   PetscCall(VecDestroy(&b));
194:   PetscCall(MatDestroy(&C));
195:   PetscCall(PetscFinalize());
196:   return 0;
197: }

199: /*TEST

201:     test:
202:       args: -pc_type jacobi -ksp_monitor_short -m 5 -ksp_gmres_cgs_refinement_type refine_always

204:     test:
205:       suffix: 2
206:       nsize: 2
207:       args: -pc_type jacobi -ksp_monitor_short -m 5 -ksp_gmres_cgs_refinement_type refine_always

209:     test:
210:       suffix: 2_kokkos
211:       nsize: 2
212:       args: -vec_mdot_use_gemv {{0 1}} -vec_maxpy_use_gemv {{0 1}}
213:       args: -pc_type jacobi -ksp_monitor_short -m 5 -ksp_gmres_cgs_refinement_type refine_always -mat_type aijkokkos -vec_type kokkos
214:       output_file: output/ex3_2.out
215:       requires: kokkos_kernels

217:     test:
218:       suffix: nocheby
219:       args: -ksp_est_view

221:     test:
222:       suffix: chebynoest
223:       args: -ksp_est_view -ksp_type chebyshev -ksp_chebyshev_eigenvalues 0.1,1.0

225:     test:
226:       suffix: chebyest
227:       args: -ksp_est_view -ksp_type chebyshev -ksp_chebyshev_esteig
228:       filter:  sed -e "s/Iterations 19/Iterations 20/g"

230:     test:
231:       suffix: gamg_provided_not_ok
232:       filter: grep -v "variant HERMITIAN" | sed -e "s/Iterations 4/Iterations 5/g"
233:       args: -pc_type gamg -mg_levels_pc_type sor -mg_levels_esteig_ksp_type cg -ksp_view

235:     test:
236:       suffix: build_solution
237:       requires: !complex
238:       filter: grep -v Norm
239:       args: -ksp_type {{chebyshev cg groppcg pipecg pipecgrr pipelcg pipeprcg cgne nash stcg gltr fcg pipefcg gmres fgmres lgmres dgmres pgmres tcqmr bcgs ibcgs qmrcgs fbcgs fbcgsr bcgsl pipebcgs cgs tfqmr cr pipecr bicg minres lcd gcr cgls richardson}} -test_build_solution
240:       output_file: output/empty.out

242:     test:
243:       suffix: hypre
244:       requires: hypre
245:       args: -pc_type hypre

247: TEST*/