Remove a file that was probably never intended to be added.

diff --git a/tests/codim_one/10-jul-08-report b/tests/codim_one/10-jul-08-report
deleted file mode 100644 (file)
index f757062..0000000
--- a/tests/codim_one/10-jul-08-report
+++ /dev/null
@@ -1,101 +0,0 @@
-ADVANCEMENTS INTRODUCED IN THE DEAL.II LIBRARY TO IMPLEMENT BOUNDARY ELEMENT METHOD PROBLEMS
-
-  Up till now the library was capable of handling n-dimensional cells in an n-dimensional space (for instance, in two dimensions a
-quadrilateral can be a cell, but not a segment or a piece of a curve). This is a reasonable choice as long as one has to solve FEM problems,
-but it makes very complicate, if not impossible, implementing Boundary Element Method (BEM) problems. In brief, formulating a problem in BEM 
-consists in finding a suitable transformation of the equations used that allows one to express and solve the problem just on the boundary of
-the domain and then to extend this boundary solution to the whole domain. One can show, for instance, that the 3d exterior Laplace equation
-can be transformed into an integral equation on the boundary surface, solved there and then extended to the rest of the space (by the way,
-this method can be used to study the irrotational flow around an obstacle without meshing the entire fluid around it, but just meshing the
-surface of the obstacle). So, the great advantage that the BEM offers is the significant reduction of the number of degrees of freedom. On
-the other hand, the integral operators used in the boundary equations give rise to full matrices, so one needs to find some proper way to
-approximate these operators and obtain diagonal-predominant matrices.
-  In order to exploit what the library already offered without writing new code, a new template parameter "spacedim" was added
-to each class that needed it. As one may expect, the first one was the class Triangulation<dim> which was changed into
-Triangulation<dim, spacedim> and then all the others listed at the end of this document were modified. With this change, if one wanted to 
-create an object representing a surface in 3d space one would write:
-
-Triangulation<2,3> surface; 
-       
-The declaration of the new parameter was made in such a way that if one does not specify it, the compiler assumes it has the default value dim
-(if one writes Triangulation<2> it is the same as writing Triangulation<2,2>), so that all the existing examples and programs need not be 
-modified if one wants to use this new version. Notice that a declaration such as A_Class<1,3>, altough being legal, is not usable 
-because none of the deal.II functions has been implemented for this case (just the <1,2> and <2,3> cases were considered). 
-  What follows is a description of each of the new tests added to the library testsuite in order to show the new functionalities (they can be
-found in the tests/codim_one subdirectory).
-
-
-TEST grid_in_out
-  It shows the way to use GridIn and GridOut classes with meshes written in UCD format that are stored in codim_one/grids. It is not possible
-now to create meshes with functions in the library, one has to create them before and then pass them to the library.
-
-TEST data_out
-  A basic test showing the functionality of the DataOut class (here vertex numbers are written in a vtk file).
-
-TEST grid_refinement
-  It uses the HyperBallBoundary class to show how a hyperspherical mesh can be refined. The class internal function execute_refinement was
-specialized for the cases Triangulation<1,2> and Triangulation<2,3>, basically reusing the code written for Triangulation<2> and 
-Triangulation<3>, respectively.
-
-TEST mapping_q1
-  It calculates the points in real space corresponding to the quadrature points on the reference element. The inverse function, that is 
-mapping.transform_real_to_unit_cell, has not been written for the moment, because it is not needed. An exception is thrown if this function is
-called by any mapping class object. 
-   
-TEST surface
-  This test was used to verify the correct calculation of the surface of a hypersphere and of the normal vector in a point of the cell. In
-order to calculate an integral on a line or on a surface, one needs to calculate the jacobian of the transformation from the reference
-element to the real one. If dim=spacedim one just needs to compute the modulus of the determinant of the jacobian and consider it as a factor
-of the integrating function. On the other hand, if dim is different from spacedim, the jacobian is a rectangular matrix and one should
-calculate the Gram determinant of this matrix and then use it as a factor in the integration. In the code added (see the fill_fe_values
-function in mapping_q1.cc) a general way to calculate the Gram determinant is not implemented since in the <1,2> case it coincides with the
-norm of the jacobian (which in this case is a vector) and in the <2,3> case it is the modulus of the cross product of the two first rows of
-the jacobian. The normals can then be easily calculated in both cases. Perhaps a more general way to calculate the Gram determinant would be
-more useful in the long run. As can be seen, no modification is needed for the quadrature classes. Notice, however, that only continuous Q
-element can be used up to now, even if there is a partial implementation of discontinuous ones which are needed since they are commonly used
-in BEM problems (at least constants).
-
-TESTS interpolation, projection, projection_dgp
-  Adaptation of the existing function VectorTools::interpolate and VectorTools::project to the newly created classes. No other functions in
-VectorTools than interpolate and project have been modified for use with codimension one problems. Discontinous elements (fe_dgp) were 
-implemented without calling the functions compute_embedding_matrices and compute_projection_matrices in the constructors, so no passage 
-of information between meshes of different refinement level is possible.
-
-TEST gradients
-  This test calculates the directional derivative of a simple function (a polynomial) projected on the finite element space in order to
-verify that the covariant matrix is calculated properly. In fact, one needs this matrix to obtain the gradients of the shape functions and
-then one uses these gradients in order to calculate the gradient of the projected function. Finally, the scalar product of this latter
-gradient with the tangential taken at the midpoint of the cell is made so as to obtain the desired directional derivative (in the <2,3> case
-the tangential with z component equal to zero is chosen out of the tangent plane). 
-  Here follow some details about the calculation of the covariant matrix. Since the contravariant matrix is rectangular, as described above,
-also the covariant matrix turns out to be rectangular (in fact, it is the left inverse of the contravariant matrix, see the compute_fill
-function in mapping_q1.cc). Finally, two specializations for the transform_covariant functions have been added, one for the <1,2> case, the
-other for the <2,3> case.
-  Notice also that DGQ elements have been used, also if in a very basic way. Further testing on these elements is evidently needed. Their
-implementation in the codimension 1 case is also partial, since in the class constructor 2 functions, namely compute_embedding_matrices and
-compute_projection_matrices, were excluded, apparently without consequences at least in the case of constants. Anyway, no passage 
-of information between meshes of different refinement level is possible.
-
-TEST integrate_log
-  A test for the class QGaussLog that here is used to integrate f(x)*log(x-a) on a given interval (a,b). The weights have been explicitly
-inserted in the definition of the class, but a method to calculate them as the one described in Numerical Recipes will be implemented as soon
-as possible. It is not easy to find the points and weights for a formula on a general interval (a,b) and the ones given here work for the
-integration on the interval (0,1) with the singularity either in 0 or in 1. However, with a simple change of variable one can easily extend
-the interval, as explained in the documentation and shown in the test, but the singularity still remains in one of the extrema. If the
-singularity is in the middle of the interval, one can always decide to integrate separately the right and the left interval (in fact, it is
-possible to revert points and weights if the boolean variable revert in the constructor is set to true, so that one can integrate
-f(x)*ln(a-x) ).
-
-
-ALPHABETICAL LIST OF THE MOST IMPORTANT CLASSES THAT HAVE BEEN MODIFIED
-
-DataOut
-DoFHandler
-FE_DGP (partial)
-FE_DGQ (partial)
-FE_Q
-FEValues
-GridIn
-MappingQ1
-Triangulation
-VectorTools
\ No newline at end of file