gmv_io.h

Go to the documentation of this file.

// The libMesh Finite Element Library.
// Copyright (C) 2002-2014 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"
#include "libmesh/enum_elem_type.h"

// C++ includes
#include <cstddef>
#include <cstring>  // for memcpy
#include <map>

namespace libMesh
{

// Forward declarations
class MeshBase;



// ------------------------------------------------------------
// GMVIO class definition
class GMVIO : public MeshInput<MeshBase>,
              public MeshOutput<MeshBase>
{
public:

  explicit
  GMVIO (const MeshBase&);

  explicit
  GMVIO (MeshBase&);

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

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

  //   /**
  //    * This method implements reading a mesh from a specified file.
  //    */
  //   virtual void read (const std::string& mesh_file)
  //   { this->read_mesh_and_nodal_data(mesh_file, NULL); }

  //   /**
  //    * Extension of the MeshInput::read() routine which
  //    * also takes an optional EquationSystems pointer and
  //    * tries to read field variables from the GMV file
  //    * into the EquationSystems object.
  //    */
  //   virtual void read_mesh_and_nodal_data (const std::string& ,
  //  EquationSystems* es=NULL);

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

  bool & binary ();

  bool & discontinuous();

  bool & partitioning();

  bool & write_subdomain_id_as_material();

  bool & subdivide_second_order();

  bool & p_levels();

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


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

  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>* = NULL,
                             const std::vector<std::string>* = NULL);

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

  template <typename T>
  void to_binary_stream(std::ostream& out,
                        const T i);

  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(const char* elemname);
  void _read_materials();
  void _read_var();
  std::map<std::string, std::vector<Number> > _nodal_data;
};



// ------------------------------------------------------------
// GMVIO inline members
inline
GMVIO::GMVIO (const MeshBase& mesh) :
  MeshOutput<MeshBase>    (mesh),
  _binary                 (false),
  _discontinuous          (false),
  _partitioning           (true),
  _write_subdomain_id_as_material (false),
  _subdivide_second_order (true),
  _p_levels               (true),
  _next_elem_id           (0)
{
}

inline
GMVIO::GMVIO (MeshBase& mesh) :
  MeshInput<MeshBase> (mesh),
  MeshOutput<MeshBase>(mesh),
  _binary (false),
  _discontinuous          (false),
  _partitioning           (true),
  _write_subdomain_id_as_material (false),
  _subdivide_second_order (true),
  _p_levels               (true),
  _next_elem_id           (0)
{
}



inline
bool & GMVIO::binary ()
{
  return _binary;
}



inline
bool & GMVIO::discontinuous ()
{
  return _discontinuous;
}



inline
bool & GMVIO::partitioning ()
{
  return _partitioning;
}


inline
bool & GMVIO::write_subdomain_id_as_material ()
{
  return _write_subdomain_id_as_material;
}



inline
bool & GMVIO::subdivide_second_order ()
{
  return _subdivide_second_order;
}



inline
bool & GMVIO::p_levels()
{
  return _p_levels;
}



template <typename T>
void GMVIO::to_binary_stream(std::ostream& out_str,
                             const T i)
{
  static char buf[sizeof(T)];
  memcpy(buf, &i, sizeof(T));
  out_str.write(buf, sizeof(T));
}

} // namespace libMesh


#endif // LIBMESH_GMV_IO_H