grid_out.h

Go to the documentation of this file.

// ---------------------------------------------------------------------
//
// Copyright (C) 1999 - 2020 by the deal.II authors
//
// This file is part of the deal.II library.
//
// The deal.II library is free software; you can use it, redistribute
// it, and/or modify it under the terms of the GNU Lesser General
// Public License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// The full text of the license can be found in the file LICENSE.md at
// the top level directory of deal.II.
//
// ---------------------------------------------------------------------

#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>
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;

    DEAL_II_DEPRECATED unsigned int &n_boundary_face_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);

    Gnuplot(const Gnuplot &flags);

    Gnuplot &
    operator=(const Gnuplot &flags);

    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_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