The deal.II news page
Keywords: deal.II
Date: $Date: 2013-10-31 10:29:06 -0400 (Thu, 31 Oct 2013) $

## Changes between versions 5.2 and 6.0

This is the list of changes made after the release of deal.II version 5.2. 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: Several functions in the linear algebra classes that have been deprecated for more than a year have been removed.
   (GK 2007/08/22)

2. Changed: Implementing gradients for the class `FunctionDerivative`, it became evident that its enums for difference formulas clashed with those of `AutoDerivativeFunction`. Therefore, only the latter survived.
   (GK 2007/08/02)

3. Changed: When new multigrid transfer classes were introduced, the existing class `MGTransferSelect` was moved to the new header file `multigrid/mg_transfer_component`. It also received a new base class `MGTransferComponent`.
   (GK 2007/04/26)

4. Changed: Everything that is part of the deal.II library has been moved into a namespace `dealii`. To allow your code to compile, you will have to either put a `using namespace dealii;` declaration at the top of each file, or qualify each deal.II class and function explicitly with `dealii::` namespace access.
   (WB 2006/10/22)

5. Changed: Indices, such as vertex indices, are usually represented by unsigned integers in deal.II. One place where we didn't do this was in the `CellData` structure that can be used to describe cells when building a triangulation. This has now been rectified.
   (WB 2006/09/06)

6. Changed: Lower dimensional objects have been removed from the hierarchical structure of levels in `TriaLevel`. Faces, i.e. lines in 2D and lines and quads in 3D, have no associated level anymore. Therefore, the level argument of some iterator functions have been removed. The affected functions are `Triangulation`:: `begin_raw_face`, `begin_face`, `begin_active_face` and all `last_*_face` or `end_*_face` functions, no matter whether raw, used or active. Also effected are the direct iterator functions which are related to faces like `begin_line` in 2D and 3D or `begin_quad` in 3D. Again, the same applies to `last_*` and `end_*`.
   The respective functions in `DoFHandler`, `hp::DoFHandler` and `MGDoFHandler` have been changed accordingly.
   Nested loops with an outer loop over all levels and an inner loop over all faces on that level have to be changed to a single loop over all faces. In most cases, the necessary changes should be internal to the library.
   (Tobias Leicht, 2006/06/13)

7. Changed: In order to facilitate the implementation of hp finite elements, the ordering of boundary DoFs returned by `DoFTools::map_dof_to_boundary_indices` has been changed. Fortunately, this is a rarely used function so that the effect should be limited to only a few programs.
   (WB 2006/04/26)

8. Changed: The `distribute_local_to_global` functions have been moved from the classes implementing accessors to arbitrary objects in the triangulation to the cell accessors, to facilitate the implementation of hp methods. That means that you can't call these functions for face or edge iterators any more, but only cells. Since this is what is usually desired, this should not be too severe a restriction.
   (WB 2006/04/26)

9. Changed: The template argument of the `InterGridMap` class has been changed. Code like e.g. `InterGridMap<DoFHandler,2>` must be replaced by `InterGridMap<DoFHandler<2> >`.
   (RH 2006/02/27)

10. Changed: The `DoFObjectAccessor` and derived classes used to take only the space dimension and the dimension of the object they represented as template arguments. Now the later argument is replaced by the type of DoFHandler they correspond to. This may be `::DoFHandler` or `hp::DoFHandler`.
    (RH 2006/02/10, WB 2005/12/20)

11. Removed: Support for gcc2.95 in particular, and all compilers that do not support the `std::ostringstream` class in general, has been removed.
    (WB 2006/02/03)

12. Changed: Several classes related to the storage of data in the Triangulation and DoFHandler classes have been moved into internal namespaces, and some have also been removed. Since these were not for use anywhere outside the library, it is unlikely that this poses problems to application programs. On the other hand, it moves common names like `Line` and `Quad` out of the global namespace.
    (WB 2006/01/13)

13. Changed: Previously, if `mg_dof_handler` was a multilevel DoF handler object, calling `DoFRenumbering::component_wise(mg_dof_handler)`) didn't quite do what was probably intended: it did an implicit cast of `mg_dof_handler` to its base class, `DoFHandler` and then renumbered the global degrees of freedom, but didn't touch the multilevel part. This has now been fixed: there is another function that takes a `MGDoFHandler` object and that renumbers the global part as well as all levels of the multigrid part. The change is incompatible since the previous call now leads to a different action; if you really want the old behavior back, cast the argument to the base class before the call, like so: `DoFRenumbering::component_wise(static_cast<DoFHandler<dim>&>(mg_dof_handler))`)
    (WB 2005/12/15)

14. Changed: The internal numbering of faces, lines and vertices has been reimplemented. Now the numbering scheme uses a lexicographic ordering (with x running fastest) wherever possible. For more information on the new numbering scheme, see the announcement on the mailing list.
    The ordering of vertices in `CellData` given to the `Triangulation::create_triangulation` function has been changed accordingly. For backward compatibility there is now a new `Triangulation::create_triangulation_compatibility` function which takes `CellData` in the old vertex ordering. However, as this function might not be supported forever users are advised to change their code to the new numbering scheme and to use the `Triangulation::create_triangulation` function.
    (RH 2005/11/02)

### General

1. Improved: Tests for libraries in configure can handle --without now.
   (GK 2007/08/22)

2. Updated: The version of UMFPACK bundled with deal.II has been updated to release 5.1.0.
   (WB 2007/08/15)

3. New: The step-27 tutorial program has been added. It solves a Laplace equation with hp finite elements and shows how to set finite element degrees, assemble matrices on cells with varying polynomial degrees, and how to compute a simple criterion for estimating the local Sobolev smoothness of a function.
   (WB 2007/08/09)

4. Improved: The table of contents of tutorial programs now also shows subsections of introduction and results.
   (WB 2007/08/05)

