plt_loader.h

Go to the documentation of this file.

// The libMesh Finite Element Library.
// Copyright (C) 2002-2019 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_PLT_LOADER_H
#define LIBMESH_PLT_LOADER_H
 
// Local includes
#include "libmesh/libmesh_common.h"
 
// C++ includes
#include <string>
#include <vector>
 
namespace libMesh
{
 
 
 
class PltLoader
{
public:
 
  PltLoader  (const bool v=false);
 
  PltLoader  (const std::string & name, const bool v=false);
 
  ~PltLoader ();
 
  void clear ();
 
  bool verbose () const { return _verbose; }
 
  void read (const std::string & name);
 
  void write_dat (const std::string & name,
                  const unsigned int version=10) const;
 
  // BSK - this functionality requires FORTRAN subroutine calls,
  //       and there is no need to "dirty up" \p libMesh with FORTRAN
  //       just to enable these methods.
  //   /**
  //    * Writes a plot3d files.  The grid will be in basename.g and
  //    * the solution will be in basename.q.  It is assumed that the
  //    * first three variables from the .plt file are the (x,y,z)
  //    * locations of the grid points.  The optional parameter \p reverse
  //    * specifies if the output file will have reversed byte ordering.
  //    */
  //   void write_plot3d (const std::string & basename,
  //      const bool reverse=false,
  //      const bool gridonly=false) const;
 
  //   /**
  //    * Writes a Cart3D .tri component file.  The number of components
  //    * will be the number of zones in the .plt file.
  //    */
  //   void write_tri (const std::string & name,
  //   const bool reverse=false,
  //   const bool gridonly=false) const;
 
 
 
  //--------------------------------------------------------------
  // Data access
 
 
 
  enum OldZoneType { BLOCK=0,
                     POINT,
                     FEBLOCK,
                     FEPOINT };
 
  enum NewZoneType { ORDERED=0,
                     FELINESEG,
                     FETRIANGLE,
                     FEQUADRILATERAL,
                     FETETRAHEDRON,
                     FEBRICK };
 
  enum DataType { FLOAT=1,
                  DOUBLE,
                  LONGINT,
                  SHORTINT,
                  BYTE,
                  BIT};
 
  enum FEType { TRI=0,
                QUAD,
                TET,
                HEX };
 
 
 
  //--------------------------------------------------------------
  // Public Data Access
 
 
 
  const std::string & version () const { return _version; }
 
  bool is_foreign () const { return _is_foreign; }
 
  const std::string & title () const { return _title; }
 
  unsigned int n_vars () const { return _n_vars; }
 
  const std::string & var_name (const unsigned int v) const;
 
  unsigned int var_type (const unsigned int v) const;
 
  unsigned int n_zones () const { return _n_zones; }
 
  unsigned int zone_type (const unsigned int z) const;
 
  const std::string & zone_name (const unsigned int z) const;
 
  unsigned int zone_pack (const unsigned int z) const;
 
  unsigned int imax (const unsigned int z) const;
 
  unsigned int jmax (const unsigned int z) const;
 
  unsigned int kmax (const unsigned int z) const;
 
  unsigned int n_nodes (const unsigned int z) const;
 
  unsigned int n_elem (const unsigned int z) const;
 
  FEType elem_type (const unsigned int z) const;
 
  const std::vector<std::vector<std::vector<float>>> & get_data () const;
 
  static const unsigned int NNodes[4];
 
 
private:
 
 
  void read_header (std::istream & in);
 
  void read_data (std::istream & in);
 
  void read_block_data (std::istream & in, const unsigned int zn);
 
  void read_point_data (std::istream & in, const unsigned int zn);
 
  void read_feblock_data (std::istream & in, const unsigned int zn);
 
  void read_fepoint_data (std::istream & in, const unsigned int zn);
 
 
  //--------------------------------------------------------------
  // Private Data Access
 
 
 
  std::string & version () { return _version; }
 
