gmv_io.h

Go to the documentation of this file.

// The libMesh Finite Element Library.
// Copyright (C) 2002-2018 Benjamin S. Kirk, John W. Peterson, Roy H. Stogner

// This library is free software; you can 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.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.

// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA



#ifndef LIBMESH_GMV_IO_H
#define LIBMESH_GMV_IO_H

// Local includes
#include "libmesh/libmesh_common.h"
#include "libmesh/mesh_output.h"
#include "libmesh/mesh_input.h"

#ifdef LIBMESH_FORWARD_DECLARE_ENUMS
namespace libMesh
{
enum ElemType : int;
}
#else
#include "libmesh/enum_elem_type.h"
#endif

// C++ includes
#include <map>

namespace libMesh
{

// Forward declarations
class MeshBase;

class GMVIO : public MeshInput<MeshBase>,
              public MeshOutput<MeshBase>
{
public:

  explicit
  GMVIO (const MeshBase &);

  explicit
  GMVIO (MeshBase &);

  virtual void write (const std::string &) override;

  virtual void read (const std::string & mesh_file) override;

  using MeshOutput<MeshBase>::write_nodal_data;

  virtual void write_nodal_data (const std::string &,
                                 const std::vector<Number> &,
                                 const std::vector<std::string> &) override;

  bool & binary () { return _binary; }

  bool & discontinuous() { return _discontinuous; }

  bool & partitioning() { return _partitioning; }

  bool & write_subdomain_id_as_material() { return _write_subdomain_id_as_material; }

  bool & subdivide_second_order() { return _subdivide_second_order; }

  bool & p_levels() { return _p_levels; }

  void write_discontinuous_gmv (const std::string & name,
                                const EquationSystems & es,
                                const bool write_partitioning,
                                const std::set<std::string> * system_names=nullptr) const;


  void write_ascii_new_impl (const std::string &,
                             const std::vector<Number> * = nullptr,
                             const std::vector<std::string> * = nullptr);

  void add_cell_centered_data (const std::string &       cell_centered_data_name,
                               const std::vector<Real> * cell_centered_data_vals);

  void copy_nodal_solution(EquationSystems & es);

private:

  void write_ascii_old_impl (const std::string &,
                             const std::vector<Number> * = nullptr,
                             const std::vector<std::string> * = nullptr);

  void write_binary (const std::string &,
                     const std::vector<Number> * = nullptr,
                     const std::vector<std::string> * = nullptr);

  bool _binary;

  bool _discontinuous;

  bool _partitioning;

  bool _write_subdomain_id_as_material;

  bool _subdivide_second_order;

  bool _p_levels;

  std::map<std::string, const std::vector<Real> * > _cell_centered_data;

  void _read_nodes();
  unsigned int _next_elem_id;
  void _read_one_cell();
  ElemType gmv_elem_to_libmesh_elem(std::string elemname);
  void _read_materials();
  void _read_var();
  std::map<std::string, std::vector<Number>> _nodal_data;

  static std::map<std::string, ElemType> _reading_element_map;

  static std::map<std::string, ElemType> build_reading_element_map();
};

} // namespace libMesh


#endif // LIBMESH_GMV_IO_H