template <int> class FEValuesBase;
+//TODO: Most of the documentation of DataOut_DoFData applies to DataOut.
/**
- * This is an abstract class which provides the functionality to generate
- * patches for output by base classes from data vectors on a grid. It allows
- * to store a pointer to a DoFHandler object and one or more pointers to
- * node and cell data denoting functions on the grid which shall later
- * be written in any of the implemented data formats.
+ * This is an abstract class which provides the functionality to
+ * generate patches for output by base classes from data vectors on a
+ * grid. It allows to store a pointer to a DoFHandler object and one
+ * or more pointers to node and cell data denoting functions on the
+ * grid which shall later be written in any of the implemented data
+ * formats.
*
*
* <h3>User visible interface</h3>
* vectors which will later be written to a file in some format. Instead of
* pondering about the different functions, an example is probably the best
* way:
- * @verbatim
+ * @code
* ...
* ... // compute solution, which contains nodal values
* ...
* data_out.write_xxx (output_file);
*
* data_out.clear();
- * @endverbatim
+ * @endcode
*
- * @p attach_dof_handler tells this class that all future operations are to take
- * place with the DoFHandler object and the triangulation it lives on. We then
- * add the solution vector and the error estimator; note that they have different
- * dimensions, because the solution is a nodal vector, here consisting of two
- * components ("x-displacement" and "y-displacement") while the error estimator
- * probably is a vector holding cell data. When attaching a data vector, you have
- * to give a name to each component of the vector, which is done through an object
- * of type <tt>vector<string></tt> as second argument; if only one component is in the
- * vector, for example if we are adding cell data as in the second case, or if
- * the finite element used by the DoFHandler has only one component, then you
- * can use the second @p add_data_vector function which takes a @p string instead
- * of the <tt>vector<string></tt>.
+ * attach_dof_handler() tells this class that all future operations
+ * are to take place with the DoFHandler object and the triangulation
+ * it lives on. We then add the solution vector and the error
+ * estimator; note that they have different dimensions, because the
+ * solution is a nodal vector, here consisting of two components
+ * ("x-displacement" and "y-displacement") while the error estimator
+ * probably is a vector holding cell data. When attaching a data
+ * vector, you have to give a name to each component of the vector,
+ * which is done through an object of type <tt>vector<string></tt> as
+ * second argument; if only one component is in the vector, for
+ * example if we are adding cell data as in the second case, or if the
+ * finite element used by the DoFHandler has only one component, then
+ * you can use the second add_data_vector() function which takes a @p
+ * string instead of the <tt>vector<string></tt>.
*
* You should note that this class does not copy the vector given to it through
- * the @p add_data_vector functions, for memory consumption reasons. It only
+ * the add_data_vector() functions, for memory consumption reasons. It only
* stores a reference to it, so it is in your responsibility to make sure that
* the data vectors exist long enough.
*
* After adding all data vectors, you need to call a function which generates
* the patches for output from the stored data. This function is here called
- * @p build_patches, but the naming is up to the derived class that actually
+ * build_patches(), but the naming is up to the derived class that actually
* implements this.
*
- * Finally, you write the data in one format or other, indicated by @p write_xxx,
+ * Finally, you write() the data in one format or other,
* to a file and may want to clear this object as soon as possible to reduce
* memory requirements.
*
* class does not provide means to actually generate the patches, only aids to
* store and access data.
*
- * Note that the base class of this class, DataOutInterface offers several
- * functions to ease programming with run-time determinable output formats
- * (i.e. you need not use a fixed format by calling @p write_xxx in the above
- * example, but you can select it by a run-time parameter without having
- * to write the <tt>if () ... else ...</tt> clauses yourself), and also functions
- * and classes offering ways to control the appearance of the output by
- * setting flags for each output format.
+ * Note that the base class of this class, DataOutInterface offers
+ * several functions to ease programming with run-time determinable
+ * output formats (i.e. you need not use a fixed format by calling
+ * DataOutInterface::write_xxx in the above example, but you can
+ * select it by a run-time parameter without having to write the
+ * <tt>if () ... else ...</tt> clauses yourself), and also functions
+ * and classes offering ways to control the appearance of the output
+ * by setting flags for each output format.
*
*
- * @sect3{Information for derived classes}
+ * <h3>Information for derived classes</h3>
*
* What is actually missing this class is a way to produce the patches
* for output itself, from the stored data and degree of freedom
* possible in this respect.
*
* For this reason, it is left to a derived class to provide a
- * function, named usually @p build_patches or the like, which fills
- * the @p patches array of this class.
+ * function, named usually build_patches() or the like, which fills
+ * the #patches array of this class.
*
* Regarding the templates of this class, it needs three values: first
* the space dimension in which the triangulation and the DoF handler
* triangulation underlying the
* DoFHandler object (such
* as error per cell data). The
- * value @p type_automatic tells
+ * value #type_automatic tells
* add_data_vector() to find
* out itself (see the
* documentation of
- * @p add_data_vector for the
+ * add_data_vector() for the
* method used).
*/
enum DataVectorType {
- type_dof_data, type_cell_data, type_automatic
+ /// Data vector entries are associated to degrees of freedom
+ type_dof_data,
+ /// Data vector entries are one per grid cell
+ type_cell_data,
+ /// Find out automatically
+ type_automatic
};
/**
* case, you can change the last
* argument of the function from
* its default value
- * @p type_automatic to either
- * @p type_dof_data or @p type_cell_data,
+ * #type_automatic to either
+ * #type_dof_data or #type_cell_data,
* depending on what the vector
* represents. Apart from this
* corner case, you can leave the
* shall only contain characters
* which are letters, underscore
* and a few other ones. Refer to
- * the @p ExcInvalidCharacter
+ * the ExcInvalidCharacter
* exception declared in this
* class to see which characters
* are valid and which are not.
*
* The actual type for the template
* argument may be any vector type from
- * which FEValue can extract values
+ * which FEValues can extract values
* on a cell using the
- * @p get_function_values function.
+ * FEValuesBase::get_function_values() function.
*/
template <class VECTOR>
void add_data_vector (const VECTOR &data,
* after a conversion of the
* @p name to a vector of
* strings, to the other
- * @p add_data_vector function
+ * add_data_vector() function
* above.
*
* If @p data is a vector with
*
* The actual type for the template
* argument may be any vector type from
- * which FEValue can extract values
+ * which FEValues can extract values
* on a cell using the
- * @p get_function_values function.
+ * FEValuesBase::get_function_values() function.
*/
template <class VECTOR>
void add_data_vector (const VECTOR &data,
* data vectors and the DoF
* handler. You have to set all
* data entries again using the
- * @p add_data_vector
+ * add_data_vector()
* function. The pointer to the
* dof handler is cleared as
* well, along with all other
get_cell_data_value (const unsigned int cell_number) const = 0;
/**
- * Given a @p FEValuesBase object,
+ * Given a FEValuesBase object,
* extract the values on the present
* cell from the vector we actually
* store.
std::vector<double> &patch_values) const = 0;
/**
- * Given a @p FEValuesBase object,
+ * Given a FEValuesBase object,
* extract the values on the present
* cell from the vector we actually
* store. This function does the same
get_cell_data_value (const unsigned int cell_number) const;
/**
- * Given a @p FEValuesBase object,
+ * Given a FEValuesBase object,
* extract the values on the present
* cell from the vector we actually
* store.
std::vector<double> &patch_values) const;
/**
- * Given a @p FEValuesBase object,
+ * Given a FEValuesBase object,
* extract the values on the present
* cell from the vector we actually
* store. This function does the same
/**
* Abbreviate the somewhat lengthy
- * name for the @p Patch class.
+ * name for the Patch class.
*/
typedef ::DataOutBase::Patch<patch_dim,patch_space_dim> Patch;
/**
* This is a list of patches that is
- * created each time @p build_patches
+ * created each time build_patches()
* is called. These patches are used
* in the output routines of the base
* classes.
/**
* Make all template siblings
* friends. Needed for the
- * @p merge_patches function.
+ * merge_patches() function.
*/
template <int,int,int> friend class DataOut_DoFData;
/**
* This class is an actual implementation of the functionality proposed by
- * the DataOut_DoFData() class. It offers a function @p build_patches that
+ * the DataOut_DoFData class. It offers a function build_patches() that
* generates the patches to be written in some graphics format from the data
* stored in the base class. Most of the interface and an example of its
* use is described in the documentation of the base class.
* output is to subdivide each cell of the mesh into several cells for
* graphical output.
*
- * Note that after having called @p build_patches once, you can call one or
- * more of the <tt>write_*</tt> functions of the base classes. You can therefore
+ * Note that after having called build_patches() once, you can call one or
+ * more of the write() functions of DataOutInterface. You can therefore
* output the same data in more than one format without having to rebuild
* the patches.
*
* region of the domain (for example in parallel programs such as the step-18
* example program), or for some other reason.
*
- * For this, internally the @p build_patches function does not generate
+ * For this, internally build_patches() does not generate
* the sequence of cells to be converted into patches itself, but relies
- * on the two functions @p first_cell and @p next_cell. By default, they
+ * on the two functions first_cell() and next_cell(). By default, they
* return the first active cell, and the next active cell, respectively.
* Since they are @p virtual functions, you may overload them to select other
* cells for output. If cells are not active, interpolated values are taken
* determine the next one.
*
* There is one caveat, however: if you have cell data (in contrast to nodal,
- * or dof, data) such as error indicators, then you must make sure that the @p
- * first_cell and @p next_cell only walk over active cells, since cell data
+ * or dof, data) such as error indicators, then you must make sure that
+ * first_cell() and next_cell() only walk over active cells, since cell data
* cannot be interpolated to a coarser cell. If you do have cell data and use
* this pair of functions and they return a non-active cell, then an exception
* will be thrown.
* Return the next cell after
* @p cell which we want output
* for. If there are no more
- * cells, <tt>dofs->end()</tt> shall
+ * cells, <tt>#dofs->end()</tt> shall
* be returned.
*
* The default implementation
* implementation assumes that
* the given @p cell is active,
* which is guaranteed as long as
- * @p first_cell is also used
+ * first_cell() is also used
* from the default
* implementation. Overloading
* only one of the two functions
* globally to avoid allocation
* of memory in the threads.
*
- * The @p index_to_patch_map is
+ * The #index_to_patch_map is
* an array that stores for index
* <tt>[i][j]</tt> the number of the
* patch that associated with the
projects / dealii-svn.git / commitdiff