5. Extended: Up to now, in 3D only 'orientable' meshes could be used in deal.II, i.e. all lines are in standard orientation and the faces can be either in standard orientation or with a reversed normal. In order to enable the treatment of all purely hexahedral meshes, this interface (only the boolean flag `face_orientation` so far) has been extended by new flags `face_flip` and `face_rotation`, denoting a face which is rotated against the 'standard face' by 180 and 90 degrees, respectively. Furthermore, there is a new flag `line_orientation` with obvious meaning.
   These flags have to be respected during creation and refinement of a triangulation, when projecting quadrature points to faces or when the dof indices on a cell are extracted. Furthermore, asking for vertices and lines of cells is in some cases a bit more complicated. The same applies, for example, to the extraction of the information, which child of a neighbor is behind a given subface. However, this information is supplied by various functions in `GeometryInfo`. As a rule-of-thumb: if you want to use non-standard meshes, all occurrences of `face_orientation` have to be supplemented by `face_flip` and `face_rotation`.
   In order to reduce the impact of possible bugs, the grid is still given to `GridReordering`, which now returns the original connectivity if the reordering was not possible.
   A more detailed document concerning these topics will be available in the future.
   (Tobias Leicht 2007/02/09)

6. New: a program `reconfigure` has been added to the deal.II main directory, which reruns `configure` with the sam command line arguments as last time.
   (GK 2006/10/24)

7. New: The step-25 tutorial program, demonstrating the solution of the nonlinear sine-Gordon equation (a variant of the time dependent wave equation) has been added.
   (WB 2006/11/05)

8. New: The step-21 tutorial program is ready. It considers time dependent two-phase flow through a porous medium.
   (WB 2006/10/30)

9. New: The step-23/step-24 tutorial programs have been added, discussing how to solve the wave equation.
   (WB 2006/10/03)

10. Fixed: when building the library in parallel, using `make -jN` (most often with rather large values of `N`, for example 8), it could sometimes happen that the same file is compiled twice at exactly the same time. This leads to invalid object files and libraries that would contain illegal instructions. This is now fixed.
    (WB 2006/08/09)

11. Changed: The default number of subdivisions in the `build_patches` functions of the DataOut classes is now part of the parameters read by `parse_parameters`. This default value is used whenever patches with zero subdivisions are being built.
    (GK 2006/06/18)

12. New: a configuration parameter `--with-boost` has been introduced, allowing the selection of a previously installed boost library instead of the contibuted.
    (GK 2006/03/23)

13. New: The step-20 tutorial program was added. It shows how to use Raviart-Thomas elements to solve a mixed formulation of the Laplace equation. It also demonstrates the use of block matrices and vectors, and how they can be used to define more complex solvers and preconditioners working on the Schur complement.
    (WB 2006/02/12)

14. Updated: The `deal.II/contrib/boost` library has been updated to boost version 1.33.1.
    (RH 2006/02/08)

15. Improved: Documentation has been greatly enhanced, both in the API documentation as well as in the tutorial programs. In particular, the step-1 through step-8 tutorial programs have been overhauled and in many cases the documentation has been rewritten in large parts. The presentation of tutorial programs and reference manual should also be nicer and better readable in many cases.
    (WB 2006/02/07)

16. Changed: Previously, the UMFPACK code was linked into its own library, `liblac_umfpack.*`. Instead, it is now directly linked into the `liblac.*` libraries. This makes further linking simpler than before and also simplified the link process.
    (WB 2006/01/19)

17. Improved: The order of quadrature points is now x fastest, z slowest, as well as the vertices of cells. Also, the nodes and subcells of patches in DataOutBase follow the same ordering. Output code could be simplified a lot, saving 900 lines of code.
    (GK 2006/01/18)

18. Improved: Documentation of tutorial program is now run through Doxygen. This allows cross-referencing the tutorial programs to the API manual (and the other way round) and leads to a generally much nicer output. In particular, formulas embedded in the documentation of the programs are now properly displayed.
    (WB 2006/01/16)

19. Improved: The link to the manual now points directly to Doxygen's module list, and almost all classes are now grouped into modules that capture related functionality.
    (WB 2006/01/16)

20. Improved: If you do have a PETSc installation and have set the `PETSC_DIR` and `PETSC_ARCH` environment variables but do not wish deal.II to be configured for PETSc use, you should specify `--with-petsc=no` as a flag during configuration.
    (WB 2006/01/16)

