Geom<double>* NeighborSearch::init_geometry(Geom<double>** ext_cache_e, SurfPos *ep) { ensure_central_pss_rm(this); ensure_active_segment(this); int eo = get_quad_eo(); if (n_neighbors == 1) // go-up or no-transf neighborhood { // Do the same as if assembling standard (non-DG) surface forms. if (ext_cache_e[eo] == NULL) ext_cache_e[eo] = new InterfaceGeom<double> (init_geom_surf(central_rm, ep, eo), neighb_el->marker, neighb_el->id, neighb_el->get_diameter()); return ext_cache_e[eo]; } else // go-down neighborhood { // Also take into account the transformations of the central element. Key key(eo, active_segment); if (cache_e[key] == NULL) cache_e[key] = new InterfaceGeom<double> (init_geom_surf(central_rm, ep, eo), neighb_el->marker, neighb_el->id, neighb_el->get_diameter()); return cache_e[key]; } }
int init_surface_geometry_points(RefMap** reference_mapping, int reference_mapping_count, int& order, int isurf, int marker, Geom<double>*& geometry, double*& jacobian_x_weights) { RefMap* rep_reference_mapping = nullptr; for (int i = 0; i < reference_mapping_count; i++) { if (reference_mapping[i]) { if (reference_mapping[i]->get_active_element()) { rep_reference_mapping = reference_mapping[i]; break; } } } int eo = rep_reference_mapping->get_quad_2d()->get_edge_points(isurf, order, rep_reference_mapping->get_active_element()->get_mode()); double3* pt = rep_reference_mapping->get_quad_2d()->get_points(eo, rep_reference_mapping->get_active_element()->get_mode()); int np = rep_reference_mapping->get_quad_2d()->get_num_points(eo, rep_reference_mapping->get_active_element()->get_mode()); // Init geometry and jacobian*weights. double3* tan; geometry = init_geom_surf(rep_reference_mapping, isurf, marker, eo, tan); geometry->area = rep_reference_mapping->get_active_element()->get_area(); geometry->diam = rep_reference_mapping->get_active_element()->get_diameter(); jacobian_x_weights = new double[np]; for (int i = 0; i < np; i++) jacobian_x_weights[i] = pt[i][2] * tan[i][2]; order = eo; return np; }
double DiscontinuityDetector::calculate_relative_flow_direction(Element* e, int edge_i) { // Set active element to the two solutions (density_vel_x, density_vel_y). solutions[1]->set_active_element(e); solutions[2]->set_active_element(e); // Set Geometry. SurfPos surf_pos; surf_pos.marker = e->marker; surf_pos.surf_num = edge_i; int eo = solutions[1]->get_quad_2d()->get_edge_points(surf_pos.surf_num, 5); double3* pt = solutions[1]->get_quad_2d()->get_points(eo); int np = solutions[1]->get_quad_2d()->get_num_points(eo); Geom<double>* geom = init_geom_surf(solutions[1]->get_refmap(), &surf_pos, eo); double3* tan = solutions[1]->get_refmap()->get_tangent(surf_pos.surf_num, eo); double* jwt = new double[np]; for(int i = 0; i < np; i++) jwt[i] = pt[i][2] * tan[i][2]; // Calculate. Func<scalar>* density_vel_x = init_fn(solutions[1], eo); Func<scalar>* density_vel_y = init_fn(solutions[2], eo); double result = 0.0; for(int point_i = 0; point_i < np; point_i++) result += jwt[point_i] * density_vel_x->val[point_i] * geom->nx[point_i] + density_vel_y->val[point_i] * geom->ny[point_i]; return result; };
// Actual evaluation of surface linear form (calculates integral) scalar FeProblem::eval_form(WeakForm::VectorFormSurf *vfs, Tuple<Solution *> u_ext, PrecalcShapeset *fv, RefMap *rv, EdgePos* ep) { // eval the form Quad2D* quad = fv->get_quad_2d(); int eo = quad->get_edge_points(ep->edge); double3* pt = quad->get_points(eo); int np = quad->get_num_points(eo); // init geometry and jacobian*weights if (cache_e[eo] == NULL) { cache_e[eo] = init_geom_surf(rv, ep, eo); double3* tan = rv->get_tangent(ep->edge); cache_jwt[eo] = new double[np]; for(int i = 0; i < np; i++) cache_jwt[eo][i] = pt[i][2] * tan[i][2]; } Geom<double>* e = cache_e[eo]; double* jwt = cache_jwt[eo]; // function values and values of external functions AUTOLA_OR(Func<scalar>*, prev, wf->neq); for (int i = 0; i < wf->neq; i++) prev[i] = init_fn(u_ext[i], rv, eo); Func<double>* v = get_fn(fv, rv, eo); ExtData<scalar>* ext = init_ext_fns(vfs->ext, rv, eo); scalar res = vfs->fn(np, jwt, prev, v, e, ext); for (int i = 0; i < wf->neq; i++) { prev[i]->free_fn(); delete prev[i]; } ext->free(); delete ext; return 0.5 * res; }
double KellyTypeAdapt::eval_boundary_estimator(KellyTypeAdapt::ErrorEstimatorForm* err_est_form, RefMap *rm, SurfPos* surf_pos) { // determine the integration order int inc = (this->sln[err_est_form->i]->get_num_components() == 2) ? 1 : 0; Func<Ord>** oi = new Func<Ord>* [num]; for (int i = 0; i < num; i++) oi[i] = init_fn_ord(this->sln[i]->get_edge_fn_order(surf_pos->surf_num) + inc); // Order of additional external functions. ExtData<Ord>* fake_ext = dp.init_ext_fns_ord(err_est_form->ext, surf_pos->surf_num); double fake_wt = 1.0; Geom<Ord>* fake_e = init_geom_ord(); Ord o = err_est_form->ord(1, &fake_wt, oi, oi[err_est_form->i], fake_e, fake_ext); int order = rm->get_inv_ref_order(); order += o.get_order(); limit_order(order); // Clean up. for (int i = 0; i < this->num; i++) if (oi[i] != NULL) { oi[i]->free_ord(); delete oi[i]; } delete [] oi; delete fake_e; delete fake_ext; // eval the form Quad2D* quad = this->sln[err_est_form->i]->get_quad_2d(); int eo = quad->get_edge_points(surf_pos->surf_num, order); double3* pt = quad->get_points(eo); int np = quad->get_num_points(eo); // init geometry and jacobian*weights Geom<double>* e = init_geom_surf(rm, surf_pos, eo); double3* tan = rm->get_tangent(surf_pos->surf_num, eo); double* jwt = new double[np]; for(int i = 0; i < np; i++) jwt[i] = pt[i][2] * tan[i][2]; // function values Func<scalar>** ui = new Func<scalar>* [num]; for (int i = 0; i < num; i++) ui[i] = init_fn(this->sln[i], eo); ExtData<scalar>* ext = dp.init_ext_fns(err_est_form->ext, rm, eo); scalar res = boundary_scaling_const * err_est_form->value(np, jwt, ui, ui[err_est_form->i], e, ext); for (int i = 0; i < this->num; i++) if (ui[i] != NULL) { ui[i]->free_fn(); delete ui[i]; } delete [] ui; if (ext != NULL) { ext->free(); delete ext; } e->free(); delete e; delete [] jwt; return std::abs(0.5*res); // Edges are parameterized from 0 to 1 while integration weights // are defined in (-1, 1). Thus multiplying with 0.5 to correct // the weights. }
double DiscontinuityDetector::calculate_jumps(Element* e, int edge_i) { // Set active element to the solutions. solutions[0]->set_active_element(e); solutions[1]->set_active_element(e); solutions[2]->set_active_element(e); solutions[3]->set_active_element(e); // Set Geometry. SurfPos surf_pos; surf_pos.marker = e->marker; surf_pos.surf_num = edge_i; int eo = solutions[0]->get_quad_2d()->get_edge_points(surf_pos.surf_num, 5); double3* pt = solutions[0]->get_quad_2d()->get_points(eo); int np = solutions[0]->get_quad_2d()->get_num_points(eo); Geom<double>* geom = init_geom_surf(solutions[0]->get_refmap(), &surf_pos, eo); double3* tan = solutions[0]->get_refmap()->get_tangent(surf_pos.surf_num, eo); double* jwt = new double[np]; for(int i = 0; i < np; i++) jwt[i] = pt[i][2] * tan[i][2]; // Prepare functions on the central element. Func<scalar>* density = init_fn(solutions[0], eo); Func<scalar>* density_vel_x = init_fn(solutions[1], eo); Func<scalar>* density_vel_y = init_fn(solutions[2], eo); Func<scalar>* density_energy = init_fn(solutions[3], eo); // Set neighbor element to the solutions. solutions[0]->set_active_element(e->get_neighbor(edge_i)); solutions[1]->set_active_element(e->get_neighbor(edge_i)); solutions[2]->set_active_element(e->get_neighbor(edge_i)); solutions[3]->set_active_element(e->get_neighbor(edge_i)); // Prepare functions on the neighbor element. Func<scalar>* density_neighbor = init_fn(solutions[0], eo); Func<scalar>* density_vel_x_neighbor = init_fn(solutions[1], eo); Func<scalar>* density_vel_y_neighbor = init_fn(solutions[2], eo); Func<scalar>* density_energy_neighbor = init_fn(solutions[3], eo); DiscontinuousFunc<scalar> density_discontinuous(density, density_neighbor, true); DiscontinuousFunc<scalar> density_vel_x_discontinuous(density_vel_x, density_vel_x_neighbor, true); DiscontinuousFunc<scalar> density_vel_y_discontinuous(density_vel_y, density_vel_y_neighbor, true); DiscontinuousFunc<scalar> density_energy_discontinuous(density_energy, density_energy_neighbor, true); double result = 0.0; for(int point_i = 0; point_i < np; point_i++) result += jwt[point_i] * ( std::pow(density_discontinuous.get_val_central(point_i) - density_discontinuous.get_val_neighbor(point_i), 2) + std::pow(density_vel_x_discontinuous.get_val_central(point_i) - density_vel_x_discontinuous.get_val_neighbor(point_i), 2) + std::pow(density_vel_y_discontinuous.get_val_central(point_i) - density_vel_y_discontinuous.get_val_neighbor(point_i), 2) + std::pow(density_energy_discontinuous.get_val_central(point_i) - density_energy_discontinuous.get_val_neighbor(point_i), 2)); return std::sqrt(result); };
int init_surface_geometry_points_allocated_jwt(RefMap* rep_reference_mapping, int& order, int isurf, int marker, Geom<double>*& geometry, double* jacobian_x_weights) { Element* e = rep_reference_mapping->get_active_element(); int eo = rep_reference_mapping->get_quad_2d()->get_edge_points(isurf, order, e->get_mode()); double3* pt = rep_reference_mapping->get_quad_2d()->get_points(eo, e->get_mode()); int np = rep_reference_mapping->get_quad_2d()->get_num_points(eo, e->get_mode()); // Init geometry and jacobian*weights. double3* tan; geometry = init_geom_surf(rep_reference_mapping, isurf, marker, eo, tan); for (int i = 0; i < np; i++) jacobian_x_weights[i] = pt[i][2] * tan[i][2]; order = eo; return np; }
double KellyTypeAdapt::eval_interface_estimator(KellyTypeAdapt::ErrorEstimatorForm* err_est_form, RefMap *rm, SurfPos* surf_pos, LightArray<NeighborSearch*>& neighbor_searches, int neighbor_index) { NeighborSearch* nbs = neighbor_searches.get(neighbor_index); Hermes::vector<MeshFunction*> slns; for (int i = 0; i < num; i++) slns.push_back(this->sln[i]); // Determine integration order. ExtData<Ord>* fake_ui = dp.init_ext_fns_ord(slns, neighbor_searches); // Order of additional external functions. // ExtData<Ord>* fake_ext = dp.init_ext_fns_ord(err_est_form->ext, nbs); // Order of geometric attributes (eg. for multiplication of a solution with coordinates, normals, etc.). Geom<Ord>* fake_e = new InterfaceGeom<Ord>(init_geom_ord(), nbs->neighb_el->marker, nbs->neighb_el->id, nbs->neighb_el->get_diameter()); double fake_wt = 1.0; Ord o = err_est_form->ord(1, &fake_wt, fake_ui->fn, fake_ui->fn[err_est_form->i], fake_e, NULL); int order = rm->get_inv_ref_order(); order += o.get_order(); limit_order(order); // Clean up. if (fake_ui != NULL) { for (int i = 0; i < num; i++) delete fake_ui->fn[i]; fake_ui->free_ord(); delete fake_ui; } delete fake_e; //delete fake_ext; Quad2D* quad = this->sln[err_est_form->i]->get_quad_2d(); int eo = quad->get_edge_points(surf_pos->surf_num, order); int np = quad->get_num_points(eo); double3* pt = quad->get_points(eo); // Init geometry and jacobian*weights (do not use the NeighborSearch caching mechanism). double3* tan = rm->get_tangent(surf_pos->surf_num, eo); double* jwt = new double[np]; for(int i = 0; i < np; i++) jwt[i] = pt[i][2] * tan[i][2]; Geom<double>* e = new InterfaceGeom<double>(init_geom_surf(rm, surf_pos, eo), nbs->neighb_el->marker, nbs->neighb_el->id, nbs->neighb_el->get_diameter()); // function values ExtData<scalar>* ui = dp.init_ext_fns(slns, neighbor_searches, order); //ExtData<scalar>* ext = dp.init_ext_fns(err_est_form->ext, nbs); scalar res = interface_scaling_const * err_est_form->value(np, jwt, ui->fn, ui->fn[err_est_form->i], e, NULL); if (ui != NULL) { ui->free(); delete ui; } //if (ext != NULL) { ext->free(); delete ext; } e->free(); delete e; delete [] jwt; return std::abs(0.5*res); // Edges are parameterized from 0 to 1 while integration weights // are defined in (-1, 1). Thus multiplying with 0.5 to correct // the weights. }
void Element::calc_area(bool precise_for_curvature) { // First some basic arithmetics. double ax, ay, bx, by; ax = vn[1]->x - vn[0]->x; ay = vn[1]->y - vn[0]->y; bx = vn[2]->x - vn[0]->x; by = vn[2]->y - vn[0]->y; this->area = 0.5*(ax*by - ay*bx); if (is_quad()) { ax = bx; ay = by; bx = vn[3]->x - vn[0]->x; by = vn[3]->y - vn[0]->y; this->area = area + 0.5*(ax*by - ay*bx); } // Either the basic approximation is fine. if (!this->is_curved() || !precise_for_curvature) return; // Or we want to capture the curvature precisely. else { // Utility data. RefMap refmap_curv; RefMap refmap_straight; double3* tan; double x_center, y_center; this->get_center(x_center, y_center); for (int isurf = 0; isurf < this->nvert; isurf++) { // 0 - prepare data structures. int eo = g_quad_2d_std.get_edge_points(isurf, this->get_mode() == HERMES_MODE_TRIANGLE ? g_max_tri : g_max_quad, this->get_mode()); int np = g_quad_2d_std.get_num_points(eo, this->get_mode()); double* x_curv = new double[np]; double* y_curv = new double[np]; double* x_straight = new double[np]; double* y_straight = new double[np]; // 1 - get the x,y coordinates for the curved element. refmap_curv.set_active_element(this); Geom<double>* geometry = init_geom_surf(&refmap_curv, isurf, this->en[isurf]->marker, eo, tan); memcpy(x_curv, geometry->x, np*sizeof(double)); memcpy(y_curv, geometry->y, np*sizeof(double)); geometry->free(); delete geometry; // 2. - act if there was no curvature CurvMap* cm_temp = this->cm; this->cm = nullptr; refmap_straight.set_active_element(this); geometry = init_geom_surf(&refmap_straight, isurf, this->en[isurf]->marker, eo, tan); memcpy(x_straight, geometry->x, np*sizeof(double)); memcpy(y_straight, geometry->y, np*sizeof(double)); geometry->free(); delete geometry; // 3. - compare the two, get the updated area. double previous_distance; for (int i = 0; i < np; i++) { // Distance between the curved and straight edges. double distance_i = std::sqrt(std::pow(x_straight[i] - x_curv[i], 2.0) + std::pow(y_straight[i] - y_curv[i], 2.0)); // Add to- or Subtract from- the area (depends on the curvature and we shall decide based on distance from the element center). double distance_from_center_curved = std::pow(x_center - x_curv[i], 2.0) + std::pow(y_center - y_curv[i], 2.0); double distance_from_center_straight = std::pow(x_center - x_straight[i], 2.0) + std::pow(y_center - y_straight[i], 2.0); bool add = distance_from_center_curved > distance_from_center_straight; // Calculate now the area delta. // It depends on the integration point number etc. double area_delta; if (i == 0) { double distance_along_edge = std::sqrt(std::pow(x_straight[i] - this->vn[isurf]->x, 2.0) + std::pow(y_straight[i] - this->vn[isurf]->y, 2.0)); area_delta = distance_i * distance_along_edge * 0.5; } if (i > 0 && i < np - 1) { double distance_along_edge = std::sqrt(std::pow(x_straight[i] - x_straight[i - 1], 2.0) + std::pow(y_straight[i] - y_straight[i - 1], 2.0)); area_delta = 0.5*(distance_i + previous_distance) * distance_along_edge; } if (i == np - 1) { double distance_along_edge = std::sqrt(std::pow(x_straight[i] - this->vn[(isurf + 1) % this->nvert]->x, 2.0) + std::pow(y_straight[i] - this->vn[(isurf + 1) % this->nvert]->y, 2.0)); area_delta = distance_i * distance_along_edge * 0.5; } if (add) area += area_delta; else area -= area_delta; previous_distance = distance_i; } // 4. - re-add the curvature. this->cm = cm_temp; // clean up delete[] x_curv; delete[] y_curv; delete[] x_straight; delete[] y_straight; } } }