int
main(int argc, char **argv)
{
pmacrosurface3d mg;
psurface3d gr;
pamatrix Vfull, KMfull;
pbem3d bem_slp, bem_dlp;
pcluster root;
pblock block;
phmatrix V, KM;
pclusterbasis Vrb, Vcb, KMrb, KMcb;
ph2matrix V2, KM2;
uint n, q, clf, m, l;
real eta, delta, eps_aca;
field kvec[3];
cl_device_id *devices;
cl_uint ndevices;
uint *idx;
uint i;
init_h2lib(&argc, &argv);
get_opencl_devices(&devices, &ndevices);
ndevices = 1;
set_opencl_devices(devices, ndevices, 2);
kvec[0] = 2.0, kvec[1] = 0.0, kvec[2] = 0.0;
n = 512;
q = 2;
clf = 16;
eta = 1.0;
mg = new_sphere_macrosurface3d();
gr = build_from_macrosurface3d_surface3d(mg, REAL_SQRT(n * 0.125));
n = gr->triangles;
printf("Testing unit sphere with %d triangles\n", n);
bem_slp = new_slp_helmholtz_ocl_bem3d(kvec, gr, q, q + 2,
BASIS_CONSTANT_BEM3D);
bem_dlp = new_dlp_helmholtz_ocl_bem3d(kvec, gr, q, q + 2,
BASIS_CONSTANT_BEM3D,
BASIS_CONSTANT_BEM3D, 0.5);
root = build_bem3d_cluster(bem_slp, clf, BASIS_CONSTANT_BEM3D);
block = build_nonstrict_block(root, root, &eta, admissible_max_cluster);
max_pardepth = 0;
Vfull = new_amatrix(n, n);
KMfull = new_amatrix(n, n);
idx = allocuint(n);
for (i = 0; i < n; ++i) {
idx[i] = i;
}
SCHEDULE_OPENCL(0, 1, bem_slp->nearfield, idx, idx, bem_slp, false, Vfull);
SCHEDULE_OPENCL(0, 1, bem_dlp->nearfield, idx, idx, bem_dlp, false, KMfull);
V = build_from_block_hmatrix(block, 0);
KM = build_from_block_hmatrix(block, 0);
printf("----------------------------------------\n");
printf("Testing outer Boundary integral equations:\n");
printf("----------------------------------------\n\n");
/*
* Test Interpolation
*/
m = 4;
setup_hmatrix_aprx_inter_row_bem3d(bem_slp, root, root, block, m);
setup_hmatrix_aprx_inter_row_bem3d(bem_dlp, root, root, block, m);
test_hmatrix_system("Interpolation row", Vfull, KMfull, block, bem_slp, V,
bem_dlp, KM, false, true, 1.0e-3, 2.0e-3);
setup_hmatrix_aprx_inter_col_bem3d(bem_slp, root, root, block, m);
setup_hmatrix_aprx_inter_col_bem3d(bem_dlp, root, root, block, m);
test_hmatrix_system("Interpolation column", Vfull, KMfull, block, bem_slp,
V, bem_dlp, KM, false, true, 1.0e-3, 2.0e-3);
setup_hmatrix_aprx_inter_mixed_bem3d(bem_slp, root, root, block, m);
setup_hmatrix_aprx_inter_mixed_bem3d(bem_dlp, root, root, block, m);
test_hmatrix_system("Interpolation mixed", Vfull, KMfull, block, bem_slp, V,
bem_dlp, KM, false, true, 1.0e-3, 2.0e-3);
/*
* Test Green
*/
m = 5;
l = 1;
delta = 0.5;
setup_hmatrix_aprx_green_row_bem3d(bem_slp, root, root, block, m, l, delta,
build_bem3d_cube_quadpoints);
setup_hmatrix_aprx_green_row_bem3d(bem_dlp, root, root, block, m, l, delta,
build_bem3d_cube_quadpoints);
test_hmatrix_system("Green row", Vfull, KMfull, block, bem_slp, V, bem_dlp,
KM, false, true, 1.0e-3, 2.0e-3);
setup_hmatrix_aprx_green_col_bem3d(bem_slp, root, root, block, m, l, delta,
build_bem3d_cube_quadpoints);
setup_hmatrix_aprx_green_col_bem3d(bem_dlp, root, root, block, m, l, delta,
build_bem3d_cube_quadpoints);
test_hmatrix_system("Green column", Vfull, KMfull, block, bem_slp, V,
bem_dlp, KM, false, true, 1.0e-3, 2.0e-3);
setup_hmatrix_aprx_green_mixed_bem3d(bem_slp, root, root, block, m, l,
delta, build_bem3d_cube_quadpoints);
setup_hmatrix_aprx_green_mixed_bem3d(bem_dlp, root, root, block, m, l,
delta, build_bem3d_cube_quadpoints);
test_hmatrix_system("Green mixed", Vfull, KMfull, block, bem_slp, V,
bem_dlp, KM, false, true, 1.0e-3, 2.0e-3);
/*
* Test Greenhybrid
*/
m = 2;
l = 1;
delta = 1.0;
eps_aca = 2.0e-2;
setup_hmatrix_aprx_greenhybrid_row_bem3d(bem_slp, root, root, block, m, l,
delta, eps_aca,
build_bem3d_cube_quadpoints);
setup_hmatrix_aprx_greenhybrid_row_bem3d(bem_dlp, root, root, block, m, l,
delta, eps_aca,
build_bem3d_cube_quadpoints);
test_hmatrix_system("Greenhybrid row", Vfull, KMfull, block, bem_slp, V,
bem_dlp, KM, false, true, 1.0e-3, 2.0e-3);
setup_hmatrix_aprx_greenhybrid_col_bem3d(bem_slp, root, root, block, m, l,
delta, eps_aca,
build_bem3d_cube_quadpoints);
setup_hmatrix_aprx_greenhybrid_col_bem3d(bem_dlp, root, root, block, m, l,
delta, eps_aca,
build_bem3d_cube_quadpoints);
test_hmatrix_system("Greenhybrid column", Vfull, KMfull, block, bem_slp, V,
bem_dlp, KM, false, true, 1.0e-3, 2.0e-3);
setup_hmatrix_aprx_greenhybrid_mixed_bem3d(bem_slp, root, root, block, m, l,
delta, eps_aca,
build_bem3d_cube_quadpoints);
setup_hmatrix_aprx_greenhybrid_mixed_bem3d(bem_dlp, root, root, block, m, l,
delta, eps_aca,
build_bem3d_cube_quadpoints);
test_hmatrix_system("Greenhybrid mixed", Vfull, KMfull, block, bem_slp, V,
bem_dlp, KM, false, true, 1.0e-3, 2.0e-3);
/*
* Test ACA / PACA / HCA
*/
m = 2;
eps_aca = 1.0e-2;
/* Nearfield computation on GPU not applicable here yet! */
// setup_hmatrix_aprx_aca_bem3d(bem_slp, root, root, block, eps_aca);
// setup_hmatrix_aprx_aca_bem3d(bem_dlp, root, root, block, eps_aca);
// test_hmatrix_system("ACA full pivoting", Vfull, KMfull, block, bem_slp, V,
// bem_dlp, KM, false, true, 1.0e-3, 2.0e-3);
//
// setup_hmatrix_aprx_paca_bem3d(bem_slp, root, root, block, eps_aca);
// setup_hmatrix_aprx_paca_bem3d(bem_slp, root, root, block, eps_aca);
// test_hmatrix_system("ACA partial pivoting", Vfull, KMfull, block, bem_slp, V,
// bem_dlp, KM, false, true, 1.0e-3, 2.0e-3);
setup_hmatrix_aprx_hca_bem3d(bem_slp, root, root, block, m, eps_aca);
setup_hmatrix_aprx_hca_bem3d(bem_slp, root, root, block, m, eps_aca);
test_hmatrix_system("HCA2", Vfull, KMfull, block, bem_slp, V, bem_dlp, KM,
false, true, 1.0e-3, 2.0e-3);
del_hmatrix(V);
del_hmatrix(KM);
del_block(block);
/*
* H2-matrix
*/
block = build_strict_block(root, root, &eta, admissible_max_cluster);
Vrb = build_from_cluster_clusterbasis(root);
Vcb = build_from_cluster_clusterbasis(root);
KMrb = build_from_cluster_clusterbasis(root);
KMcb = build_from_cluster_clusterbasis(root);
V2 = build_from_block_h2matrix(block, Vrb, Vcb);
KM2 = build_from_block_h2matrix(block, KMrb, KMcb);
/*
* Test Interpolation
*/
m = 3;
setup_h2matrix_aprx_inter_bem3d(bem_slp, Vrb, Vcb, block, m);
setup_h2matrix_aprx_inter_bem3d(bem_dlp, KMrb, KMcb, block, m);
test_h2matrix_system("Interpolation", Vfull, KMfull, block, bem_slp, V2,
bem_dlp, KM2, false, true, 1.0e-3, 2.0e-3);
/*
* Test Greenhybrid
*/
m = 2;
l = 1;
delta = 1.0;
eps_aca = 2.0e-2;
setup_h2matrix_aprx_greenhybrid_bem3d(bem_slp, Vrb, Vcb, block, m, l, delta,
eps_aca, build_bem3d_cube_quadpoints);
setup_h2matrix_aprx_greenhybrid_bem3d(bem_dlp, KMrb, KMcb, block, m, l,
delta, eps_aca,
build_bem3d_cube_quadpoints);
test_h2matrix_system("Greenhybrid", Vfull, KMfull, block, bem_slp, V2,
bem_dlp, KM2, false, true, 1.0e-3, 2.0e-3);
/* Nearfield computation on GPU not applicable here yet! */
// setup_h2matrix_aprx_greenhybrid_ortho_bem3d(bem_slp, Vrb, Vcb, block, m, l,
// delta, eps_aca, build_bem3d_cube_quadpoints);
// setup_h2matrix_aprx_greenhybrid_ortho_bem3d(bem_dlp, KMrb, KMcb, block, m, l,
// delta, eps_aca, build_bem3d_cube_quadpoints);
// test_h2matrix_system("Greenhybrid ortho", Vfull, KMfull, block, bem_slp, V2,
// bem_dlp, KM2, false, true, 1.0e-3, 2.0e-3);
del_h2matrix(V2);
del_h2matrix(KM2);
del_block(block);
freemem(root->idx);
del_cluster(root);
del_helmholtz_ocl_bem3d(bem_slp);
del_helmholtz_ocl_bem3d(bem_dlp);
del_amatrix(Vfull);
del_amatrix(KMfull);
del_surface3d(gr);
del_macrosurface3d(mg);
freemem(idx);
(void) printf("----------------------------------------\n"
" %u matrices and\n"
" %u vectors still active\n"
" %u errors found\n", getactives_amatrix(),
getactives_avector(), problems);
uninit_h2lib();
return problems;
}
psurface3d
read_surface3d(const char *filename)
{
psurface3d gr;
#ifdef USE_ZLIB
gzFile in;
#else
FILE *in;
#endif
uint vertices, edges, triangles;
real(*x)[3];
uint(*e)[2];
uint(*t)[3];
uint(*s)[3];
char buf[80];
char *line;
uint i, ln;
#ifdef USE_ZLIB
in = gzopen(filename, "rb");
#else
in = fopen(filename, "r");
#endif
if (in == 0) {
(void) fprintf(stderr, "Could not open file \"%s\" for reading\n",
filename);
return 0;
}
ln = 0;
line = readline(buf, 80, in, &ln);
if (line == 0 || sscanf(line, "%u %u %u", &vertices, &edges, &triangles)
!= 3) {
(void) fprintf(stderr, "Could not read first line of file \"%s\"\n",
filename);
#ifdef USE_ZLIB
gzclose(in);
#else
fclose(in);
#endif
return 0;
}
gr = new_surface3d(vertices, edges, triangles);
x = gr->x;
e = gr->e;
t = gr->t;
s = gr->s;
for (i = 0; i < vertices; i++) {
line = readline(buf, 80, in, &ln);
if (line == 0 || sscanf(line, "%" SCANF_PREFIX "f %" SCANF_PREFIX "f %"
SCANF_PREFIX "f", x[i], x[i] + 1, x[i] + 2)
!= 3) {
(void) fprintf(stderr,
"Could not read vertex %u in line %u of file \"%s\"\n",
i, ln, filename);
del_surface3d(gr);
#ifdef USE_ZLIB
gzclose(in);
#else
fclose(in);
#endif
}
}
for (i = 0; i < edges; i++) {
line = readline(buf, 80, in, &ln);
if (line == 0 || sscanf(line, "%u %u", e[i], e[i] + 1) != 2) {
(void) fprintf(stderr,
"Could not read edge %u in line %u of file \"%s\"\n", i,
ln, filename);
del_surface3d(gr);
#ifdef USE_ZLIB
gzclose(in);
#else
fclose(in);
#endif
}
}
for (i = 0; i < triangles; i++) {
line = readline(buf, 80, in, &ln);
if (line == 0 || sscanf(line, "%u %u %u %u %u %u", t[i], t[i] + 1,
t[i] + 2, s[i], s[i] + 1, s[i] + 2)
!= 6) {
(void) fprintf(stderr,
"Could not read triangle %u in line %u of file \"%s\"\n",
i, ln, filename);
del_surface3d(gr);
#ifdef USE_ZLIB
gzclose(in);
#else
fclose(in);
#endif
}
}
#ifdef USE_ZLIB
gzclose(in);
#else
fclose(in);
#endif
prepare_surface3d(gr);
return gr;
}
