static inline field
dlp_kernel_helmholtzbem3d(const real * x, const real * y,
const real * nx, const real * ny, void *data)
{
pcbem3d bem = (pcbem3d) data;
real k = bem->k;
real dist[3];
real norm, norm2, rnorm, s, c;
field res;
(void) nx;
dist[0] = x[0] - y[0];
dist[1] = x[1] - y[1];
dist[2] = x[2] - y[2];
norm2 = REAL_NORMSQR3(dist[0], dist[1], dist[2]);
rnorm = REAL_RSQRT(norm2);
norm = k * norm2 * rnorm;
s = sin(norm);
c = cos(norm);
res = (c + norm * s + (s - c * norm) * I);
res *= (rnorm * rnorm * rnorm) * DOT3(dist, ny);
return res;
}
static inline field
hs_kernel_helmholtzbem3d(const real * x, const real * y,
const real * nx, const real * ny, void *data)
{
pcbem3d bem = (pcbem3d) data;
real k = bem->k;
real dist[3];
real norm, norm2, rnorm, s, c, dot, dotxy, hr, hi;
field res;
dist[0] = x[0] - y[0];
dist[1] = x[1] - y[1];
dist[2] = x[2] - y[2];
norm2 = REAL_NORMSQR3(dist[0], dist[1], dist[2]);
rnorm = REAL_RSQRT(norm2);
norm = k * norm2 * rnorm;
rnorm = (rnorm * rnorm) * (rnorm * rnorm) * rnorm;
s = sin(norm);
c = cos(norm);
dot = REAL_DOT3(dist, nx) * REAL_DOT3(dist, ny);
dotxy = REAL_DOT3(nx, ny);
hr = (norm * norm - 3.0) * dot + norm2 * dotxy;
hi = 3.0 * norm * dot - norm * norm2 * dotxy;
res = rnorm * (c * hr - s * hi + (c * hi + s * hr) * I);
return res;
}
static inline field
slp_kernel_helmholtzbem3d(const real * x, const real * y,
const real * nx, const real * ny, void *data)
{
pcbem3d bem = (pcbem3d) data;
real k = bem->k;
real dist[3];
real norm, norm2, rnorm;
field res;
(void) nx;
(void) ny;
dist[0] = x[0] - y[0];
dist[1] = x[1] - y[1];
dist[2] = x[2] - y[2];
norm2 = REAL_NORMSQR3(dist[0], dist[1], dist[2]);
rnorm = REAL_RSQRT(norm2);
norm = k * norm2 * rnorm;
res = (cos(norm) + I * sin(norm)) * rnorm;
return res;
}
field
eval_brakhage_werner_c(pcbem3d bem, pcavector w, field eta, real * x)
{
pcsurface3d gr = bem->gr;
const real(*gr_x)[3] = (const real(*)[3]) gr->x;
const uint(*gr_t)[3] = (const uint(*)[3]) gr->t;
const real(*gr_n)[3] = (const real(*)[3]) gr->n;
const preal gr_g = (const preal) gr->g;
const uint rows = gr->triangles;
const field *kvec = bem->kvec;
uint nq = bem->sq->n_single;
real *xx = bem->sq->x_single;
real *yy = bem->sq->y_single;
real *ww = bem->sq->w_single + 3 * nq;
const real *A, *B, *C, *ns;
uint s, ss, q;
real gs_fac, dx, dy, dz, tx, sx, Ax, Bx, Cx, norm, rnorm, norm2;
field k, sum;
field res;
k = REAL_SQRT(ABSSQR(kvec[0]) + ABSSQR(kvec[1]) + ABSSQR(kvec[2]));
/*
* integrate kernel function over first variable with constant basisfunctions
*/
res = 0.0;
for (s = 0; s < rows; ++s) {
ss = s;
gs_fac = gr_g[ss] * 0.0795774715459476679;
ns = gr_n[ss];
A = gr_x[gr_t[ss][0]];
B = gr_x[gr_t[ss][1]];
C = gr_x[gr_t[ss][2]];
sum = 0.0;
for (q = 0; q < nq; ++q) {
tx = xx[q];
sx = yy[q];
Ax = 1.0 - tx;
Bx = tx - sx;
Cx = sx;
dx = x[0] - (A[0] * Ax + B[0] * Bx + C[0] * Cx);
dy = x[1] - (A[1] * Ax + B[1] * Bx + C[1] * Cx);
dz = x[2] - (A[2] * Ax + B[2] * Bx + C[2] * Cx);
norm2 = dx * dx + dy * dy + dz * dz;
rnorm = REAL_RSQRT(norm2);
norm = norm2 * rnorm;
rnorm *= rnorm * rnorm;
sum += ww[q]
* cexp(I * k * norm)
* rnorm
* ((1.0 - I * k * norm) * (dx * ns[0] + dy * ns[1] + dz * ns[2]) - I
* eta * norm2);
}
res += sum * gs_fac * w->v[ss];
}
return res;
}
static void
fill_dlp_cc_sing_cpu_wrapper_helmholtzbem3d(void *data)
{
merge_data_nf *mdata = (merge_data_nf *) data;
pcbem3d bem = mdata->bem;
const pcsurface3d gr = bem->gr;
const real(*gr_x)[3] = (const real(*)[3]) gr->x;
const uint(*gr_t)[3] = (const uint(*)[3]) gr->t;
const real(*gr_n)[3] = (const real(*)[3]) gr->n;
const real *gr_g = (const real *) gr->g;
field *aa = mdata->N;
uint pos = mdata->pos;
field **addr = mdata->addr;
field k = bem->k;
const real *A_t, *B_t, *C_t, *A_s, *B_s, *C_s, *ns;
const uint *tri_t, *tri_s;
real *xq, *yq, *wq;
uint tp[3], sp[3];
real Ax, Bx, Cx, Ay, By, Cy, tx, sx, ty, sy, dx, dy, dz, factor, norm,
norm2, rnorm, base;
field sum;
uint q, nq, ss, tt, t;
for (t = 0; t < pos; ++t) {
tt = ((uint *) aa)[0];
tri_t = gr_t[tt];
ss = ((uint *) aa)[1];
tri_s = gr_t[ss];
ns = gr_n[ss];
factor = gr_g[ss] * gr_g[tt] * KERNEL_CONST_HELMHOLTZBEM3D;
if (tt == ss) {
sum = 0.5 * bem->alpha * gr_g[tt];
*(addr[t]) = sum;
}
else {
(void) select_quadrature_singquad2d(bem->sq, tri_t, tri_s, tp, sp, &xq,
&yq, &wq, &nq, &base);
wq += 9 * nq;
A_t = gr_x[tri_t[tp[0]]];
B_t = gr_x[tri_t[tp[1]]];
C_t = gr_x[tri_t[tp[2]]];
A_s = gr_x[tri_s[sp[0]]];
B_s = gr_x[tri_s[sp[1]]];
C_s = gr_x[tri_s[sp[2]]];
sum = base;
for (q = 0; q < nq; ++q) {
tx = xq[q];
sx = xq[q + nq];
ty = yq[q];
sy = yq[q + nq];
Ax = 1.0 - tx;
Bx = tx - sx;
Cx = sx;
Ay = 1.0 - ty;
By = ty - sy;
Cy = sy;
dx = A_t[0] * Ax + B_t[0] * Bx + C_t[0] * Cx
- (A_s[0] * Ay + B_s[0] * By + C_s[0] * Cy);
dy = A_t[1] * Ax + B_t[1] * Bx + C_t[1] * Cx
- (A_s[1] * Ay + B_s[1] * By + C_s[1] * Cy);
dz = A_t[2] * Ax + B_t[2] * Bx + C_t[2] * Cx
- (A_s[2] * Ay + B_s[2] * By + C_s[2] * Cy);
norm2 = dx * dx + dy * dy + dz * dz;
rnorm = REAL_RSQRT(norm2);
if (IMAG(k) == 0.0) {
norm = REAL(k) * norm2 * rnorm;
sum += wq[q] * (cos(norm) + I * sin(norm)) * rnorm * rnorm * rnorm
* (1.0 - I * norm) * (dx * ns[0] + dy * ns[1] + dz * ns[2]);
}
else {
norm = norm2 * rnorm;
sum += wq[q] * exp(-IMAG(k) * norm)
* (cos(REAL(k) * norm) + I * sin(REAL(k) * norm)) * rnorm
* rnorm * rnorm * (1.0 - I * k * norm)
* (dx * ns[0] + dy * ns[1] + dz * ns[2]);
}
}
*(addr[t]) = sum * factor;
}
}
}
