template <int dim, typename Number>
inline
Tensor<1,dim,Number>
-cross_product (const Tensor<1,dim,Number> &src)
+cross_product_2d (const Tensor<1,dim,Number> &src)
{
Assert (dim==2, ExcInternalError());
template <int dim, typename Number>
inline
Tensor<1,dim,Number>
-cross_product (const Tensor<1,dim,Number> &src1,
- const Tensor<1,dim,Number> &src2)
+cross_product_3d (const Tensor<1,dim,Number> &src1,
+ const Tensor<1,dim,Number> &src2)
{
Assert (dim==3, ExcInternalError());
// now compute the
// two normals
- orthonormals[0] = cross_product (vector, tmp);
- orthonormals[1] = cross_product (vector, orthonormals[0]);
+ orthonormals[0] = cross_product_3d (vector, tmp);
+ orthonormals[1] = cross_product_3d (vector, orthonormals[0]);
break;
}
// The RHS entries are:
// \int_{edge} (tangential* boundary_value) * (tangential * edge_shape_function_i) dS.
//
- // In 2D, tangential*vector is equivalent to cross_product(normal, vector), so we use this instead.
+ // In 2D, tangential*vector is equivalent to cross_product_3d(normal, vector), so we use this instead.
// This avoids possible issues with the computation of the tangent.
// Store the normal at this quad point:
const unsigned int cell_j = fe.face_to_cell_index (j_face_idx, face);
cross_product_j =
- cross_product(normal_vector,
- fe_face_values[vec].value(cell_j, q_point));
+ cross_product_3d(normal_vector,
+ fe_face_values[vec].value(cell_j, q_point));
for (unsigned int i = 0; i < associated_face_dofs; ++i)
{
const unsigned int i_face_idx = associated_face_dof_to_face_dof[i];
const unsigned int cell_i = fe.face_to_cell_index (i_face_idx, face);
cross_product_i =
- cross_product(normal_vector,
- fe_face_values[vec].value(cell_i, q_point));
+ cross_product_3d(normal_vector,
+ fe_face_values[vec].value(cell_i, q_point));
face_matrix(i, j) += fe_face_values.JxW(q_point) *
cross_product_i * cross_product_j;
}
// compute rhs
- cross_product_rhs = cross_product(normal_vector, tmp);
+ cross_product_rhs = cross_product_3d(normal_vector, tmp);
face_rhs(j) += fe_face_values.JxW(q_point) *
cross_product_rhs * cross_product_j;
}
// we get here only for dim==3, but at least one isn't
// quite smart enough to notice this and warns when
// compiling the function in 2d
- tangent = cross_product (normals[0], normals[dim-2]);
+ tangent = cross_product_3d (normals[0], normals[dim-2]);
break;
default:
Assert (false, ExcNotImplemented());
Tensor<1,3>
wedge_product (const Tensor<1,3> (&derivative)[2])
{
- return cross_product (derivative[0], derivative[1]);
+ return cross_product_3d (derivative[0], derivative[1]);
}
-1 : +1);
break;
case 2:
- output_data.boundary_forms[i] = cross_product(data.aux[0][i]);
+ output_data.boundary_forms[i] = cross_product_2d(data.aux[0][i]);
break;
case 3:
output_data.boundary_forms[i] =
- cross_product(data.aux[0][i], data.aux[1][i]);
+ cross_product_3d(data.aux[0][i], data.aux[1][i]);
break;
default:
Assert(false, ExcNotImplemented());
data.contravariant[point].transpose();
Tensor<1, spacedim> cell_normal =
- cross_product(DX_t[0], DX_t[1]);
+ cross_product_3d(DX_t[0], DX_t[1]);
cell_normal /= cell_normal.norm();
// then compute the face normal from the face tangent
// and the cell normal:
output_data.boundary_forms[point] =
- cross_product(data.aux[0][point], cell_normal);
+ cross_product_3d(data.aux[0][point], cell_normal);
}
}
if (dim==1)
output_data.normal_vectors[point] =
- cross_product(-DX_t[0]);
+ cross_product_2d(-DX_t[0]);
else //dim == 2
output_data.normal_vectors[point] =
- cross_product(DX_t[0], DX_t[1]);
+ cross_product_3d(DX_t[0], DX_t[1]);
output_data.normal_vectors[point] /= output_data.normal_vectors[point].norm();
if (dim==1)
output_data.normal_vectors[point] =
- cross_product(-DX_t[0]);
+ cross_product_2d(-DX_t[0]);
else //dim == 2
output_data.normal_vectors[point] =
- cross_product(DX_t[0], DX_t[1]);
+ cross_product_3d(DX_t[0], DX_t[1]);
output_data.normal_vectors[point] /= output_data.normal_vectors[point].norm();
break;
case 2:
output_data.boundary_forms[i] =
- cross_product(data.aux[0][i]);
+ cross_product_2d(data.aux[0][i]);
break;
case 3:
output_data.boundary_forms[i] =
- cross_product(data.aux[0][i], data.aux[1][i]);
+ cross_product_3d(data.aux[0][i], data.aux[1][i]);
break;
default:
Assert(false, ExcNotImplemented());
data.contravariant[point].transpose();
Tensor<1, spacedim> cell_normal =
- cross_product(DX_t[0], DX_t[1]);
+ cross_product_3d(DX_t[0], DX_t[1]);
cell_normal /= cell_normal.norm();
// then compute the face normal from the face tangent
// and the cell normal:
output_data.boundary_forms[point] =
- cross_product(data.aux[0][point], cell_normal);
+ cross_product_3d(data.aux[0][point], cell_normal);
}
}
}
const Tensor<1,3> v01 = accessor.vertex(1) - accessor.vertex(0);
const Tensor<1,3> v02 = accessor.vertex(2) - accessor.vertex(0);
- Tensor<1,3> normal = cross_product(v01, v02);
+ Tensor<1,3> normal = cross_product_3d(v01, v02);
const Tensor<1,3> v03 = accessor.vertex(3) - accessor.vertex(0);
// the face is planar. then its area is 1/2 of the norm of the
// cross product of the two diagonals
const Tensor<1,3> v12 = accessor.vertex(2) - accessor.vertex(1);
- Tensor<1,3> twice_area = cross_product(v03, v12);
+ Tensor<1,3> twice_area = cross_product_3d(v03, v12);
return 0.5 * twice_area.norm();
}
Tensor<1,2>
normalized_alternating_product (const Tensor<1,2> (&basis_vectors)[1])
{
- Tensor<1,2> tmp = cross_product (basis_vectors[0]);
+ Tensor<1,2> tmp = cross_product_2d (basis_vectors[0]);
return tmp/tmp.norm();
}
Tensor<1,3>
normalized_alternating_product (const Tensor<1,3> (&basis_vectors)[2])
{
- Tensor<1,3> tmp = cross_product (basis_vectors[0], basis_vectors[1]);
+ Tensor<1,3> tmp = cross_product_3d (basis_vectors[0], basis_vectors[1]);
return tmp/tmp.norm();
}
// then compute the normal by taking the cross product. since the
// normal is not required to be normalized, no problem here
- face_vertex_normals[vertex] = cross_product(tangents[0], tangents[1]);
+ face_vertex_normals[vertex] = cross_product_3d(tangents[0], tangents[1]);
};
}