21. Improved: In all directories, including those for tutorial programs, we generate a file called `Makefile.dep` that lists the dependencies of object files on source files, and that the `make` uses to determine which files to recompile. If the generation of this file failed (for example if `LD_LIBRARY_PATH` hadn't been set correctly), a number of very strange things would happen, among others the attempt to link an empty object file. This was almost impossible to figure out if you didn't know what was going on. This mechanism has now been robustified and should yield better error messages.
    (WB 2005/11/23)

22. New: The dynamic libraries, which is the name of shared libs under Apples OSX, are now supported on these platforms and enabled by default. They should safe a lot of harddisk space.
    (Oliver Kayser-Herold 2005/10/20)

23. Fixed: The `Tecplot` library (`tecio.a`) was detected but not added to `LIBS`. This is now fixed.
    (RH 2005/09/23)

24. New: `configure` will automatically detect a `NetCDF` installation, when its path is given by the `NETCDF_DIR` environment variable. The path of the `NetCDF` installation directory can also be specified through the `--with-netcdf=/path/to/netcdf` configure option.
    (RH 2005/09/23)

25. Fixed: The PETSc libraries have been relinked each time `make` was called. Now, the PETSc libraries will only be relinked if necessary.
    (RH 2005/09/15)

### base

1. New: There is a new class: `Functions::FEFieldFunction` which is a Function interface to a finite element solution.
   (Luca Heltai 2007/08/29)

2. Improved: `FunctionDerivative` is now derived from `AutoDerivativeFunction` and implements gradients as well, giving you automatic second derivatives of a function.
   (GK 2007/08/02)

3. New: The function `Utilities::fixed_power<n>(q)` calculates `q` to the power of `n` where `n` is a constant known at compile time. It allows to calculate powers efficiently at compile time, most often things like a number to the power `dim`.
   (WB 2007/06/23)

4. New: The deal.II intermediate format has been changed. Since files in this format are only meant to be processed by exactly the same version of deal.II, this should be of no concern to users. However, this restriction was previously undocumented, even if implied. The documentation for this has now been updated.
   (WB 2007/02/08)

5. New: The new `Functions::Monomial` class implements monomials as a function object.
   (WB 2006/12/15)

6. Fixed: If no substring is found with a width smaller than the given threshold, the `Utilities::break_text_into_lines` function now returns the smallest possible substring (larger than the threshold).
   (Tobias Leicht 2006/12/13)

7. Changed: We used to set preprocessor variables `PACKAGE_NAME`, `PACKAGE_TARNAME`, `PACKAGE_VERSION`, `PACKAGE_STRING`, `PACKAGE_BUGREPORT` in the file `<base/config.h>`. These variables were automatically set by the autoconf package, with which we generate the `./configure` script. However, these variables would conflict if someone were to use a different package that also uses autoconf, since that package would have the same variables, just set to different values. The preprocessor warns about these cases.
   We now avoid this conflict by not using these names any more. Instead, we use the preprocessor names as above, prefixed with `DEAL_II_`.
   (WB 2006/11/10)

8. Extended: The `QGaussLobatto` quadrature rule computes Legendre-Gauss-Lobatto nodes and quadrature weights.
   (Florian Prill 2006/11/02)

9. Extended: The `contract` function family contracts two tensors. There is now a new version of this function, that contracts a tensor of rank three with a second one of rank two over given indices `index1` and `index2` of the first and second tensor, respectively, resulting in a tensor of rank three.
   (Tobias Leicht 2006/09/27)

10. Fixed: The `DataOutBase::write_deal_II_intermediate` function did not check whether it can actually write to the stream given. It would therefore silently do nothing if the file could not be written to. This is now fixed: an exception is generated in that case, as for all the other output functions in that class.
    (WB 2006/08/31)

11. Improved: Stack backtraces in multithreaded mode were often very long and almost unreadable because the functions in namespace `Threads` that are used to set up new threads have long and awkward signatures. The output is now filtered to make these backtraces easier to read.
    (WB 2006/08/15)

12. New: The second argument to `Utilities::int_to_string` can now be omitted, leading to a string that isn't zero padded at all.
    (WB 2006/08/02)

13. Changed: When there is still a `SmartPointer` object pointing to another object at the time it is destroyed, this would cause the program to be aborted. However, there are cases where this is not desirable, for example here:

                  void f()
                  {
        	    Triangulation tria;
        	    DoFHandler *dh = new DoFHandler(tria);
        	    ...some function that throws an exception
                  }

    When the exception is thrown but not caught, the two local objects are destroyed in reverse order of their construction, i.e. first the pointer then the triangulation. However, only the pointer, not the `DoFHandler` pointed to is destroyed, triggering the abort in the triangulation since there is still the `DoFHandler` object pointing to it at the time of destruction of the triangulation. In such cases, one would not want to see the program aborted, since then one would never learn about the actual exception being thrown.
    The behavior of the `Subscriptor` class as therefore been changed to not abort the program any more if an exception is being handled at the moment. Rather, only an error message is shown on `std::cerr`.
    (WB 2006/08/01)

14. Fixed: The `TableHandler::write_tex` accidentally took a parameter of type `std::ofstream` instead of `std::ostream` and could therefore only write to files, not to other kinds of streams. This is now fixed.
    (WB 2006/07/28)

15. New: `GeometryInfo` offers several new functions, `is_inside_unit_cell` with an epsilon parameter to specify allowable offsets from the actual unit cell, `distance_to_unit_cell` returning the infinity norm of the distance of a given point to the unit cell, and `project_to_unit_cell` returning the projection of a point onto the unit cell. Also, a new member `vertex_to_face` allow to determine to which faces of a cell a vertex belongs.
    (Ralf B. Schulz 2006/05/10)

16. Improved: `DataOutBase`::`OutputFormat` has a new value `none`, writing no output at all. This way, the writing of output files can be controlled more easily from parameter files.
    (GK 2006/04/14)

17. Improved: `VectorSlice` has new functions `begin()` and `end()`, returning the corresponding vector iterators.
    (GK 2006/03/31)

18. New: The various tensor classes can now effectively be reset to zero by simply writing `t=0;` as has long been allowed for matrices and vectors.
    (WB 2006/03/24)

19. New: The new `deal_II_numbers::is_finite` function can be used to check whether a floating point number is finite, i.e. neither plus or minus infinite nor NaN (not a number); it is in the new include file `base/numbers.h`, which will contain non-configured inline functions of this type.
    (WB 2006/03/15) (GK 2006/03/22)

20. Improved: If the C++ runtime environment allows it, we now demangle stacktraces generated whenever an exception is thrown.
    (WB 2006/03/14)

21. Improved: The function `Subscriptor`::`list_subscribers` logs all current subscribers of an object to `deallog`.
    (GK 2006/03/08)

22. Fixed: Writing a denormal "NaN" through `LogStream` objects such as `deallog` erroneously printed zero, rather than "nan". This is now fixed.
    (Luca Heltai, WB 2006/03/07)

23. Improved: The `TableBase` base class of all the `Table` classes had an `>operator()` that takes a `TableIndices` object that represents the entire set of indices at once. However, due to C++ name lookup rules, this operator wasn't accessible through the `Table` class without explicitly specifying the base class name. This is now fixed by also providing a similar `>operator()` in the derived classes.
    (WB 2006/02/21)

24. Fixed: The `QGauss` constructor hangs on x86 linux systems when deal.II is run from inside MATLAB. The reason is that while the processor offers long double accuracy, MATLAB switches off support for that inside the CPU. It therefore leaves codes that expect the additional accuracy high and dry. Annoyingly, these codes of course run just fine outside of MATLAB's environment. This behavior leads to an infinite loop inside the QGauss constructor, where we want to use the additional accuracy to compute quadrature points to high precision. To avoid the infinite loop, we now check during runtime whether the extra precision is available, not only at compile time.
    (Christian Kamm, WB 2006/02/21)

25. Fixed: The `ParameterHandler::get_integer` had an erroneous check that the value given for a parameter really represented an integer. This check always succeeded, even in face of an error, and a zero value was returned every time the value in the parameter file happened to be not an integer.
    (WB 2006/02/17)

26. Improved: The `ComponentSelect` class can now also handle the case that one wants to select multiple vector components at once, not only a single one.
    (WB 2006/02/12)

27. Improved: A new function `TableBase`::`fill`, filling the whole table with the same element has been introduced.
    (GK 2006/01/18)

28. Improved: `DataOutBase` now writes binary files for OpenDX.
    (GK 2006/01/18)

29. New: There are now functions `ParameterHandler::set` that allow to set the value of a parameter to something different later on.
    (Marc Secanell, WB 2006/1/2)

30. New: There are new functions `Utilities::match_at_string_start` and `Utilities::get_integer_at_position`.
    (WB 2005/12/19)

31. Fixed: The computation of `HMIN` and `HMAX` in `DataOutBase::write_povray` has been wrong. This is now fixed.
    (RH 2005/11/02)

32. Fixed: `DataOutBase<2,3>::write_tecplot_binary` did not write the `z` coordinates. This is now fixed.
    (RH 2005/09/28)

33. Fixed: The `tecplot_binary` `OutputFormat` has been added to `DataOutBase::get_output_format_names`. Now an exception will be raised if `write_tecplot_binary` is invoked without specifying the filename through the `DataOutBase::TecplotFlags` interface.
    (RH 2005/09/23)

34. New: There are now new `get_n_mpi_processes` and `get_this_mpi_process` functions in the `Utilities::System` namespace. In case of a code not running in parallel, they simply return 1 and 0, respectively.
    (RH 2005/09/20)

### lac

1. Changed: The `CompressedBlockSparsityPattern` has been renamed to `BlockCompressedSparsityPattern` to be consistent, since the "block" part builds on the "compressed sparsity pattern", not the other way around. The old name remains as a typedef, but its use is deprecated.
   (WB 2007/06/17)

2. New: The `CompressedSetSparsityPattern` class is an alternative to the `CompressedSparsityPattern` class that appears to be better suited for problems that have many entries per row. There is also a block version, `BlockCompressedSetSparsityPattern`. The two new classes can used in all places where a regular compressed sparsity pattern can also be used.
   (Oliver Kayser-Herold, WB 2007/06/03)

3. Fixed: The `SolverBicgstab` class did not handle hitting on the solution early very gracefully (it threw an exception). This is now fixed.
   (Roger Young 2007/03/07)

4. Fixed: The `SparseDirectMA27` class allows to run the sparse direct solver as a separate program (the `detached_ma27` program) rather than as part of the current program in order to be able to run several instances of it in parallel during multithreaded computations. However, the destructor of the `SparseDirectMA27` class had a bug that when using this detached mode led to a segmentation fault. This is now fixed.
   (WB 2007/02/09)

5. Improved: A simple `print_formatted` function has been added to `SparseMatrixEZ`.
   (Moritz Allmaras 2007/02/08)

6. Fixed: The `SparseDirectMA27` class works for symmetric matrices and had a check to make sure the matrix is indeed symmetric. However, the check compared entries for equality, something one should not do for floating point numbers. It now checks that symmetric entries are equal up to a small relative number.
   (WB 2006/12/21)

7. Fixed: The `FullMatrix::invert` function would return wrong results if one tried to invert a matrix of dimension smaller than 5 in situ. This is now fixed.
   (Florian Prill 2006/12/18)

8. Improved: The `SparsityPattern` class would produce segmentation faults if one tried to allocate a matrix with more than about 4.2 billion elements (i.e. the number that one can store in a 32-bit unsigned integer). This is now fixed: if you have enough memory, this is now possible on 64-bit systems. (The number of rows is still limited by the 32-bit limit, but this is probably going to be enough for some time to come.) This fix also required changing the return type of the `SparsityPattern::get_rowstart_indices` function from `const unsigned int *` to `const std::size_t *`; since this function should not be used outside of the library anyway, this is probably not a change that affects user code.
   (WB 2006/12/14)

9. New: The class `PointerMatrixVector` implements the functions `vmult` and `Tvmult` for a 1xn-matrix represented by a single vector.
   (GK 2006/09/17)

10. Improved: The class `SolverCG` can now estimate the condition number of the linear system using `TridiagonalMatrix` and LAPACK.
    (GK 2006/09/06)

11. New: the class `TridiagonalMatrix` has been introduced together with its basic methods, including an eigenvalue solver for the symmetric case (LAPACK).
    (GK 2006/09/06)

12. Improved: PETSc 2.3.1 (build 16) is now supported by the linear preconditioner classes. The new PETSc functions `PCFactorSetXXX` are used.
    (Florian Prill, 2006/08/04)

13. New: The class `TransposeMatrix` modeled after `PointerMatrix` swaps the `vmult` functions such that its effect is the transpose of the matrix it points to.
    (GK 2006/07/07)

14. New: There is now a function `FullMatrix::trace` that does what its name suggests it does.
    (WB 2006/06/16)

15. Improved: `PointerMatrixAux` now has a default constructor and a function for setting the `VectorMemory` object.
    (GK 2006/06/14)

16. Fixed: `FullMatrix::print` would yield a link error when used with `std::ofstream` since an explicit instantiation was missing. The function has now been moved to the header file and made inline so that it is always visible, whatever the type of the output stream is.
    (WB 2006/06/07)

17. Improved: The `SparseDirectUMFPACK` solver can now also be used with sparse matrices with elements of type float, as well as with block matrices with types float and double.
    (WB 2006/04/25)

18. New: The function `BlockSparsityPattern::row_length` adds up the row lengths of the individual blocks of a block matrix for a given row.
    (WB 2006/04/25)

19. New: There is a new class `IdentityMatrix` that represents an efficient version of the matrix with ones on the diagonal and zeros everywhere else. The main usefulness of this matrix lies in the fact that most other important matrix classes have assignment operators and copy constructors that allow to conveniently fill a (sparse, full) matrix with the identity matrix.
    (WB 2006/04/24)

20. New: There are now assignment operators from `BlockVector` to `Vector` and back.
    (WB 2006/03/30)

21. Improved: `BlockSparsityPattern` can be initialized directly using the vector generated by `DoFTools`::`compute_row_length_vector`.
    (GK 2006/03/30)

22. Improved: All matrix (and some vector) classes now check whether entries written into them represent finite floating point values. This should catch some bugs earlier where one writes infinite or NaN values into a matrix only to realize later that the linear solver fails.
    (Stephan Kramer, WB 2006/03/15)

23. Changed: There are new `FullMatrix`::`equ` functions which assign `this` matrix to the linear combination of one, two or three matrices. Also there is now a new `Vector`::`equ` function for three vectors.
    (RH 2006/02/21)

24. Fixed: The `SolverMinRes` class did not work with the `BlockVector` class. This is now fixed.
    (Luca Heltai 2006/02/19)

25. Changed: There are now new `FullMatrix`::`add` functions which add two and three scaled matrices.
    (RH 2006/02/16)

26. Changed: The matrix classes `FullMatrix`, `SparseMatrix`, `SparseMatrixEZ` and `BlockMatrixBase` now have an `add` function analogous to the `add` of vector classes. The old `add_scaled` functions are now deprecated.
    (RH 2006/02/16)

27. Improved: `BlockMatrixArray`::`enter_aux` allows using matrices without adding vector multiplication by using `PointerMatrixAux`.
    (GK 2006/02/02)

28. New: The class `PointerMatrixAux` was introduced for use with matrix classes lacking the adding vector multiplication functions. It implements these by using its own auxiliary vector.
    (GK 2006/02/02)

29. Improved: The `FilteredMatrix` class was able to filter only the `SparseMatrix` matrix class. A new (faster) version is now in its place with the same interface that is able to perform such a filter on anything that provides the usual matrix vector operations.
    (Luca Heltai 2006/01/09)

30. New: All solver classes took an argument of type `VectorMemory` which they use to allocate memory for temporary vectors. A clever implementation of this class might allow reusing temporary vectors, and thus reduce the overhead of repeatedly allocating and freeing memory. However, almost all instances of using these classes used the `PrimitiveVectorMemory` class. The solver class have now been changed so that if one omits the respective argument, they fall back to using such a memory object. Also, all example programs that did not specifically use a different memory allocation class, have been changed to not specify anything at all, and thus fall back to the default.
    (WB 2005/11/23)

31. Fixed: The `SparseMatrix` iterators had a problem when one wrote code like `iterator->value()=0` (i.e. with a zero integer, rather than a floating point number on the right), in that that opened up a second conversion sequence and the compiler complained about an ambiguity. This is now fixed.
    (WB 2005/10/17)

32. New: Now the class `SparseILU` supports also the `Tvmult` method. This feature allows the straightforward use of `SparseILU` as a multigrid smoother within the framework.
    (Oliver Kayser-Herold 2005/09/15)

### deal.II

1. New: There is a new class: `Functions::ParsedFunction` which is friendly wrapper to the `FunctionParser` class.
   (Luca Heltai 2007/08/29)

2. Fixed: the function `DataOut::build_patches` had a quadratic algorithm when generatic cell-data (as opposed to DoF data). This algorithm became a bottleneck when generating output on meshes with large number of cells. This is now fixed.
   (WB 2007/08/28)

3. New: the function `DoFTools::get_active_fe_indices` extracts for each cell the active finite element index used on it.
   (WB 2007/08/07)

4. Extended: the function `Triangulation::copy_triangulation` copies all members of a triangulation except for the list of `RefinementListener`s. In most cases this is exactly the intended behavior. However, if a RefinementListener should be copied to the new triangulation, e.g. if a Persistent Triangulation is created from an ordinary one, it can do so now through implementing the new function `RefinementListener::copy_notification`.
   (Tobias Leicht 2007/06/05)

5. New: the function `DoFTools::make_sparsity_pattern` now takes an optional constraint matrix argument that can be used to avoid the subsequent call to condense the sparsity pattern. In effect, the sparsity pattern is generated condensed right away. For problems in 3d and with many constraints, this is many times faster than separate creation and condensation.
   (WB 2007/06/03)

6. New: the new function `ConstraintMatrix::add_entries_local_to_global` can be used to add entries to a matrix where entries that will appear if the current entry corresponds to a constrained degree of freedom are also added.
   (WB 2007/06/03)

7. Fixed: the function `GridTools::find_cells_adjacent_to_vertex` was not detecting properly the coarse cells adjacent to refined cells.
   (Luca Heltai 2007/05/15)

8. Fixed: the two tools `DoFTools::count_dofs_per_component` and `DoFTools::count_dofs_per_block` where changing the size of the destination vector. Consistently with (most of) the rest of the library, now the vectors are expected to be the right size before calling these functions.
   (Luca Heltai 2007/05/15)

9. New: The classes `MGTransferBlockSelect` and `MGTransferBlock` allow for transfer of multigrid vectors for single blocks of a system and for several blocks.
   (GK 2007/04/26)

10. New: There is a new variant of `DoFTools::make_sparsity_pattern` that can be used to construct sparsity patterns corresponding to problems where one would like to test shape functions defined on one mesh with shape functions defined on a different mesh (or on the same mesh but using a different DoFHandler that may use a different finite element, for example).
    (Yaqi Wang 2007/03/09)

11. New: The `GridTools::get_active_child_cells` function determines all active children of a cell.
    (Yaqi Wang 2007/03/09)

12. New: The `ConstraintMatrix::write_dot` function can be used to produce a graphical representation of the graph of constraints stored in the constraint matrix. The output can be sent through the "dot" program to produce a number of graphical formats, such as postscript, png, or xfig.
    (WB 2007/03/08)

13. Fixed: The `GridGenerator::cylinder` function in 3d properly set the boundary indicators of the end faces of the generated cylinder to a different value than the outer faces, but it forgot to also adjust the boundary indicators of the edges purely in the interior to the ends of the cylinder. This is now fixed.
    (WB 2007/03/08)

14. Improved: The `CylinderBoundary` class can now describe the boundaries of arbitrarily oriented cylinders, not only does oriented parallel to the axes and going through the origin.
    (WB 2007/03/08)

15. Improved: The `GridRefinement::refine_and_coarsen_fixed_number` and `GridRefinement::refine_and_coarsen_fixed_fraction` functions have gained an additional last argument that can be used to specify a maximal number of cells that we would like to use in a triangulation. Its default value is set to indicate that no limit is desired, as is the previous behavior.
    (WB 2007/02/20)

16. New: Added function `GridGenerator`::`hyper_cube_with_cylindrical_hole` that produces a square with a circular hole in the middle in 2d, and extrudes it along the z-direction between 0 and L.
    (Luca Heltai 2007/02/15)

17. Workaround: The class `GridOut`::`write_msh` produces a mesh which can be visualized in the Gmsh reader. A bug in Gmsh prevented the boundary indicator to be properly visualized. The boundary indicator was added to the material flag of the faces (which is ignored when reading back the mesh) in order for the Gmsh reader to be able to display the boundary indicator in a proper way.
    (Luca Heltai 2007/02/15)

18. Fixed: The function `DoFTools`::`distribute_cell_to_dof_vector` produced wrong results if the vector into which the result is to be stored contained nonzero values. This is now fixed.
    (Rohallah Tavakoli, WB 2007/02/13)

19. Fixed: A local variable in `TriaAccessor<3,3>::measure` was erroneously marked as static could lead to wrong results and crashes in multithreaded mode. This is now fixed.
    (WB 2007/02/09)

20. Fixed: `MatrixCreator`::`create_mass_matrix` and `create_laplace_matrix` computed wrong values for the right hand sides. This has been fixed.
    (Moritz Allmaras 2007/02/08)

21. Extended: `DataOutBase::Patch` has been extended by a new boolean flag `points_are_available`, which defaults to `false`. It is set to `true` if the coordinates of the points defining the subdivision of a patch are appended to the `data` table contained in a `Patch`. This way, `DataOut`::`build_patches()` can use a `Mapping` to represent curved boundaries, especially for higher order elements. This change corresponds to an extension of the intermediate format for graphics.
    Fixed: Using the given `Mapping` to obtain function values in `DataOut`::`build_patches()` also fixes a bug for `FE_RaviartThomas` and `FE_ABF`elements, which need to evaluate the function values on the real (mapped) cell.
    (Tobias Leicht 2007/01/30)

22. Fixed: On faces with wrong `face_orientation` the dofs have to reordered in order to be combined with the correct shape functions. This is only relevant for continuous elements in 3D. At least for `FE_Q` and systems of `FE_Q` this works now, for other finite elements the reordering vector still has to be implemented.
    (Tobias Leicht, 2007/01/17)

23. Fixed: The `Triangulation`::`execute_coarsening_and_refinement` function has to discard coarsening flags in 2d and 3d if a neighbor of a flagged cell is refined or will be refined, in order to avoid that we end up with neighboring cells that differ in refinement by two levels. The function was overly conservative, however, in that it didn't allow a cell to be coarsened if its neighbor is once refined but is also marked for coarsening. This is now fixed and will lead to a few more cells being coarsened.
    (Yaqi Wang, WB 2006/12/27)

24. Fixed: The `Triangulation`::`MeshSmoothing` flag `patch_level_1` wrongly produced cells on level 0 during `coarsening_and_refinement`, which is now fixed.
    (RH 2006/12/20)

25. Extended: There is now a new `Triangulation` ::`MeshSmoothing` flag `coarsest_level_1` which ensures that after `coarsening_and_refinement` there are no cells on level 0, i.e. the coarsest level is 1, if the triangulation had `coarsest_level_1` already before.
    (RH 2006/12/20)

26. Extended: The `GridIn` class can now read in tecplot files in ASCII format (block and point format, ordered and unstructured grids, format specifiers acccording to Tecplot 10 and younger versions). At the moment the implementation is restricted to 2d grids but can easily be extended to 3d as well.
    (Tobias Leicht 2006/12/14)

27. Extended: So far, the `GridReordering`::`invert_all_cells_of_negative_grid` function did nothing in 2d. Now, it inverts cells from clockwise to counterclockwise sense (in the old numbering scheme).
    (Tobias Leicht 2006/12/13)

28. New: There is now a function `GridTools`::`delete_duplicated_vertices` that deletes duplicate vertices which can occur if structured grids are read into deal.II, leading to unwanted interior boundaries. In order to reduce the effort of the quadratic algorithm, a list of vertices to be considered can be supplied if available.
    (Tobias Leicht 2006/12/13)

29. New: There are now two new functions `GridGenerator`::`subdivided_hyper_rectangle` that produces a non-uniformly subdivided rectangle, ideally suited for graded meshes. One of these functions is able to create meshes with holes.
    (Yaqi Wang 2006/11/15, 2006/12/29)

30. Fixed: Corrected `clone` method of `FE_DGQ` class for non-equidistant support points.
    (Florian Prill 2006/10/31)

31. Improved: The lookup mechanism in `FETools`::`get_fe_from_name` has been changed, so additional custom finite elements can be added using `FETools`::`add_fe_name`. In the course of this change, the implementation of the lookup mechanism has been simplified.
    (GK 2006/10/24)

32. New: There is a new functions `GridTools`::`create_union_triangulation` that generates a triangulation that contains the respectively finest cells of two input triangulations.
    (WB 2006/10/23)

33. New: The `ConstraintMatrix` class did not allow that one degree of freedom was constrained against another DoF that was itself constrained. However, this is necessary for the implementation of hp methods and is now allowed. Arbitrarily long chains of constraints are resolved at the time the `ConstraintMatrix::close()` function is called. The only thing that is not allowed are cycles in such constraints.
    (WB 2006/09/19)

34. New: There are new functions `GridTools::minimal_cell_diameter` and `GridTools::maximal_cell_diameter`, with obvious functionality.
    (WB 2006/09/06)

35. Changed: The functions `FETools::compute_embedding_matrices`, `FETools::compute_face_embedding_matrices`, and `FETools::compute_projection_matrices` (mostly used in internal computations in setting up finite element objects) previously took pointers to the first element of an array of matrices as arguments. This isn't type-safe, and in particular did not allow to check for the number of matrices in the array. The functions now take a reference to an array of the correct length.
    (WB 2006/08/14)

36. Extended: The `VectorTools::project` functions are now also implemented for 1d.
    (WB 2006/08/08)

37. Extended: `DerivativeApproximation` now offers access to the full tensor of derivatives of orders one, two and three. This information can be requested for a single cell by means of the `DerivativeApproximation``::approximate_derivative_tensor` function. If the norm of this tensor is required later on, the new `DerivativeApproximation``::derivative_norm` function can be used. Note, that for second order derivatives, this returns the largest eigenvalue instead of the Frobenius norm, which is returned by the `Tensor<rank_,dim>``::norm` function.
    (Tobias Leicht 2006/08/03)

38. Fixed: `DerivativeApproximation` offers approximated derivatives of a discrete function. The symmetrization of the derivative tensor is now done at the right place, i.e. the derivative itself is symmetrized instead of an intermediate tensor. This should improve the results slightly, but cause no problems otherwise, as this is completely internal to the class.
    (Tobias Leicht 2006/08/03)

39. Fixed: The `DataOut::build_patches` and similar functions in the related `DataOut*` classes allowed to pass zero as the second argument (denoting the number of threads to use if multithreading is enabled). This led to no output being created at all. This is now fixed by throwing an exception in this case.
    (WB 2006/07/31)

40. New: The new function `FiniteElementBase`::`n_dofs_per_object` returns either `dofs_per_vertex`, `dofs_per_line`, `dofs_per_quad`, ..., depending on the explicitly specified function template argument. This is often useful for template trickery.
    (WB, 2006/07/28)

41. Fixed: `Triangulation<dim>::fix_coarsen_flags` has been modified to allow coarsening in all possible cases. Up to now, coarsening was forbidden, if the neighbor cell was not refined but had the `refine_flag` set, whereas it was allowed, if the neighbor cell already was refined. Now, in both cases coarsening is allowed (if all children are flagged for coarsening). This leeds to triangulations with a slightly reduced number of cells. In some cases older references will have to be updated.
    (Tobias Leicht 2006/06/22)

42. New: There are now new internal `TriaObjectAccessor<1,dim>`::`lines()` and `TriaObjectAccessor<2,dim>`::`quads()` functions. By using these functions, 30 function specializations could be removed, significantly reducing code duplication.
    (RH 2006/06/13)

43. New: Function `VectorTools`::`create_point_source_vector` to calculate the projection of a Dirac pulse on the base functions. This models a point source as used in the calculations of Green's functions and can also be used to extract the value of a finite element solution in a single point.
    (Ralf B. Schulz, 2006/05/15)

44. Changed: Functions `VectorTools`::`point_value` and `VectorTools`::`point_difference` using the old interface without boundary mapping were replaced by wrapper functions calling the new versions.
    (Ralf B. Schulz, 2006/05/15)

45. Changed: The old version of `GridTools`::`find_active_cell_around_point` has been replaced by a wrapper function for backward compatibility. The wrapper calls the new version of this function, and it is highly recommended to use the new version as it automatically delivers also the local coordinate of the point (so it can save some computation time in most cases as you don't have to calculate that again).
    (Ralf B. Schulz, 2006/05/12)

46. Improved: The functions `VectorTools`::`point_value` and `VectorTools`::`point_difference` now can also use arbitrary mappings, using the new `GridTools`::`find_active_cell_around_point` algorithm.
    (Ralf B. Schulz, 2006/05/11)

47. New: In `GridTools`, several functions have been added. `GridTools::find_closest_vertex` searches for the vertex located at closest distance to a given point. `GridTools::find_cells_adjacent_to_vertex` allows to determine all cells adjacent to a given vertex. And finally, a new version of `find_active_cell_around_point`, which takes additionally a mapping as parameter, implements a new and faster algorithm to determine the active cell in which a given point is located. For points located on boundaries and edges, it is in most cases also able to give the finest cell.
    (Ralf B. Schulz 2006/05/10)

48. Changed: The `DoFObjectAccessor::get_dof_values` and `DoFObjectAccessor::set_dof_values` were part of the accessors for lines, quads, and hexes. However, they could not be called for these objects unless the object was actually a cell, i.e. one could never call this function for a line or face in 3d, for example. The functions have therefore been moved to the `DoFCellAccessor` class that provides access to cells (i.e. lines in 1d, quads in 2d, and hexes in 3d) for which this operation is actually useful.
    (WB 2006/05/01)

49. Fixed: second derivatives where not computed correctly in `FEFaceValuesBase`, i.e. when evaluating second derivatives on faces of cells. This is now fixed. Using second derivatives evaluated at quadrature points within a cell was not affected by this problem.
    (GK 2006/04/28)

50. New: The functions `Triangulation::clear_user_flags_line`, `Triangulation::clear_user_flags_quad`, and `Triangulation::clear_user_flags_hex` can be used to selectively clear only some of the user flags as needed.
    (WB 2006/04/25)

51. New: The function `VectorTools::project` functions can now also be used for vector arguments of type other than `Vector<double>`.
    (WB 2006/04/17)

52. New: The function `GridTools::get_finest_common_cells` can be used to find those cells that are shared by two triangulations that are based on the same coarse mesh. This is useful, for example, when having to integrate the solution on one mesh against the shape functions on another mesh, a situation that frequently happens in time-dependent but also in nonlinear problems.
    (WB 2006/04/14)

53. New: The function `GridTools::have_same_coarse_mesh` figures out whether two triangulations, two DoFHandlers, etc, are built on the same coarse mesh.
    (WB 2006/04/14)

54. New: Since calling `cell->get_dof_indices` is a fairly frequent operation (called about 7 times per cell in step-14, but much more often in more complicated programs), the results of this function are now cached for faster access.
    (WB 2006/03/29)

55. Fixed: An exception was generated when trying to interpolate boundary values for a primitive component of a composite finite element that also has non-primitive base elements (for example, trying to interpolate boundary values for a the last component of a RT x Q1 element). This is now fixed.
    (WB 2006/03/27)

56. New: There is a new function `FiniteElement`::`face_to_equivalent_cell_index` that can convert a face index of a degree of freedom into a corresponding cell index.
    (WB 2006/03/27)

57. New: There are now functions `VectorTools`::`point_value` that evaluate the value of a finite element function at a given point inside the domain.
    (WB 2006/03/06)

58. Improved: `GridOut` now has functions for declaring and parsing parameters in a `ParameterHandler`, like used in `DataOut_Interface` for a long time.
    (GK 2006/03/06)

59. Improved: The `Triangulation`, `PersistentTriangulation`, `DoFHandler`, `hp::DoFHandler` and `MGDoFHandler` classes now all have a `dimension` variable which allows to ask the template argument `dim` by SomeClass::`dimension`.
    (RH 2006/02/27)

60. Fixed: When used, the copy constructor of `MappingQ` would lead to memory corruption. This is now fixed.
    (RH 2006/02/23)

61. New: There is now a `StaticMappingQ1`::`mapping` object of type `MappingQ1` which is used in several parts of the library. This way multiple creation and storage of `MappingQ1` objects can be avoided.
    Similar to `StaticMappingQ1`::`mapping` there is now also an object `hp::StaticMappingQ1`::`mapping_collection` of type `MappingCollection`.
    (RH 2006/02/21)

62. New: There is now a `GridOut`::`write_gmsh` function to write in the gmsh format. It has the same features of the write_ucd one.
    (Luca Heltai 2006/02/17)

63. Changed: The `hp::FECollection`::`get_fe`, `hp::QCollection`::`get_quadrature` and `hp::MappingCollection`::`get_mapping` functions are now renamed to the standard `operator[]` function. Similarly, the `FECollection`::`n_finite_elements`, `QCollection`::`n_quadratures` and `MappingCollection`::`n_mappings` functions are now renamed to the standard `size()` function.
    (RH 2006/02/10)

64. Improved: `GridGenerator`::`half_hyper_ball` now is implemented also in three dimensions, and the boundary now is colored with 0 and one respectively on the curved and plane.
    (Luca Heltai 2006/02/07)

65. Improved: `FiniteElementData` and `FiniteElement` now support the concept of blocks along with components. See the glossary for the difference.
    (GK 2006/01/25)

66. Fixed: The `MGDoFHandler`::`distribute_dofs` and `renumber` functions could not handle coarsened grids (unused vertices, faces and cells). This is now fixed.
    (RH 2006/01/23)

67. New: The `Mapping` class and derived classes now have functions `clone()` that return a new object of the same (derived) type.
    (WB 2006/1/8)

68. Improved: The `KellyErrorEstimator` class now also allows to select the cells on which it is supposed to work by giving a material ID, instead of only a subdomain ID.
    (WB 2006/1/4)

69. Improved: A new `TriaAccessor::ExcCellHasNoChildren` exception will be raised if the `TriaObjectAccessor::child_index` function is invoked for cells without children.
    (RH 2005/12/09)

70. Fixed: We had a bug in `DataOut::build_patches` that, when used in multithreaded mode, caused an exception to be thrown. In particular, this happened when the step-14 program was run on dual processor machines and the library was compiled for multithreading. This is now fixed.
    (WB 2005/10/20)

71. New: There is now a new `Triangulation::get_boundary_indicators` function.
    (RH 2005/09/30)

72. New: There is now a new `GridTools::delete_unused_vertices` function. Previously a `private` function in `GridIn` it has now been moved to and made `public` in `GridTools`.
    (RH 2005/09/28)

73. New: The `GridIn<dim>::read_netcdf(string &filename)` function reads grids from NetCDF files. The only data format currently supported is the `TAU grid format`.
    (RH 2005/09/23)

74. Fixed: The `GridIn<dim>::read(filename, format)` function ran into an exception when called with `Default` format and a filename which does not include `/`. This is now fixed.
    (RH 2005/09/21)

Last update $Date: 2013-10-31 10:29:06 -0400 (Thu, 31 Oct 2013) $