The deal.II news page
Author: the deal.II authors <authors@dealii.org>
Keywords: deal.II

## Changes between Version 4.0.0 and 5.0.0

This is the list of changes made after the release of deal.II version 4.0. It is subdivided into changes made to the three sub-libraries base, lac, and deal.II, as well as changes to the general infrastructure, documentation, etc.

All entries are signed with the names of the author. Regular contributor's names are abbreviated by WB (Wolfgang Bangerth), GK (Guido Kanschat), RH (Ralf Hartmann).

### Incompatibilities

Following are a few modifications to the library that unfortunately are incompatible with previous versions of the library, but which we deem necessary for the future maintainability of the library. Unfortunately, some of these changes will require modifications to application programs. We apologize for the inconvenience this causes.

1. Removed: All the matrix classes have functions `reinit` that are used to resize the matrix. However, the sparse matrix classes had an equally named function without arguments that basically left the size of the matrix unchanged but set all elements of the matrix to zero. It could also be abused to notify the matrix that the sparsity pattern on which it is built has changed, an inherently risky procedure. The no-argument code reinit function has therefore been removed to avoid confusion with the `reinit` functions that take arguments. Instead, you should now use `matrix=0` to simply set all elements of the matrix to zero. If you want to notify a sparse matrix that its sparsity pattern has changed, use the `reinit(SparsityPattern)` function.
   (WB 2004/05/10)

2. Removed: All the vector and block vector classes as well as the `FullMatrix` class (the latter through its `Table` base class) had a member function `clear` which simply resets all values of the vector or matrix to zero. It did not change the size of the object, though. This was confusing, since the standard C++ container classes implement the semantics that the `clear` functions delete all entries of the containers, i.e. resize it to zero, and we implemented similar semantics also for the `SparseMatrix`, `DoFHandler`, `ConstraintMatrix` and various other classes.
   To avoid this confusion in the future, the `clear` functions have been dropped from the interface of the vector and full matrix classes, and the remaining instances where deal.II classes have a function of that name really mean that the object is reset to its virginal state. To set all elements of a matrix or vector to zero without changing its size, the recommended way is to use the more obvious notation `vector=0` and `matrix=0`. To reset the elements of a table over arbitrary objects, use `Table<T>::reset_values()`.
   (WB 2004/05/10)

3. Removed: The `SparseLUDecomposition::reinit` and `SparseMIC::reinit` functions without argument had been deprecated before, and have now been removed.
   (WB 2004/05/10)

4. Changed: the template parameter of `MGTransferPrebuilt` is now the complete vector type, not just the value type of the vector. This allows to operate on `Vector` as well as on `BlockVector`. Unfortunately, the untested class `MGTransferBlock` underwent some more changes without testing, such that it should be used with high caution.
   (GK 2004/04/01)

5. Changed: The `FiniteElement` classes had a function `restrict` that returns the restriction matrix from children to the mother cell. Unfortunately, `restrict` has become a keyword in recent standards of the C language, and some C++ compilers have picked this up. The function has therefore been renamed `get_restriction_matrix`, which also better reflects what it is actually doing. To keep consistent, we have also rename the corresponding function `prolongate` to `get_prolongation_matrix`.
   (WB 2004/02/29)

6. Fixed and changed: The `SolutionTransfer``::(refine_)interpolate(const Vector &in, Vector &out)` functions now require the `in` and `out` vectors being already of right sizes, i.e. `in.size()=n_dofs_old` and `out.size()=n_dofs_refined`. Furthermore, the `SolutionTransfer``::(refine_)interpolate(const vector<Vector> &all_in, vector<Vector> &all_out)` now check that the number of in and output vectors are the same, i.e. `all_in.size()=all_out.size()`.
   (RH 2003/10/24)

7. Changed: The `QProjector` has functions that project a lower-dimensional quadrature formula onto all faces or subfaces of a cell. In 3d, it now does this but also adds projections of these quadrature formula onto the faces from the other side. We need this due to the fact that we now support faces in 3d that have a normal vector opposite to the standard direction.
   (WB 2003/10/17)

8. Moved and changed: The header file `include/numerics/dof_renumbering.h` has been moved to the directory `include/dofs`, where it logically belongs. Furthermore, the sorting parameter of the function `DoFRenumbering``::component_wise` has changed its meaning. See the reference documentation for details.
   (GK 2003/07/03)

### General

1. New: After the documentation tool for deal.II has been changed to Doxygen, it is delivered in two tar-files. Additional to the traditional source tarball, the preprocessed documentation is available ready for reading with a web browser.
   (GK 2004/05/04)

