Reference documentation for deal.II version Git 20e5cff 20170117 12:52:29 0500

#include <deal.II/numerics/data_postprocessor.h>
Public Member Functions  
virtual  ~DataPostprocessor () 
virtual void  evaluate_scalar_field (const DataPostprocessorInputs::Scalar< dim > &input_data, std::vector< Vector< double > > &computed_quantities) const 
virtual void  compute_derived_quantities_scalar (const std::vector< double > &solution_values, const std::vector< Tensor< 1, dim > > &solution_gradients, const std::vector< Tensor< 2, dim > > &solution_hessians, const std::vector< Point< dim > > &normals, const std::vector< Point< dim > > &evaluation_points, std::vector< Vector< double > > &computed_quantities) const DEAL_II_DEPRECATED 
virtual void  evaluate_vector_field (const DataPostprocessorInputs::Vector< dim > &input_data, std::vector< Vector< double > > &computed_quantities) const 
virtual void  compute_derived_quantities_vector (const std::vector< Vector< double > > &solution_values, const std::vector< std::vector< Tensor< 1, dim > > > &solution_gradients, const std::vector< std::vector< Tensor< 2, dim > > > &solution_hessians, const std::vector< Point< dim > > &normals, const std::vector< Point< dim > > &evaluation_points, std::vector< Vector< double > > &computed_quantities) const DEAL_II_DEPRECATED 
virtual std::vector< std::string >  get_names () const =0 
virtual std::vector< DataComponentInterpretation::DataComponentInterpretation >  get_data_component_interpretation () const 
virtual UpdateFlags  get_needed_update_flags () const =0 
Public Member Functions inherited from Subscriptor  
Subscriptor ()  
Subscriptor (const Subscriptor &)  
Subscriptor (Subscriptor &&)  
virtual  ~Subscriptor () 
Subscriptor &  operator= (const Subscriptor &) 
Subscriptor &  operator= (Subscriptor &&) 
void  subscribe (const char *identifier=0) const 
void  unsubscribe (const char *identifier=0) const 
unsigned int  n_subscriptions () const 
void  list_subscribers () const 
template<class Archive >  
void  serialize (Archive &ar, const unsigned int version) 
Additional Inherited Members  
Static Public Member Functions inherited from Subscriptor  
static::ExceptionBase &  ExcInUse (int arg1, char *arg2, std::string &arg3) 
static::ExceptionBase &  ExcNoSubscriber (char *arg1, char *arg2) 
This class provides an interface to compute derived quantities from a solution that can then be output in graphical formats for visualization, using facilities such as the DataOut class.
For the (graphical) output of a FE solution one frequently wants to include derived quantities, which are calculated from the values of the solution and possibly the first and second derivatives of the solution. Examples are the calculation of Mach numbers from velocity and density in supersonic flow computations, or the computation of the magnitude of a complexvalued solution as demonstrated in step29. Other uses are shown in step32 and step33. This class offers the interface to perform such postprocessing. Given the values and derivatives of the solution at those points where we want to generated output, the functions of this class can be overloaded to compute new quantities.
A data vector and an object of a class derived from the current one can be given to the DataOut::add_data_vector() function (and similarly for DataOutRotation and DataOutFaces). This will cause DataOut::build_patches() to compute the derived quantities instead of using the data provided by the data vector (typically the solution vector). Note that the DataPostprocessor object (i.e., in reality the object of your derived class) has to live until the DataOut object is destroyed as the latter keeps a pointer to the former and will complain if the object pointed to is destroyed while the latter still has a pointer to it. If both the data postprocessor and DataOut objects are local variables of a function (as they are, for example, in step29), then you can avoid this error by declaring the data postprocessor variable before the DataOut variable as objects are destroyed in reverse order of declaration.
In order not to perform needless calculations, DataPostprocessor has to provide information which input data is needed for the calculation of the derived quantities, i.e. whether it needs the values, the first derivative and/or the second derivative of the provided data. DataPostprocessor objects which are used in combination with a DataOutFaces object can also ask for the normal vectors at each point. The information which data is needed has to be provided via the UpdateFlags returned by the virtual function get_needed_update_flags(). It is your responsibility to use only those values which were updated in the calculation of derived quantities. The DataOut object will provide references to the requested data in the call to evaluate_scalar_field() or evaluate_vector_field() (DataOut decides which of the two functions to call depending on whether the finite element in use has only a single, or multiple vector components; note that this is only determined by the number of components in the finite element in use, and not by whether the data computed by a class derived from the current one is scalar or vector valued).
Furthermore, derived classes have to implement the get_names() function, where the number of output variables returned by the latter function has to match the size of the vector returned by the former. Furthermore, this number has to match the number of computed quantities, of course.
Deriving from the current class allows to implement very general postprocessors. For example, in the step32 program, we implement a postprocessor that takes a solution that consists of velocity, pressure and temperature (dim+2 components) and computes a variety of output quantities, some of which are vector valued and some of which are scalar. On the other hand, in step29 we implement a postprocessor that only computes the magnitude of a complex number given by a twocomponent finite element. It seems silly to have to implement four virtual functions for this (evaluate_scalar_field() or evaluate_vector_field(), get_names(), get_update_flags() and get_data_component_interpretation()).
To this end there are two classes DataPostprocessorScalar and DataPostprocessorVector that are meant to be used if the output quantity is either a single scalar or a single vector (here used meaning to have exactly dim components). When using these classes, one only has to write a constructor that passes the name of the output variable and the update flags to the constructor of the base class and overload the function that actually computes the results.
Definition at line 415 of file data_postprocessor.h.

