grid_out.h

Go to the documentation of this file.

// -----------------------------------------------------------------------------
//
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception OR LGPL-2.1-or-later
// Copyright (C) 1999 - 2025 by the deal.II authors
//
// This file is part of the deal.II library.
//
// Detailed license information governing the source code and contributions
// can be found in LICENSE.md and CONTRIBUTING.md at the top level directory.
//
// -----------------------------------------------------------------------------
 
#ifndef dealii_grid_out_h
#define dealii_grid_out_h
 
 
 
#include <deal.II/base/config.h>
 
#include <deal.II/base/data_out_base.h>
#include <deal.II/base/exceptions.h>
#include <deal.II/base/point.h>
 
#include <string>
 
DEAL_II_NAMESPACE_OPEN
 
// Forward declarations
#ifndef DOXYGEN
class ParameterHandler;
template <int dim, int spacedim>
DEAL_II_CXX20_REQUIRES((concepts::is_valid_dim_spacedim<dim, spacedim>))
class Triangulation;
template <int dim, int spacedim>
class Mapping;
#endif
 
 
namespace GridOutFlags
{
  struct DX
  {
    bool write_cells;
 
    bool write_faces;
 
    bool write_diameter;
 
    bool write_measure;
 
    bool write_all_faces;
 
    DX(const bool write_cells     = true,
       const bool write_faces     = false,
       const bool write_diameter  = false,
       const bool write_measure   = false,
       const bool write_all_faces = true);
 
    static void
    declare_parameters(ParameterHandler &param);
 
    void
    parse_parameters(ParameterHandler &param);
  };
 
  struct Msh
  {
    bool write_faces;
    bool write_lines;
 
    Msh(const bool write_faces = false, const bool write_lines = false);
    static void
    declare_parameters(ParameterHandler &param);
 
    void
    parse_parameters(ParameterHandler &param);
  };
 
 
  struct Ucd
  {
    bool write_preamble;
 
    bool write_faces;
 
    bool write_lines;
 
    Ucd(const bool write_preamble = false,
        const bool write_faces    = false,
        const bool write_lines    = false);
 
    static void
    declare_parameters(ParameterHandler &param);
 
    void
    parse_parameters(ParameterHandler &param);
  };
 
 
  struct Gnuplot
  {
    bool write_cell_numbers;
 
    unsigned int n_extra_curved_line_points;
 
    bool curved_inner_cells;
 
    bool write_additional_boundary_lines;
 
    Gnuplot(const bool         write_cell_number               = false,
            const unsigned int n_extra_curved_line_points      = 2,
            const bool         curved_inner_cells              = false,
            const bool         write_additional_boundary_lines = true);
 
    static void
    declare_parameters(ParameterHandler &param);
 
    void
    parse_parameters(ParameterHandler &param);
  };
 
  struct EpsFlagsBase
  {
    enum SizeType
    {
      width,
      height
    };
 
    SizeType size_type;
 
    unsigned int size;
 
    double line_width;
 
    bool color_lines_on_user_flag;
 
    unsigned int n_boundary_face_points;
 
    bool color_lines_level;
 
    EpsFlagsBase(const SizeType     size_type                = width,
                 const unsigned int size                     = 300,
                 const double       line_width               = 0.5,
                 const bool         color_lines_on_user_flag = false,
                 const unsigned int n_boundary_face_points   = 2,
                 const bool         color_lines_level        = false);
    static void
    declare_parameters(ParameterHandler &param);
 
    void
    parse_parameters(ParameterHandler &param);
  };
 
 
  template <int dim>
  struct Eps
  {};
 
  template <>
  struct Eps<1> : public EpsFlagsBase
  {
    Eps(const SizeType     size_type                = width,
        const unsigned int size                     = 300,
        const double       line_width               = 0.5,
        const bool         color_lines_on_user_flag = false,
        const unsigned int n_boundary_face_points   = 2);
    static void
    declare_parameters(ParameterHandler &param);
 
    void
    parse_parameters(ParameterHandler &param);
  };
 
 
  template <>
  struct Eps<2> : public EpsFlagsBase
  {
    bool write_cell_numbers;
    bool write_cell_number_level;
 
    bool write_vertex_numbers;
 
    Eps(const SizeType     size_type                = width,
        const unsigned int size                     = 300,
        const double       line_width               = 0.5,
        const bool         color_lines_on_user_flag = false,
        const unsigned int n_boundary_face_points   = 2,
        const bool         write_cell_numbers       = false,
        const bool         write_cell_number_level  = true,
        const bool         write_vertex_numbers     = false,
        const bool         color_lines_level        = false);
    static void
    declare_parameters(ParameterHandler &param);
 