2. New: The step-15 example is about solving a nonlinear 1d problem, and dealing with transporting a solution across mesh refinement. Step-16 is still not finished.
   (WB 2004/04/17)

3. New: The step-17 example program shows how to use the new PETSc wrapper classes, and how to do large-scale computations with up to many millions of unknowns on a cluster of computers. This program shows that deal.II is well-suited for truly massive parallel computations. The step-15 and step-16 programs have not yet been finished (despite having been started long before step-17), which explains the holes in the numbering of example programs.
   (WB 2004/04/12)

4. New: deal.II is now able to interface to the METIS library to generate domain partitionings. This is enabled if a METIS installation is detected, which either happens automatically in `./configure`, or by passing a value to the switch `--with-metis` to configure the path of a METIS installation. For more information see the README file.
   (WB 2004/03/08)

5. New: We now support MIPSpro compiler version 7.41 from SGI. deal.II now runs on IRIX64 machines in 64-bit mode.
   Please note, that we cannot support earlier MIPSpro compilers because the compiler version 7.3 was not C++ standard conforming. Version 7.4 is standard conforming but still too buggy.
   (RH 2004/03/08)

6. New: deal.II now comes with a complete set of wrappers classes for PETSc vectors, matrices, linear solvers and preconditioners. Many of the algorithms in deal.II have also been updated to make use of these wrappers. All of this is only enabled if a PETSc installation is detected. This either happens automatically in `./configure`, or by passing values to the switches `--with-petsc` and `--with-petsc-arch` to configure path and architecture of an existing PETSc installation. If these switches are not used, then environment variables are searched for this information. For more information see the README file.
   (WB 2004/03/01)

7. Changed: The part of the boost library in the `contrib` directory is now updated to boost version 1-30.2. We include only a minimal part (about 3% in size) of boost which is needed to compile deal.II. For the case the compilation of deal.II on some compiler/platforms requires boost files in addition to those included in the `contrib` directory please report the missing boost files to the deal.II mailing list.
   (RH 2004/02/16)

8. Changed: We don't support compilation by Intel'c icc compiler version 5 anymore. Since the present version of this compiler is 8, this is probably not a real problem.
   (WB 2003/12/20)

9. Fixed: `step-9` had the computation of the value of the solution in the mid-point of the neighbor cell wrong. This is now fixed. Consequently, the resulting mesh also looks much nicer now (much smoother).
   (Werner Scholz 2003/12/11)

10. New: The `config.h` file now declares a variable `deal_II_numbers::invalid_unsigned_int`. It is a representation of the largest number that can be put into an unsigned integer. This value is widely used throughout the library as a marker for an invalid unsigned integer value, such as an invalid array index, an invalid array size, and the like.
    (WB 2003/10/24)

11. Augmented: The `GeometryInfo::child_cell_on_face` results in a result that might not be what you expect in 3d in some cases. A warning has been added to the documentation, as well as a reference to the function to call instead.
    (WB 2003/10/17)

12. Fixed: The step-14 program had a bug in the rare case that there are more CPUs in a machine than there are cells. This is now fixed.
    (WB 2003/09/23)

13. Fixed: In the step-14 example program, overly conservative quadrature formulas were chosen (with 2N+1 quadrature points per space dimension, where N is the degree of polynomials). This is unnecessary, and now fixed.
    (WB 2003/09/23)

14. Fixed: On AIX systems, the xlf Fortran77 compiler wasn't recognized due to the fact that when called with -v it generates many pages of output, later leading to a shell error. This is now fixed.
    (WB 2003/09/19)

15. Fixed: The elastic example program, step-8, had a bug in the way the system matrix is assembled. In effect, we were solving the wrong equation. This should now be fixed.
    (WB 2003/09/11)

16. Fixed: When building with both sparse direct solver MA27 and the TECPLOT libraries, the `detached_ma27` would not link properly. This is now fixed.
    (WB 2003/09/05)

17. Improved: The script that builds the dependency lists for Makefiles has been rewritten in C++, since the previous perl script became just too slow after the addition of parts of BOOST. Using the old perl script should still work, although it simply forwards to the new program. In order to use the new one, simply replace the line ``

                 $(PERL) $D/common/scripts/make_dependencies.pl ...

    by `

                 $D/common/scripts/make_dependencies ...

    ` i.e. call the program directly without the perl interpreter and without the file extension for a perl program.
    (WB 2003/08/19)

18. New: First steps to a migration of the documentation from `kdoc` to Doxygen have been done. It can be generated after installing Doxygen by calling `make` in `doc/doxygen` and using the preliminary link page index.html in that directory.
    (GK 2003/08/02)

### base