virtual 
Destructor. This function doesn't actually do anything but is marked as virtual to ensure that data postprocessors can be destroyed through pointers to the base class.
Definition at line 25 of file data_postprocessor.cc.

virtual 
This is the main function which actually performs the postprocessing. The second argument is a reference to the postprocessed data which already has correct size and must be filled by this function.
The function takes the values, gradients, and higher derivatives of the solution at all evaluation points, as well as other data such as the cell, via the first argument. Not all of the member vectors of this argument will be filled with data – in fact, derivatives and other quantities will only be contain valid data if the corresponding flags are returned by by an overloaded version of the get_needed_update_flags() function (implemented in a user's derived class). Otherwise those vectors will be in an unspecified state.
This function is called when the finite element field that is being converted into graphical data by DataOut or similar classes represents scalar data, i.e. the finite element in use has only a single vector component.
Definition at line 33 of file data_postprocessor.cc.

virtual 
If a user class derived from the current class (or from DataPostprocessorScalar) does not overload the function above, but instead overloads the current (legacy) form of the function, then the default implementation of the function above will simply call the current function. However, not all elements of the DataPostprocessorInputs::Scalar argument the function above receives have corresponding function arguments in the current function, and consequently not all information that function has available is passed on to the current one. In other words, there are pieces of information you may need in an implementation of a postprocess that are available if you overload the new form of this function above, but that are not available if you overload the old form of the function here.
Definition at line 54 of file data_postprocessor.cc.

virtual 
Same as the evaluate_scalar_field() function, but this function is called when the original data vector represents vector data, i.e. the finite element in use has multiple vector components.
Definition at line 70 of file data_postprocessor.cc.

virtual 
If a user class derived from the current class (or from DataPostprocessorVector) does not overload the function above, but instead overloads the current (legacy) form of the function, then the default implementation of the function above will simply call the current function. However, not all elements of the DataPostprocessorInputs::Vector argument the function above receives have corresponding function arguments in the current function, and consequently not all information that function has available is passed on to the current one. In other words, there are pieces of information you may need in an implementation of a postprocess that are available if you overload the new form of this function above, but that are not available if you overload the old form of the function here.
Definition at line 91 of file data_postprocessor.cc.

pure virtual 
Return the vector of strings describing the names of the computed quantities.
Implemented in DataPostprocessorVector< dim >, and DataPostprocessorScalar< dim >.

virtual 
This functions returns information about how the individual components of output files that consist of more than one data set are to be interpreted.
For example, if one has a finite element for the Stokes equations in 2d, representing components (u,v,p), one would like to indicate that the first two, u and v, represent a logical vector so that later on when we generate graphical output we can hand them off to a visualization program that will automatically know to render them as a vector field, rather than as two separate and independent scalar fields.
The default implementation of this function returns a vector of values DataComponentInterpretation::component_is_scalar, indicating that all output components are independent scalar fields. However, if a derived class produces data that represents vectors, it may return a vector that contains values DataComponentInterpretation::component_is_part_of_vector. In the example above, one would return a vector with components (DataComponentInterpretation::component_is_part_of_vector, DataComponentInterpretation::component_is_part_of_vector, DataComponentInterpretation::component_is_scalar) for (u,v,p).
Reimplemented in DataPostprocessorVector< dim >, and DataPostprocessorScalar< dim >.
Definition at line 106 of file data_postprocessor.cc.

pure virtual 
Return, which data has to be provided to compute the derived quantities. This has to be a combination of update_values
, update_gradients
and update_hessians
. If the DataPostprocessor is to be used in combination with DataOutFaces, you may also ask for a update of normals via the update_normal_vectors
flag.
Implemented in DataPostprocessorVector< dim >, and DataPostprocessorScalar< dim >.