    void
    parse_parameters(ParameterHandler &param);
  };
 
  template <>
  struct Eps<3> : public EpsFlagsBase
  {
    double azimut_angle;
 
    double turn_angle;
 
    Eps(const SizeType     size_type                = width,
        const unsigned int size                     = 300,
        const double       line_width               = 0.5,
        const bool         color_lines_on_user_flag = false,
        const unsigned int n_boundary_face_points   = 2,
        const double       azimut_angle             = 60,
        const double       turn_angle               = 30);
    static void
    declare_parameters(ParameterHandler &param);
 
    void
    parse_parameters(ParameterHandler &param);
  };
 
  struct XFig
  {
    bool draw_boundary;
 
    enum Coloring
    {
      material_id,
      level_number,
      subdomain_id,
      level_subdomain_id
    } color_by;
 
    bool level_depth;
 
    unsigned int n_boundary_face_points;
 
    Point<2> scaling;
 
    Point<2> offset;
 
    int fill_style;
 
    int line_style;
 
    int line_thickness;
 
    int boundary_style;
 
    int boundary_thickness;
 
    XFig();
    static void
    declare_parameters(ParameterHandler &param);
 
    void
    parse_parameters(ParameterHandler &param);
  };
 
 
  struct Svg
  {
    unsigned int height;
 
    unsigned int width;
 
    unsigned int line_thickness;
    unsigned int boundary_line_thickness;
 
    bool margin;
 
    enum Background
    {
      transparent,
 
      white,
 
      dealii
    };
 
    Background background;
 
    // View angles for the perspective view of the grid; Default is 0, 0 (top
    // view).
 
    int azimuth_angle;
 
    int polar_angle;
 
    enum Coloring
    {
      none,
      material_id,
      level_number,
      subdomain_id,
      level_subdomain_id
    };
 
    Coloring coloring;
 
    bool convert_level_number_to_height;
 
    float level_height_factor;
 
    float cell_font_scaling;
    bool label_level_number;
 
    bool label_cell_index;
 
    bool label_material_id;
 
    bool label_subdomain_id;
 
    bool label_level_subdomain_id;
 
    bool label_boundary_id;
 
    bool draw_colorbar;
 
    bool draw_legend;
 
    Svg(const unsigned int line_thickness                 = 2,
        const unsigned int boundary_line_thickness        = 4,
        const bool         margin                         = true,
        const Background   background                     = white,
        const int          azimuth_angle                  = 0,
        const int          polar_angle                    = 0,
        const Coloring     coloring                       = level_number,
        const bool         convert_level_number_to_height = false,
        const bool         label_level_number             = false,
        const bool         label_cell_index               = false,
        const bool         label_material_id              = false,
        const bool         label_subdomain_id             = false,
        const bool         draw_colorbar                  = false,
        const bool         draw_legend                    = false,
        const bool         label_boundary_id              = false);
  };
 
  struct MathGL
  {
    MathGL();
 
    bool draw_bounding_box;
 
    static void
    declare_parameters(ParameterHandler &param);
 
    void
    parse_parameters(ParameterHandler &param);
  };
 
 
  struct Vtk : public DataOutBase::VtkFlags
  {
    Vtk(const bool output_cells         = true,
        const bool output_faces         = true,
        const bool output_edges         = true,
        const bool output_only_relevant = true)
      : output_cells(output_cells)
      , output_faces(output_faces)
      , output_edges(output_edges)
      , output_only_relevant(output_only_relevant)
    {}
 
    bool output_cells;
 
    bool output_faces;
 
    bool output_edges;
 
    bool output_only_relevant;
  };
 
 
  struct Vtu : public DataOutBase::VtkFlags
  {
    Vtu(const bool serialize_triangulation = false)
      : serialize_triangulation(serialize_triangulation)
    {}
 
    bool serialize_triangulation;
  };
} // namespace GridOutFlags
 
 
 
class GridOut
{
public:
  enum OutputFormat
  {
    none,
    dx,
    gnuplot,
    eps,
    ucd,
    xfig,
    msh,
    svg,
    mathgl,
    vtk,
    vtu
  };
 
  GridOut();
 
  template <int dim, int spacedim>
  void
  write_dx(const Triangulation<dim, spacedim> &tria, std::ostream &out) const;
 