1. New: There is now a new `PolynomialsP` class which is based on `Polynomials::Monomial` and `PolynomialSpace`. In contrast to the default ordering of the polynomials in `PolynomialSpace`, (e.g. for degree=2) 1, x, x2, y, xy, y2, the `PolynomialsP` class now gives the (natural?!) ordering 1, x, y, xy, x2, y2.
   (RH 2004/03/11)

2. New: The classes `PolynomialSpace` and `TensorProductPolynomials` now have new `set_numbering` functions which allow to change the ordering of the polynomials. The ordering and the indices of the polynomials kann be checked by using the new `output_indices` functions.
   (RH 2004/03/11)

3. New: The class `PolynomialsBDM` implements BDM polynomials in two dimensions on the unit square. It was implemented as is according to some urgent need, but should be suitable to be fit into a `FiniteElement` similar to Raviart/Thomas.
   (GK 2004/01/05)

4. New: Objects of type `Polynomial` can now be added to and subtracted from each other through operators `+=` and `-=`.
   (GK 2003/12/16)

5. New: There is now a class `QuadratureSelector` that allows to select a quadrature formula based on a string argument and possibly a number indicating the order of the formula.
   (Ralf B. Schulz 2003/10/29)

6. Fixed: The constructor of the `QGauss` class computed positions and weights of quadrature points in long double accuracy. However, on machines where long double is the same as double, it never reached the requested accuracy, in effect leading to an infinite loop. This is now fixed.
   (WB 2003/09/19)

7. New: The `Function` class now exports the value of its template argument through the static member variable `dimension`.
   (WB 2003/09/15)

8. Changed: The `ParameterHandler::declare_entry` function now allows to redeclare an entry that has already been declared. This can be used to override a default value previously set.
   (WB 2003/09/03)

9. Improved: The `ParameterHandler::declare_entry` function now takes an additional parameter (defaulting to the empty string) that can be used to document the intent of a parameter. This string, together with the default value of an entry, is written to the output by the `ParameterHandler::print_parameters` function that can be used to generate a virginial parameter file, or one that contains the settings of all parameters used in a computation.
   (WB 2003/08/13)

10. Changed: The `ParameterHandler::declare_entry` previously returned a value indicating whether the just-declared entry didn't already existed and that the default value matches the given pattern. However, this value could only always be true since these two conditions were already guarded by assertions in the implementation at least in debug mode, so the return value was meaningless. The function has now no return type any more.
    (WB 2003/08/13)

11. Improved: `Logstream`::`depth_console`, `Logstream`::`depth_file`, `Logstream`::`log_execution_time` and `Logstream`::`log_time_differences` return the previous value.
    (GK 2003/06/22)

### lac

1. Improved: The matrix-vector operations of `SparseMatrix` accept arguments of type `BlockVector`.
   (GK/2004/03/31)

2. Fixed: The `SparseMatrix` iterator classes had various interesting bugs when rows of the matrix were completely empty. These should now be fixed.
   (WB 2004/03/30)

3. New: The `SparsityPattern` class now also has an iterator class that allows to walk over all nonzero entries of a sparsity pattern.
   (WB 2004/03/29)

4. New: The iterator classes into `SparseMatrix` have been rearranged and extended, so that it is now also possible to write to individual matrix entries through these iterators.
   (WB 2004/03/29)

5. New: The `Vector` and `BlockVector` classes now have member functions `is_non_negative` that check whether a vector has no negative entries.
   (WB 2004/02/29)

6. Fixed: The `SolverMinRes` class had a nasty bug where we were inadvertently copying vectors; this could also have led to a memory corruption bug. This is now fixed.
   (WB 2004/02/26)

7. New: There is now a function `FullMatrix::add_scaled`. It replaces the old function `FullMatrix::add` which did the same, but had a name that was incompatible with respective functions in the other matrix classes.
   (WB 2004/02/23)

8. New: `FullMatrix` has new functions `add` and ,`Tadd` allowing to add to a selected block of the matrix.
   (GK 2004/02/12)

9. New: The `Vector` class now has operators to compare for equality and inequality.
   (WB 2004/02/09)

10. New: The `SparseMatrix::operator()` generated an assertion failure if the requested entry in the matrix isn't there. This has been changed so that it actually throws an exception instead, also in optimized mode.
    (WB 2004/02/06)

11. New: There is now a function `SparseMatrix::frobenius_norm` that computes the Frobenius norm of a sparse matrix.
    (WB 2004/02/06)

12. Changed: In matrix-vector operations of the `Full/SparseMatrix` classes, source and destination cannot be the same. We now also check that this is indeed the case.
    (WB 2004/01/26)

