This is the list of changes made between the deal.II releases listed above. 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

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)
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)
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)
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)
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)
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)
New: Changes have been made to support compiling and using deal.II on AIX 5 systems.
(WB 2003/01/24)
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)
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)
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)
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)
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)
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)
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)
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)
New: base/config.h now exports the deal.II base directory through the DEAL_II_PATH preprocessor variable.
(WB 2002/09/09)
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)
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)
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)
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)
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

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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
Changed: Because they became too many, the classes describing 1d polynomials are now in a namespace Polynomials.
(WB 2002/10/14)
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)
Changed: The class Table::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)
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)
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)
New: Global exception class ExcIteratorPastEnd, which should be used if an iterator is incremented or decremented beyond its end value.
(GK 2002/09/08)
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 assistance 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)
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)
New: There are now functions returning the transpose of Tensor objects of rank 2.
(WB 2002/08/31)
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)
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)
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)
New: There are now operators to allow multiplication and division of Tensor objects by scalar factors.
(WB 2002/06/07)

lac

New: Function BlockSparseMatrix::print_formatted added, similar to the BlockVector::print_formatted function.
(Brian Carnes 2003/06/02)
New: Functions SparseMatrix::operator *= and SparseMatrix::operator /= as well as BlockSparseMatrix::operator *= and BlockSparseMatrix::operator /= are added.
(Brian Carnes 2003/06/02)
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)
New: Vector, BlockVector and FullMatrix now have operator/= for scaling by a scalar.
(WB 2003/05/31)
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)
New: SparseLUDecomposition now has empty() function, which calls the inherited SparseMatrix empty() function.
(Brian Carnes 2003/05/22)
New: PreconditionPSOR implements interface to permuted SOR preconditioner function in SparseMatrix.
(GK 2003/05/12)
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)
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)
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)
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)
New: FullMatrix has a function copy_from, copying from sparse matrices. It uses iterators of the sparse matrix classes.
(GK 2003/01/08)
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)
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)
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)
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)
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 distinct 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)
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)
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)
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)
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)
New: Vector has a function lp_norm, computing the l_p-norm of a vector for arbitrary p.
(GK 2002/08/13)
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

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)
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)
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)
New: The functions in the DerivativeApproximation class can now also work on BlockVector.
(WB 2003/04/11)
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)
New: The GridGenerator::subdivided_hyper_cube generated a hypercube as coarse grid that is subdivided a given number of times.
(WB 2003/04/05)
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)
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)
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)
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)
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)
New: There is now a function GridIn::read_xda that allows reading grids from a file in XDA format.
(WB 2003/02/21)
Changed: Some implementation details of the GridReordering class have been moved to a namespace internal.
(WB 2003/02/19)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
Improved: The different transfer functions in FETools operate on template vector arguments.
(GK 2002/09/24)
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)
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)
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)
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)
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)
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)
Improved: VectorTools::integrate_difference can compute L^p and W^1,p norms for arbitrary p. The function receives an additional optional argument p for this. All previous functionality remains unchanged, although the code has been cleaned up a bit.
(GK 2002/08/01)
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)
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)
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)
Fixed: Bug in Triangulation<3>::load_user_flags(vector<bool> &) is now fixed.
(RH 2002/06/14)
Fixed: Triangulation::load_user_flags(vector<bool> &) erroneously threw an assertion for dim==1. This is now fixed.
(RH 2002/06/14)
Changed: Triangulation<1>::n_quads now returns 0, instead of throwing an assertion, as before. The same holds for similar functions like Triangulation::n_hexs that now returns 0 for dim<3.
(RH 2002/06/14)
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)
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)
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)
Changed: The constructor of DoFHandler now takes a reference to a const Triangulation.
(RH 2002/06/12)
Changed: The constructors of all DoFAccessor, TriaAccessor and TriaIterator classes now take pointers to const Triangulations.
(RH 2002/06/12)
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)
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)
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)