  template <int dim, int spacedim>
  void
  write_gnuplot(const Triangulation<dim, spacedim> &tria,
                std::ostream                       &out,
                const Mapping<dim, spacedim>       *mapping = nullptr) const;
 
  template <int dim, int spacedim>
  void
  write_msh(const Triangulation<dim, spacedim> &tria, std::ostream &out) const;
 
  template <int dim, int spacedim>
  void
  write_msh(const Triangulation<dim, spacedim> &tria,
            const std::string                  &filename) const;
 
  template <int dim, int spacedim>
  void
  write_ucd(const Triangulation<dim, spacedim> &tria, std::ostream &out) const;
 
  template <int dim, int spacedim>
  void
  write_eps(const Triangulation<dim, spacedim> &tria,
            std::ostream                       &out,
            const Mapping<dim, spacedim>       *mapping = nullptr) const;
 
  template <int dim, int spacedim>
  void
  write_xfig(const Triangulation<dim, spacedim> &tria,
             std::ostream                       &out,
             const Mapping<dim, spacedim>       *mapping = nullptr) const;
 
  void
  write_svg(const Triangulation<2, 2> &tria, std::ostream &out) const;
 
  template <int dim, int spacedim>
  void
  write_svg(const Triangulation<dim, spacedim> &tria, std::ostream &out) const;
 
 
  template <int dim, int spacedim>
  void
  write_mathgl(const Triangulation<dim, spacedim> &tria,
               std::ostream                       &out) const;
 
  template <int dim, int spacedim>
  void
  write_vtk(const Triangulation<dim, spacedim> &tria, std::ostream &out) const;
 
  template <int dim, int spacedim>
  void
  write_vtu(const Triangulation<dim, spacedim> &tria, std::ostream &out) const;
 
  template <int dim, int spacedim>
  void
  write_mesh_per_processor_as_vtu(const Triangulation<dim, spacedim> &tria,
                                  const std::string &filename_without_extension,
                                  const bool         view_levels = false,
                                  const bool include_artificial  = false) const;
 
  template <int dim, int spacedim>
  void
  write(const Triangulation<dim, spacedim> &tria,
        std::ostream                       &out,
        const OutputFormat                  output_format,
        const Mapping<dim, spacedim>       *mapping = nullptr) const;
 
  template <int dim, int spacedim>
  void
  write(const Triangulation<dim, spacedim> &tria,
        std::ostream                       &out,
        const Mapping<dim, spacedim>       *mapping = nullptr) const;
 
  void
  set_flags(const GridOutFlags::DX &flags);
 
  void
  set_flags(const GridOutFlags::Msh &flags);
 
  void
  set_flags(const GridOutFlags::Ucd &flags);
 
  void
  set_flags(const GridOutFlags::Gnuplot &flags);
 
  void
  set_flags(const GridOutFlags::Eps<1> &flags);
 
  void
  set_flags(const GridOutFlags::Eps<2> &flags);
 
  void
  set_flags(const GridOutFlags::Eps<3> &flags);
 
  void
  set_flags(const GridOutFlags::XFig &flags);
 
  void
  set_flags(const GridOutFlags::Svg &flags);
 
  void
  set_flags(const GridOutFlags::MathGL &flags);
 
  void
  set_flags(const GridOutFlags::Vtk &flags);
 
  void
  set_flags(const GridOutFlags::Vtu &flags);
 
  static std::string
  default_suffix(const OutputFormat output_format);
 
  std::string
  default_suffix() const;
 
  static OutputFormat
  parse_output_format(const std::string &format_name);
 
  static std::string
  get_output_format_names();
 
  static void
  declare_parameters(ParameterHandler &param);
 
  void
  parse_parameters(ParameterHandler &param);
 
  std::size_t
  memory_consumption() const;
 
  DeclException0(ExcInvalidState);
 
private:
  OutputFormat default_format;
 
  GridOutFlags::DX dx_flags;
 
  GridOutFlags::Msh msh_flags;
 
  GridOutFlags::Ucd ucd_flags;
 
  GridOutFlags::Gnuplot gnuplot_flags;
 
  GridOutFlags::Eps<1> eps_flags_1;
 
  GridOutFlags::Eps<2> eps_flags_2;
 
  GridOutFlags::Eps<3> eps_flags_3;
 
  GridOutFlags::XFig xfig_flags;
 
  GridOutFlags::Svg svg_flags;
 
  GridOutFlags::MathGL mathgl_flags;
 
  GridOutFlags::Vtk vtk_flags;
 
  GridOutFlags::Vtu vtu_flags;
 
