![]() |
Reference documentation for deal.II version 8.1.0
|
#include <data_out_base.h>
Public Member Functions | |
void | read (std::istream &in) |
void | merge (const DataOutReader< dim, spacedim > &other) |
DeclException0 (ExcNoPatches) | |
DeclException0 (ExcIncompatibleDatasetNames) | |
DeclException0 (ExcIncompatiblePatchLists) | |
DeclException4 (ExcIncompatibleDimensions, int, int, int, int,<< "Either the dimensions <"<< arg1<< "> and <"<< arg2<< "> or the space dimensions <"<< arg3<< "> and <"<< arg4<< "> do not match!") | |
![]() | |
DataOutInterface () | |
virtual | ~DataOutInterface () |
void | write_dx (std::ostream &out) const |
void | write_eps (std::ostream &out) const |
void | write_gmv (std::ostream &out) const |
void | write_gnuplot (std::ostream &out) const |
void | write_povray (std::ostream &out) const |
void | write_tecplot (std::ostream &out) const |
void | write_tecplot_binary (std::ostream &out) const |
void | write_ucd (std::ostream &out) const |
void | write_vtk (std::ostream &out) const |
void | write_vtu (std::ostream &out) const |
void | write_vtu_in_parallel (const char *filename, MPI_Comm comm) const |
void | write_pvtu_record (std::ostream &out, const std::vector< std::string > &piece_names) const |
void | write_pvd_record (std::ostream &out, const std::vector< std::pair< double, std::string > > ×_and_names) const |
void | write_visit_record (std::ostream &out, const std::vector< std::string > &piece_names) const |
void | write_visit_record (std::ostream &out, const std::vector< std::vector< std::string > > &piece_names) const |
void | write_svg (std::ostream &out) const |
void | write_deal_II_intermediate (std::ostream &out) const |
XDMFEntry | create_xdmf_entry (const std::string &h5_filename, const double cur_time, MPI_Comm comm) const DEAL_II_DEPRECATED |
XDMFEntry | create_xdmf_entry (const DataOutFilter &data_filter, const std::string &h5_filename, const double cur_time, MPI_Comm comm) const |
XDMFEntry | create_xdmf_entry (const DataOutFilter &data_filter, const std::string &h5_mesh_filename, const std::string &h5_solution_filename, const double cur_time, MPI_Comm comm) const |
void | write_xdmf_file (const std::vector< XDMFEntry > &entries, const std::string &filename, MPI_Comm comm) const |
void | write_hdf5_parallel (const std::string &filename, MPI_Comm comm) const DEAL_II_DEPRECATED |
void | write_hdf5_parallel (const DataOutFilter &data_filter, const std::string &filename, MPI_Comm comm) const |
void | write_hdf5_parallel (const DataOutFilter &data_filter, const bool write_mesh_file, const std::string &mesh_filename, const std::string &solution_filename, MPI_Comm comm) const |
void | write_filtered_data (DataOutFilter &filtered_data) const |
void | write (std::ostream &out, const OutputFormat output_format=default_format) const |
void | set_default_format (const OutputFormat default_format) |
void | set_flags (const DXFlags &dx_flags) |
void | set_flags (const UcdFlags &ucd_flags) |
void | set_flags (const GnuplotFlags &gnuplot_flags) |
void | set_flags (const PovrayFlags &povray_flags) |
void | set_flags (const EpsFlags &eps_flags) |
void | set_flags (const GmvFlags &gmv_flags) |
void | set_flags (const TecplotFlags &tecplot_flags) |
void | set_flags (const VtkFlags &vtk_flags) |
void | set_flags (const SvgFlags &svg_flags) |
void | set_flags (const Deal_II_IntermediateFlags &deal_II_intermediate_flags) |
std::string | default_suffix (const OutputFormat output_format=default_format) const |
void | parse_parameters (ParameterHandler &prm) |
std::size_t | memory_consumption () const |
Protected Member Functions | |
virtual const std::vector< typename::DataOutBase::Patch< dim, spacedim > > & | get_patches () const |
virtual std::vector< std::string > | get_dataset_names () const |
virtual std::vector< std_cxx1x::tuple< unsigned int, unsigned int, std::string > > | get_vector_data_ranges () const |
Private Attributes | |
std::vector< typename::DataOutBase::Patch< dim, spacedim > > | patches |
std::vector< std::string > | dataset_names |
std::vector< std_cxx1x::tuple< unsigned int, unsigned int, std::string > > | vector_data_ranges |
Additional Inherited Members | |
![]() | |
enum | OutputFormat |
![]() | |
static void | declare_parameters (ParameterHandler &prm) |
![]() | |
unsigned int | default_subdivisions |
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.
This second use scenario is explained in some detail in the step-18 example program.
Both these applications are implemented in the step-19 example program. There, a slight complication is also explained: in order to read data back into this object, you have to know the template parameters for the space dimension which were used when writing the data. If this knowledge is available at compile time, then this is no problem. However, if it is not (such as in a simple format converter), then it needs to be figured out at run time, even though the compiler already needs it at compile time. A way around using the DataOutBase::determine_intermediate_format_dimensions() function is explained in step-19.
Note that the intermediate format is what its name suggests: a direct representation of internal data. It isn't standardized and will change whenever we change our internal representation. You can only expect to process files written in this format using the same version of deal.II that was used for writing.
Definition at line 3012 of file data_out_base.h.
void DataOutReader< dim, spacedim >::read | ( | std::istream & | in | ) |
Read a sequence of patches as written previously by DataOutBase::write_deal_II_intermediate
and store them in the present object. This overwrites any previous content.
void DataOutReader< dim, spacedim >::merge | ( | const DataOutReader< dim, spacedim > & | other | ) |
This function can be used to merge the patches read by the other object into the patches that this present object stores. This is sometimes handy if one has, for example, a domain decomposition algorithm where each block is represented by a DoFHandler of its own, but one wants to output the solution on all the blocks at the same time. Alternatively, it may also be used for parallel programs, where each process only generates output for its share of the cells, even if all processes can see all cells.
For this to work, the input files for the present object and the given argument need to have the same number of output vectors, and they need to use the same number of subdivisions per patch. The output will probably look rather funny if patches in both objects overlap in space.
If you call read() for this object after merging in patches, the previous state is overwritten, and the merged-in patches are lost.
This function will fail if either this or the other object did not yet set up any patches.
The use of this function is demonstrated in step-19.
DataOutReader< dim, spacedim >::DeclException0 | ( | ExcNoPatches | ) |
Exception
DataOutReader< dim, spacedim >::DeclException0 | ( | ExcIncompatibleDatasetNames | ) |
Exception
DataOutReader< dim, spacedim >::DeclException0 | ( | ExcIncompatiblePatchLists | ) |
Exception
DataOutReader< dim, spacedim >::DeclException4 | ( | ExcIncompatibleDimensions | , |
int | , | ||
int | , | ||
int | , | ||
int | |||
) |
Exception
|
protectedvirtual |
This is the function through which this class propagates preprocessed data in the form of Patch structures (declared in the base class DataOutBase) to the actual output function.
It returns the patches as read the last time a stream was given to the read() function.
Implements DataOutInterface< dim, spacedim >.
|
protectedvirtual |
Abstract virtual function through which the names of data sets are obtained by the output functions of the base class.
Return the names of the variables as read the last time we read a file.
Implements DataOutInterface< dim, spacedim >.
|
protectedvirtual |
This functions returns information about how the individual components of output files that consist of more than one data set are to be interpreted.
It returns a list of index pairs and corresponding name indicating which components of the output are to be considered vector-valued rather than just a collection of scalar data. The index pairs are inclusive; for example, if we have a Stokes problem in 2d with components (u,v,p), then the corresponding vector data range should be (0,1), and the returned list would consist of only a single element with a tuple such as (0,1,"velocity").
Since some of the derived classes do not know about vector data, this function has a default implementation that simply returns an empty string, meaning that all data is to be considered a collection of scalar fields.
Reimplemented from DataOutInterface< dim, spacedim >.
|
private |
Arrays holding the set of patches as well as the names of output variables, all of which we read from an input stream.
Definition at line 3120 of file data_out_base.h.
|
private |
Information about whether certain components of the output field are to be considered vectors.
Definition at line 3128 of file data_out_base.h.