*
* Given the lines as described above, a cut through this data in Gnuplot
* can then be achieved like this:
- * @begin{verbatim}
+ * @verbatim
* set data style lines
* splot [:][:][0:] "T" using 1:2:($3==.5 ? $4 : -1)
- * @end{verbatim}
+ * @endverbatim
* This command plots data in x- and y-direction unbounded, but in z-direction
* only those data points which are above the x-y-plane (we assume here a
* positive solution, if it has negative values, you might want to decrease the
*
* The output uses two different povray-objects:
*
- * @begin{itemize}
+ * <ul>
* @item <tt>BICUBIC_PATCH</tt>
* A <tt>bicubic_patch</tt> is a 3-dimensional Bezier patch. It consists of 16 Points
* describing the surface. The 4 corner points are touched by the object,
*
* Using the smooth flag povray interpolates the normals on the triangles,
* imitating a curved surface
- * @end{itemize}
+ * </ul>
*
* All objects get one texture definition called Tex. This texture has to be
* declared somewhere before the object data. This may be in an external
*
* You need povray (>=3.0) to render the scene. The minimum options for povray
* are:
- * @begin{verbatim}
+ * @verbatim
* povray +I<inputfile> +W<horiz. size> +H<ver. size> +L<include path>
- * @end{verbatim}
+ * @endverbatim
* If the external file "data.inc" is used, the path to this file has to be
* included in the povray options.
*
* <tt>n_subdivision</tt> = 4 because
* the number of cells is
* equal to <tt>2^dim</tt>.
- * @begin{verbatim}
+ * @verbatim
* __ __ __ __
* | | | | |
* |__|__|__|__|
* |__|__|__|__|
* | | | | |
* |__|__|__|__|
- * @end{verbatim}
+ * @endverbatim
* @author Wolfgang Bangerth
*/
template <int dim, int spacedim=dim>
* <tt>(0, 3, 1,2)</tt> in 2d, and
* <tt>(0, 4, 3, 7, 1, 5, 2, 6)</tt>
* in 3d as following:
- * @begin{verbatim}
+ * @verbatim
*
* 7________6
* / /|
* | / | /
* | / | /
* 0|/______1/
- * @end{verbatim}
+ * @endverbatim
*
* For exemple in 2d: If
* <tt>subdivisions==2</tt> the
* given by the following
* numeration:
*
- * @begin{verbatim}
+ * @verbatim
* 2 ____5 ____8
* | | |
* | | |
* | | |
* | | |
* 0|____3|____6|
- * @end{verbatim}
+ * @endverbatim
*
* Since the number of data vectors
* is usually the same for all
* Gnuplot-default of 0 is
* the following:
*
- * @begin{verbatim}
+ * @verbatim
*
* 3________7
* / /|
* | / | /
* 1|/______5/
*
- * @end{verbatim}
+ * @endverbatim
*/
double turn_angle;
* suffix with a given output format
* usually has. At present the following
* formats are defined:
- * @begin{itemize}
+ * <ul>
* @item <tt>dx</tt>: <tt>.dx</tt>
* @item <tt>ucd</tt>: <tt>.inp</tt>
* @item <tt>gnuplot</tt>: <tt>.gnuplot</tt>
* @item <tt>eps</tt>: <tt>.eps</tt>
* @item <tt>gmv</tt>: <tt>.gmv</tt>
* @item <tt>vtk</tt>: <tt>.vtk</tt>.
- * @end{itemize}
+ * </ul>
*
* If this function is called
* with no argument or
* than that the program flow should not have reached a certain point,
* e.g. a <tt>default</tt> section of a <tt>switch</tt> statement. In this case,
* raise the exception by the following construct:
- * @begin{verbatim}
+ * @verbatim
* Assert (false, ExcInternalError());
- * @end{verbatim}
+ * @endverbatim
*
* As mentioned above, the program is terminated once a call to
* <tt>Assert</tt> fails. However, there is one case where we do not want
/**
* Relay exceptions from the <tt>Assert</tt> macro to the
* <tt>__IssueError_Assert</tt> function. Used to convert the last
- * argument from arbitrary type to @ref{ExceptionBase} which is not
+ * argument from arbitrary type to ExceptionBase which is not
* possible inside the <tt>Assert</tt> macro due to syntactical
* difficulties in connection with the way we use the macro and the
* declaration of the exception classes.
/**
* Namespace implementing some concrete classes derived from the
- * @ref{Function} class that describe actual functions. This is rather
+ * 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
* point.
* for time dependent problems.
*
* Access to the time goes through the following functions:
- * @begin{verbatim}
+ * @verbatim
* @item <tt>get_time</tt>: return the present value of the time variable.
* @item <tt>set_time</tt>: set the time value to a specific value.
* @item <tt>advance_time</tt>: increase the time by a certain time step.
- * @end{verbatim}
+ * @endverbatim
* The latter two functions are virtual, so that derived classes can
* perform computations which need only be done once for every new time.
* For example, if a time dependent function had a factor <tt>sin(t)</tt>, then
/**
* A class that simplifies the process of execution logging. It does so by
* providing
- * @begin{itemize}
+ * <ul>
* @item a push and pop mechanism for prefixes, and
* @item the possibility of distributing information to files and the
* console.
- * @end{itemize}
+ * </ul>
*
* The usual usage of this class is through the pregenerated object
* <tt>deallog</tt>. Typical steps are
- * @begin{itemize}
+ * <ul>
* @item <tt>deallog.attach(std::ostream)</tt>: write logging information into a file.
* @item <tt>deallog.depth_console(n)</tt>: restrict output on screen to outer loops.
* @item Before entering a new phase of your program, e.g. a new loop,
* @item <tt>deallog << anything << std::endl;</tt> to write logging information
* (Usage of <tt>std::endl</tt> is mandatory!).
* @item <tt>deallog.pop()</tt> when leaving that stage entered with <tt>push</tt>.
- * @end{itemize}
+ * </ul>
*
* @author Guido Kanschat, Wolfgang Bangerth, 1999, 2003
*/
* be recognised if in the declaration multiple whitespace is used.
*
* In entry names and values the following characters are not allowed: <tt>\#</tt>, <tt>{</tt>,
- * <tt>}</tt>, <tt>|</tt>. Their use is reserved for the @ref{MultipleParameterLoop} class.
+ * <tt>}</tt>, <tt>|</tt>. Their use is reserved for the MultipleParameterLoop class.
*
* Comments starting with \# are skipped.
*
* set Maximum number of iterations = 100
* end
* end
- * @end{verbatim}
+ * @endverbatim
*
* And here is the ouput of the program:
- * @begin{verbatim}
+ * @verbatim
* Line 8:
* The entry value
* Gauss-Seidel
* a comment when this class is
* asked to write out all
* declarations to a stream using
- * the @ref{print_parameters}
+ * the print_parameters()
* function.
*
* The function generates an
* from the actual value, as well
* as the documenting string
* given to the
- * @ref{declare_entry} function
+ * declare_entry() function
* if available.
*/
std::ostream & print_parameters (std::ostream &out,
* variable. This variable is
* controlled by entering and
* leaving subsections through
- * the @ref{enter_subsection} and
- * @ref{leave_subsection}
+ * the enter_subsection() and
+ * leave_subsection()
* functions.
*
* In most cases, you will not
* variable. This variable is
* controlled by entering and
* leaving subsections through
- * the @ref{enter_subsection} and
- * @ref{leave_subsection}
+ * the enter_subsection() and
+ * leave_subsection()
* functions.
*
* In most cases, you will not
* of the two solvers.
*
* Opposite to a variant entry, an array entry looks like this:
- * @begin{verbatim}
+ * @verbatim
* set Output file = ofile.{{ 1 | 2 | 3 | 4 }}
- * @end{verbatim}
+ * @endverbatim
* This indicates that if there are variant entries producing a total of four
* different runs will write their results to the files <tt>ofile.1</tt>, <tt>ofile.2</tt>,
* <tt>ofile.3</tt> and <tt>ofile.4</tt>, respectively. Array entries do not generate multiple
* constructor. This way, it can
* use the non-standard
* constructor of
- * @ref{Polynomial}.
+ * Polynomial.
*/
static const std::vector<double> &
get_coefficients (const unsigned int k);
*
* This function may be
* used to initialize the
- * @ref{TensorProductPolynomials},
- * @ref{AnisotropicPolynomials},
- * and @ref{PolynomialSpace}
+ * TensorProductPolynomials,
+ * AnisotropicPolynomials,
+ * and PolynomialSpace
* classes.
*/
static
* constructor. This way, it can
* use the non-standard
* constructor of
- * @ref{Polynomial}.
+ * Polynomial.
*/
static const std::vector<double> &
get_coefficients (const unsigned int p);
* P<sub>i</sub>(x)P<sub>j</sub>(y)P<sub>k</sub>(z)</i>, where the sum
* of <i>i</i>, <i>j</i> and <i>k</i> is less than or equal <i>n</i>.
*
- * The @ref{output_indices} function prints the ordering of the
+ * The output_indices() function prints the ordering of the
* polynomials, i.e. for each dim-dimensional polynomial in the
* polynomial space it gives the indices i,j,k of the one-dimensional
* polynomials in x,y and z direction. The ordering of the
* dim-dimensional polynomials can be changed by using the
- * @p{set_polynomial_ordering} function.
+ * set_polynomial_ordering() function.
*
* @author Guido Kanschat, 2002, Wolfgang Bangerth, 2003, Ralf Hartmann 2004
*/
* Note, that this number is
* <tt>PolynomialSpace::degree()-1</tt>,
* compare definition in
- * @ref{PolynomialSpace}.
+ * PolynomialSpace.
*/
unsigned int degree() const;
* is therefore not meant to
* actually perform integrations,
* but rather to be used with
- * @ref{FEValues} objects in
+ * FEValues objects in
* order to find the position of
* some points (the quadrature
* points in this object) on the
* cell, one set of which will
* then be selected at each
* time. This is used in the
- * @ref{FEFaceValues} class,
+ * FEFaceValues class,
* where we initialize the
* values, derivatives, etc on
* all faces at once, while
* The coefficients of these quadrature rules are computed by the
* function found in <tt>Numerical Recipies</tt>. For lower order
* quadrature rules, the use of this class is thus equivalent to the
- * use of the @ref{QGauss1} through @ref{QGauss7} classes, for which
+ * use of the QGauss1 through QGauss7 classes, for which
* the coefficients are hardcoded, but this class can provide higher
* order formulae as well.
*
/**
* This class implements the quadrature rule passed to its constructor
- * as a string. Supported quadratures are @ref{QGauss} (of all
- * orders), @ref{QMidpoint}, @ref{QMilne}, @ref{QSimpson},
- * @ref{QTrapez} and @ref{QWeddle}.
+ * as a string. Supported quadratures are QGauss (of all
+ * orders), QMidpoint, QMilne, QSimpson,
+ * QTrapez and QWeddle.
*
* This class is useful if you want to use flexible quadrature rules,
- * that are read from a parameter file (see @ref{ParameterHandler} for
+ * that are read from a parameter file (see ParameterHandler for
* this).
*
* @author Ralf Schulz, 2003
* as a list separated by <tt>|</tt>,
* so that you can use it for the
* definition of parameter files
- * (see @ref{ParameterHandler} for
+ * (see ParameterHandler for
* details).
*/
static std::string get_quadrature_names();
* is only considered in a call, if all parts of its signature can be
* instantiated with the template parameter replaced by the respective
* types/values in this particular call. Example:
- * @begin{verbatim}
+ * @verbatim
* template <typename T>
* typename T::type foo(T) {...};
* ...
* foo(1);
- * @end{verbatim}
+ * @endverbatim
* The compiler should detect that in this call, the template
* parameter T must be identified with the type "int". However,
* the return type T::type does not exist. The trick now is
*
* The idea is then to make the return type un-instantiatable if
* certain constraints on the template types are not satisfied:
- * @begin{verbatim}
+ * @verbatim
* template <bool, typename> struct constraint_and_return_value;
* template <typename T> struct constraint_and_return_value<true,T> {
* typedef T type;
* };
- * @end{verbatim}
+ * @endverbatim
* constraint_and_return_value<false,T> is not defined. Given something like
- * @begin{verbatim}
+ * @verbatim
* template <typename>
* struct int_or_double { static const bool value = false;};
* template <>
* struct int_or_double<int> { static const bool value = true; };
* template <>
* struct int_or_double<double> { static const bool value = true; };
- * @end{verbatim}
+ * @endverbatim
* we can write a template
- * @begin{verbatim}
+ * @verbatim
* template <typename T>
* typename constraint_and_return_value<int_or_double<T>::value,void>::type
* f (T);
- * @end{verbatim}
+ * @endverbatim
* which can only be instantiated if T=int or T=double. A call to
* f('c') will just fail with a compiler error: "no instance of
* f(char) found". On the other hand, if the predicate in the first
/**
* This class is a model for a tensor valued function. The interface
- * of the class is mostly the same as that for the @ref{Function}
+ * of the class is mostly the same as that for the Function
* class, with the exception that it does not support vector-valued
* functions with several components, but that the return type is
* always tensor-valued. The returned values of the evaluation of
* P<sub>2</sub>(x)P<sub>2</sub>(y), P<sub>3</sub>(x)P<sub>2</sub>(y),
* ...</i> and likewise in 3d.
*
- * The @ref{output_indices} function prints the ordering of the
+ * The output_indices() function prints the ordering of the
* dim-dimensional polynomials, i.e. for each polynomial in the
* polynomial space it gives the indices i,j,k of the one-dimensional
* polynomials in x,y and z direction. The ordering of the
* dim-dimensional polynomials can be changed by using the
- * @p{set_renumbering} function.
+ * set_renumbering() function.
*
* @author Ralf Hartmann, 2000, 2004, Guido Kanschat, 2000, Wolfgang Bangerth 2003
*/
// per default set this index map
// to identity. This map can be
// changed by the user through the
- // set_renumbering function
+ // set_renumbering() function
for (unsigned int i=0; i<n_tensor_pols; ++i)
{
index_map[i]=i;
* Upon program start, this number
* is one. It is increased each
* time a thread is created using
- * the @ref{Threads::spawn} or
- * @ref{Threads::spawn_n}
+ * the Threads::spawn or
+ * Threads::spawn_n()
* functions. It is decreased once
* a thread terminates by returning
* from the function that was
/**
* @internal
* Class derived from
- * @ref{thread_description_base}
+ * thread_description_base()
* that also provides the
* possibility to store a return
* value.
projects / dealii-svn.git / commitdiff