  bool & is_foreign () { return _is_foreign; }
 
  std::string & title () { return _title; }
 
  void set_n_vars (const unsigned int nv);
 
  std::string & var_name (const unsigned int v);
 
  unsigned int & var_type (const unsigned int v);
 
  void set_n_zones (const unsigned int nz);
 
  unsigned int & zone_type (const unsigned int z);
 
  std::string & zone_name (const unsigned int z);
 
  unsigned int & zone_pack (const unsigned int z);
 
  unsigned int & imax (const unsigned int z);
 
  unsigned int & jmax (const unsigned int z);
 
  unsigned int & kmax (const unsigned int z);
 
 
  //--------------------------------------------------------------
  // Private Data
 
 
  const bool _verbose;
 
  std::string _version;
 
  bool _is_foreign;
 
  std::string _title;
 
  unsigned int _n_vars;
 
  std::vector<std::string> _var_names;
 
  std::vector<unsigned int> _var_types;
 
  unsigned int _n_zones;
 
  std::vector<unsigned int> _zone_types;
 
  std::vector<std::string> _zone_names;
 
  std::vector<unsigned int> _zone_pack;
 
  std::vector<unsigned int> _imax;
  std::vector<unsigned int> _jmax;
  std::vector<unsigned int> _kmax;
 
  std::vector<std::vector<std::vector<float>>>  _data;
 
  std::vector<std::vector<int>> _conn;
 
