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).
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)
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<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)
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 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)
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)
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 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)
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 lp-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)
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 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)
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<dim>::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 Triangulation
s.
(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)