]> https://gitweb.dealii.org/ - dealii.git/commitdiff
Write documentation.
authorWolfgang Bangerth <bangerth@math.tamu.edu>
Tue, 5 Apr 2005 21:06:26 +0000 (21:06 +0000)
committerWolfgang Bangerth <bangerth@math.tamu.edu>
Tue, 5 Apr 2005 21:06:26 +0000 (21:06 +0000)
git-svn-id: https://svn.dealii.org/trunk@10364 0785d39b-7218-0410-832d-ea1e28bc413d

deal.II/base/include/base/data_out_base.h

index f11f2e0d5246acfae26c1c773bfea45c9136816b..6fc6609e96ad5ff2066aae28cf48368f951e85af 100644 (file)
@@ -327,31 +327,32 @@ class ParameterHandler;
  * @subsection DataOutBaseD2 deal.II intermediate format
  *
  * In addition to all the other formats, this class can also write
- * data in the deal.II format. This is not a format that is read by
- * any other graphics program, but is rather a direct dump of the
+ * data in the deal.II format. This is not a format that read by any
+ * other graphics program, but is rather a direct dump of the
  * intermediate internal format used by deal.II. This internal format
  * is generated by the various classes that can generate output using
  * the DataOutBase class, for example from a finite element solution,
  * and is then converted in the present class to the final graphics
  * format. The reason why we offer to write out this intermediate
- * format is that it can be read back into a deal.II program, which is
- * helpful in at least two contexts: First, this can be used to later
- * generate graphical output in any other graphics format presently
- * understood; this way, it is not necessary to know at run-time which
- * output format is requested, or if multiple output files in
- * different formats are needed. Secondly, in contrast to almost all
- * other graphics formats, it is possible to merge several files that
- * contain intermediate format data, and generate a single output file
- * from it, which may be again in intermediate format or any of the
- * final formats. This latter option is most helpful for parallel
- * programs: as demonstrated in the step-17 example program, it is
- * possible to let only one processor generate the graphical output
- * for the entire parallel program, but this can become vastly
- * inefficient if many processors are involved, because the load is no
- * longer balanced. The way out is to let each processor generate
- * intermediate graphical output for its chunk of the domain, and the
- * later merge the different files into one, which is an operation
- * that is much cheaper than the generation of the intermediate data.
+ * format is that it can be read back into a deal.II program using the
+ * DataOutReader class, which is helpful in at least two contexts:
+ * First, this can be used to later generate graphical output in any
+ * other graphics format presently understood; this way, it is not
+ * necessary to know at run-time which output format is requested, or
+ * if multiple output files in different formats are needed. Secondly,
+ * in contrast to almost all other graphics formats, it is possible to
+ * merge several files that contain intermediate format data, and
+ * generate a single output file from it, which may be again in
+ * intermediate format or any of the final formats. This latter option
+ * is most helpful for parallel programs: as demonstrated in the
+ * step-17 example program, it is possible to let only one processor
+ * generate the graphical output for the entire parallel program, but
+ * this can become vastly inefficient if many processors are involved,
+ * because the load is no longer balanced. The way out is to let each
+ * processor generate intermediate graphical output for its chunk of
+ * the domain, and the later merge the different files into one, which
+ * is an operation that is much cheaper than the generation of the
+ * intermediate data.
  *
  * Intermediate format deal.II data is usually stored in files with
  * the ending <tt>.d2</tt>.
@@ -2237,6 +2238,36 @@ class DataOutInterface : private DataOutBase
 
 
 
+/**
+ * A class that is used to read data written in deal.II intermediate
+ * format back in, so that it can be written out in any of the other
+ * supported graphics formats. This class has two main purposes:
+ *
+ * The first use of this class is so that application programs can
+ * defer the decision of which graphics format to use until after the
+ * program has been run. The data is written in intermediate format
+ * into a file, and later on it can then be converted into any
+ * graphics format you wish. This may be useful, for example, if you
+ * want to convert it to gnuplot format to get a quick glimpse and
+ * later on want to convert it to OpenDX format as well to get a high
+ * quality version of the data. The present class allows to read this
+ * intermediate format back into the program, and allows it to be
+ * written in any other supported format using the relevant functions
+ * of the base class.
+ *
+ * The second use is mostly useful in parallel programs: rather than
+ * having one central process generate the graphical output for the
+ * entire program, one can let each process generate the graphical
+ * data for the cells it owns, and write it into a separate file in
+ * intermediate format. Later on, all these intermediate files can
+ * then be read back in and merged together, a process that is fast
+ * compared to generating the data in the first place. The use of the
+ * intermediate format is mostly because it allows separate files to
+ * be merged, while this is almost impossible once the data has been
+ * written out in any of the supported established graphics formats.
+ *
+ * @author Wolfgang Bangerth, 2005
+ */
 template <int dim, int spacedim=dim>
 class DataOutReader : public DataOutInterface<dim,spacedim>
 {

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.