int main(int argc, char **argv) {
int res = ERR_SUCCESS;
#ifdef WITH_PETSC
PetscInitialize(&argc, &argv, (char *) PETSC_NULL, PETSC_NULL);
#endif
set_verbose(false);
if (argc < 3) error("Not enough parameters");
printf("* Loading mesh '%s'\n", argv[1]);
Mesh mesh;
H3DReader mesh_loader;
if (!mesh_loader.load(argv[1], &mesh)) error("Loading mesh file '%s'\n", argv[1]);
int o;
sscanf(argv[2], "%d", &o);
printf(" - Setting uniform order to %d\n", o);
printf("* Setting the space up\n");
H1Space space(&mesh, bc_types, essential_bc_values, o);
int ndofs = space.assign_dofs();
printf(" - Number of DOFs: %d\n", ndofs);
printf("* Calculating a solution\n");
#if defined WITH_UMFPACK
UMFPackMatrix mat;
UMFPackVector rhs;
UMFPackLinearSolver solver(&mat, &rhs);
#elif defined WITH_PARDISO
PardisoMatrix mat;
PardisoVector rhs;
PardisoLinearSolver solver(&mat, &rhs);
#elif defined WITH_PETSC
PetscMatrix mat;
PetscVector rhs;
PetscLinearSolver solver(&mat, &rhs);
#elif defined WITH_MUMPS
MumpsMatrix mat;
MumpsVector rhs;
MumpsSolver solver(&mat, &rhs);
#endif
WeakForm wf;
wf.add_matrix_form(bilinear_form<double, scalar>, bilinear_form<Ord, Ord>, SYM);
wf.add_vector_form(linear_form<double, scalar>, linear_form<Ord, Ord>);
DiscreteProblem dp(&wf, &space, true);
// assemble stiffness matrix
Timer assemble_timer("Assembling stiffness matrix");
assemble_timer.start();
dp.assemble(&mat, &rhs);
assemble_timer.stop();
// solve the stiffness matrix
Timer solve_timer("Solving stiffness matrix");
solve_timer.start();
bool solved = solver.solve();
solve_timer.stop();
// output the measured values
printf("%s: %s (%lf secs)\n", assemble_timer.get_name(), assemble_timer.get_human_time(), assemble_timer.get_seconds());
printf("%s: %s (%lf secs)\n", solve_timer.get_name(), solve_timer.get_human_time(), solve_timer.get_seconds());
if (solved) {
Solution sln(&mesh);
sln.set_coeff_vector(&space, solver.get_solution());
ExactSolution ex_sln(&mesh, exact_solution);
// norm
double h1_sln_norm = h1_norm(&sln);
double h1_err_norm = h1_error(&sln, &ex_sln);
printf(" - H1 solution norm: % le\n", h1_sln_norm);
printf(" - H1 error norm: % le\n", h1_err_norm);
double l2_sln_norm = l2_norm(&sln);
double l2_err_norm = l2_error(&sln, &ex_sln);
printf(" - L2 solution norm: % le\n", l2_sln_norm);
printf(" - L2 error norm: % le\n", l2_err_norm);
if (h1_err_norm > EPS || l2_err_norm > EPS) {
// calculated solution is not enough precise
res = ERR_FAILURE;
}
#if 0 //def OUTPUT_DIR
// output
const char *of_name = OUTPUT_DIR "/solution.pos";
FILE *ofile = fopen(of_name, "w");
if (ofile != NULL) {
ExactSolution ex_sln(&mesh, exact_solution);
DiffFilter eh(&sln, &ex_sln);
// DiffFilter eh_dx(&mesh, &sln, &ex_sln, FN_DX, FN_DX);
// DiffFilter eh_dy(&mesh, &sln, &ex_sln, FN_DY, FN_DY);
// DiffFilter eh_dz(&mesh, &sln, &ex_sln, FN_DZ, FN_DZ);
GmshOutputEngine output(ofile);
output.out(&sln, "Uh");
// output.out(&sln, "Uh dx", FN_DX_0);
// output.out(&sln, "Uh dy", FN_DY_0);
// output.out(&sln, "Uh dz", FN_DZ_0);
output.out(&eh, "Eh");
// output.out(&eh_dx, "Eh dx");
// output.out(&eh_dy, "Eh dy");
// output.out(&eh_dz, "Eh dz");
output.out(&ex_sln, "U");
// output.out(&ex_sln, "U dx", FN_DX_0);
// output.out(&ex_sln, "U dy", FN_DY_0);
// output.out(&ex_sln, "U dz", FN_DZ_0);
fclose(ofile);
}
else {
warning("Can not open '%s' for writing.", of_name);
}
#endif
}
#ifdef WITH_PETSC
mat.free();
rhs.free();
PetscFinalize();
#endif
TRACE_END;
return res;
}
int main(int argc, char **args) {
int res = ERR_SUCCESS;
#ifdef WITH_PETSC
PetscInitialize(&argc, &args, (char *) PETSC_NULL, PETSC_NULL);
#endif
set_verbose(false);
if (argc < 5) error("Not enough parameters");
sscanf(args[2], "%d", &m);
sscanf(args[3], "%d", &n);
sscanf(args[4], "%d", &o);
printf("* Loading mesh '%s'\n", args[1]);
Mesh mesh;
H3DReader mesh_loader;
if (!mesh_loader.load(args[1], &mesh)) error("Loading mesh file '%s'\n", args[1]);
H1ShapesetLobattoHex shapeset;
printf("* Setting the space up\n");
int mx = maxn(4, m, n, o, 4);
Ord3 order(mx, mx, mx);
// Ord3 order(1, 1, 1);
printf(" - Setting uniform order to (%d, %d, %d)\n", mx, mx, mx);
H1Space space(&mesh, bc_types, NULL, order);
int ndofs = space.assign_dofs();
printf(" - Number of DOFs: %d\n", ndofs);
printf("* Calculating a solution\n");
#if defined WITH_UMFPACK
UMFPackMatrix mat;
UMFPackVector rhs;
UMFPackLinearSolver solver(&mat, &rhs);
#elif defined WITH_PARDISO
PardisoMatrix mat;
PardisoVector rhs;
PardisoLinearSolver solver(&mat, &rhs);
#elif defined WITH_PETSC
PetscMatrix mat;
PetscVector rhs;
PetscLinearSolver solver(&mat, &rhs);
#elif defined WITH_MUMPS
MumpsMatrix mat;
MumpsVector rhs;
MumpsSolver solver(&mat, &rhs);
#endif
WeakForm wf;
wf.add_matrix_form(bilinear_form<double, scalar>, bilinear_form<Ord, Ord>, SYM);
wf.add_matrix_form_surf(bilinear_form_surf<double, scalar>, bilinear_form_surf<Ord, Ord>);
wf.add_vector_form(linear_form<double, scalar>, linear_form<Ord, Ord>);
wf.add_vector_form_surf(linear_form_surf<double, scalar>, linear_form_surf<Ord, Ord>);
DiscreteProblem dp(&wf, &space, true);
// assemble stiffness matrix
printf(" - assembling... "); fflush(stdout);
Timer assemble_timer;
assemble_timer.start();
dp.assemble(&mat, &rhs);
assemble_timer.stop();
printf("%s (%lf secs)\n", assemble_timer.get_human_time(), assemble_timer.get_seconds());
// solve the stiffness matrix
printf(" - solving... "); fflush(stdout);
Timer solve_timer;
solve_timer.start();
bool solved = solver.solve();
solve_timer.stop();
printf("%s (%lf secs)\n", solve_timer.get_human_time(), solve_timer.get_seconds());
// mat.dump(stdout, "a");
// rhs.dump(stdout, "b");
if (solved) {
Solution sln(&mesh);
sln.set_coeff_vector(&space, solver.get_solution());
printf("* Solution:\n");
// double *s = solver.get_solution();
// for (int i = 1; i <= ndofs; i++) {
// printf(" x[% 3d] = % lf\n", i, s[i]);
// }
// norm
ExactSolution ex_sln(&mesh, exact_solution);
double h1_sln_norm = h1_norm(&sln);
double h1_err_norm = h1_error(&sln, &ex_sln);
printf(" - H1 solution norm: % le\n", h1_sln_norm);
printf(" - H1 error norm: % le\n", h1_err_norm);
double l2_sln_norm = l2_norm(&sln);
double l2_err_norm = l2_error(&sln, &ex_sln);
printf(" - L2 solution norm: % le\n", l2_sln_norm);
printf(" - L2 error norm: % le\n", l2_err_norm);
if (h1_err_norm > EPS || l2_err_norm > EPS) {
// calculated solution is not enough precise
res = ERR_FAILURE;
}
#ifdef OUTPUT_DIR
printf("* Output\n");
// output
const char *of_name = OUTPUT_DIR "/solution.pos";
FILE *ofile = fopen(of_name, "w");
if (ofile != NULL) {
ExactSolution ex_sln(&mesh, exact_solution);
// DiffFilter eh(&sln, &ex_sln);
// DiffFilter eh_dx(mesh, &sln, &ex_sln, FN_DX, FN_DX);
// DiffFilter eh_dy(mesh, &sln, &ex_sln, FN_DY, FN_DY);
// DiffFilter eh_dz(mesh, &sln, &ex_sln, FN_DZ, FN_DZ);
GmshOutputEngine output(ofile);
output.out(&sln, "Uh");
// output.out(&sln, "Uh dx", FN_DX_0);
// output.out(&sln, "Uh dy", FN_DY_0);
// output.out(&sln, "Uh dz", FN_DZ_0);
// output.out(&eh, "Eh");
// output.out(&eh_dx, "Eh dx");
// output.out(&eh_dy, "Eh dy");
// output.out(&eh_dz, "Eh dz");
output.out(&ex_sln, "U");
// output.out(&ex_sln, "U dx", FN_DX_0);
// output.out(&ex_sln, "U dy", FN_DY_0);
// output.out(&ex_sln, "U dz", FN_DZ_0);
fclose(ofile);
}
else {
warning("Can not open '%s' for writing.", of_name);
}
#endif
}
else
res = ERR_FAILURE;
#ifdef WITH_PETSC
mat.free();
rhs.free();
PetscFinalize();
#endif
return res;
}
int main(int argc, char **args) {
int res = ERR_SUCCESS;
#ifdef WITH_PETSC
PetscInitialize(&argc, &args, (char *) PETSC_NULL, PETSC_NULL);
#endif
set_verbose(false);
if (argc < 5) error("Not enough parameters");
sscanf(args[2], "%d", &m);
sscanf(args[3], "%d", &n);
sscanf(args[4], "%d", &o);
printf("* Loading mesh '%s'\n", args[1]);
Mesh mesh;
Mesh3DReader mesh_loader;
if (!mesh_loader.load(args[1], &mesh)) error("Loading mesh file '%s'\n", args[1]);
// for (int it = 0; it < 8; it++) {
// mesh.refine_all_elements(H3D_H3D_H3D_REFT_HEX_XYZ);
// mesh.refine_all_elements(H3D_H3D_H3D_REFT_HEX_XYZ);
// mesh.refine_all_elements(H3D_H3D_H3D_REFT_HEX_XYZ);
H1ShapesetLobattoHex shapeset;
// printf("* Setting the space up\n");
H1Space space(&mesh, &shapeset);
space.set_bc_types(bc_types);
space.set_essential_bc_values(essential_bc_values);
int mx = maxn(4, m, n, o, 4);
order3_t order(mx, mx, mx);
// order3_t order(3, 3, 4);
printf(" - Setting uniform order to (%d, %d, %d)\n", order.x, order.y, order.z);
space.set_uniform_order(order);
int ndofs = space.assign_dofs();
printf(" - Number of DOFs: %d\n", ndofs);
// printf("elems: %d ", mesh.get_num_active_elements()); fflush(stdout);
printf("* Calculating a solution\n");
#if defined WITH_UMFPACK
UMFPackMatrix mat;
UMFPackVector rhs;
UMFPackLinearSolver solver(&mat, &rhs);
#elif defined WITH_PARDISO
PardisoMatrix mat;
PardisoVector rhs;
PardisoLinearSolver solver(&mat, &rhs);
#elif defined WITH_PETSC
PetscMatrix mat;
PetscVector rhs;
PetscLinearSolver solver(&mat, &rhs);
#elif defined WITH_MUMPS
MumpsMatrix mat;
MumpsVector rhs;
MumpsSolver solver(&mat, &rhs);
#endif
WeakForm wf;
wf.add_matrix_form(bilinear_form<double, scalar>, bilinear_form<ord_t, ord_t>, SYM);
wf.add_vector_form(linear_form<double, scalar>, linear_form<ord_t, ord_t>);
LinearProblem lp(&wf);
lp.set_space(&space);
// assemble stiffness matrix
printf(" - assembling... "); fflush(stdout);
Timer assemble_timer;
assemble_timer.start();
lp.assemble(&mat, &rhs);
assemble_timer.stop();
printf("%s (%lf secs)\n", assemble_timer.get_human_time(), assemble_timer.get_seconds());
// solve the stiffness matrix
printf(" - solving... "); fflush(stdout);
Timer solve_timer;
solve_timer.start();
bool solved = solver.solve();
solve_timer.stop();
printf("%s (%lf secs)\n", solve_timer.get_human_time(), solve_timer.get_seconds());
// mat.dump(stdout, "a");
// rhs.dump(stdout, "b");
if (solved) {
Timer sln_pre_tmr;
Solution sln(&mesh);
sln_pre_tmr.start();
sln.set_fe_solution(&space, solver.get_solution());
sln_pre_tmr.stop();
printf("* Solution:\n");
ExactSolution ex_sln(&mesh, exact_solution);
// norm
double h1_sln_norm = h1_norm(&sln);
double h1_err_norm = h1_error(&sln, &ex_sln);
printf(" - H1 solution norm: % le\n", h1_sln_norm);
printf(" - H1 error norm: % le\n", h1_err_norm);
double l2_sln_norm = l2_norm(&sln);
double l2_err_norm = l2_error(&sln, &ex_sln);
printf(" - L2 solution norm: % le\n", l2_sln_norm);
printf(" - L2 error norm: % le\n", l2_err_norm);
if (h1_err_norm > EPS || l2_err_norm > EPS) {
// calculated solution is not enough precise
res = ERR_FAILURE;
}
#ifdef OUTPUT_DIR
// printf("* Output\n");
// output
const char *of_name = OUTPUT_DIR "/solution.pos";
FILE *ofile = fopen(of_name, "w");
if (ofile != NULL) {
Timer sln_out_tmr;
sln_out_tmr.start();
ExactSolution ex_sln(&mesh, exact_solution);
DiffFilter eh(&sln, &ex_sln);
// DiffFilter eh_dx(&sln, &ex_sln, FN_DX, FN_DX);
// DiffFilter eh_dy(&sln, &ex_sln, FN_DY, FN_DY);
// DiffFilter eh_dz(&sln, &ex_sln, FN_DZ, FN_DZ);
GmshOutputEngine output(ofile);
output.out(&sln, "Uh", FN_VAL_0);
// output.out(&sln, "Uh dx", FN_DX_0);
// output.out(&sln, "Uh dy", FN_DY_0);
// output.out(&sln, "Uh dz", FN_DZ_0);
// output.out(&eh, "Eh");
// output.out(&eh_dx, "Eh dx");
// output.out(&eh_dy, "Eh dy");
// output.out(&eh_dz, "Eh dz");
output.out(&ex_sln, "U");
// output.out(&ex_sln, "U dx", FN_DX_0);
// output.out(&ex_sln, "U dy", FN_DY_0);
// output.out(&ex_sln, "U dz", FN_DZ_0);
sln_out_tmr.stop();
// printf(" | %s (%lf secs)", sln_pre_tmr.get_human_time(), sln_pre_tmr.get_seconds());
// printf(" | %s (%lf secs)\n", sln_out_tmr.get_human_time(), sln_out_tmr.get_seconds());
fclose(ofile);
}
else {
warning("Can not open '%s' for writing.", of_name);
}
#endif
}
else
res = ERR_FAILURE;
#ifdef WITH_PETSC
mat.free();
rhs.free();
PetscFinalize();
#endif
return res;
}
int main(int argc, char **args) {
int res = ERR_SUCCESS;
#ifdef WITH_PETSC
PetscInitialize(&argc, &args, (char *) PETSC_NULL, PETSC_NULL);
#endif
set_verbose(false);
if (argc < 2) error("Not enough parameters");
H1ShapesetLobattoHex shapeset;
printf("* Loading mesh '%s'\n", args[1]);
Mesh mesh;
H3DReader mesh_loader;
if (!mesh_loader.load(args[1], &mesh)) error("Loading mesh file '%s'\n", args[1]);
printf("* Setup space #1\n");
Ord3 o1(2, 2, 2);
printf(" - Setting uniform order to (%d, %d, %d)\n", o1.x, o1.y, o1.z);
H1Space space1(&mesh, bc_types, essential_bc_values, o1);
printf("* Setup space #2\n");
Ord3 o2(4, 4, 4);
H1Space space2(&mesh, bc_types, essential_bc_values, o2);
printf(" - Setting uniform order to (%d, %d, %d)\n", o2.x, o2.y, o2.z);
int ndofs = 0;
ndofs += space1.assign_dofs();
ndofs += space2.assign_dofs(ndofs);
printf(" - Number of DOFs: %d\n", ndofs);
printf("* Calculating a solution\n");
#if defined WITH_UMFPACK
UMFPackMatrix mat;
UMFPackVector rhs;
UMFPackLinearSolver solver(&mat, &rhs);
#elif defined WITH_PARDISO
PardisoMatrix mat;
PardisoVector rhs;
PardisoLinearSolver solver(&mat, &rhs);
#elif defined WITH_PETSC
PetscMatrix mat;
PetscVector rhs;
PetscLinearSolver solver(&mat, &rhs);
#elif defined WITH_MUMPS
MumpsMatrix mat;
MumpsVector rhs;
MumpsSolver solver(&mat, &rhs);
#endif
WeakForm wf(2);
wf.add_matrix_form(0, 0, bilinear_form_1<double, scalar>, bilinear_form_1<Ord, Ord>, SYM);
wf.add_vector_form(0, linear_form_1<double, scalar>, linear_form_1<Ord, Ord>);
wf.add_matrix_form(1, 1, bilinear_form_2<double, scalar>, bilinear_form_2<Ord, Ord>, SYM);
wf.add_vector_form(1, linear_form_2<double, scalar>, linear_form_2<Ord, Ord>);
DiscreteProblem lp(&wf, Tuple<Space *>(&space1, &space2), true);
// assemble stiffness matrix
Timer assemble_timer("Assembling stiffness matrix");
assemble_timer.start();
lp.assemble(&mat, &rhs);
assemble_timer.stop();
// solve the stiffness matrix
Timer solve_timer("Solving stiffness matrix");
solve_timer.start();
bool solved = solver.solve();
solve_timer.stop();
// output the measured values
printf("%s: %s (%lf secs)\n", assemble_timer.get_name(), assemble_timer.get_human_time(), assemble_timer.get_seconds());
printf("%s: %s (%lf secs)\n", solve_timer.get_name(), solve_timer.get_human_time(), solve_timer.get_seconds());
if (solved) {
// solution 1
Solution sln1(&mesh);
sln1.set_coeff_vector(&space1, solver.get_solution());
ExactSolution esln1(&mesh, exact_sln_fn_1);
// norm
double h1_sln_norm1 = h1_norm(&sln1);
double h1_err_norm1 = h1_error(&sln1, &esln1);
printf(" - H1 solution norm: % le\n", h1_sln_norm1);
printf(" - H1 error norm: % le\n", h1_err_norm1);
double l2_sln_norm1 = l2_norm(&sln1);
double l2_err_norm1 = l2_error(&sln1, &esln1);
printf(" - L2 solution norm: % le\n", l2_sln_norm1);
printf(" - L2 error norm: % le\n", l2_err_norm1);
if (h1_err_norm1 > EPS || l2_err_norm1 > EPS) {
// calculated solution is not enough precise
res = ERR_FAILURE;
}
// solution 2
Solution sln2(&mesh);
sln2.set_coeff_vector(&space2, solver.get_solution());
ExactSolution esln2(&mesh, exact_sln_fn_2);
// norm
double h1_sln_norm2 = h1_norm(&sln2);
double h1_err_norm2 = h1_error(&sln2, &esln2);
printf(" - H1 solution norm: % le\n", h1_sln_norm2);
printf(" - H1 error norm: % le\n", h1_err_norm2);
double l2_sln_norm2 = l2_norm(&sln2);
double l2_err_norm2 = l2_error(&sln2, &esln2);
printf(" - L2 solution norm: % le\n", l2_sln_norm2);
printf(" - L2 error norm: % le\n", l2_err_norm2);
if (h1_err_norm2 > EPS || l2_err_norm2 > EPS) {
// calculated solution is not enough precise
res = ERR_FAILURE;
}
#ifdef OUTPUT_DIR
// output
const char *of_name = OUTPUT_DIR "/solution.pos";
FILE *ofile = fopen(of_name, "w");
if (ofile != NULL) {
GmshOutputEngine output(ofile);
output.out(&sln1, "Uh_1");
output.out(&esln1, "U1");
output.out(&sln2, "Uh_2");
output.out(&esln2, "U2");
fclose(ofile);
}
else {
warning("Can not open '%s' for writing.", of_name);
}
#endif
}
#ifdef WITH_PETSC
mat.free();
rhs.free();
PetscFinalize();
#endif
TRACE_END;
return res;
}
