int test_mesh3d_loader(char *file_name) { _F_ Mesh mesh; Mesh3DReader mloader; if (mloader.load(file_name, &mesh)) { mesh.dump(); return ERROR_SUCCESS; } else { printf("failed\n"); return ERROR_FAILURE; } }
int main(int argc, char **argv) { // Load the mesh. Mesh mesh; Mesh3DReader mloader; mloader.load("lshape_hex.mesh3d", &mesh); // rough surface handler roughSurface r1 ; r1.setFilneName(std::string("1.surf")) ; r1.loadSurface() ; r1.findMinMax(); columnList myCols ; bool further =true ; for(int iter=0 ; iter < 16 && further == true ; iter++) { std::cout << "Performing Refinement Level: " << iter << std::endl ; further = false ; for ( Word_t idx = mesh.elements.first(), _max = mesh.elements.count(); idx <= _max && idx != INVALID_IDX; idx = mesh.elements.next(idx) ) if ( mesh.elements[idx]->used) if (mesh.elements[idx]->active) { std::vector<Word_t> vtcs(mesh.elements[idx]->get_num_vertices()) ; //Word_t vtcs[mesh.elements[idx]->get_num_vertices()] ; mesh.elements[idx]->get_vertices(&vtcs[0]) ; //mesh.vertices[vtcs[0]]->dump() ; double minX=+std::numeric_limits<double>::max() ; double maxX=-std::numeric_limits<double>::max() ; double minY=+std::numeric_limits<double>::max() ; double maxY=-std::numeric_limits<double>::max() ; double minZ=+std::numeric_limits<double>::max() ; double maxZ=-std::numeric_limits<double>::max() ; for( int i=0 ; i<vtcs.size() ; i++) { double x = mesh.vertices[vtcs[i]]->x ; double y = mesh.vertices[vtcs[i]]->y ; if(minX > x) minX = x ; if(maxX < x) maxX = x ; if(minY > y) minY = y ; if(maxY < y) maxY = y ; } double sX = 0.05e-6; double sY = 0.05e-6; double deltaX = (maxX-minX) ; double deltaY = (maxY-minY) ; int nX = (int)floor(deltaX/sX) ; int nY = (int)floor(deltaY/sY) ; for( int u=0 ; u<=nX ; u++) for( int u=0 ; u<nY ; u++) { double x = minX + u*sX ; double y = minY + u*sY ; double z = r1.interpolate(x, y) ; if(minZ > z) minZ = z ; if(maxZ < z) maxZ = z ; } myCols[corner(minX,minY)].elements.insert(idx) ; myCols[corner(minX,minY)].lo = minZ ; myCols[corner(minX,minY)].hi = maxZ ; double deltaZ = std::abs(maxZ - minZ) ; if( deltaZ > 2.e-6) { //std::cout << "\n Iter., element, A.R., deltaZ: " << iter << " " << idx << " " << 2.*3.e-6/deltaX << " " << deltaZ ; if(mesh.can_refine_element(idx, H3D_H3D_REFT_HEX_XY)) mesh.refine_element(idx, H3D_H3D_REFT_HEX_XY) ; further = true ; } //mesh.elements[idx]->dump() ; } } //for ( Word_t idx = mesh.vertices.first(), _max = mesh.vertices.count(); idx <= _max && idx != INVALID_IDX; idx = mesh.vertices.next(idx) ) //if( std::abs(mesh.vertices[idx]->z - 0.) < 1e-32 ) mesh.vertices[idx]->z = r1.interpolate(mesh.vertices[idx]->x,mesh.vertices[idx]->y) ; for ( Word_t idx = mesh.elements.first(), _max = mesh.elements.count(); idx <= _max && idx != INVALID_IDX; idx = mesh.elements.next(idx) ) if ( mesh.elements[idx]->used) if (mesh.elements[idx]->active) { std::vector<Word_t> vtcs(mesh.elements[idx]->get_num_vertices()) ; mesh.elements[idx]->get_vertices(&vtcs[0]) ; double minZ=+std::numeric_limits<double>::max() ; double maxZ=-std::numeric_limits<double>::max() ; double deltaZ=-std::numeric_limits<double>::max() ; for(std::vector<Word_t>::iterator i=vtcs.begin() ; i!=vtcs.end() ; i++) { double z = mesh.vertices[*i]->z ; if(minZ > z) minZ = z ; if(maxZ < z) maxZ = z ; deltaZ = std::abs(maxZ - minZ) ; } //std::cout << std::endl ; if(deltaZ > 6e-6) { if( mesh.can_refine_element(idx, H3D_REFT_HEX_Z) ) mesh.refine_element(idx, H3D_REFT_HEX_Z) ; //else if( mesh.can_refine_element(idx, H3D_H3D_H3D_REFT_HEX_XYZ) ) mesh.refine_element(idx, H3D_H3D_H3D_REFT_HEX_XYZ) ; } } //mesh.refine_element(172, H3D_REFT_HEX_Z); //mesh.refine_all_elements(H3D_H3D_H3D_REFT_HEX_XYZ); //mesh.refine_all_elements(H3D_REFT_HEX_Z); //mesh.refine_element(4,H3D_H3D_H3D_REFT_HEX_XYZ); out_mesh(&mesh, "mesh"); return 0; }
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); TRACE_START("trace.txt"); DEBUG_OUTPUT_ON; SET_VERBOSE_LEVEL(0); 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 mloader; if (!mloader.load(args[1], &mesh)) error("Loading mesh file '%s'\n", args[1]); H1ShapesetLobattoHex shapeset; printf("* Setting the space up\n"); H1Space space(&mesh, &shapeset); space.set_bc_types(bc_types); int mx = maxn(4, m, n, o, 4); order3_t order(mx, mx, mx); // order3_t order(1, 1, 1); // order3_t order(m, n, o); printf(" - Setting uniform order to (%d, %d, %d)\n", mx, mx, mx); space.set_uniform_order(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_t, ord_t>, SYM); wf.add_vector_form(linear_form<double, scalar>, linear_form<ord_t, ord_t>); wf.add_vector_form_surf(linear_form_surf<double, scalar>, linear_form_surf<ord_t, ord_t>); LinearProblem lp(&wf, &space); // assemble stiffness matrix printf(" - assembling...\n"); 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) { 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]); // } 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 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 TRACE_END; return res; }
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 < 5) error("Not enough parameters."); H1ShapesetLobattoHex shapeset; printf("* Loading mesh '%s'\n", argv[1]); Mesh mesh; Mesh3DReader mloader; if (!mloader.load(argv[1], &mesh)) error("Loading mesh file '%s'\n", argv[1]); 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 o[3] = { 0, 0, 0 }; sscanf(argv[2], "%d", o + 0); sscanf(argv[3], "%d", o + 1); sscanf(argv[4], "%d", o + 2); order3_t order(o[0], o[1], o[2]); printf(" - Setting uniform order to (%d, %d, %d)\n", order.x, order.y, order.z); space.set_uniform_order(order); WeakForm wf; wf.add_matrix_form(bilinear_form<double, scalar>, bilinear_form<ord_t, ord_t>, SYM, ANY); wf.add_vector_form(linear_form<double, scalar>, linear_form<ord_t, ord_t>, ANY); LinearProblem lp(&wf); lp.set_space(&space); bool done = false; int iter = 0; do { Timer assemble_timer("Assembling stiffness matrix"); Timer solve_timer("Solving stiffness matrix"); printf("\n=== Iter #%d ================================================================\n", iter); printf("\nSolution\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 int ndofs = space.assign_dofs(); printf(" - Number of DOFs: %d\n", ndofs); // assemble stiffness matrix printf(" - Assembling... "); fflush(stdout); assemble_timer.reset(); assemble_timer.start(); lp.assemble(&mat, &rhs); assemble_timer.stop(); printf("done in %s (%lf secs)\n", assemble_timer.get_human_time(), assemble_timer.get_seconds()); // solve the stiffness matrix printf(" - Solving... "); fflush(stdout); solve_timer.reset(); solve_timer.start(); bool solved = solver.solve(); solve_timer.stop(); if (solved) printf("done in %s (%lf secs)\n", solve_timer.get_human_time(), solve_timer.get_seconds()); else { res = ERR_FAILURE; printf("failed\n"); break; } printf("Reference solution\n"); #if defined WITH_UMFPACK UMFPackLinearSolver rsolver(&mat, &rhs); #elif defined WITH_PARDISO PardisoLinearSolver rsolver(&mat, &rhs); #elif defined WITH_PETSC PetscLinearSolver rsolver(&mat, &rhs); #elif defined WITH_MUMPS MumpsSolver rsolver(&mat, &rhs); #endif Mesh rmesh; rmesh.copy(mesh); rmesh.refine_all_elements(H3D_H3D_H3D_REFT_HEX_XYZ); Space *rspace = space.dup(&rmesh); rspace->copy_orders(space, 1); LinearProblem rlp(&wf); rlp.set_space(rspace); int rndofs = rspace->assign_dofs(); printf(" - Number of DOFs: %d\n", rndofs); printf(" - Assembling... "); fflush(stdout); assemble_timer.reset(); assemble_timer.start(); rlp.assemble(&mat, &rhs); assemble_timer.stop(); printf("done in %s (%lf secs)\n", assemble_timer.get_human_time(), assemble_timer.get_seconds()); printf(" - Solving... "); fflush(stdout); solve_timer.reset(); solve_timer.start(); bool rsolved = rsolver.solve(); solve_timer.stop(); if (rsolved) printf("done in %s (%lf secs)\n", solve_timer.get_human_time(), solve_timer.get_seconds()); else { res = ERR_FAILURE; printf("failed\n"); break; } Solution sln(&mesh); sln.set_coeff_vector(&space, solver.get_solution()); Solution rsln(&rmesh); rsln.set_coeff_vector(rspace, rsolver.get_solution()); printf("Adaptivity:\n"); H1Adapt hp(&space); double tol = hp.calc_error(&sln, &rsln) * 100; printf(" - tolerance: "); fflush(stdout); printf("% lf\n", tol); if (tol < TOLERANCE) { printf("\nDone\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; } break; } Timer t(""); printf(" - adapting... "); fflush(stdout); t.start(); hp.adapt(THRESHOLD); t.stop(); printf("done in %lf secs (refined %d element(s))\n", t.get_seconds(), hp.get_num_refined_elements()); iter++; } while (!done); #ifdef WITH_PETSC PetscFinalize(); #endif return res; }
/*********************************************************************************** * main program * ***********************************************************************************/ int main(int argc, char **argv) { #ifdef WITH_PETSC PetscInitialize(&argc, &argv, (char *) PETSC_NULL, PETSC_NULL); PetscPushErrorHandler(PetscIgnoreErrorHandler, PETSC_NULL); // Disable PETSc error handler. #endif // Load the initial mesh. Mesh mesh; Mesh3DReader mloader; mloader.load("l-beam.mesh3d", &mesh); // Initial uniform mesh refinements. printf("Performing %d initial mesh refinements.\n", INIT_REF_NUM); for (int i=0; i < INIT_REF_NUM; i++) mesh.refine_all_elements(H3D_H3D_H3D_REFT_HEX_XYZ); Word_t (nelem) = mesh.get_num_elements(); printf("New number of elements is %d.\n", (int) nelem); // Initialize the shapeset and the cache. H1ShapesetLobattoHex shapeset; #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 // Create H1 spaces x-displacement component. H1Space xdisp(&mesh, &shapeset); xdisp.set_bc_types(bc_types_x); xdisp.set_uniform_order(order3_t(P_INIT, P_INIT, P_INIT)); // Create H1 spaces y-displacement component. H1Space ydisp(&mesh, &shapeset); ydisp.set_bc_types(bc_types_y); ydisp.set_uniform_order(order3_t(P_INIT, P_INIT, P_INIT)); // Create H1 spaces z-displacement component. H1Space zdisp(&mesh, &shapeset); zdisp.set_bc_types(bc_types_z); zdisp.set_uniform_order(order3_t(P_INIT, P_INIT, P_INIT)); // Assign DOF. int ndofs = 0; ndofs += xdisp.assign_dofs(ndofs); ndofs += ydisp.assign_dofs(ndofs); ndofs += zdisp.assign_dofs(ndofs); printf(" - Number of DOFs: %d\n", ndofs); // Initialized the Weak formulation. WeakForm wf(3); wf.add_matrix_form(0, 0, bilinear_form_0_0<double, scalar>, bilinear_form_0_0<ord_t, ord_t>, SYM); wf.add_matrix_form(0, 1, bilinear_form_0_1<double, scalar>, bilinear_form_0_1<ord_t, ord_t>, SYM); wf.add_matrix_form(0, 2, bilinear_form_0_2<double, scalar>, bilinear_form_0_2<ord_t, ord_t>, SYM); wf.add_vector_form_surf(0, surf_linear_form_0<double, scalar>, surf_linear_form_0<ord_t, ord_t>); wf.add_matrix_form(1, 1, bilinear_form_1_1<double, scalar>, bilinear_form_1_1<ord_t, ord_t>, SYM); wf.add_matrix_form(1, 2, bilinear_form_1_2<double, scalar>, bilinear_form_1_2<ord_t, ord_t>, SYM); wf.add_vector_form_surf(1, surf_linear_form_1<double, scalar>, surf_linear_form_1<ord_t, ord_t>); wf.add_matrix_form(2, 2, bilinear_form_2_2<double, scalar>, bilinear_form_2_2<ord_t, ord_t>, SYM); wf.add_vector_form_surf(2, surf_linear_form_2<double, scalar>, surf_linear_form_2<ord_t, ord_t>, 5); // Initialize the mesh problem. LinearProblem lp(&wf); lp.set_spaces(Tuple<Space *>(&xdisp, &ydisp, &zdisp)); // Assemble stiffness matrix printf(" - Assembling... "); fflush(stdout); Timer tmr_assemble; tmr_assemble.start(); bool assembled = lp.assemble(&mat, &rhs); tmr_assemble.stop(); if (assembled) printf("done in %s (%lf secs)\n", tmr_assemble.get_human_time(), tmr_assemble.get_seconds()); else error("failed!"); // Solve the stiffness matrix. printf(" - Solving... "); fflush(stdout); Timer tmr_solve; tmr_solve.start(); bool solved = solver.solve(); tmr_solve.stop(); if (solved) printf("done in %s (%lf secs)\n", tmr_solve.get_human_time(), tmr_solve.get_seconds()); else { printf("failed\n"); } // Construct a solution. double *s = solver.get_solution(); Solution xsln(&mesh), ysln(&mesh), zsln(&mesh); xsln.set_fe_solution(&xdisp, s); ysln.set_fe_solution(&ydisp, s); zsln.set_fe_solution(&zdisp, s); // Output the solutions. printf(" - Output... "); fflush(stdout); out_fn(&xsln, &ysln, &zsln, "disp"); printf("done\n"); #ifdef WITH_PETSC mat.free(); rhs.free(); PetscFinalize(); #endif return 1; }
int main(int argc, char *argv[]) { _F_ int ret = ERROR_SUCCESS; if (argc < 3) { fprintf(stderr, "ERROR: not enough parameters\n"); return ERR_FAILURE; } if (strcmp(argv[1], "h1") != 0 && strcmp(argv[1], "h1-ipol")) { fprintf(stderr, "ERROR: unknown type of the projection\n"); return ERR_FAILURE; } #ifdef WITH_PETSC PetscInitialize(NULL, NULL, (char *) PETSC_NULL, PETSC_NULL); #endif set_verbose(false); H1ShapesetLobattoHex shapeset; Mesh mesh; Mesh3DReader mloader; if (!mloader.load(argv[2], &mesh)) { fprintf(stderr, "ERROR: loading mesh file '%s'\n", argv[2]); return ERR_FAILURE; } #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 Word_t ne = mesh.elements.count(); // make the mesh for the ref. solution mesh.refine_all_elements(H3D_H3D_H3D_REFT_HEX_XYZ); H1Space space(&mesh, &shapeset); space.set_bc_types(bc_types); space.set_essential_bc_values(essential_bc_values); #if defined X2_Y2_Z2 order3_t o(2, 2, 2); #elif defined X3_Y3_Z3 order3_t o(3, 3, 3); #elif defined XN_YM_ZO order3_t o(2, 3, 4); #endif space.set_uniform_order(o); WeakForm wf; wf.add_matrix_form(bilinear_form<double, scalar>, bilinear_form<ord_t, ord_t>, SYM, ANY); wf.add_vector_form(linear_form<double, scalar>, linear_form<ord_t, ord_t>, ANY); LinearProblem lp(&wf, &space); space.assign_dofs(); // assemble the stiffness matrix lp.assemble(&mat, &rhs); // solve the stiffness matrix solver.solve(); Solution sln(&mesh); sln.set_coeff_vector(&space, solver.get_solution()); for (Word_t idx = mesh.elements.first(); idx <= ne; idx = mesh.elements.next(idx)) { Element *e = mesh.elements[idx]; order3_t order(4, 4, 4); double error; Projection *proj; if (strcmp(argv[1], "h1") == 0) proj = new H1Projection(&sln, e, &shapeset); else if (strcmp(argv[1], "h1-ipol") == 0) proj = new H1ProjectionIpol(&sln, e, &shapeset); else return ERR_FAILURE; // error = 0.0; error += proj->get_error(H3D_REFT_HEX_NONE, -1, order); error = sqrt(error); CHECK_ERROR; // error = 0.0; error += proj->get_error(H3D_REFT_HEX_X, 20, order); error += proj->get_error(H3D_REFT_HEX_X, 21, order); error = sqrt(error); CHECK_ERROR; // error = 0.0; error += proj->get_error(H3D_REFT_HEX_Y, 22, order); error += proj->get_error(H3D_REFT_HEX_Y, 23, order); error = sqrt(error); CHECK_ERROR; // error = 0.0; error += proj->get_error(H3D_REFT_HEX_Z, 24, order); error += proj->get_error(H3D_REFT_HEX_Z, 25, order); error = sqrt(error); CHECK_ERROR; // error = 0.0; error += proj->get_error(H3D_H3D_REFT_HEX_XY, 8, order); error += proj->get_error(H3D_H3D_REFT_HEX_XY, 9, order); error += proj->get_error(H3D_H3D_REFT_HEX_XY, 10, order); error += proj->get_error(H3D_H3D_REFT_HEX_XY, 11, order); error = sqrt(error); CHECK_ERROR; // error = 0.0; error += proj->get_error(H3D_H3D_REFT_HEX_XZ, 12, order); error += proj->get_error(H3D_H3D_REFT_HEX_XZ, 13, order); error += proj->get_error(H3D_H3D_REFT_HEX_XZ, 14, order); error += proj->get_error(H3D_H3D_REFT_HEX_XZ, 15, order); error = sqrt(error); CHECK_ERROR; // error = 0.0; error += proj->get_error(H3D_H3D_REFT_HEX_YZ, 16, order); error += proj->get_error(H3D_H3D_REFT_HEX_YZ, 17, order); error += proj->get_error(H3D_H3D_REFT_HEX_YZ, 18, order); error += proj->get_error(H3D_H3D_REFT_HEX_YZ, 19, order); error = sqrt(error); CHECK_ERROR; // error = 0.0; for (int j = 0; j < 8; j++) error += proj->get_error(H3D_H3D_H3D_REFT_HEX_XYZ, j, order); error = sqrt(error); CHECK_ERROR; delete proj; } #ifdef WITH_PETSC PetscFinalize(); #endif return ret; }