plt_loader.h

Go to the documentation of this file.

// Copyright (C) 2002-2007  Benjamin S. Kirk

// 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 subrouitine 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