13. Improved: Initialization routines of class `SparseMatrix` have an additional parameter controlling the storage of diagonal entries.
    (GK 2003/11/18)

14. New: `SolverFGMRES` implements the flexible GMRES method with varying preconditioner from the right. It is also accessible in `SolverSelector` by choosing `fgmres`.
    (GK 2003/10/07)

15. Changed: The `SparseDirectMA27` class used to store a pointer to the sparsity pattern of the matrix. It now releases this as soon as it doesn't need it any more.
    (WB 2003/09/09)

16. New: Some of the member matrix-vector functions of the `BlockSparseMatrix` class that previously could only be used with arguments of type `BlockVector` can now also be used with the usual `Vector` class provided the block matrix has only one block row or column.
    (WB 2003/09/09)

17. Fixed: `FullMatrix`::`copy_from` didn't compile when copying from a sparse matrix. This is now fixed.
    (Ralf B. Schulz 2003/09/04)

18. New: The classes `FullMatrix` and `PreconditionBlockJacobi` have a `const_iterator`.
    (GK 2003/07/18)

### deal.II

1. Improved: The `DoFTools::compute_Cuthill_McKee` function needs to build a sparsity pattern for its operations, and uses the `DoFHandler::max_couplings_per_dof` function for this. However, the estimates returned by the latter function are rather bad in 3d, leading to excessive memory allocation in the Cuthill McKee algorithm in 3d. This is fixed by using an intermediate compressed sparsity pattern instead if we are in 3d.
   (WB 2004/05/18)

2. Improved: `Triangulation` has functions `n_faces` and `n_active_faces`, globally as well as by level, similar to `n_cells`.
   (GK 2004/05/18)

3. New: Added support for gmsh mesh format in `GridIn::read_msh`.
   (Luca Heltai 2004/04/21)

4. New: The function `GridGenerator::cylinder_shell` generates a domain of the type which the name suggests.
   (WB 2004/04/19)

5. Changed: The `KellyErrorEstimator::estimate` function takes an additional parameter that lets it only compute error indicators for a certain subdomain. This is meant to allow for a better parallelization of efforts in parallel programs.
   (GK 2004/04/01)

6. Changed: `MGTransferSelect` uses target components correctly. Unfortunately, the untested class `MGTransferBlock` does not work anymore. Since its usefulness was not clear anyway, this state may continue for a while.
   (GK 2004/04/01)

7. New: There is now a new `FE_Poly` class which is templatized for polynomial spaces like `TensorProductPolynomials`, `PolynomialSpace` or `PolynomialsP`. Many finite element classes are now derived from this class and the implementation of all common functionality is now moved from these finite element classes to `FE_Poly`.
   (RH 2004/03/18)

8. New: The new function `MatrixTools::local_apply_boundary_values` folds boundary value information into local matrices and vectors before they are written into the global matrix and vector. This way, the final call to `MatrixTools::apply_boundary_values` can be avoided.
   (WB 2004/03/16)

9. New: There are now functions `ConstraintMatrix::distribute_local_to_global` that take a local matrix or vector and distribute it to a global one, but taking care of constrained degrees of freedom; in that case, the respective entries are already distributed to the final place in the global matrix or vector. That way, the final call to the `ConstraintMatrix::condense` function can be avoided.
   (WB 2004/03/15)

10. New: The new functions `SparsityPattern::partition`, `GridTools::partition_triangulation`, `DoFTools::get_subdomain_association`, `DoFTools::count_dofs_with_subdomain_association`, `GridTools::get_subdomain_association`, `GridTools::count_cells_with_subdomain_association`, and `DoFRenumbering::subdomain_wise` can now be used to generate partitions of a triangulation and its associated degrees of freedom suitable for parallel computations with PETSc.
    (WB 2004/03/08)

11. Improved: When eliminating nodes from a matrix using the `ConstraintMatrix::condense` functions, the diagonal entry was set to one. It is now set to an entry that more resembles the size of the other diagonal entries, so that we don't run into scaling problems for applications that have very large or small domains.
    (WB 2004/03/02)

12. Changed: The classes `DataOut*` and `KellyErrorEstimator` have been generalized to take more and different vector types as input parameters. In particular, they now take normal and block vectors over doubles and floats, as well as PETSc vectors if PETSc support is detected during configuration of the library.
    (WB 2004/03/01)

13. Changed: The template parameter of the functions in the `GridRefinement` class have been changed. Where they previously denoted the type over which the `Vector` class is to be templated, they now mean the actual vector class. Thus, they can be any other template class as long as there are suitable operations defined over them. In addition, the documentation stated that they must be vectors of floats; this hasn't been true any more for quite a while already, and is duly removed from the documentation.
    (WB 2004/02/28)

