// process all elements of the mesh
for_all_active_elements(e, mesh)
{
sln->set_active_element(e);
sln->set_quad_order(0, item);
scalar* val = sln->get_values(ia, ib);
if (disp)
{
xdisp->set_active_element(e);
ydisp->set_active_element(e);
}
int iv[4];
for (unsigned int i = 0; i < e->nvert; i++)
iv[i] = get_top_vertex(id2id[e->vn[i]->id], getval(i));
// we won't bother calculating physical coordinates from the refmap if this is not a curved element
curved = e->is_curved();
cmax = e->get_diameter();
// recur to sub-elements
if (e->is_triangle())
process_triangle(iv[0], iv[1], iv[2], 0, NULL, NULL, NULL, NULL);
else
process_quad(iv[0], iv[1], iv[2], iv[3], 0, NULL, NULL, NULL, NULL);
for (unsigned int i = 0; i < e->nvert; i++)
process_edge(iv[i], iv[e->next_vert(i)], e->en[i]->marker);
}
void Vectorizer::process_triangle(int iv0, int iv1, int iv2, int level,
scalar* xval, scalar* yval, double* phx, double* phy, int* idx)
{
if (level < LIN_MAX_LEVEL)
{
int i;
if (!(level & 1))
{
// obtain solution values and physical element coordinates
xsln->set_quad_order(1, xitem);
ysln->set_quad_order(1, yitem);
xval = xsln->get_values(xia, xib);
yval = ysln->get_values(yia, yib);
for (i = 0; i < lin_np_tri[1]; i++) {
double m = getmag(i);
if (finite(m) && fabs(m) > max) max = fabs(m);
}
if (curved)
{
RefMap* refmap = xsln->get_refmap();
phx = refmap->get_phys_x(1);
phy = refmap->get_phys_y(1);
}
idx = tri_indices[0];
}
// obtain linearized values and coordinates at the midpoints
double midval[4][3];
for (i = 0; i < 4; i++)
{
midval[i][0] = (verts[iv0][i] + verts[iv1][i])*0.5;
midval[i][1] = (verts[iv1][i] + verts[iv2][i])*0.5;
midval[i][2] = (verts[iv2][i] + verts[iv0][i])*0.5;
};
// determine whether or not to split the element
bool split;
if (eps >= 1.0)
{
//if eps > 1, the user wants a fixed number of refinements (no adaptivity)
split = (level < eps);
}
else
{
// calculate the approximate error of linearizing the normalized solution
double err = fabs(getmag(idx[0]) - midmag(0)) +
fabs(getmag(idx[1]) - midmag(1)) +
fabs(getmag(idx[2]) - midmag(2));
split = !finite(err) || err > max*3*eps;
// do the same for the curvature
if (curved && !split)
{
double cerr = 0.0, cden = 0.0; // fixme
for (i = 0; i < 3; i++)
{
cerr += fabs(phx[idx[i]] - midval[0][i]) + fabs(phy[idx[i]] - midval[1][i]);
cden += fabs(phx[idx[i]]) + fabs(phy[idx[i]]);
}
split = (cerr > cden*2.5e-4);
}
// do extra tests at level 0, so as not to miss some functions with zero error at edge midpoints
if (level == 0 && !split)
{
split = (fabs(getmag(8) - 0.5*(midmag(0) + midmag(1))) +
fabs(getmag(9) - 0.5*(midmag(1) + midmag(2))) +
fabs(getmag(4) - 0.5*(midmag(2) + midmag(0)))) > max*3*eps;
}
}
// split the triangle if the error is too large, otherwise produce a linear triangle
if (split)
{
if (curved)
for (i = 0; i < 3; i++) {
midval[0][i] = phx[idx[i]];
midval[1][i] = phy[idx[i]];
}
// obtain mid-edge vertices
int mid0 = get_vertex(iv0, iv1, midval[0][0], midval[1][0], getvalx(idx[0]), getvaly(idx[0]));
int mid1 = get_vertex(iv1, iv2, midval[0][1], midval[1][1], getvalx(idx[1]), getvaly(idx[1]));
int mid2 = get_vertex(iv2, iv0, midval[0][2], midval[1][2], getvalx(idx[2]), getvaly(idx[2]));
// recur to sub-elements
push_transform(0); process_triangle(iv0, mid0, mid2, level+1, xval, yval, phx, phy, tri_indices[1]); pop_transform();
push_transform(1); process_triangle(mid0, iv1, mid1, level+1, xval, yval, phx, phy, tri_indices[2]); pop_transform();
push_transform(2); process_triangle(mid2, mid1, iv2, level+1, xval, yval, phx, phy, tri_indices[3]); pop_transform();
push_transform(3); process_triangle(mid1, mid2, mid0, level+1, xval, yval, phx, phy, tri_indices[4]); pop_transform();
return;
}
}
// no splitting: output a linear triangle
add_triangle(iv0, iv1, iv2);
}
void Linearizer::process_triangle(int iv0, int iv1, int iv2, int level,
scalar* val, double* phx, double* phy, int* idx)
{
double midval[3][3];
if (level < LIN_MAX_LEVEL)
{
int i;
if (!(level & 1))
{
// obtain solution values
sln->set_quad_order(1, item);
val = sln->get_values(ia, ib);
if (auto_max)
for (i = 0; i < lin_np_tri[1]; i++) {
double v = getval(i);
if (finite(v) && fabs(v) > max) max = fabs(v);
}
// obtain physical element coordinates
if (curved || disp)
{
RefMap* refmap = sln->get_refmap();
phx = refmap->get_phys_x(1);
phy = refmap->get_phys_y(1);
if (disp)
{
xdisp->force_transform(sln);
ydisp->force_transform(sln);
xdisp->set_quad_order(1, FN_VAL);
ydisp->set_quad_order(1, FN_VAL);
scalar* dx = xdisp->get_fn_values();
scalar* dy = ydisp->get_fn_values();
for (i = 0; i < lin_np_tri[1]; i++) {
phx[i] += dmult*realpart(dx[i]);
phy[i] += dmult*realpart(dy[i]);
}
}
}
idx = tri_indices[0];
}
// obtain linearized values and coordinates at the midpoints
for (i = 0; i < 3; i++)
{
midval[i][0] = (verts[iv0][i] + verts[iv1][i])*0.5;
midval[i][1] = (verts[iv1][i] + verts[iv2][i])*0.5;
midval[i][2] = (verts[iv2][i] + verts[iv0][i])*0.5;
};
// determine whether or not to split the element
bool split;
if (eps >= 1.0)
{
// if eps > 1, the user wants a fixed number of refinements (no adaptivity)
split = (level < eps);
}
else
{
if (!auto_max && fabs(verts[iv0][2]) > max && fabs(verts[iv1][2]) > max && fabs(verts[iv2][2]) > max)
{
// do not split if the whole triangle is above the specified maximum value
split = false;
}
else
{
// calculate the approximate error of linearizing the normalized solution
double err = fabs(getval(idx[0]) - midval[2][0]) +
fabs(getval(idx[1]) - midval[2][1]) +
fabs(getval(idx[2]) - midval[2][2]);
split = !finite(err) || err > max*3*eps;
}
// do the same for the curvature
if (!split && (curved || disp))
{
for (i = 0; i < 3; i++)
if (sqr(phx[idx[i]] - midval[0][i]) + sqr(phy[idx[i]] - midval[1][i]) > sqr(cmax*1.5e-3))
{ split = true; break; }
}
// do extra tests at level 0, so as not to miss some functions with zero error at edge midpoints
if (level == 0 && !split)
{
split = (fabs(getval(8) - 0.5*(midval[2][0] + midval[2][1])) +
fabs(getval(9) - 0.5*(midval[2][1] + midval[2][2])) +
fabs(getval(4) - 0.5*(midval[2][2] + midval[2][0]))) > max*3*eps;
}
}
// split the triangle if the error is too large, otherwise produce a linear triangle
if (split)
{
if (curved || disp)
for (i = 0; i < 3; i++) {
midval[0][i] = phx[idx[i]];
midval[1][i] = phy[idx[i]];
}
// obtain mid-edge vertices
int mid0 = get_vertex(iv0, iv1, midval[0][0], midval[1][0], getval(idx[0]));
int mid1 = get_vertex(iv1, iv2, midval[0][1], midval[1][1], getval(idx[1]));
int mid2 = get_vertex(iv2, iv0, midval[0][2], midval[1][2], getval(idx[2]));
// recur to sub-elements
sln->push_transform(0); process_triangle(iv0, mid0, mid2, level+1, val, phx, phy, tri_indices[1]); sln->pop_transform();
sln->push_transform(1); process_triangle(mid0, iv1, mid1, level+1, val, phx, phy, tri_indices[2]); sln->pop_transform();
sln->push_transform(2); process_triangle(mid2, mid1, iv2, level+1, val, phx, phy, tri_indices[3]); sln->pop_transform();
sln->push_transform(3); process_triangle(mid1, mid2, mid0, level+1, val, phx, phy, tri_indices[4]); sln->pop_transform();
return;
}
}
// no splitting: output a linear triangle
add_triangle(iv0, iv1, iv2);
}
void Vectorizer::process_solution(MeshFunction* xsln, int xitem, MeshFunction* ysln, int yitem, double eps)
{
// sanity check
if (xsln == NULL || ysln == NULL) error("One of the solutions is NULL in Vectorizer:process_solution().");
lock_data();
TimePeriod cpu_time;
// initialization
this->xsln = xsln;
this->ysln = ysln;
this->xitem = xitem;
this->yitem = yitem;
this->eps = eps;
nv = nt = ne = nd = 0;
del_slot = -1;
Mesh* meshes[2] = { xsln->get_mesh(), ysln->get_mesh() };
if (meshes[0] == NULL || meshes[1] == NULL) {
error("One of the meshes is NULL in Vectorizer:process_solution().");
}
Transformable* fns[2] = { xsln, ysln };
Traverse trav;
// estimate the required number of vertices and triangles
// (based on the assumption that the linear mesh will be
// about four-times finer than the original mesh).
int nn = meshes[0]->get_num_elements() + meshes[1]->get_num_elements();
int ev = std::max(32 * nn, 10000);
int et = std::max(64 * nn, 20000);
int ee = std::max(24 * nn, 7500);
int ed = ee;
lin_init_array(verts, double4, cv, ev);
lin_init_array(tris, int3, ct, et);
lin_init_array(edges, int3, ce, ee);
lin_init_array(dashes, int2, cd, ed);
info = (int4*) malloc(sizeof(int4) * cv);
// initialize the hash table
int size = 0x1000;
while (size*2 < cv) size *= 2;
hash_table = (int*) malloc(sizeof(int) * size);
memset(hash_table, 0xff, sizeof(int) * size);
mask = size-1;
// select the linearization quadrature
Quad2D *old_quad_x, *old_quad_y;
old_quad_x = xsln->get_quad_2d();
old_quad_y = ysln->get_quad_2d();
xsln->set_quad_2d((Quad2D*) &quad_lin);
ysln->set_quad_2d((Quad2D*) &quad_lin);
if (!xitem) error("Parameter 'xitem' cannot be zero.");
if (!yitem) error("Parameter 'yitem' cannot be zero.");
get_gv_a_b(xitem, xia, xib);
get_gv_a_b(yitem, yia, yib);
if (xib >= 6) error("Invalid value of paremeter 'xitem'.");
if (yib >= 6) error("Invalid value of paremeter 'yitem'.");
max = 1e-10;
trav.begin(2, meshes, fns);
Element** e;
while ((e = trav.get_next_state(NULL, NULL)) != NULL)
{
xsln->set_quad_order(0, xitem);
ysln->set_quad_order(0, yitem);
scalar* xval = xsln->get_values(xia, xib);
scalar* yval = ysln->get_values(yia, yib);
for (unsigned int i = 0; i < e[0]->nvert; i++)
{
double fx = getvalx(i);
double fy = getvaly(i);
if (fabs(sqrt(fx*fx + fy*fy)) > max) max = fabs(sqrt(fx*fx + fy*fy));
}
}
trav.finish();
trav.begin(2, meshes, fns);
// process all elements of the mesh
while ((e = trav.get_next_state(NULL, NULL)) != NULL)
{
xsln->set_quad_order(0, xitem);
ysln->set_quad_order(0, yitem);
scalar* xval = xsln->get_values(xia, xib);
scalar* yval = ysln->get_values(yia, yib);
double* x = xsln->get_refmap()->get_phys_x(0);
double* y = ysln->get_refmap()->get_phys_y(0);
int iv[4];
for (unsigned int i = 0; i < e[0]->nvert; i++)
{
double fx = getvalx(i);
double fy = getvaly(i);
iv[i] = create_vertex(x[i], y[i], fx, fy);
}
// we won't bother calculating physical coordinates from the refmap if this is not a curved element
curved = (e[0]->cm != NULL);
// recur to sub-elements
if (e[0]->is_triangle())
process_triangle(iv[0], iv[1], iv[2], 0, NULL, NULL, NULL, NULL, NULL);
else
process_quad(iv[0], iv[1], iv[2], iv[3], 0, NULL, NULL, NULL, NULL, NULL);
// process edges and dashes (bold line for edge in both meshes, dashed line for edge in one of the meshes)
Trf* xctm = xsln->get_ctm();
Trf* yctm = ysln->get_ctm();
double r[4] = { -1.0, 1.0, 1.0, -1.0 };
double ref[4][2] = { {-1.0,-1.0}, {1.0,-1.0}, {1.0,1.0}, {-1.0,1.0} };
for (unsigned int i = 0; i < e[0]->nvert; i++)
{
bool bold = false;
double px = ref[i][0];
double py = ref[i][1];
// for odd edges (1, 3) we check x coordinate after ctm transformation, if it's the same (1 or -1) in both meshes => bold
if (i & 1) {
if ((xctm->m[0]*px + xctm->t[0] == r[i]) && (yctm->m[0]*px + yctm->t[0] == r[i]))
bold = true;
}
// for even edges (0, 4) we check y coordinate after ctm transformation, if it's the same (-1 or 1) in both meshes => bold
else {
if ((xctm->m[1]*py + xctm->t[1] == r[i]) && (yctm->m[1]*py + yctm->t[1] == r[i]))
bold = true;
}
int j = e[0]->next_vert(i);
// we draw a line only if both edges lies on the boundary or if the line is from left top to right bottom
if (((e[0]->en[i]->bnd) && (e[1]->en[i]->bnd)) ||
(verts[iv[i]][1] < verts[iv[j]][1]) ||
(verts[iv[i]][1] == verts[iv[j]][1] && verts[iv[i]][0] < verts[iv[j]][0]))
{
if (bold)
process_edge(iv[i], iv[j], e[0]->en[i]->marker);
else
process_dash(iv[i], iv[j]);
}
}
}
trav.finish();
find_min_max();
verbose("Vectorizer created %d verts and %d tris in %0.3g s", nv, nt, cpu_time.tick().last());
//if (verbose_mode) print_hash_stats();
unlock_data();
// select old quadratrues
xsln->set_quad_2d(old_quad_x);
ysln->set_quad_2d(old_quad_y);
// clean up
::free(hash_table);
::free(info);
}
