Beispiel #1
0
scalar liform_surf(int n, double *wt, Func<scalar> *u_ext[], Func<double> *v, Geom<double> *e, ExtData<scalar> *ext)
{
  cplx ii = cplx(0.0, 1.0);
  scalar result = 0;
  for (int i = 0; i < n; i++) {
    scalar dx[3], dy[3], dz[3];
    scalar3 ev;
    ev[0] = exact(e->x[i], e->y[i], e->z[i], dx, dy, dz)[0];
    ev[1] = exact(e->x[i], e->y[i], e->z[i], dx, dy, dz)[0];
    ev[2] = exact(e->x[i], e->y[i], e->z[i], dx, dy, dz)[0];

    scalar curl_e[3];
    calc_curl(dx, dy, dz, curl_e);
    scalar tpe[3];
    calc_tan_proj(e->nx[i], e->ny[i], e->nz[i], ev, tpe);

    scalar g[3] = {
      (e->nz[i] * curl_e[1] - e->ny[i] * curl_e[2]) - ii * kappa * tpe[0],
      (e->nx[i] * curl_e[2] - e->nz[i] * curl_e[0]) - ii * kappa * tpe[1],
      (e->ny[i] * curl_e[0] - e->nx[i] * curl_e[1]) - ii * kappa * tpe[2],
    };

    // tpv is tangencial projection of v (test function)
    scalar vv[3] = { v->val0[i], v->val1[i], v->val2[i] };
    scalar tpv[3];
    calc_tan_proj(e->nx[i], e->ny[i], e->nz[i], vv, tpv);

    result += wt[i] * (g[0] * tpv[0] + g[1] * tpv[1] + g[2] * tpv[2]);
  }

  return result;
}
Beispiel #2
0
scalar biform_surf(int n, double *wt, Func<scalar> *u_ext[], Func<double> *u, Func<double> *v, Geom<double> *e, ExtData<scalar> *ext)
{
  // j * kappa * E_T * F_T
  // E_T = nu x E x nu  (nu is outer normal)
  cplx ii = cplx(0.0, 1.0);
  scalar result = 0;
  for (int i = 0; i < n; i++) {
    scalar uu[3] = { u->val0[i], u->val1[i], u->val2[i] };
    scalar tpu[3];
    calc_tan_proj(e->nx[i], e->ny[i], e->nz[i], uu, tpu);

    scalar vv[3] = { v->val0[i], v->val1[i], v->val2[i] };
    scalar tpv[3];
    calc_tan_proj(e->nx[i], e->ny[i], e->nz[i], vv, tpv);

    result += wt[i] * (uu[0] * vv[0] + uu[1] * vv[1] + uu[2] * vv[2]);
  }

  return ii * (-kappa) * result;
}
Beispiel #3
0
Scalar linear_form_surf(int n, double *wt, Func<Scalar> *u_ext[], Func<Real> *v, Geom<Real> *e, ExtData<Scalar> *data) {
	Scalar result = 0.0;
	for (int i = 0; i < n; i++) {
		Scalar ev[3], dx[3], dy[3], dz[3];
		exact_sln(e->x[i], e->y[i], e->z[i], ev, dx, dy, dz);

		Scalar curl_e[3];
		calc_curl(dx, dy, dz, curl_e);
		Scalar tpe[3];
		calc_tan_proj(e->nx[i], e->ny[i], e->nz[i], ev, tpe);

		Scalar g[3] = {
			(e->nz[i] * curl_e[1] - e->ny[i] * curl_e[2]) - img * tpe[0],
			(e->nx[i] * curl_e[2] - e->nz[i] * curl_e[0]) - img * tpe[1],
			(e->ny[i] * curl_e[0] - e->nx[i] * curl_e[1]) - img * tpe[2],
		};
		result += wt[i] * (v->val0[i] * g[0] + v->val1[i] * g[1] + v->val2[i] * g[2]);
	}
	return result;
}
Beispiel #4
0
sFunc *init_fn(ShapeFunction *shfn, RefMap *rm, int iface, const int np, const QuadPt3D *pt) {
	_F_

	sFunc *u = new sFunc; MEM_CHECK(u);
  u->num_gip = np;
	u->nc = shfn->get_num_components();
	shfn->precalculate(np, pt, FN_DEFAULT);
	if (u->nc == 1) {
		u->val = new double [np]; MEM_CHECK(u->val);
		u->dx = new double [np]; MEM_CHECK(u->dx);
		u->dy = new double [np]; MEM_CHECK(u->dy);
		u->dz = new double [np]; MEM_CHECK(u->dz);

		double *val = shfn->get_fn_values();
		double *dx = shfn->get_dx_values();
		double *dy = shfn->get_dy_values();
		double *dz = shfn->get_dz_values();
		double3x3 *m = rm->get_inv_ref_map(np, pt);
		for (int i = 0; i < np; i++) {
			u->val[i] = val[i];
			u->dx[i] = (dx[i] * m[i][0][0] + dy[i] * m[i][0][1] + dz[i] * m[i][0][2]);
			u->dy[i] = (dx[i] * m[i][1][0] + dy[i] * m[i][1][1] + dz[i] * m[i][1][2]);
			u->dz[i] = (dx[i] * m[i][2][0] + dy[i] * m[i][2][1] + dz[i] * m[i][2][2]);
		}
		delete [] m;
	}

	if (shfn->get_type() == HERMES_HCURL_SPACE) {
		double *nx, *ny, *nz;
		rm->calc_face_normal(iface, np, pt, nx, ny, nz);

		u->val0 = new double [np]; MEM_CHECK(u->val0);
		u->val1 = new double [np]; MEM_CHECK(u->val1);
		u->val2 = new double [np]; MEM_CHECK(u->val2);

		double *val[3];
		for (int c = 0; c < 3; c++)
			val[c] = shfn->get_fn_values(c);

		double3x3 *m = rm->get_inv_ref_map(np, pt);
		for (int i = 0; i < np; i++) {
			double ev[3] = {
				val[0][i] * m[i][0][0] + val[1][i] * m[i][0][1] + val[2][i] * m[i][0][2],
				val[0][i] * m[i][1][0] + val[1][i] * m[i][1][1] + val[2][i] * m[i][1][2],
				val[0][i] * m[i][2][0] + val[1][i] * m[i][2][1] + val[2][i] * m[i][2][2]
			};
			double tpe[3];
			calc_tan_proj(nx[i], ny[i], nz[i], ev, tpe);
			u->val0[i] = tpe[0];
			u->val1[i] = tpe[1];
			u->val2[i] = tpe[2];
		}

		delete [] m;
		delete [] nx;
		delete [] ny;
		delete [] nz;
	}

	return u;
}