14. New: The function FETools::project_dg performs L2-projections between finite element spaces of different degrees on the same mesh.
    (GK 2003/11/28)

15. Improved: `FiniteElementData` has a function tensor_degree(), returning the degree of the polynomial space suitable for choosing a tensor product quadrature formula.
    (GK 2003/11/28)

16. New: Long requested but never implemented before in the library: there is now a function `GridTool`::find_active_cell_around_point that, given a point, finds the active cell in which this point lies.
    (WB 2003/10/30)

17. New: `MGCoarseGridHouseholder` implements a coarse grid solver using QR-factorization.
    (GK 2003/10/17)

18. Fixed: The `FEFaceValuesBase::boundary_form` function was declared but not implemented. This is now fixed.
    (Jörg R. Weimar 2003/10/22)

19. Improved: The `MatrixCreator::create_mass_matrix` functions are now templatized also on the template argument of the `SparseMatrix` class. This allows invoking this function for `SparseMatrix<double>` and `SparseMatrix<float>` objects.
    (RH 2003/10/22)

20. New: There is now also a function `MGDoFCellAccessor::neighbor_child_on_subface` that returns the result of the `CellAccessor::neighbor_child_on_subface` function but converts it so that one can also access MGDoF data.
    (RH 2003/10/22)

21. New: There are now functions `CellAccessor::neighbor_child_on_subface` and `DoFCellAccessor::neighbor_child_on_subface` that should be called instead of using `GeometryInfo::child_cell_on_face` in most cases.
    (WB 2003/10/17)

22. New: `GridGenerator` has a new function `subdivided_hyper_rectangle` which generates a rectangle with given corner points and possibly different numbers of subdivisions in different directions. Use it, e.g., to generate a domain of 1*4 length units with square cells.
    (Joerg Weimar 2003/09/09)

23. Improved: The 3d grid reordering code in the `GridReordering` class now uses an algorithm that is linear in the number of elements. The old code was exponential, so this is a vast improvement.
    (Michael Anderson 2003/09/23)

24. Improved: `GridOut` has a an improved functionality for `write_eps` to color the grid according to the refinement level. A corresponding option is included in `GridOutFlags::Eps<2>`.
    (Joerg Weimar 2003/09/09)

25. New: The `TriaAccessor`::`point_inside` function is now also implemented in 3d.
    (Joerg Weimar, WB 2003/09/04)

26. New: The `TriaAccessor`::`recursively_set_material_id` function sets the material id of the present cell and of all its children, grandchildren, etc to the given value.
    (WB 2003/09/04)

27. New: The new `FETools`::`get_fe_from_name` function can do the reverse of the `FiniteElement`::`get_name` function: it takes a string and parses it to regenerate a finite element from it. Useful for parsing finite element names from input files.
    (WB 2003/07/08)

28. New: The `DataOut_DoFData`::`merge_patches` now takes a second parameter that indicates a shift for each vertex of the given patches to be merged. This is sometimes nice if one wants to generate "exploded" views of a collection of subdomains. It is also templatized on the first argument, so can merge in some other `DataOut_DoFData` that create the same type of patches but are otherwise different.
    (WB 2003/06/30)

29. Fixed: The `FETools`::`extrapolate` function operates on patches of cells, but didn't check whether the grid is at least refined once everywhere. If this was not the case, it would generate wrong results. It now checks for this, and if the grid has unrefined coarse grid cells, an exception is generated.
    (WB 2003/06/25)

30. Improved: `FEFaceValuesBase` has a new function `orientation` accessing a unique and consistent orientation for each face.
    (GK 2003/06/23)

31. Changed: Embedding and restriction matrices for intergrid transfer are now computed in the constructor of most elements, rather than taken from precomputed and tabulated values. This removes restrictions on which elements are available since the old tables were only precomputed for certain polynomial degrees and are now available for all.
    (WB 2003/06/09)

32. New: Finite elements got a function `get_interpolation_matrix`, with which they can compute interpolations between different finite elements. Most will use this to compute interpolations between finite elements of the same kind but different polynomial degrees. The `FETools::get_interpolation_matrix` makes use of this function if it implements the desired interpolation, and falls back to the old algorithm if this is not the case.
    (WB 2003/06/09)

33. New: Finite elements got a function `get_name`, which can be used to identify a finite element by its name.
    (WB 2003/06/09)

34. New: Raviart-Thomas elements are now implemented in the `FE_RaviartThomas` class.
    (WB 2003/06/09)

Last update $Date: 2012-05-29 15:16:36 -0400 (Tue, 29 May 2012) $