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

## Changes after Version 3.4

This is the list of changes made after the release of deal.II version 3.4. 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).

### General

1. New: deal.II now uses a new threading scheme. The new scheme is simpler to use, and in particular more flexible in some cases where only one thread is started, or where a thread is completely detached, since we got rid of the `ThreadManager` class and now only store handles to individual threads (which can be discarded, or added to a `ThreadGroup` variable that is able to wait for a whole set of threads at once.
   The new scheme also implements a much needed feature: calling functions on a new thread that return values. Previously, such functions needed to be written in a way that they return their return value through an additional reference parameter. This was inflexible if one wanted to call functions that already exist. This restriction is now lifted: such functions can be called, and the return value can be accessed once the thread has finished.
   (WB 2003/02/06)

2. New: deal.II now makes use of some parts of the boost library, which is supposed to be a testground for the next generation C++ standard library. The parts which we use are now in `contrib/boost/include/boost_local/` and can be referenced from within your programs. The directory contains the string `_local` since you may still want to use another version or installation of boost in your own programs.

   Also note that boost is large -- much larger than the subset we have imported --, so we only took what we needed.
   (WB 2003/02/06)

3. Fixed: A longstanding bug in the documentation system has been fixed: if a namespace was ended with `}` instead of `};` (note the semicolon), then the documentation tool assumed that the following entities were still part of the namespace just left. This was since the closing brace alone was not accepted as ending a namespace (after all, structures, classes, and enums -- the other entities that can enclose other declarations -- need the semicolon). This led to some classes not showing up in the class index of the sublibraries. This is now fixed.
   (WB 2003/02/02)

4. Changed: Classes and structures that are declared inside namespaces named `internal` are now no longer shown in the class index view of the documentation of each of the sublibraries. Since they are supposed to be used internally only, this is no drawback for the general public. However, they are documented as members of these namespaces.
   (WB 2003/02/02)

5. Fixed: Some of the formulas in the step-14 tutorial were obviously scrambled a little. This is now fixed.
   (Roy Stogner, WB 2003/01/30)

6. Changed: The main Makefile has been changed to sequentialize building the base, lac, and deal.II sublibraries. We changed this, since on some systems (notably AIX), the latter libraries need to be linked against the former ones, when creating shared libraries.
   (WB 2003/01/24)

7. New: Changes have been made to support compiling and using deal.II on AIX 5 systems.
   (WB 2003/01/24)

8. Removed: Thread support now relies solely on the use of POSIX functions. The use of the ACE (Adaptive Communications Environment) library for this is now no longer supported. However, application programs can of course still use ACE, but they will need to generate paths to this library in their makefiles themselves.
   (WB 2003/01/11)

9. New: Some changes have been made to support Mac OS X 10.2. Shared libraries are not supported on this architecture, but everything else should work.
   (WB 2002/12/18)

10. New: deal.II can be compiled with version 7.0 of Intel's icc compiler, which was recently released. Since this compiler finally supports the very restrictive flags `-Xc -ansi` that check for close conformance with the C++ standard, we use them (previous versions of icc would crash when these two flags are given). This requires that we distinguish between these compiler versions, and the corresponding Makefile variable `GXX-VERSION` now no longer holds the non-versioned string `intel_icc` when icc is detected, but rather either `intel_icc5`, `intel_icc6`, or `intel_icc7`, depending on what version of the compiler was detected.
    (WB 2002/12/05)

11. Changed: Previously, we just set the preprocessor variable `DEAL_II_USE_MT`, when `--with-multithreading` was given as argument to `./configure`. Tests in the code therefore looked like `#ifdef DEAL_II_USE_MT`. This has been changed so that the variable is always defined, but its value is now equal to `1` when multithreading was requested, and zero otherwise. The reason for this is that you can now write `if (DEAL_II_USE_MT && ...)` conditions, and need not interleave if-else clauses from regular code and the preprocessor, if conditions involve both the state of this preprocessor variable and the run-time state of your program. However, this change requires that all appearances of `#ifdef DEAL_II_USE_MT` be changed to `#if DEAL_II_USE_MT == 1`, since the variable is now defined unconditionally.
    (WB 2002/11/14)

12. New: Object files are now named according to the local defaults on the system we are running on. On Unix systems, this is usually a `.o` suffix, while on Windows it is `.obj`. Likewise for executables, which have no suffix on Unix, but `.exe` on Windows.
    (WB 2002/11/11)

13. New: deal.II can now also be compiled with Red Hat's version of the gcc compiler, gcc 2.96. However, some problems remain; for more information.
    (WB 2002/10/14)

14. Fixed: On CygWin, one header files has a `#define quad quad_t`. This is annoying, since we have local variables and member functions with the name `quad`, and in fact it breaks compilation on those versions of CygWin that has this. Fortunately, the define is only active if a preprocessor variable `_POSIX_SOURCE` is not set. Thus, we now check for the define when configuring the library, and if necessary set the preprocessor variable. However, while this allows to compile the library on these systems, it may otherwise affect your code, if you use functions or other features of the system that are not available when the flag is set.
    (Stephen Kolaroff, WB 2002/09/28)

15. New: Since `math.h` only defines the values of PI or E (as `M_PI` and `M_E`) when certain defines are set (on Linux, these are `__USE_BSD` or `__USE_XOPEN`), portable programs usually defined these constants themselves. In deal.II, this happened at 6 different places. To avoid this in the future, `base/config.h` now exports a namespace `deal_II_numbers` that defines these two, and a number of other numerical constants.
    (WB 2002/09/12)

16. New: `base/config.h` now exports the deal.II base directory through the `DEAL_II_PATH` preprocessor variable.
    (WB 2002/09/09)

17. Removed: The forward declarations files have gone. We have never propagated their use in the example programs, but these files have been there in the base, lac, and grid include directories, and forward declared all classes that were present in the respective parts of the library. This, the idea was, enables you to use just this include file in your own header files, rather than including the full declarations of these classes. However, maintaining these forward declaration files has been a constant thorn in our side, be it that the timing of their generation was difficult when using parallel builds, or that they were difficult to generate at first. The latter is now the reason for their abolition: we had a script for their generation, but it did not take into account namespaces, so we got clashes when we found that we had used the same class name in two different namespaces, since the script put the forward declaration incorrectly into the global namespace where they conflicted. Since we do not plan to extend the script by a parser that can properly handle opening and closing braces of namespaces, we simply drop these files.
    What you should do if you have used these forward declaration files: you have two possibilities - either include the respective header file in which the class is fully declared, or write the forward declaration into your headers yourself.
    (WB 2002/09/05)

18. New: There is now a new report on assembling matrices available from the documentation page. The main focus is assembling of matrices for vector-valued problems, where shape functions are vector-valued, and may have only one or more non-zero vector components.
    (WB 2002/06/17)

19. Removed: The functions `FEValuesBase::get_shape_values`, `FEValuesBase::get_shape_grads`, and `FEValuesBase::get_shape_2nd_derivatives` are now removed as they expose too much of the internal data structure of their class, and interfere with plans for the extension of this and related classes. These functions, which had been deprecated in the previous version, are thus not part of the release after version 3.4 any more. Use the `FEValuesBase::shape_value` and alike functions as a replacement.
    For more information, read this mail.
    (WB 2002/06/10)

20. New: deal.II now also supports vector-valued finite elements with shape functions for which more than just one vector component is non-zero. Such elements are, for example, the Nedelec and Raviart-Thomas families. Previously, vector-valued elements were only supported insofar as they could be composed of scalar ones; in that case, each (vector-valued) shape function had only one non-zero vector component.
    (WB 2002/06/10)

21. New: The top-level makefile now how a target `distclean`. `clean` leaves the libraries now, removing everything that is not needed to use deal.II. `distclean` removes even the libraries, leaving the directory more or less in the state like after `configure`.
    (GK 2002/06/07)

### base

1. Fixed: A bug in the `Patterns::MultipleSelection` class if more than two elements in a comma-separated list were given.
   (Brian Carnes 2003/05/14)

2. Changed: The `Polynomials::Legendre` class lost its template argument and is now just a regular class. There was no real good reason for the template argument, it had just crept in.
   (WB 2003/05/12)

3. New: There is now a class `AnisotropicPolynomials` that constructs a higher dimensional polynomial space from a set of 1-d polynomials in each of the coordinate directions.
   (WB 2003/04/20)

4. Changed: The `Table` accessor classes have been moved to a namespace `internal`. Since these classes are not (or should not be) used directly in applications, this should not change compatibility. However, they will now no longer show up in the class overview of the documentation, which they were cluttering up.
   (WB 2003/02/13)

5. New: The `Function` class now has an assignment operator. This way, you can put function objects into containers. However, the assignment operator makes sure that only objects can be assigned that have the same number of vector components.
   (WB 2003/02/06)

6. New: The `ThreadMutex` classes now have a member class `ScopedLock` that implements the scoped thread-safe locking pattern of Doug Schmidt. It is also used in various places of the code now.
   (WB 2003/01/28)

7. Fixed: The `PosixThreadManager` called its `wait` function in the destructor. If this had been called before already, then the same threads would have been waited for twice, which invokes undefined behavior. This is fixed by making sure that `wait` removes the id's of the threads it has already waited for, and so calling it more than once will not wait for threads which have already been waited for.
   (Michael Anderson, WB 2003/01/16)

8. Fixed: The `Subscriptor` uses a counter to count how many `SmartPointer` objects subscribe to the pointed-to object. This counter needs to be a volatile variable in multithreaded mode, to avoid false compiler optimizations based on the assumption that the variable cannot change between two subsequent reads.
   (WB 2003/01/11)

9. Fixed: In multithreaded mode, when a new thread is started, the arguments to the function being called need to be copied from the stack of the starting thread to that of the new thread. In order to synchronise this, mutexes were used that were acquired from one thread and released from another thread. On Linux this does not lead to problems, but POSIX functions do not guarantee that this actually works, and it also leads to problems when running programs under valgrind. This is now fixed with the help of condition variables.
   (Michael Anderson, WB 2003/01/11)

10. New: There are now classes `ThreadCondition` that implement thread condition variable operations through POSIX functions (in multithreaded mode) or doing nothing (in singlethreaded mode).
    (WB 2003/01/11)

11. New: Newer versions of gcc have a very nice feature: you can set a verbose terminate handler, that not only aborts a program when an exception is thrown and not caught somewhere, but before aborting it prints that an exception has been thrown, and possibly what the std::exception::what() function has to say. Since many people run into the trap of not having a catch clause in main(), they wonder where that abort may be coming from. The terminate handler then at least says what is missing in their program.
    (WB 2002/12/19)

12. New: There is now a `Patterns::List` pattern that matches a list of elements each of which has to satisfy a pattern that was given to the constructor.
    (WB 2002/11/29)

13. Changed: In POSIX mode, when the `ThreadManager` class created a new thread through `pthread_create`, it only checked for the error code and aborted if it was non-zero. Now, it checks whether the error code is `EAGAIN` and simply retries the call if this is the case. This may, in rare cases, lead to a deadlock or an infinite loop, but will usually just wait until the respective resources for thread creation are available from the operating system and will then succeed.
    (WB 2002/11/13)

14. Fixed: The `write_text` and `write_tex` functions of the `TableHandler` class now check whether their `ofstream` arguments are in a proper state before using them for output.
    (RH 2002/11/11)

15. New: Added Hierarchical Polynomial (similar to Legendre class). Will eventually be used in a hierarchical FiniteElement class similar to FE_Q class. Included in Polynomials namespace.
    (Brian Carnes 2002/10/15)

16. Changed: Because they became too many, the classes describing 1d polynomials are now in a `namespace Polynomials`.
    (WB 2002/10/14)

17. Changed: When an exception is thrown but not caught in a sub-thread, this exception is not passed to the main thread by the operating system. Rather, if the exception is not caught from the function that was invoked by the spawning system function, the entire program is terminated without an additional message. The wrapper functions which are used to spawn new threads in the `Threads` namespace therefore now catch these exceptions and at least print the message they carry, before aborting the program. This way, at least the message gets displayed.
    (WB 2002/10/13)

18. Changed: The class `Table<2>::fill` function, which is also inherited from the `FullMatrix` class, used to work also when the size of the matrix was zero, by simply not copying something. This led to difficult to detect errors. It is therefore no more allowed to call this function when the matrix is empty. For all other cases, the status of copying without checking the size of the array copied from remains unchanged.
    (WB 2002/09/28)

19. New: The classes `TableIndices<N>` and `Table<N,T>` are now implemented also for `N=4,5` and `6`. The `Table<N,T>` class represents an `N`-dimensional array and might replace the N-times-nested-use of the `std::vector` class.
    (RH 2002/09/24)

20. New: The `Threads::n_existing_threads` function returns the present number of existing threads, allowing an assessment whether it is useful to spawn new threads or rather perform the operation in question sequentially.
    (WB 2002/09/08)

21. New: Global exception class `ExcIteratorPastEnd`, which should be used if an iterator is incremented or decremented beyond its end value.
    (GK 2002/09/08)

22. Extended: Previously, the `Threads::PosixThreadBarrier` class could not be used at all (they threw exceptions), if your system did not have the respective POSIX functions. This restriction is lifted for the special case that you give one as the number of parties that will be waiting for the barrier: in this case, a barrier is a no-operation, so we do not need assistence from the operating system. This change makes it slightly simpler to write programs in a way such that they run in both single- and multithreaded environments.
    (WB 2002/09/05)

23. New: The old class `vector2d`, implementing a two-dimensional array of objects is now gone. Instead, there is the new `Table` class that implements tables of arbitrary dimension. Transition is painless: where there was `vector2d<type>` before, use `Table<2,type>` now (and don't forget to update the name of the header file, of course). If you have a three-dimensional array, you can use `Table<3,type>` now.
    (WB 2002/09/03)

24. New: There are now functions returning the transpose of `Tensor` objects of rank 2.
    (WB 2002/08/31)

25. New: Row accessors for the `vector2d` class now have a member function `size` that returns the size of the row, i.e. the number of columns of the table.
    (WB 2002/07/24)

26. Fixed: In EPS output, colors were set to invalid values if the values of the field that is used for coloring are all equal. This happens, for example, in the very first time step of time dependent problems, if initial values are zero. The color value now used is arbitrary, but valid.
    (WB 2002/07/24)

27. Changed: To save disk space, color values in EPS output are written as grey scale with only one value instead of three RGB values if the color so represented is actually a grey scale.
    (WB 2002/07/24)

28. New: There are now operators to allow multiplication and division of `Tensor` objects by scalar factors.
    (WB 2002/06/07)

### lac

1. New: Function `BlockSparseMatrix::print_formatted` added, similar to the `BlockVector::print_formatted` function.
   (Brian Carnes 2003/06/02)

2. New: Functions `SparseMatrix::operator *=` and `SparseMatrix::operator /=` as well as `BlockSparseMatrix::operator *=` and `BlockSparseMatrix::operator /=` are added.
   (Brian Carnes 2003/06/02)

3. Deprecated: The functions `Vector::scale` and `BlockVector::scale` are now deprecated and will be removed in a future version. Use `operator*=` and `operator/=` instead.
   (WB 2003/05/31)

4. New: `Vector`, `BlockVector` and `FullMatrix` now have `operator/=` for scaling by a scalar.
   (WB 2003/05/31)

5. New: `PointerMatrix` now has `empty()` function, which returns true if the pointer is null; otherwise we call the pointer's `empty()` function. This requires the class MATRIX to have an `empty()` function.
   (Brian Carnes 2003/05/22)

6. New: `SparseLUDecomposition` now has `empty()` function, which calls the inherited `SparseMatrix` `empty()` function.
   (Brian Carnes 2003/05/22)

7. New: `PreconditionPSOR` implements interface to permuted SOR preconditioner function in `SparseMatrix`.
   (GK 2003/05/12)

8. Improved: `FullMatrix`::`fill` now copies the largest possible block, whether the destination or source matrix is bigger. Additionally, an offset inside the source matrix may be specified.
   (GK 2003/03/31)

9. New/Changed: The `SparseILU`, `SparseMIC` and `SparseLUDecomposition` now use the same interface (`initialize`, `vmult`, `clear`) as all `PreconditionBlock` classes. In virtue of an unified preconditioner interface it is now recommended to use the new methods. The old methods (`reinit`, `decompose`, `apply_decomposition`) are now deprecated, and will be removed in a later version.
   (RH 2003/02/19)

10. Changed: The `BlockVector` accessor classes have been moved to a namespace `internal`. Since these classes are not (or should not be) used directly in applications, this should not change compatibility. However, they will now no longer show up in the class overview of the documentation, which they were cluttering up.
    (WB 2003/02/13)

11. New: The `SolverGMRES` now accepts an `AdditionalData` parameter `use_default_residual` whose default is `true`. By setting this flag to `false`, the stopping criterion of the left-preconditioned GMRes solver is not the default preconditioned residual but the normal (unpreconditioned) residual and visa versa for the right-preconditioned GMRes solver. Due to a performance loss of the solver this flag should be set to `false` only for debugging/testing purposes.
    (RH 2003/01/31)

12. New: `FullMatrix` has a function `copy_from`, copying from sparse matrices. It uses iterators of the sparse matrix classes.
    (GK 2003/01/08)

13. Changed: In an attempt to unify the use of preconditioners a little, the function `initialize` of classes `PreconditionRelaxation` and `PreconditionBlock` take an argument of type `AdditionalData`, defined in the same class. Standard behavior of `PreconditionBlock` has been changed on this occasion to invert diagonal blocks during initialization.
    (GK 2003/01/06)

14. New: The interface for sparse decompositions has been abstracted, and there is now an Modified Incomplete Cholesky (MIC) decomposition in addition to the Incomplete LU (ILU) decomposition.
    (Stephen Kolaroff 2002/11/27)

15. Changed: In multithread mode, the `SparseMatrix` would spawn `multithread_info.n_default_threads` threads to perform matrix-vector multiplications and similar operations. It would even do so if `multithread_info.n_default_threads` was equal to one. In that case, we now do the operation on the thread we are presently on, eliminating the overhead of spawning a single thread, and later waiting and terminating it.
    (WB 2002/11/13)

16. Fixed: In the `SparseDirectMA27` class, wrapping the MA27 solver written in Fortran77 into some structure amenable to C++, we wrote beyond the end of an array on rare inputs. This is now fixed. The same probably holds for the respective code for MA47.
    (WB 2002/09/30)

17. New: Since the MA27 sparse direct solver uses Fortran common blocks, it was previously impossible to run several instances of this solver in parallel, in a multihreaded environment. To solve this problem, the `SparseDirectMA27` class now has a detached mode, in which it forks off a separate program that will do the computations using this solver. The actual operations are therefore distributed to distint programs that have separate address spaces. This allows to have as many concurrent instances of this solver in parallel as you want. For more information, read the documentation of the `SparseDirectMA27` class.
    (WB 2002/09/25)

18. Changed: The classes `PreconditionBlock`, `PreconditionBlockJacobi`, `PreconditionBlockSOR`, and `PreconditionBlockSSOR` have changed their template signature. The first template argument is now the matrix type, not just a number type.
    (GK 2002/09/18)

19. New: Class `BlockVector` has a function `collect_sizes()`, very much as `BlockSparsityPattern`. This allows updating internal structures after blocks have been resized.
    (GK 2002/09/17)

20. New: Class `SparseMatrix` has an STL-conforming `const_iterator` and functions `begin()` and `end()` for looping through all existing entries. Furthermore, `begin(row)` and `end(row)` allow looping through all entries of a single line.
    (GK 2002/09/11)

21. New: Classes `SparsityPattern` and `SparseMatrix` now have functions `block_write/block_read`, allowing to dump the data of these objects into a file in binary format, and later to re-read it without much need for parsing.
    (WB 2002/09/09)

22. New: `Vector` has a function `lp_norm`, computing the lp-norm of a vector for arbitrary p.
    (GK 2002/08/13)

23. New: a way of using abstract base classes for matrices has been implemented with `PointerMatrixBase` and `PointerMatrix`. Storing a matrix in `PointerMatrix` allows to use the base class in functions only templated for the vector class.
    (GK 2002/07/18)

### deal.II

1. Fixed: The restriction matrices for the Q1 element in 1d had a trivial bug in that one element was not set. Due to the fact that contributions from all child cells are taken into account, this did no harm, though, since all computations were done correctly anyway.
   (WB 2003/05/06)

2. New: The `GeometryInfo` classes now have new static member functions `child_cell_from_point` that, given a point in the unit cell, returns which child cell it is on; `cell_to_child_coordinates` that transforms coordinates between the unit coordinate systems from the mother to the child cell; `child_to_cell_coordinates` that does exactly the opposite; and `is_inside_unit_cell` that tells whether a given point is inside the unit cell.
   (WB 2003/05/01)

3. New: There are now functions `recursively_set/clear_user_pointer` that do much the same as `recursively_set/clear_user_flag` on a line/quad/hex and all of its descendants, but on user pointers rather than flags.
   (WB 2003/04/11)

4. New: The functions in the `DerivativeApproximation` class can now also work on `BlockVector`.
   (WB 2003/04/11)

5. Changed: The cell argument to `Mapping::transform_unit_to_real_cell` (and its reverse function) is now passed by reference, rather than by value, for efficiency reasons.
   (WB 2003/04/06)

6. New: The `GridGenerator::subdivided_hyper_cube` generated a hypercube as coarse grid that is subdivided a given number of times.
   (WB 2003/04/05)

7. New: The `DataOut_DoFData::merge_patches` function allows to merge the patches of two objects, so as to create one output file from several DoF handlers. This is useful if one uses a domain decomposition algorithm where each block of the domain is represented by one DoF handler.
   (WB 2003/04/05)

8. Fixed: The `DataOutStack` class had a problem when there were as many degrees of freedom as there were cells (i.e. if we were using DG0 elements). This should now be fixed.
   (WB 2003/03/02)

9. Fixed: The `DataOutFaces` class was broken for cell data. It should now be correct, although the algorithm used is not optimal, being approximately quadratic in runtime.
   (WB 2003/02/25)

10. New: The `ConstraintMatrix::shift` function shifts and translates the elements of the constraint matrix by a certain number of indices.
    (Roy Stogner 2003/02/24)

11. New: The `GridReordering` class now uses a vastly better algorithm in 2d than previously. The new algorithm is linear in time, where it could be exponential before.
    (Michael Anderson 2003/02/21)

12. New: There is now a function `GridIn::read_xda` that allows reading grids from a file in XDA format.
    (WB 2003/02/21)

13. Changed: Some implementation details of the `GridReordering` class have been moved to a namespace `internal`.
    (WB 2003/02/19)

14. New: There are now functions `FiniteElement::prolongation_is_implemented` and `FiniteElement::constraints_are_implemented` that inform the caller about whether the finite element in question in fact implements its prolongation matrices and hanging node constraints.
    (WB 2003/02/15)

15. Fixed: The `ConstraintMatrix::is_identity_constrained` function would previously generate a segmentation fault if called on a constraint matrix object that did not contain any constraints at all. This is now fixed.
    (WB 2003/02/15)

16. Fixed: Objects of type `FESystem` could not be constructed if one of the elements it is to be composed of did not implement interface constraints for hanging nodes. This is now fixed: you can construct such a composed element, but it does not implement hanging node constraints either.
    (WB 2003/02/15)

17. New: For each of the renumbering functions in the `DoFRenumbering` class there is now an additional `compute_*` function. These new functions compute and return the corresponding renumbering vectors but do not perform the actual renumbering on the `DoFHandler` object. The behaviour of the old functions is not changed.
    (RH 2003/02/03)

18. Fixed: The `GridReordering` tried to be thread-safe in the initialization of some data, but was not due to a typo. This is now fixed.
    (WB 2003/01/28)

19. Changed: The `FEValues::get_cell` and `FEValues::get_face` functions have been removed, since they limited our ability to use this class for other types of DoFHandlers, for example future extensions for hp elements.
    (WB 2003/01/17)

20. New: The DoF accessor classes now have a function `get_fe()` that returns a reference to the finite element being used on this cell. The result is of course identical to what a call to `iterator->get_dof_handler().get_fe()` would have yielded.
    (WB 2003/01/10)

21. New: Checked in new `GridGenerator` member function `half_hyper_ball`, derived from member `hyper_ball`. The initial mesh contains four elements. This mesh will work with the boundary class `HalfHyperBallBoundary`.
    (Brian Carnes 2002/12/16)

22. New: Checked in new class `FE_Q_Hierarchical` derived from class `FiniteElement`. This element is analogous to `FE_Q`, but makes use of hierarchical shape functions, based on the `Polynomials::Hierarchical` class. For `degree>1`, the non-nodal basis functions are "bubble" functions, which are not Lagrange polynomials. Therefore, the usual interpolation based on using unit support points will not work for `degree>1`. It is planned to implement a different interpolation-projection operator, based on an hp-type interpolant.
    The files for this element are `deal.II/include/fe/fe_q_hierarchical.h` and `deal.II/source/fe/fe_q_hierarchical.cc`.
    (Brian Carnes 2002/12/13)

23. New: For finite element classes, the functions `unit_support_point` and `unit_face_support_point` return the position of an individual support point. This is necessary when you want to get information about the support points of certain components in a composed finite element, where not all components provide support points, and the composed element thus does not fill the array the `get_unit_support_points` function returns.
    (WB 2002/11/23)

24. Fixed: Vectors could not be given as input and output vectors to the `SolutionTransfer` class at the same time, but this was not checked. An assertion has now been added to ensure this requirement.
    (WB 2002/10/28)

25. Fixed: The `DoFRenumbering::component_wise` function accepts a parameter indicating the order in which the degrees of freedom corresponding to one vector component are to be sorted. However, it did not honor this order, but always sorted them in the order in which the components appear. This is now fixed.
    (WB 2002/10/17)

26. New: The `FiniteElement::system_to_base_index` function now exports the values of the `FiniteElement::system_to_base_table` member variable. Likewise for the indices on faces.
    (WB 2002/10/17)

27. New: The `FiniteElement::element_multiplicity` function was previously only available in the `FESystem` class, where it actually returned a non-trivial value. However, in some cases one would need to access this field also for general finite elements, even if the returned value will be equal to one in all cases other than a composed element.
    (WB 2002/10/17)

28. Fixed: The algorithm to generate neighbor information for patches from cells in `DataOut::build_patches` was rather inefficient, tripling the time for patch generation when support for neighbor information was added. Furthermore, the algorithm was at least O(N log N), where the rest was all O(N), making this particularly problematic when the data set was already large. This should now be back to the previous level, by using a more efficient algorithm.
    (WB 2002/10/10)

29. Changed (internals): Previously, the finite element base class initialized the restriction, prolongation, and face constraints matrices to their correct size. Derived classes had to fill these classes, and should have set their size back to zero in case they chose not to implement them. However, we found a class that forgot to resize it to zero, so it is now the other way round: they remain at size zero, and a class that chooses to implement these matrices has to set them to the correct size, to avoid programs that run on data that as just been forgotten to add. (This information only concerns programs that implement some finite element class on their own.)
    (WB 2002/09/28)

30. Improved: The different transfer functions in `FETools` operate on template vector arguments.
    (GK 2002/09/24)

31. New: the class `FE_DGPNonparametric` implements finite elements where shape functions are polynomials of order k on the actual grid cell. This is achieved by evaluating the polynomials at the mapped quadrature points. No grid transfer matrices are available for this class.
    (GK 2002/09/19)

32. Fixed: Some of the various instances of the `VectorTools::interpolate_boundary_values` functions were not explicitly instantiated, leading to linker errors. This is now fixed.
    (WB 2002/09/19)

33. Removed: The `FiniteElement::component_to_system_index` function and its counterpart for faces is gone. This data did not make much sense in the case of elements that are non-zero in more than one vector component, such as the Nedelec element. The respective information can also be obtained from other sources provided by the finite element classes, if so necessary.
    (WB 2002/09/16)

34. Changed: The `FiniteElement::restriction_is_additive` function used to take an argument that denoted the vector component of a finite element. This has become difficult with elements that are non-zero in more than one vector component, such as the Nedelec element. Thus, the semantics of the function have been changed so that the argument now denotes the index of a shape function, rather than a vector component. Since the function is probably not used in application code, this will most probably not lead to more serious problems.
    (WB 2002/09/16)

35. New: The mapping classes now also know how to transform tensors of rank 2, not only vectors (tensors of rank 1) in a co- and contravariant way.
    (WB 2002/09/03)

36. Fixed: the `GridIn` class had problems when reading in UCD grids with comment lines that contained only the comment sign, but nothing else. This is now fixed.
    (WB 2002/08/30)

37. Improved: `VectorTools`::`integrate_difference` can compute Lp and W1,p norms for arbitrary p. The function receives an additional optional argument p for this. All previous fuctionality remains unchanged, although the code has been cleaned up a bit.
    (GK 2002/08/01)

38. New: The `GridTools` class now offers functions to apply general transformations to all vertices of a triangulation, and also more specialized functions that shift, scale, and rotate triangulations.
    (RH 2002/07/25)

39. New: The existing `FETools::extrapolate` functions does not take into account hanging node constraints. Therefore, it works for continuous elements on globally refined grids and on discontinuous elements, only. Now, there is a new `FETools::extrapolate` function with an additional `ConstraintMatrix` argument for the hanging node constraints. This new function works for continuous as well as for discontinuous elements. But, the old function is still supported.
    (RH 2002/06/17)

40. New: There are now `Triangulation::save/load_user_pointers(vector<void *> &)` functions similar to the respective `Triangulation::save/load_user_flags(vector<bool> &)` functions.
    (RH 2002/06/14)

41. Fixed: Bug in `Triangulation<3>::load_user_flags(vector<bool> &)` is now fixed.
    (RH 2002/06/14)

42. Fixed: `Triangulation::load_user_flags(vector<bool> &)` erroneously threw an assertion for `dim==1`. This is now fixed.
    (RH 2002/06/14)

43. Changed: `Triangulation<1>::n_quads` now returns 0, instead of throwing an assertion, as before. The same holds for similar functions like `Triangulation<dim>::n_hexs` that now returns 0 for `dim<3`.
    (RH 2002/06/14)

44. Improved: Several functions like the `DoFHandler::distribute_dofs` and `DoFTools::make_flux_sparsity_pattern` functions altered the `user_flags`. This was stated in the documentation of these functions. Nevertheless, it might have led to unexpected behaviour of the `user_flags` for users who weren't aware of this side-effect. Now, these functions do not alter the `user_flags`, any more. Consequently, the users do not need to worry any more about the reliability of the `user_flags` when calling any function of the library.
    (RH 2002/06/14)

45. Fixed: `FE_Q::has_support_on_face` always returned true in 1d, partly because faces are not really an issue in 1d. It now does so only when the support point of the respective shape function is actually the requested vertex. The same applied to `FE_DGQ::has_support_on_face`
    (WB 2002/06/13)

46. New: The existing `FETools::interpolate`, `FETools::back_interpolate` and `FETools::interpolate_difference` functions do not take into account hanging node constraints. Therefore, they work for continuous elements on globally refined grids and on discontinuous elements, only. Now, there are new functions with the same names but additional `ConstraintMatrix` arguments for the hanging node constraints. These new functions work for continuous as well as for discontinuous elements. But, the old functions are still supported.
    (RH 2002/06/13)

47. Changed: The constructor of `DoFHandler` now takes a reference to a `const` `Triangulation`.
    (RH 2002/06/12)

48. Changed: The constructors of all `DoFAccessor`, `TriaAccessor` and `TriaIterator` classes now take pointers to `const` `Triangulation`s.
    (RH 2002/06/12)

49. Fixed: In debug mode the `MappingQ1::transform_real_to_unit_cell` function erroneously threw an assertion when used in 1 or 3 dimensions. This is now fixed.
    (RH 2002/06/10)

50. Fixed: The `get_dof_indices` functions of DoF accessor classes used to work also for non-active cells. However, the results were bogus except for the special case that we had a finite element that has all its degrees of freedom located in vertices. This is now fixed: the function throws an exception in all other cases, since there is no useful meaning for it then. It continues to work in the special case.
    (WB 2002/06/08)

51. New: For encapsulated postscript output of 2d grids, it is now possible to tell the `GridOut` class to write the cell numbers into each cell, as well as the numbers of the vertices.
    (WB 2002/06/04)

Last update $Date: 2013-12-21 16:26:26 -0500 (Sat, 21 Dec 2013) $