template <int dim> class GeometryInfo;
+
+/**
+ * Dimension independent base class for the <tt>GeometryInfo<dim></tt>
+ * classes with <tt>dim=1,2,3,4</tt>. Includes all data and methods
+ * which can be defined in an dimension indendent way.
+ *
+ * @ingroup grid geomprimitives
+ * @author Ralf Hartmann, 2005
+ */
+class GeometryInfoBase
+{
+ private:
+ /**
+ * The maximal dimension for
+ * which data in this class is
+ * implemented.
+ */
+ static const unsigned int max_dim = 4;
+
+ /**
+ * Number of faces of a cell for
+ * <tt>dim=max_dim</tt>.
+ */
+ static const unsigned int faces_per_cell_max_dim = 2*max_dim;
+
+ public:
+
+ /**
+ * For each face of the reference
+ * cell, this field stores the
+ * coordinate direction in which
+ * its normal vector points. In
+ * <tt>dim</tt> dimension these
+ * are the <tt>2*dim</tt> first
+ * entries of
+ * <tt>{0,0,1,1,2,2,3,3}</tt>.
+ *
+ * Remark that this is only the
+ * coordinate number. The actual
+ * direction of the normal vector
+ * is obtained by multiplying the
+ * unit vector in this direction
+ * with #unit_normal_orientation.
+ */
+ static const unsigned int unit_normal_direction[faces_per_cell_max_dim];
+
+ /**
+ * Orientation of the unit normal
+ * vector of a face of the
+ * reference cell. In
+ * <tt>dim</tt> dimension these
+ * are the <tt>2*dim</tt> first
+ * entries of
+ * <tt>{-1,1,-1,1,-1,1,-1,1}</tt>.
+ *
+ * Each value is either
+ * <tt>1</tt> or <tt>-1</tt>,
+ * corresponding to a normal
+ * vector pointing in the
+ * positive or negative
+ * coordinate direction,
+ * respectively.
+ */
+ static const int unit_normal_orientation[faces_per_cell_max_dim];
+
+ /**
+ * List of numbers which denotes
+ * which face is opposite to a
+ * given face. Its entries are
+ * <tt>{ 1, 0, 3, 2, 5, 4, 7, 6}</tt>.
+ */
+ static const unsigned int opposite_face[faces_per_cell_max_dim];
+};
+
+
+
+
/**
* Topological description of zero dimensional cells,
* i.e. points. This class might not look too useful but often is if
* vertices, neighbors and so on, since it can be used dimension
* independently.
*
- * @ingroup grid
+ * @ingroup grid geomprimitives
* @author Wolfgang Bangerth, 1998
*/
template <>
-//! Topological description of cells.
-/**
- * Dimension independent base class for the <tt>GeometryInfo<dim></tt>
- * classes with <tt>dim=1,2,3,4</tt>. Includes all data and methods
- * which can be defined in an dimension indendent way.
- *
- * @author Ralf Hartmann, 2005
- */
-class GeometryInfoBase
-{
- private:
- /**
- * The maximal dimension for
- * which data in this class is
- * implemented.
- */
- static const unsigned int max_dim = 4;
-
- /**
- * Number of faces of a cell for
- * <tt>dim=max_dim</tt>.
- */
- static const unsigned int faces_per_cell_max_dim = 2*max_dim;
-
- public:
-
- /**
- * For each face of the reference
- * cell, this field stores the
- * coordinate direction in which
- * its normal vector points. In
- * <tt>dim</tt> dimension these
- * are the <tt>2*dim</tt> first
- * entries of
- * <tt>{0,0,1,1,2,2,3,3}</tt>.
- *
- * Remark that this is only the
- * coordinate number. The actual
- * direction of the normal vector
- * is obtained by multiplying the
- * unit vector in this direction
- * with #unit_normal_orientation.
- */
- static const unsigned int unit_normal_direction[faces_per_cell_max_dim];
-
- /**
- * Orientation of the unit normal
- * vector of a face of the
- * reference cell. In
- * <tt>dim</tt> dimension these
- * are the <tt>2*dim</tt> first
- * entries of
- * <tt>{-1,1,-1,1,-1,1,-1,1}</tt>.
- *
- * Each value is either
- * <tt>1</tt> or <tt>-1</tt>,
- * corresponding to a normal
- * vector pointing in the
- * positive or negative
- * coordinate direction,
- * respectively.
- */
- static const int unit_normal_orientation[faces_per_cell_max_dim];
-
- /**
- * List of numbers which denotes
- * which face is opposite to a
- * given face. Its entries are
- * <tt>{ 1, 0, 3, 2, 5, 4, 7, 6}</tt>.
- */
- static const unsigned int opposite_face[faces_per_cell_max_dim];
-};
-
/**
* This template specifies the interface to all topological structure
* of the mesh cells.
*
- * @ingroup grid
+ * @ingroup grid geomprimitives
* @ref Instantiations few (dim = 1,2,3,4 and a specialization for dim=0)
* @author Wolfgang Bangerth, 1998, Ralf Hartmann, 2005
*/
* 1, or vector, with as many elements as a point object, but with different
* physical units), we use the <tt>Tensor<1,dim></tt> class.
*
+ * @ingroup geomprimitives
* @author Wolfgang Bangerth, 1997
*/
template <int dim>
* application programs to restrict operations on individual elements
* to simple reads or writes.
*
+ * @ingroup geomprimitives
* @author Wolfgang Bangerth, 2005
*/
template <int rank, int dim>
* as well as the location of the data. It is therefore possible to
* produce far more efficient code than for matrices with
* runtime-dependent dimension.
+ *
+ * @ingroup geomprimitives
+ * @author Wolfgang Bangerth, 1998-2005
*/
template <int rank_, int dim>
class Tensor
* Output operator for tensors. Print the elements consecutively, with
* a space in between, two spaces between rank 1 subtensors, three
* between rank 2 and so on.
+ *
+ * @relates Tensor
*/
template <int rank_, int dim>
inline
* other uses, such as the gradient of a scalar function (which is a tensor of
* rank 1, or vector, with as many elements as a point object, but with
* different physical units), we use the <tt>Tensor<1,dim></tt> class.
+ *
+ * @ingroup geomprimitives
+ * @author Wolfgang Bangerth, 1998-2005
*/
template <int dim>
class Tensor<1,dim>
}
+#endif // DOXYGEN
+
/**
* Output operator for tensors of rank 1. Print the elements
* consecutively, with a space in between.
+ *
+ * @relates Tensor<1,dim>
*/
template <int dim>
inline
* Output operator for tensors of rank 1 and dimension 1. This is
* implemented specialized from the general template in order to avoid
* a compiler warning that the loop is empty.
+ *
+ * @relates Tensor<1,dim>
*/
inline
std::ostream & operator << (std::ostream &out, const Tensor<1,1> &p)
/**
* Multiplication of a tensor of rank 1 with a scalar double from the right.
+ *
+ * @relates Tensor<1,dim>
*/
template <int dim>
inline
/**
* Multiplication of a tensor of rank 1 with a scalar double from the left.
+ *
+ * @relates Tensor<1,dim>
*/
template <int dim>
inline
/**
* Division of a tensor of rank 1 by a scalar double.
+ *
+ * @relates Tensor<1,dim>
*/
template <int dim>
inline
return tt;
}
-#endif // DOXYGEN
-
#endif
--- /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 geomprimitives Geometric and other primitives
+ *
+ * This group contains a number of classes that act as geometric
+ * primitives or primitives for other mathematical objects. For
+ * example, the Tensor<rank,dim> class provides tensors of rank
+ * <code>rank</code> in <code>dim</code> space dimensions. Likewise,
+ * the SymmetricTensor offers symmetric tensors.
+ *
+ * Geometrically, the Point class is the foundation of all geometric
+ * descriptions in the deal.II library. It denotes a geometric point
+ * in <code>dim</code> dimensional space. One can view a point as a
+ * vector the with <code>dim</code> coordinates that connects the
+ * origin with that particular point; as such, the Point class is
+ * derived from tensors of rank 1 (i.e. vectors), but in contrast to
+ * arbitrary tensors points have the special connotation of points in
+ * space, and therefore have some additional properties.
+ *
+ * In deal.II, meshes are built from line segments, quadrilaterals, or
+ * hexahedra (depending on the space dimension). The GeometryInfo
+ * class is used to describe properties of these basic objects in unit
+ * space (i.e. for the unit line, unit square, and unit cube). It
+ * offers static data members denoting the number of vertices per
+ * cell, lines per face, or where which vertex is located. This
+ * abstraction allows to write applications mostly independently of
+ * the actual space dimension: loops over all vertices would simply
+ * run from zero to GeometryInfo<dim>::vertices_per_cell instead of
+ * from 0 to 4 (in 2d) or 0 to 8 (in 3d). In this way, the program
+ * will be correct in 2d as well as 3d, and one can run a program in a
+ * different space dimension simply by recompilation instead of having
+ * to change a significant portion of the code. These
+ * dimension-independent programming techniques are extensively
+ * discussed in the first few tutorial programs and are used
+ * throughout deal.II.
+ */
+
* associated Patterns namespace) are used to deal with parameter files
* describing run-time parameters to a program that one doesn't want to
* hard-code within the program source.
- *
+ *
+ *
+ * <h3>The PathSearch class</h3>
+ *
+ * The PathSearch class is a helper class in input handling. It is
+ * used to find a file in a list of directories, in much the same way
+ * as unix systems find executables among the directories listed in
+ * the <code>PATH</code> environment variable.
+ *
* @ingroup IO
*/
* itself), and it can create output used for visualization of data. Finally,
* it can output matrices in a graphical format.
*
+ * In addition, deal.II has a number of helper classes for
+ * output. They are introduced in sections of their own below.
+ *
*
* <h3>Visualization of data</h3>
*
* MatrixOut class uses the DataOutBase for output. Therefore, matrices can be
* visualization in all formats supported by the latter class.
*
+ *
+ * <h3>The ConditionalOStream class</h3>
+ *
+ * The ConditionalOStream class is a class that acts like
+ * <code>std::ostream</code> in that you can pipe output into it using
+ * <code>operator <<</code>. However, it only writes these
+ * things to a file (or the screen) if a flag is set. This is useful
+ * in parallel programs, and is discussed in the step-17 tutorial
+ * program.
+ *
+ *
+ * <h3>LogStream</h3>
+ *
+ * The LogStream class is used to write status output of programs to
+ * logfiles. It, again, acts like <code>std::ostream</code>, but
+ * instead of writing things to a file or the screen only, it has the
+ * ability to write things to both a log file as well as the
+ * screen. It can also add a time stamp to each line of output, and
+ * can selectively write only certain parts of the output that are
+ * interesting enough to the screen, and suppress other parts that
+ * then only show up in the log file.
+ *
* @ingroup IO
*/