  template <int dim, int spacedim>
  unsigned int
  write_msh_faces(const Triangulation<dim, spacedim> &tria,
                  const unsigned int                  next_element_index,
                  std::ostream                       &out) const;
 
  unsigned int
  write_msh_faces(const Triangulation<1, 1> &tria,
                  const unsigned int         next_element_index,
                  std::ostream              &out) const;
  unsigned int
  write_msh_faces(const Triangulation<1, 2> &tria,
                  const unsigned int         next_element_index,
                  std::ostream              &out) const;
  unsigned int
  write_msh_faces(const Triangulation<1, 3> &tria,
                  const unsigned int         next_element_index,
                  std::ostream              &out) const;
 
 
 
  template <int dim, int spacedim>
  unsigned int
  write_msh_lines(const Triangulation<dim, spacedim> &tria,
                  const unsigned int                  next_element_index,
                  std::ostream                       &out) const;
 
  unsigned int
  write_msh_lines(const Triangulation<1, 1> &tria,
                  const unsigned int         next_element_index,
                  std::ostream              &out) const;
 
  unsigned int
  write_msh_lines(const Triangulation<1, 2> &tria,
                  const unsigned int         next_element_index,
                  std::ostream              &out) const;
 
  unsigned int
  write_msh_lines(const Triangulation<1, 3> &tria,
                  const unsigned int         next_element_index,
                  std::ostream              &out) const;
  unsigned int
  write_msh_lines(const Triangulation<2, 2> &tria,
                  const unsigned int         next_element_index,
                  std::ostream              &out) const;
  unsigned int
  write_msh_lines(const Triangulation<2, 3> &tria,
                  const unsigned int         next_element_index,
                  std::ostream              &out) const;
 
  template <int dim, int spacedim>
  unsigned int
  write_ucd_faces(const Triangulation<dim, spacedim> &tria,
                  const unsigned int                  next_element_index,
                  std::ostream                       &out) const;
 
  unsigned int
  write_ucd_faces(const Triangulation<1, 1> &tria,
                  const unsigned int         next_element_index,
                  std::ostream              &out) const;
 
  unsigned int
  write_ucd_faces(const Triangulation<1, 2> &tria,
                  const unsigned int         next_element_index,
                  std::ostream              &out) const;
  unsigned int
  write_ucd_faces(const Triangulation<1, 3> &tria,
                  const unsigned int         next_element_index,
                  std::ostream              &out) const;
 
 
  template <int dim, int spacedim>
  unsigned int
  write_ucd_lines(const Triangulation<dim, spacedim> &tria,
                  const unsigned int                  next_element_index,
                  std::ostream                       &out) const;
 
  unsigned int
  write_ucd_lines(const Triangulation<1, 1> &tria,
                  const unsigned int         next_element_index,
                  std::ostream              &out) const;
  unsigned int
  write_ucd_lines(const Triangulation<1, 2> &tria,
                  const unsigned int         next_element_index,
                  std::ostream              &out) const;
  unsigned int
  write_ucd_lines(const Triangulation<1, 3> &tria,
                  const unsigned int         next_element_index,
                  std::ostream              &out) const;
 
 
  unsigned int
  write_ucd_lines(const Triangulation<2, 2> &tria,
                  const unsigned int         next_element_index,
                  std::ostream              &out) const;
  unsigned int
  write_ucd_lines(const Triangulation<2, 3> &tria,
                  const unsigned int         next_element_index,
                  std::ostream              &out) const;
 
 
  template <int dim, int spacedim>
  unsigned int
  n_boundary_faces(const Triangulation<dim, spacedim> &tria) const;
 
  unsigned int
  n_boundary_faces(const Triangulation<1, 1> &tria) const;
 
  unsigned int
  n_boundary_faces(const Triangulation<1, 2> &tria) const;
 
  unsigned int
  n_boundary_faces(const Triangulation<1, 3> &tria) const;
 
  template <int dim, int spacedim>
  unsigned int
  n_boundary_lines(const Triangulation<dim, spacedim> &tria) const;
 
  unsigned int
  n_boundary_lines(const Triangulation<1, 1> &tria) const;
 
  unsigned int
  n_boundary_lines(const Triangulation<1, 2> &tria) const;
 
  unsigned int
  n_boundary_lines(const Triangulation<1, 3> &tria) const;
 
  unsigned int
  n_boundary_lines(const Triangulation<2, 2> &tria) const;
  unsigned int
  n_boundary_lines(const Triangulation<2, 3> &tria) const;
};
 
 
 
DEAL_II_NAMESPACE_CLOSE
 
#endif