  mutable char buf[512];
};
 
 
 
//---------------------------------------------------------
// PltLoader inline members
inline
PltLoader::PltLoader (const bool v) :
  _verbose      (v),
  _is_foreign   (false),
  _n_vars       (0),
  _n_zones      (0)
{
}
 
 
 
inline
PltLoader::PltLoader (const std::string & name, const bool v) :
  _verbose      (v),
  _is_foreign   (false),
  _n_vars       (0),
  _n_zones      (0)
{
  this->read (name);
}
 
 
 
inline
PltLoader::~PltLoader()
{
}
 
 
 
inline
const std::string & PltLoader::var_name (const unsigned int v) const
{
  libmesh_assert_less (v, this->n_vars());
  libmesh_assert_less (v, _var_names.size());
  libmesh_assert_equal_to (this->n_vars(), _var_names.size());
 
  return _var_names[v];
}
 
 
 
inline
std::string & PltLoader::var_name (const unsigned int v)
{
  libmesh_assert_less (v, this->n_vars());
  libmesh_assert_less (v, _var_names.size());
  libmesh_assert_equal_to (this->n_vars(), _var_names.size());
 
  return _var_names[v];
}
 
 
 
inline
unsigned int PltLoader::var_type (const unsigned int v) const
{
  libmesh_assert_less (v, this->n_vars());
  libmesh_assert_less (v, _var_types.size());
  libmesh_assert_equal_to (this->n_vars(), _var_types.size());
 
  return _var_types[v];
}
 
 
 
inline
unsigned int & PltLoader::var_type (const unsigned int v)
{
  libmesh_assert_less (v, this->n_vars());
  libmesh_assert_less (v, _var_types.size());
  libmesh_assert_equal_to (this->n_vars(), _var_types.size());
 
  return _var_types[v];
}
 
 
 
inline
unsigned int PltLoader::zone_type (const unsigned int z) const
{
  libmesh_assert_less (z, this->n_zones());
  libmesh_assert_less (z, _zone_types.size());
  libmesh_assert_equal_to (this->n_zones(), _zone_types.size());
 
  return _zone_types[z];
}
 
 
 
inline
unsigned int & PltLoader::zone_type (const unsigned int z)
{
  libmesh_assert_less (z, this->n_zones());
  libmesh_assert_less (z, _zone_types.size());
  libmesh_assert_equal_to (this->n_zones(), _zone_types.size());
 
  return _zone_types[z];
}
 
 
 
inline
const std::string & PltLoader::zone_name (const unsigned int z) const
{
  libmesh_assert_less (z, this->n_zones());
  libmesh_assert_less (z, _zone_names.size());
  libmesh_assert_equal_to (this->n_zones(), _zone_names.size());
 
  return _zone_names[z];
}
 
 
 
inline
std::string & PltLoader::zone_name (const unsigned int z)
{
  libmesh_assert_less (z, this->n_zones());
  libmesh_assert_less (z, _zone_names.size());
  libmesh_assert_equal_to (this->n_zones(), _zone_names.size());
 
  return _zone_names[z];
}
 
 
 
inline
unsigned int PltLoader::zone_pack (const unsigned int z) const
{
  libmesh_assert_less (z, this->n_zones());
  libmesh_assert_less (z, _zone_pack.size());
  libmesh_assert_equal_to (this->n_zones(), _zone_pack.size());
 
  return _zone_pack[z];
}
 
 
 
inline
unsigned int & PltLoader::zone_pack (const unsigned int z)
{
  libmesh_assert_less (z, this->n_zones());
  libmesh_assert_less (z, _zone_pack.size());
  libmesh_assert_equal_to (this->n_zones(), _zone_pack.size());
 
  return _zone_pack[z];
}
 
 
 
inline
unsigned int PltLoader::imax (const unsigned int z) const
{
  libmesh_assert_less (z, this->n_zones());
  libmesh_assert_equal_to (_imax.size(), this->n_zones());
 
  return _imax[z];
}
 
 
 
inline
unsigned int & PltLoader::imax (const unsigned int z)
{
  libmesh_assert_less (z, this->n_zones());
  libmesh_assert_equal_to (_imax.size(), this->n_zones());
 
  return _imax[z];
}
 
 
 
inline
unsigned int PltLoader::jmax (const unsigned int z) const
{
  libmesh_assert_less (z, this->n_zones());
  libmesh_assert_equal_to (_jmax.size(), this->n_zones());
 
  return _jmax[z];
}
 
 
 
inline
unsigned int & PltLoader::jmax (const unsigned int z)
{
  libmesh_assert_less (z, this->n_zones());
  libmesh_assert_equal_to (_jmax.size(), this->n_zones());
 
  return _jmax[z];
}
 
 
 
inline
unsigned int PltLoader::kmax (const unsigned int z) const
{
  libmesh_assert_less (z, this->n_zones());
  libmesh_assert_equal_to (_kmax.size(), this->n_zones());
 
  return _kmax[z];
}
 
 
 
inline
unsigned int & PltLoader::kmax (const unsigned int z)
{
  libmesh_assert_less (z, this->n_zones());
  libmesh_assert_equal_to (_kmax.size(), this->n_zones());
 
  return _kmax[z];
}
 
 
 
inline
unsigned int PltLoader::n_nodes (const unsigned int z) const
{
  libmesh_assert_less (z, this->n_zones());
 
  // Only for unstructured zones!
  libmesh_assert_greater (this->zone_type(z), 1);
 
  return this->imax(z);
}
 
 
 
inline
unsigned int PltLoader::n_elem (const unsigned int z) const
{
  libmesh_assert_less (z, this->n_zones());
 
  // Only for unstructured zones!
  libmesh_assert_greater (this->zone_type(z), 1);
 
  return this->jmax(z);
}
 
 
 
inline
PltLoader::FEType PltLoader::elem_type (const unsigned int z) const
{
  libmesh_assert_less (z, this->n_zones());
 
  // Only for unstructured zones!
  libmesh_assert_greater (this->zone_type(z), 1);
 
  return static_cast<FEType>(this->kmax(z));
}
 
 
inline
const std::vector<std::vector<std::vector<float>>> &
PltLoader::get_data () const
{
  return _data;
}
 
 
 
 
} // namespace libMesh
 
 
#endif // LIBMESH_PLT_LOADER_H