void
compare3(GtkAction* action, GtkWidget* window) {
GList* files = g_list_first((GList*)g_object_get_data(G_OBJECT(action), "xdiff-ext::compare3"));
gchar* f1 = 0;
gchar* f2 = 0;
gchar* f3 = 0;
gchar* uri;
uri = thunarx_file_info_get_uri((ThunarxFileInfo*)files->data);
f1 = g_filename_from_uri(uri, NULL, NULL);
g_free(uri);
files = g_list_next(files);
uri = thunarx_file_info_get_uri((ThunarxFileInfo*)files->data);
f2 = g_filename_from_uri(uri, NULL, NULL);
g_free(uri);
files = g_list_next(files);
uri = thunarx_file_info_get_uri((ThunarxFileInfo*)files->data);
f3 = g_filename_from_uri(uri, NULL, NULL);
g_free(uri);
diff3(f1, f2, f3);
g_free(f1);
g_free(f2);
g_free(f3);
}
GLdouble dist3(GLdouble p[3], GLdouble q[3])
{
GLdouble d[3];
diff3(p, q, d);
return length3(d);
}
void
compare3_to(GtkAction* action, GtkWidget* window) {
GList* files = g_list_first((GList*)g_object_get_data(G_OBJECT(action), "xdiff-ext::compare_to"));
GList* saved = (GList*)g_object_get_data(G_OBJECT(action), "xdiff-ext::saved");
gchar* f1 = 0;
gchar* f2 = 0;
gchar* f3 = (gchar*)saved->data;
gboolean keep_file = FALSE;
gchar* uri;
xdiff_ext_preferences* p = xdiff_ext_preferences_instance();
g_object_get(G_OBJECT(p), "keep-files-in-list", &keep_file, NULL);
g_object_unref(p);
uri = thunarx_file_info_get_uri((ThunarxFileInfo*)files->data);
f1 = g_filename_from_uri(uri, NULL, NULL);
g_free(uri);
files = g_list_next(files);
uri = thunarx_file_info_get_uri((ThunarxFileInfo*)files->data);
f2 = g_filename_from_uri(uri, NULL, NULL);
g_free(uri);
diff3(f1, f2, f3);
g_free(f1);
g_free(f2);
if(!keep_file) {
clear_queue(_saved);
}
}
void
MeshEdgeElementTable::calcNormalVector(int index)
{
if (normals == NULL)
return;
// Create normal
const int* nodeIds = getNodeIds(index);
Point3& normal = normals[index];
Point3& p1 = meshNodes[nodeIds[0]];
Point3& p2 = meshNodes[nodeIds[1]];
Point3 a;
diff3(p2, p1, a);
normal[0] = -a[1];
normal[1] = a[0];
normal[2] = 0.0;
normalize(normal);
for (int i = 0; i < 3; i++) {
if ( isZero(normal[i]) ) {
normal[i] = 0.0;
}
}
}
void
MeshFaceElementTable::calcNormalVector(int index)
{
if (normals == NULL)
return;
meshElementCode elem_code = getElementCode(index);
// Pick normal
Point3& normal = normals[index];
Point3 *p1, *p2, *p3;
switch (elem_code) {
case MEC_303:
case MEC_304:
case MEC_306:
case MEC_307:
p1 = &meshNodes[nodeIds[index][0]];
p2 = &meshNodes[nodeIds[index][1]];
p3 = &meshNodes[nodeIds[index][2]];
break;
case MEC_404:
case MEC_405:
case MEC_408:
case MEC_409:
p1 = &meshNodes[nodeIds[index][0]];
p2 = &meshNodes[nodeIds[index][1]];
p3 = &meshNodes[nodeIds[index][2]];
break;
default:
return;
}
Point3 a, b;
diff3(*p3, *p1, a);
diff3(*p2, *p1, b);
cross3(b, a, normal);
normalize(normal);
for (int i = 0; i < 3; i++) {
if ( isZero(normal[i]) ) {
normal[i] = 0.0;
}
}
}
static void recorditem(GLdouble *n1, GLdouble *n2, GLdouble *n3,
GLdouble center[3], GLdouble radius, GLenum shadeType, int avnormal)
{
GLdouble p1[3], p2[3], p3[3], q0[3], q1[3], n11[3], n22[3], n33[3];
int i;
for (i = 0; i < 3; i++) {
p1[i] = n1[i]*radius + center[i];
p2[i] = n2[i]*radius + center[i];
p3[i] = n3[i]*radius + center[i];
}
if (avnormal == 0) {
diff3(p1, p2, q0);
diff3(p2, p3, q1);
crossprod(q0, q1, q1);
normalize(q1);
m_xformpt(p1, p1, q1, n11);
m_xformptonly(p2, p2);
m_xformptonly(p3, p3);
glBegin (shadeType);
glNormal3dv(n11);
glVertex3dv(p1);
glVertex3dv(p2);
glVertex3dv(p3);
glEnd();
return;
}
m_xformpt(p1, p1, n1, n11);
m_xformpt(p2, p2, n2, n22);
m_xformpt(p3, p3, n3, n33);
glBegin (shadeType);
glNormal3dv(n11);
glVertex3dv(p1);
glNormal3dv(n22);
glVertex3dv(p2);
glNormal3dv(n33);
glVertex3dv(p3);
glEnd();
}
void TestNonlinearEquationPde()
{
ChastePoint<1> zero1(0);
ChastePoint<2> zero2(0,0);
ChastePoint<3> zero3(0,0,0);
double u = 2.0;
NonlinearEquationPde<1> heat_equation1;
NonlinearEquationPde<2> heat_equation2;
NonlinearEquationPde<3> heat_equation3;
TS_ASSERT_DELTA(heat_equation1.ComputeNonlinearSourceTerm(zero1,u),0.0,1e-12);
TS_ASSERT_DELTA(heat_equation2.ComputeNonlinearSourceTerm(zero2,u),0.0,1e-12);
TS_ASSERT_DELTA(heat_equation3.ComputeNonlinearSourceTerm(zero3,u),0.0,1e-12);
// Diffusion matrices should be equal to identity * u;
c_matrix<double, 1, 1> diff1 = heat_equation1.ComputeDiffusionTerm(zero1,u);
c_matrix<double, 2, 2> diff2 = heat_equation2.ComputeDiffusionTerm(zero2,u);
c_matrix<double, 3, 3> diff3 = heat_equation3.ComputeDiffusionTerm(zero3,u);
TS_ASSERT_DELTA(diff1(0,0),u,1e-12);
TS_ASSERT_DELTA(diff2(0,0),u,1e-12);
TS_ASSERT_DELTA(diff2(1,1),u,1e-12);
TS_ASSERT_DELTA(diff2(0,1),0,1e-12);
TS_ASSERT_DELTA(diff3(0,0),u,1e-12);
TS_ASSERT_DELTA(diff3(1,1),u,1e-12);
TS_ASSERT_DELTA(diff3(2,2),u,1e-12);
TS_ASSERT_DELTA(diff3(0,1),0,1e-12);
TS_ASSERT_DELTA(diff3(0,2),0,1e-12);
TS_ASSERT_DELTA(diff3(1,2),0,1e-12);
}
static void pentagon(int a, int b, int c, int d, int e, GLenum shadeType)
{
GLdouble n0[3], d1[3], d2[3], d3[3], d4[3], d5[3], nout[3];
diff3(&dodec[a][0], &dodec[b][0], d1);
diff3(&dodec[b][0], &dodec[c][0], d2);
crossprod(d1, d2, n0);
normalize(n0);
m_xformpt(&dodec[a][0], d1, n0, nout);
m_xformptonly(&dodec[b][0], d2);
m_xformptonly(&dodec[c][0], d3);
m_xformptonly(&dodec[d][0], d4);
m_xformptonly(&dodec[e][0], d5);
glBegin (shadeType);
glNormal3dv(nout);
glVertex3dv(d1);
glVertex3dv(d2);
glVertex3dv(d3);
glVertex3dv(d4);
glVertex3dv(d5);
glEnd();
}
void
MeshElementTable::calcCenter(int index)
{
if (centers == NULL)
return;
const int* nodeIds = getNodeIds(index);
// Create center point
Point3& center = centers[index];
centerPoint(index, center);
// Calculate square of the distance of the first node
// from the center
Point3 r;
diff3(meshNodes[nodeIds[0]], center, r);
double rsquared = dot3(r, r);
rSquares[index] = rsquared;
}
void TestHeatEquation()
{
ChastePoint<1> zero1(0);
ChastePoint<2> zero2(0,0);
ChastePoint<3> zero3(0,0,0);
double u = 2.0;
HeatEquation<1> pde1;
HeatEquation<2> pde2;
HeatEquation<3> pde3;
TS_ASSERT_DELTA(pde1.ComputeSourceTerm(zero1,u), 0.0, 1e-12);
TS_ASSERT_DELTA(pde2.ComputeSourceTerm(zero2,u), 0.0, 1e-12);
TS_ASSERT_DELTA(pde3.ComputeSourceTerm(zero3,u), 0.0, 1e-12);
TS_ASSERT_DELTA(pde1.ComputeDuDtCoefficientFunction(zero1), 1.0, 1e-12);
TS_ASSERT_DELTA(pde2.ComputeDuDtCoefficientFunction(zero2), 1.0, 1e-12);
TS_ASSERT_DELTA(pde3.ComputeDuDtCoefficientFunction(zero3), 1.0, 1e-12);
// Diffusion matrices should be equal to identity
c_matrix<double, 1, 1> diff1 = pde1.ComputeDiffusionTerm(zero1);
c_matrix<double, 2, 2> diff2 = pde2.ComputeDiffusionTerm(zero2);
c_matrix<double, 3, 3> diff3 = pde3.ComputeDiffusionTerm(zero3);
TS_ASSERT_DELTA(diff1(0,0), 1, 1e-12);
TS_ASSERT_DELTA(diff2(0,0), 1, 1e-12);
TS_ASSERT_DELTA(diff2(1,1), 1, 1e-12);
TS_ASSERT_DELTA(diff2(0,1), 0, 1e-12);
TS_ASSERT_DELTA(diff3(0,0), 1, 1e-12);
TS_ASSERT_DELTA(diff3(1,1), 1, 1e-12);
TS_ASSERT_DELTA(diff3(2,2), 1, 1e-12);
TS_ASSERT_DELTA(diff3(0,1), 0, 1e-12);
TS_ASSERT_DELTA(diff3(0,2), 0, 1e-12);
TS_ASSERT_DELTA(diff3(1,2), 0, 1e-12);
Node<1> node(0, zero1);
TS_ASSERT_DELTA(pde1.ComputeSourceTermAtNode(node,u), 0.0, 1e-12);
}
void TestHeatEquationWithElementDependentSourceTerm()
{
// The PDE is set to give elements with index = 0 a source of zero
// and a source of 1 otherwise.
std::vector<Node<1>*> one_d_nodes;
one_d_nodes.push_back(new Node<1>(0, false, 2.0));
one_d_nodes.push_back(new Node<1>(1, false, 2.5));
Element<1,1> one_d_element(0u, one_d_nodes);
ChastePoint<1> zero1(0);
std::vector<Node<2>*> two_d_nodes;
two_d_nodes.push_back(new Node<2>(0, false, 0.0, 0.0));
two_d_nodes.push_back(new Node<2>(1, false, 1.0, 0.0));
two_d_nodes.push_back(new Node<2>(2, false, 0.0, 1.0));
Element<2,2> two_d_element(0u, two_d_nodes);
ChastePoint<2> zero2(0,0);
std::vector<Node<3>*> three_d_nodes;
three_d_nodes.push_back(new Node<3>(0, false, 0.0, 0.0, 0.0));
three_d_nodes.push_back(new Node<3>(1, false, 1.0, 0.0, 0.0));
three_d_nodes.push_back(new Node<3>(2, false, 0.0, 1.0, 0.0));
three_d_nodes.push_back(new Node<3>(3, false, 0.0, 0.0, 1.0));
Element<3,3> three_d_element(0u, three_d_nodes);
ChastePoint<3> zero3(0,0,0);
double u = 2.0;
HeatEquationWithElementDependentSourceTerm<1> pde1;
HeatEquationWithElementDependentSourceTerm<2> pde2;
HeatEquationWithElementDependentSourceTerm<3> pde3;
TS_ASSERT_DELTA(pde1.ComputeSourceTerm(zero1, u, &one_d_element), 0.0, 1e-12);
one_d_element.ResetIndex(1u);
TS_ASSERT_DELTA(pde1.ComputeSourceTerm(zero1, u, &one_d_element), 1.0, 1e-12);
TS_ASSERT_DELTA(pde2.ComputeSourceTerm(zero2, u, &two_d_element), 0.0, 1e-12);
two_d_element.ResetIndex(1u);
TS_ASSERT_DELTA(pde2.ComputeSourceTerm(zero2, u, &two_d_element), 1.0, 1e-12);
TS_ASSERT_DELTA(pde3.ComputeSourceTerm(zero3, u, &three_d_element), 0.0, 1e-12);
three_d_element.ResetIndex(1u);
TS_ASSERT_DELTA(pde3.ComputeSourceTerm(zero3, u, &three_d_element), 1.0, 1e-12);
TS_ASSERT_DELTA(pde1.ComputeDuDtCoefficientFunction(zero1), 1.0, 1e-12);
TS_ASSERT_DELTA(pde2.ComputeDuDtCoefficientFunction(zero2), 1.0, 1e-12);
TS_ASSERT_DELTA(pde3.ComputeDuDtCoefficientFunction(zero3), 1.0, 1e-12);
// Diffusion matrices should be equal to identity
c_matrix<double, 1, 1> diff1 = pde1.ComputeDiffusionTerm(zero1);
c_matrix<double, 2, 2> diff2 = pde2.ComputeDiffusionTerm(zero2);
c_matrix<double, 3, 3> diff3 = pde3.ComputeDiffusionTerm(zero3);
TS_ASSERT_DELTA(diff1(0,0), 1, 1e-12);
TS_ASSERT_DELTA(diff2(0,0), 1, 1e-12);
TS_ASSERT_DELTA(diff2(1,1), 1, 1e-12);
TS_ASSERT_DELTA(diff2(0,1), 0, 1e-12);
TS_ASSERT_DELTA(diff3(0,0), 1, 1e-12);
TS_ASSERT_DELTA(diff3(1,1), 1, 1e-12);
TS_ASSERT_DELTA(diff3(2,2), 1, 1e-12);
TS_ASSERT_DELTA(diff3(0,1), 0, 1e-12);
TS_ASSERT_DELTA(diff3(0,2), 0, 1e-12);
TS_ASSERT_DELTA(diff3(1,2), 0, 1e-12);
delete one_d_nodes[0];
delete one_d_nodes[1];
delete two_d_nodes[0];
delete two_d_nodes[1];
delete two_d_nodes[2];
delete three_d_nodes[0];
delete three_d_nodes[1];
delete three_d_nodes[2];
delete three_d_nodes[3];
}
int
MeshEdgeElementTable::calcLineIntersections(int elem_index, short elem_dir,
Point3& lstart, Point3& ldir, Point3* isec_points)
{
meshElementCode elem_code = getElementCode(elem_index);
if (elem_code < MEC_202 || elem_code >= 303)
return 0;
const int* nodeIds = getNodeIds(elem_index, elem_dir);
Point3& p0 = meshNodes[nodeIds[0]];
Point3& p1 = meshNodes[nodeIds[1]];
Point3& normal = normals[elem_index];
if (elem_dir == -1)
scalarmult(-1, normal, normal);
// Check end-point cases
if ( samepoint(p0, lstart) ){
copy3(p0, *isec_points);
return 1;
}
if ( samepoint(p1, lstart) ){
copy3(p1, *isec_points);
return 1;
}
Point3 edge_dir, l_delta0, tmp;
// Edge direction vector (normalized)
edge_dir[0] = normal[1];
edge_dir[1] = -1 * normal[0];
edge_dir[2] = 0.0;
// Edge length
diff3(p1, p0, tmp);
double edge_len = dot3(edge_dir, tmp);
// Vector l_delta0 = lstart - p0
diff3(lstart, p0, l_delta0);
// Check that intersection is "within" the edge
// project the intersection point to the edge
double t = dot3(edge_dir, l_delta0);
if ( isLess(t, 0.0) ||
isGreater(t, edge_len)
)
return 0;
// Check that intersection distance from the edge is ok
// project intersection point to the edge normal
double d = dot3(normal, l_delta0);
if (d < 0)
d *= -1;
if ( isGreater(d, MeshEdgeElementTable::pickingTolerance) )
return 0;
// Intersection point is: p0 + t * (p1 - p0)
scalarmult(t, edge_dir, tmp);
add3(p0, tmp, *isec_points);
return 1;
}
