]> https://gitweb.dealii.org/ - dealii.git/commitdiff
Move more classes into modules. More general doc updates.
authorWolfgang Bangerth <bangerth@math.tamu.edu>
Tue, 17 Jan 2006 20:36:20 +0000 (20:36 +0000)
committerWolfgang Bangerth <bangerth@math.tamu.edu>
Tue, 17 Jan 2006 20:36:20 +0000 (20:36 +0000)
git-svn-id: https://svn.dealii.org/trunk@12068 0785d39b-7218-0410-832d-ea1e28bc413d

deal.II/base/include/base/geometry_info.h
deal.II/base/include/base/point.h
deal.II/base/include/base/symmetric_tensor.h
deal.II/base/include/base/tensor.h
deal.II/base/include/base/tensor_base.h
deal.II/doc/doxygen/headers/geometry_and_primitives.h [new file with mode: 0644]
deal.II/doc/doxygen/headers/io.h

index ca85c9daea9621be83d6594cdd0d7b3cf6540dfa..b89b5970b910fb4e14127e12eeefc0c7c99354c1 100644 (file)
 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
@@ -39,7 +116,7 @@ template <int dim> class GeometryInfo;
  * vertices, neighbors and so on, since it can be used dimension
  * independently.
  *
- * @ingroup grid
+ * @ingroup grid geomprimitives
  * @author Wolfgang Bangerth, 1998
  */
 template <>
@@ -108,86 +185,13 @@ struct GeometryInfo<0>
 
 
 
-//! 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
  */
index 83fdaa2c162d042473cbb0b60d6e6f3c093ec523..b55398be71589823c2e1f87ae91bb34505ac63c8 100644 (file)
@@ -44,6 +44,7 @@
  * 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>
index a7ff65fcc72e56dacdc0374907257ebfc5d3aac2..24369e595328f1fec1c23c2b6b3c8315ab13f8a0 100644 (file)
@@ -599,6 +599,7 @@ namespace internal
  * application programs to restrict operations on individual elements
  * to simple reads or writes.
  *
+ * @ingroup geomprimitives
  * @author Wolfgang Bangerth, 2005
  */
 template <int rank, int dim>
index 73dd8bba2a1f028d7bf6639e0f7068d3aceb6bd3..54888b2b04b7f059021d58458075aa2355863d52 100644 (file)
@@ -32,6 +32,9 @@ template <int dim> class Tensor<1,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
@@ -465,6 +468,8 @@ Tensor<rank_,dim>::memory_consumption ()
  * 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
index d35e4b9977480c1167e49a5f9895efdbc494ce40..11d1f269ada49995f802cdc6717f4b139916fa41 100644 (file)
@@ -60,6 +60,9 @@ template <int dim> class Tensor<1,dim>;
  * 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>
@@ -706,10 +709,14 @@ Tensor<1,dim>::memory_consumption ()
 }
 
 
+#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
@@ -728,6 +735,8 @@ std::ostream & operator << (std::ostream &out, const Tensor<1,dim> &p)
  * 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)
@@ -741,6 +750,8 @@ 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
@@ -758,6 +769,8 @@ operator * (const Tensor<1,dim> &t,
 
 /**
  * Multiplication of a tensor of rank 1 with a scalar double from the left.
+ *
+ * @relates Tensor<1,dim>
  */
 template <int dim>
 inline
@@ -775,6 +788,8 @@ operator * (const double         factor,
 
 /**
  * Division of a tensor of rank 1 by a scalar double.
+ *
+ * @relates Tensor<1,dim>
  */
 template <int dim>
 inline
@@ -788,8 +803,6 @@ operator / (const Tensor<1,dim> &t,
   return tt;
 }
 
-#endif // DOXYGEN
-
 #endif
 
 
diff --git a/deal.II/doc/doxygen/headers/geometry_and_primitives.h b/deal.II/doc/doxygen/headers/geometry_and_primitives.h
new file mode 100644 (file)
index 0000000..ad6e0b1
--- /dev/null
@@ -0,0 +1,49 @@
+//-------------------------------------------------------------------------
+//    $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.
+ */
+
index 4a67a567ab549208800629ff81637f06cd3038e9..51010d7ba62c5015ca0cf8e23bf5619832a46b2f 100644 (file)
  * 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
  */
 
@@ -49,6 +57,9 @@
  * 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 &lt;&lt;</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
  */

In the beginning the Universe was created. This has made a lot of people very angry and has been widely regarded as a bad move.

Douglas Adams


Typeset in Trocchi and Trocchi Bold Sans Serif.