* are a priori known (for example, <tt>dim</tt> elements), you might
* consider using the TensorFunction class instead.
*
+ * @ingroup functions
* @author Wolfgang Bangerth, 1998, 1999
*/
template <int dim>
* This function is of use when you want to implement homogeneous boundary
* conditions, or zero initial conditions.
*
+ * @ingroup functions
* @author Wolfgang Bangerth, 1998, 1999
*/
template <int dim>
* in all its components, which might not be overly useful a feature
* in most cases, however.
*
+ * @ingroup functions
* @author Wolfgang Bangerth, 1998, 1999
*/
template <int dim>
* <tt>VectorTools::integrate_difference</tt>, where it allows to integrate
* only one component.
*
+ * @ingroup functions
* @author Guido Kanschat, 2000
*/
template <int dim>
* schemes). Experimenting with <tt>h</tt> and the difference scheme may be
* necessary to obtain sufficient results.
*
+ * @ingroup functions
* @author Guido Kanschat, 2000
*/
template <int dim>
* Namespace implementing some concrete classes derived from the
* Function class that describe actual functions. This is rather
* a collection of classes that we have needed for our own programs
- * once and thought they might be useful to others as well at some
+ * once and thought might be useful to others as well at some
* point.
+ *
+ * @ingroup functions
*/
namespace Functions
{
*
* Together with the function, its derivatives and Laplacian are defined.
*
+ * @ingroup functions
* @author: Guido Kanschat, 1999
*/
template<int dim>
* The function <tt>xy</tt>. This function serves as an example for
* a vanishing Laplacian.
*
+ * @ingroup functions
* @author: Guido Kanschat, 2000
*/
template<int dim>
*
* Together with the function, its derivatives and Laplacian are defined.
*
+ * @ingroup functions
* @author: Guido Kanschat, 1999
*/
template<int dim>
* Cosine-shaped pillow function.
* This is another function with zero boundary values on $[-1,1]^d$. In the interior
* it is the product of $\cos(\pi/2 x_i)$.
+ *
+ * @ingroup functions
* @author Guido Kanschat, 1999
*/
template<int dim>
/**
* Product of exponential functions in each coordinate direction.
+ *
+ * @ingroup functions
* @author Guido Kanschat, 1999
*/
template<int dim>
/**
* Singularity on the L-shaped domain in 2D.
*
+ * @ingroup functions
* @author Guido Kanschat, 1999
*/
class LSingularityFunction : public Function<2>
/**
* Singularity on the slit domain in 2D.
*
+ * @ingroup functions
* @author Guido Kanschat, 1999
*/
class SlitSingularityFunction : public Function<2>
/**
* Singularity on the slit domain with one Neumann boundary in 2D.
*
+ * @ingroup functions
* @author Guido Kanschat, 2002
*/
class SlitHyperSingularityFunction : public Function<2>
std::vector<double> &values,
const unsigned int component = 0) const;
};
+
/**
*
* Together with the function, its derivatives and Laplacian are defined.
*
+ * @ingroup functions
* @author: Guido Kanschat, 2000
*/
template<int dim>
* The class has its name from the fact that it resembles one
* component of a Fourier cosine decomposition.
*
+ * @ingroup functions
* @author Wolfgang Bangerth, 2001
*/
template <int dim>
* The class has its name from the fact that it resembles one
* component of a Fourier sine decomposition.
*
+ * @ingroup functions
* @author Wolfgang Bangerth, 2001
*/
template <int dim>
* function is then recovered as
* $f(x) = \sum_j w_j sin(\sum_i k_i x_i) = Im(\sum_j w_j \exp(i k.x))$.
*
+ * @ingroup functions
* @author Wolfgang Bangerth, 2001
*/
template <int dim>
* function is then recovered as
* $f(x) = \sum_j w_j cos(\sum_i k_i x_i) = Re(\sum_j w_j \exp(i k.x))$.
*
+ * @ingroup functions
* @author Wolfgang Bangerth, 2001
*/
template <int dim>
* also stores the number of the non-zero component, if the function
* is vector-valued.
*
+ * @ingroup functions
* @author Guido Kanschat, 2002
*/
template <int dim>
* If vector valued, it can be restricted
* to a single component.
*
+ * @ingroup functions
* @author Guido Kanschat, 2001, 2002
*/
template<int dim>
* maximum value is 1. If vector valued, it can be restricted
* to a single component.
*
+ * @ingroup functions
* @author Guido Kanschat, 2001, 2002
*/
template<int dim>
* distance to the center, and $s$ is the radius of the sphere. If
* vector valued, it can be restricted to a single component.
*
+ * @ingroup functions
* @author Guido Kanschat, 2001, 2002
*/
template<int dim>
@endverbatim
*
*
+ * @ingroup functions
* @author Luca Heltai, 2005
*/
template <int dim>
* purpose than the intended one! This will inevitably lead to confusion.
*
*
+ * @ingroup functions
* @author Wolfgang Bangerth, Guido Kanschat, 1998, 1999
*/
class FunctionTime
/*------------------------------ Inline functions ------------------------------*/
+#ifndef DOXYGEN
+
inline double
FunctionTime::get_time () const
{
return time;
}
+#endif
#endif
* maps, lists, etc. If you need such functions feel free to implement
* them and send them to us for inclusion.
*
+ * @ingroup memory
* @author Wolfgang Bangerth, 2000
*/
namespace MemoryConsumption
* <tt>n_default_threads</tt> is set to the number of CPUs by default, but
* can be adjusted by the user to fit the requirements.
*
- * @author Thomas Richter, 2000
+ * @ingroup threads
+ * @author Thomas Richter, Wolfgang Bangerth, 2000
*/
class MultithreadInfo
{
/**
* Global variable of type <tt>MultithreadInfo</tt> which you may ask for the
- * number of CPUs in you system, as well as for the default number of
+ * number of CPUs in your system, as well as for the default number of
* threads that multithreaded functions shall use.
+ *
+ * @ingroup threads
*/
extern MultithreadInfo multithread_info;
* x<sup>0</sup>y<sup>0</sup>z<sup>n</sup>
* </i>
* </dl>
+ *
+ * @ingroup Polynomials
* @author Guido Kanschat, Wolfgang Bangerth, Ralf Hartmann 2002, 2003, 2004, 2005
*/
template <int dim>
*/
/**
- * @brief The set of BDM polynomials on tensor product cells
- *
* This class implements the <i>H<sup>div</sup></i>-conforming,
* vector-valued Brezzi-Douglas-Marini polynomials as described in the
* book by Brezzi and Fortin.
* This class is useful if you want to use flexible quadrature rules,
* that are read from a parameter file (see ParameterHandler for
* this).
- *
+ *
+ * @ingroup Quadrature
* @author Ralf Schulz, 2003
*/
template<int dim>
* a constant object (disallowing write access when dereferenced), while
* <tt>SmartPointer<ABC></tt> is a mutable pointer.
*
+ * @ingroup memory
* @author Guido Kanschat, Wolfgang Bangerth, 1998 - 2005
*/
template<typename T>
#include <map>
#include <string>
+
/**
* Handling of subscriptions.
*
* @note Due to a problem with <tt>volatile</tt> declarations, this
* additional feature is switched of if multithreading is used.
*
+ * @ingroup memory
* @author Guido Kanschat, 1998 - 2005
*/
class Subscriptor
* deal.II. Most of the content of this namespace is discussed in
* detail in one of the reports linked to from the documentation page
* of deal.II.
+ *
+ * @ingroup threads
*/
namespace Threads
{
--- /dev/null
+//-------------------------------------------------------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 2006 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//-------------------------------------------------------------------------
+
+/**
+ * @defgroup functions Functions
+ *
+ * Functions are used in various places in deal.II, for example to
+ * describe boundary conditions, coefficients in equations, forcing
+ * terms, or exact solutions. Since closed form expressions for
+ * equations are often hard to pass along as function arguments,
+ * deal.II uses the Function base class to describe these
+ * objects. Essentially, the interface of this base class requires
+ * derived classes to implement the ability to return the value of a
+ * function at one or a list of particular locations, and possibly (if
+ * needed) of gradients or second derivatives of the function. With
+ * this, function objects can then be used by algorithms like
+ * VectorTools::interpolate, VectorTools::project_boundary_values, and
+ * other functions.
+ *
+ * Some functions are needed again and again, and are therefore
+ * already provided in deal.II. This includes a function with a
+ * constant value; a function that is zero everywhere, or a
+ * vector-valued function for which only one vector component has a
+ * particular value and all other components are zero. Some more
+ * specialized functions are also defined in the Functions namespace.
+ *
+ * For time dependent computations, boundary conditions and/or right
+ * hand side functions may also change with time. Since at a given
+ * time step one is usually only interested in the spatial dependence
+ * of a function, it would be awkward if one had to pass a value for
+ * the time variable to all methods that use function objects. For
+ * example, the VectorTools::interpolate_boundary_values function
+ * would have to take a time argument which it can use when it wants
+ * to query the value of the boundary function at a given time
+ * step. However, it would also have to do so if we are considering a
+ * stationary problem, for which there is nothing like a time
+ * variable.
+ *
+ * To circumvent this problem, function objects are always considered
+ * spatial functions only. However, the Function class is derived from
+ * the FunctionTime base class that stores a value for a time
+ * variable, if so necessary. This way, one can define a function
+ * object that acts as a spatial function but can do so internally by
+ * referencing a particular time. In above example, one would set the
+ * time of the function object to the present time step before handing
+ * it off to the VectorTools::interpolate_boundary_values method.
+ */
--- /dev/null
+//-------------------------------------------------------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 2006 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//-------------------------------------------------------------------------
+
+/**
+ * @defgroup memory Memory handling
+ *
+ * This group has some basic classes and namespaces for memory
+ * handling. The Subscriptor and SmartPointer classes are used for
+ * counted memory handling, i.e. whenever a SmartPointer is set to
+ * point to an object, it increases a counter in that object; when the
+ * pointer is set to point elsewhere, it decreases it again. This way,
+ * one always knows how many users of an object there still are. While
+ * this is rarely useful in itself, it is used to generate an
+ * exception if an object is destroyed while a pointer somewhere is
+ * still pointing to it, as any access through that pointer at a later
+ * time would otherwise lead to access of invalid memory regions.
+ *
+ * In contrast to this, the MemoryConsumption namespace provides
+ * functions that can be used to determine the memory consumption of
+ * objects. For some simple classes, like the STL containers, it
+ * directly determines how much memory they need (or at least gives an
+ * estimate). For deal.II classes, it uses the
+ * <code>memory_consumption</code> member function that most classes
+ * have.
+ */
--- /dev/null
+//-------------------------------------------------------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 2006 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//-------------------------------------------------------------------------
+
+/**
+ * @defgroup threads Multithreading
+ *
+ * On machines with more than one processor (or multicore processors),
+ * it is often profitable to run several parts of the computations in
+ * parallel. For example, one could have several threads running in
+ * parallel, each of which assembles the cell matrices of a subset of
+ * the triangulation and then writes them into the global
+ * matrix. Since assembling matrices is often an expensive operation,
+ * this frequently leads to significant savings in compute time on
+ * multiprocessor machines.
+ *
+ * In a similar way, it is often also profitable to use multiple
+ * threads on a single-CPU system if a significant amount of input or
+ * output tasks has to be performed. In such cases, the program
+ * usually has to wait for disks or network storages to provide the
+ * requested data, or to flush buffers. If this is done on a separate
+ * thread, other threads of the program can continue to do other, more
+ * interesting things at the same time, using the CPU downtime.
+ *
+ * Support for this model of computations, i.e. using multiple threads
+ * on a shared-memory machine (SMP machine) is provided mainly through
+ * the Threads namespace that offers functions to create new threads
+ * as well as synchronisation primitives. The MultithreadInfo class
+ * allows to query certain properties of the system, such as the
+ * number of CPUs. The use of these classes is explained in the
+ * step-9, step-13 and step-14 tutorial programs.
+ *
+ * On the other hand, programs running on distributed memory machines
+ * (i.e. clusters) need a different programming model built on top of
+ * MPI and PETSc that is described in the step-17 and later example
+ * programs.
+ */
*
* All other classes in this module actually implement quadrature
* rules of different order and other characteristics.
+ *
+ *
+ * <h3>QuadratureSelector</h3>
+ *
+ * This class is used to generate a quadrature object based on a
+ * string that identifies the quadrature formula. This is useful in
+ * cases where one wants to specify a certain quadrature formula in an
+ * input file, rather than hardcode it in the program.
*/