libMesh::PltLoader Class Reference

#include <plt_loader.h>

Public Types
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 Member Functions
	PltLoader (const bool v=false)
	PltLoader (const std::string &name, const bool v=false)
	~PltLoader ()
void	clear ()
bool	verbose () const
void	read (const std::string &name)
void	write_dat (const std::string &name, const unsigned int version=10) const
const std::string &	version () const
bool	is_foreign () const
const std::string &	title () const
unsigned int	n_vars () const
const std::string &	var_name (const unsigned int v) const
unsigned int	var_type (const unsigned int v) const
unsigned int	n_zones () const
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 Public Attributes
static const unsigned int	NNodes [4] = {3, 4, 4, 8}

Private Member Functions
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)
std::string &	version ()
bool &	is_foreign ()
std::string &	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 Attributes
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
char	buf [512]

Detailed Description

This class will read a binary .plt file. These types of files are for use with Amtec's Tecplot visualization package.

Author

Benjamin S. Kirk

Date

2004

Definition at line 43 of file plt_loader.h.

Member Enumeration Documentation

DataType

enum libMesh::PltLoader::DataType

Enum defining the data type of each variable.

Enumerator
FLOAT
DOUBLE
LONGINT
SHORTINT
BYTE
BIT

Definition at line 136 of file plt_loader.h.

                { FLOAT=1,
                  DOUBLE,
                  LONGINT,
                  SHORTINT,
                  BYTE,
                  BIT};

FEType

enum libMesh::PltLoader::FEType

Enum defining the finite element types

Enumerator
TRI
QUAD
TET
HEX

Definition at line 146 of file plt_loader.h.

              { TRI=0,
                QUAD,
                TET,
                HEX };

NewZoneType

enum libMesh::PltLoader::NewZoneType

Enum defining the zone type in the Tecplot binary file, for use with the new .plt format.

Enumerator
ORDERED
FELINESEG
FETRIANGLE
FEQUADRILATERAL
FETETRAHEDRON
FEBRICK

Definition at line 126 of file plt_loader.h.

                   { ORDERED=0,
                     FELINESEG,
                     FETRIANGLE,
                     FEQUADRILATERAL,
                     FETETRAHEDRON,
                     FEBRICK };

OldZoneType

enum libMesh::PltLoader::OldZoneType

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 reverse specifies if the output file will have reversed byte ordering. Writes a Cart3D .tri component file. The number of components will be the number of zones in the .plt file. Enum defining the zone type in the Tecplot binary file, for use with the old .plt format.

Enumerator
BLOCK
POINT
FEBLOCK
FEPOINT

Definition at line 117 of file plt_loader.h.

                   { BLOCK=0,
                     POINT,
                     FEBLOCK,
                     FEPOINT };

Constructor & Destructor Documentation

PltLoader() [1/2]

libMesh::PltLoader::PltLoader ( const bool  v = false )

inline

Constructor. Initializes data.

Definition at line 449 of file plt_loader.h.

                                  :
  _verbose      (v),
  _is_foreign   (false),
  _n_vars       (0),
  _n_zones      (0)
{
}

PltLoader() [2/2]

libMesh::PltLoader::PltLoader ( const std::string &  name, const bool  v = false  )

inline

Constructor. Reads the file specified by name.

Definition at line 460 of file plt_loader.h.

References read().

                                                          :
  _verbose      (v),
  _is_foreign   (false),
  _n_vars       (0),
  _n_zones      (0)
{
  this->read (name);
}

~PltLoader()

libMesh::PltLoader::~PltLoader ( )

inline

Destructor.

Definition at line 472 of file plt_loader.h.

{
}

Member Function Documentation

clear()

void libMesh::PltLoader::clear

(

)

Clear all data and return to a pristine state.

Definition at line 35 of file plt_loader.C.

References _conn, _data, _imax, _is_foreign, _jmax, _kmax, _n_vars, _n_zones, _title, _var_names, _var_types, _version, _zone_names, _zone_pack, and _zone_types.

{
  // clear vectors & strings.  Using .erase() for strings instead of .clear()
  // since GCC 2.95.3 does not support .clear().
  _version.erase();
  _title.erase();

  _var_names.clear();
  _var_types.clear();
  _zone_types.clear();
  _zone_names.clear();
  _zone_pack.clear();
  _imax.clear();
  _jmax.clear();
  _kmax.clear();
  _data.clear();
  _conn.clear();

  // reinitialize
  _is_foreign = false;
  _n_vars     = 0;
  _n_zones    = 0;
}

elem_type()

PltLoader::FEType libMesh::PltLoader::elem_type ( const unsigned int  z ) const

inline

Returns

The element type for the zth zone (for unstructured meshes).

Definition at line 691 of file plt_loader.h.

References kmax(), n_zones(), and zone_type().

{
  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));
}

get_data()

const std::vector< std::vector< std::vector< float > > > & libMesh::PltLoader::get_data ( ) const

inline

Returns

A reference to the data read from the file

Definition at line 704 of file plt_loader.h.

References _data.

{
  return _data;
}

imax() [1/2]

unsigned int libMesh::PltLoader::imax ( const unsigned int  z ) const

inline

Returns

imax for zone z.

Definition at line 599 of file plt_loader.h.

References _imax, and n_zones().

Referenced by n_nodes(), read_block_data(), read_data(), read_feblock_data(), read_fepoint_data(), read_header(), read_point_data(), and write_dat().

{
  libmesh_assert_less (z, this->n_zones());
  libmesh_assert_equal_to (_imax.size(), this->n_zones());

  return _imax[z];
}

imax() [2/2]

unsigned int & libMesh::PltLoader::imax ( const unsigned int  z )

inlineprivate

Returns

imax for zone z.

Definition at line 610 of file plt_loader.h.

References _imax, and n_zones().

{
  libmesh_assert_less (z, this->n_zones());
  libmesh_assert_equal_to (_imax.size(), this->n_zones());

  return _imax[z];
}

is_foreign() [1/2]

bool libMesh::PltLoader::is_foreign ( ) const

inline

Returns

true if the binary type of the file is different than the machine that is reading it. If this is the case we must perform an endian-swap on all input data.

Definition at line 170 of file plt_loader.h.

References _is_foreign.

Referenced by read_block_data(), read_data(), read_feblock_data(), read_fepoint_data(), read_header(), and read_point_data().

{ return _is_foreign; }

is_foreign() [2/2]

bool& libMesh::PltLoader::is_foreign ( )

inlineprivate

Returns

true if the binary type of the file is different than the machine that is reading it. If this is the case we must perform an endian-swap on all input data.

Definition at line 302 of file plt_loader.h.

References _is_foreign.

{ return _is_foreign; }

jmax() [1/2]

unsigned int libMesh::PltLoader::jmax ( const unsigned int  z ) const

inline

Returns

jmax for zone z.

Definition at line 621 of file plt_loader.h.

References _jmax, and n_zones().

Referenced by n_elem(), read_block_data(), read_data(), read_feblock_data(), read_fepoint_data(), read_header(), read_point_data(), and write_dat().

{
  libmesh_assert_less (z, this->n_zones());
  libmesh_assert_equal_to (_jmax.size(), this->n_zones());

  return _jmax[z];
}

jmax() [2/2]

unsigned int & libMesh::PltLoader::jmax ( const unsigned int  z )

inlineprivate

Returns

jmax for zone z.

Definition at line 632 of file plt_loader.h.

References _jmax, and n_zones().

{
  libmesh_assert_less (z, this->n_zones());
  libmesh_assert_equal_to (_jmax.size(), this->n_zones());

  return _jmax[z];
}

kmax() [1/2]

unsigned int libMesh::PltLoader::kmax ( const unsigned int  z ) const

inline

Returns

kmax for zone z.

Definition at line 643 of file plt_loader.h.

References _kmax, and n_zones().

Referenced by elem_type(), read_block_data(), read_data(), read_feblock_data(), read_fepoint_data(), read_header(), read_point_data(), and write_dat().

{
  libmesh_assert_less (z, this->n_zones());
  libmesh_assert_equal_to (_kmax.size(), this->n_zones());

  return _kmax[z];
}

kmax() [2/2]

unsigned int & libMesh::PltLoader::kmax ( const unsigned int  z )

inlineprivate

Returns

kmax for zone z.

Definition at line 654 of file plt_loader.h.

References _kmax, and n_zones().

{
  libmesh_assert_less (z, this->n_zones());
  libmesh_assert_equal_to (_kmax.size(), this->n_zones());

  return _kmax[z];
}

n_elem()

unsigned int libMesh::PltLoader::n_elem ( const unsigned int  z ) const

inline

Returns

The number of elements in the mesh (for unstructured meshes).

Definition at line 678 of file plt_loader.h.

References jmax(), n_zones(), and zone_type().

Referenced by read_header().

{
  libmesh_assert_less (z, this->n_zones());

  // Only for unstructured zones!
  libmesh_assert_greater (this->zone_type(z), 1);

  return this->jmax(z);
}

n_nodes()

unsigned int libMesh::PltLoader::n_nodes ( const unsigned int  z ) const

inline

Returns

The number of nodes in the mesh (for unstructured meshes).

Definition at line 665 of file plt_loader.h.

References imax(), n_zones(), and zone_type().

Referenced by read_header().

{
  libmesh_assert_less (z, this->n_zones());

  // Only for unstructured zones!
  libmesh_assert_greater (this->zone_type(z), 1);

  return this->imax(z);
}

n_vars()

unsigned int libMesh::PltLoader::n_vars ( ) const

inline

Returns

The number of variables in the data set.

Definition at line 180 of file plt_loader.h.

References _n_vars.

Referenced by read_block_data(), read_data(), read_feblock_data(), read_fepoint_data(), read_header(), read_point_data(), set_n_vars(), set_n_zones(), var_name(), var_type(), and write_dat().

{ return _n_vars; }

n_zones()

unsigned int libMesh::PltLoader::n_zones ( ) const

inline

Returns

The number of zones.

Definition at line 195 of file plt_loader.h.

References _n_zones.

Referenced by elem_type(), imax(), jmax(), kmax(), n_elem(), n_nodes(), read_data(), read_feblock_data(), read_header(), set_n_vars(), set_n_zones(), write_dat(), zone_name(), zone_pack(), and zone_type().

{ return _n_zones; }

read()

void libMesh::PltLoader::read

(

const std::string &

name

)

Reads the .plt file specified by name.

Definition at line 35 of file plt_loader_read.C.

References libMesh::Quality::name(), libMesh::out, read_data(), read_header(), and verbose().

Referenced by PltLoader().

{
  std::ifstream in (name.c_str(), std::ios::in|std::ios::binary);

  if (!in.good())
    libmesh_error_msg("Error reading input file " << name);


  if (this->verbose())
    libMesh::out << std::endl
                 << "Reading input file " << name
                 << std::endl
                 << "-------------------------------------------------------------------------"
                 << std::endl;

  this->read_header (in);
  this->read_data   (in);

  if (this->verbose())
    libMesh::out << std::endl
                 << "-------------------------------------------------------------------------"
                 << std::endl;

}

read_block_data()

void libMesh::PltLoader::read_block_data ( std::istream &  in, const unsigned int  zn  )

private

Read data for the zth zone in BLOCK structured format.

Definition at line 829 of file plt_loader_read.C.

References _data, data, DOUBLE, FLOAT, imax(), is_foreign(), jmax(), kmax(), n_vars(), and var_type().

Referenced by read_data().

{
  libmesh_assert (in.good());


  // A byte-reverser in case the data is foreign
  Utility::ReverseBytes rb(this->is_foreign());


  for (unsigned int var=0; var<this->n_vars(); var++)
    {

      switch (this->var_type(var))
        {

          // Read a single-precision variable
        case FLOAT:
          {
            std::vector<float> & data = _data[zone][var];

            data.clear();
            data.resize (this->imax(zone)*
                         this->jmax(zone)*
                         this->kmax(zone));

            in.read (reinterpret_cast<char *>(data.data()), LIBMESH_SIZEOF_FLOAT*data.size());

            for (std::size_t i=0; i<data.size(); i++)
              rb(data[i]);

            break;
          }

          // Read a double-precision variable
        case DOUBLE:
          {
            std::vector<double> ddata;
            std::vector<float> & data = _data[zone][var];

            data.clear();
            data.resize (this->imax(zone)*
                         this->jmax(zone)*
                         this->kmax(zone));

            ddata.resize (this->imax(zone)*
                          this->jmax(zone)*
                          this->kmax(zone));

            in.read (reinterpret_cast<char *>(ddata.data()), LIBMESH_SIZEOF_DOUBLE*ddata.size());

            for (std::size_t i=0; i<data.size(); i++)
              data[i] = float(rb(ddata[i]));

            break;
          }

        default:
          libmesh_error_msg("ERROR: Unsupported data type: " << this->var_type(var));
        }
    }
}

read_data()

void libMesh::PltLoader::read_data ( std::istream &  in )

private

Read data from the binary file.

Definition at line 598 of file plt_loader_read.C.

References BLOCK, buf, FEBLOCK, FEPOINT, libMesh::BasicOStreamProxy< charT, traits >::flush(), imax(), is_foreign(), jmax(), kmax(), n_vars(), n_zones(), ORDERED, libMesh::out, POINT, read_block_data(), read_feblock_data(), read_fepoint_data(), read_point_data(), var_type(), verbose(), version(), zone_pack(), and zone_type().

Referenced by read().

{
  libmesh_assert (in.good());

  // A byte-reverser in case the data is foreign
  Utility::ReverseBytes rb(this->is_foreign());

  //----------------------------------------------------
  // Read the TECPLOT data for each zone
  if (this->verbose())
    {
      libMesh::out << "Reading Zones";
      libMesh::out.flush();
    }


  for (unsigned int zone=0; zone<this->n_zones(); zone++)
    {
      if (this->verbose())
        {
          libMesh::out << ".";
          libMesh::out.flush();
        }


      //----------------------------------------------------
      // Read plt files written by older versions of Tecplot
      if (this->version().rfind("V7") < this->version().size())
        {
          float f = 0.;

          // Find the next Zone marker.
          do
            {
              f = 0.;
              in.read (buf, LIBMESH_SIZEOF_FLOAT);
              std::memcpy  (&f, buf, LIBMESH_SIZEOF_FLOAT);
              rb(f);
            }
          while ((f != 299.) && in.good());

          // Did we overrun the file?
          if (!in.good())
            libmesh_error_msg("ERROR: Unexpected end-of-file!");

          // Get the number of repeated vars.
          unsigned int n_rep_vars=0;
          std::vector<int> rep_vars;

          {
            in.read (buf, LIBMESH_SIZEOF_INT);
            std::memcpy  (&n_rep_vars, buf, LIBMESH_SIZEOF_INT);
            rb(n_rep_vars);

            rep_vars.resize (n_rep_vars);

            // Get the repeated variables number.
            for (unsigned int v=0; v<n_rep_vars; v++)
              {
                libmesh_error_msg("ERROR:  I don't understand repeated variables yet!");

                in.read (buf, LIBMESH_SIZEOF_INT);
                std::memcpy  (&rep_vars[v], buf, LIBMESH_SIZEOF_INT);
                rb(rep_vars[v]);
              }
          }

          // Get the variable data type
          //libMesh::out << "var_types=";
          for (unsigned int v=0; v<this->n_vars(); v++)
            {
              in.read (buf, LIBMESH_SIZEOF_INT);
              std::memcpy  (&this->var_type(v), buf, LIBMESH_SIZEOF_INT);
              rb(this->var_type(v));

              //libMesh::out << this->var_type(v) << " ";
            }
          //libMesh::out << std::endl;



          // Read the data.
          switch (this->zone_type(zone) )
            {
              // Block-based data.  Structured meshes.
            case BLOCK:
              {
                this->read_block_data (in, zone);
                break;
              }

              // Point-based data.  Structured meshes.
            case POINT:
              {
                this->read_point_data (in, zone);
                break;
              }

              // FE block data.  Unstructured meshes.
            case FEBLOCK:
              {
                this->read_feblock_data (in, zone);

                if (this->verbose())

                  libMesh::out << "Zone " << zone << ":" << std::endl
                               << "  nnodes   =" << this->imax(zone) << std::endl
                               << "  nelem    =" << this->jmax(zone) << std::endl
                               << "  elem_type=" << this->kmax(zone) << std::endl
                               << std::endl;
                break;
              }

              // FE point data.  Unstructured meshes.
            case FEPOINT:
              {
                this->read_fepoint_data (in, zone);
                break;
              }

            default:
              libmesh_error_msg("ERROR: Unsupported Zone type: " << this->zone_type(zone));
            } // end switch on zone type
        }


      //----------------------------------------------------
      // Read plt files written by newer versions of Tecplot
      else if (this->version().rfind("V1") < this->version().size())
        {
          float f = 0.;

          // Find the next Zone marker.
          do
            {
              f = 0.;
              in.read (buf, LIBMESH_SIZEOF_FLOAT);
              std::memcpy  (&f, buf, LIBMESH_SIZEOF_FLOAT);
              rb(f);
            }
          while ((f != 299.) && in.good());

          // Did we overrun the file?
          if (!in.good())
            libmesh_error_msg("ERROR: Unexpected end-of-file!");

          // Get the variable data type
          for (unsigned int v=0; v<this->n_vars(); v++)
            {
              in.read (buf, LIBMESH_SIZEOF_INT);
              std::memcpy  (&this->var_type(v), buf, LIBMESH_SIZEOF_INT);
              rb(this->var_type(v));

              //libMesh::out << this->var_type(v) << " ";
            }

          // Get the variable sharing flag
          {
            int vs=0;
            int sv=0;

            in.read (buf, LIBMESH_SIZEOF_INT);
            std::memcpy  (&vs, buf, LIBMESH_SIZEOF_INT);
            rb(vs);

            if (vs)
              {
                for (unsigned int v=0; v<this->n_vars(); v++)
                  {
                    in.read (buf, LIBMESH_SIZEOF_INT);
                    std::memcpy  (&sv, buf, LIBMESH_SIZEOF_INT);
                    rb(sv);

                    if (sv != -1)
                      libmesh_error_msg("ERROR:  I don't understand variable sharing!");
                  }
              }
          }

          // Get zone to share connectivity with
          {
            int sc=0;
            in.read (buf, LIBMESH_SIZEOF_INT);
            std::memcpy  (&sc, buf, LIBMESH_SIZEOF_INT);
            rb(sc);

            libmesh_assert_equal_to (sc, -1);
          }


          // Read the data.
          if (this->zone_type(zone) == ORDERED)
            {
              // Block-based data.  Structured meshes.
              if (this->zone_pack(zone) == 0)
                this->read_block_data (in, zone);

              // Point-based data.  Structured meshes.
              else if (this->zone_pack(zone) == 1)
                this->read_point_data (in, zone);

              else
                libmesh_error_msg("Unrecognized zone_pack(zone) = " << this->zone_pack(zone));
            }
          else
            {
              // Block-based data.  Unstructured meshes.
              if (this->zone_pack(zone) == 0)
                this->read_feblock_data (in, zone);

              // Point-based data.  Unstructured meshes.
              else if (this->zone_pack(zone) == 1)
                this->read_fepoint_data (in, zone);

              else
                libmesh_error_msg("Unrecognized zone_pack(zone) = " << this->zone_pack(zone));
            }
        }



      //----------------------------------------------------
      // Unrecognized Tecplot Version!
      else
        libmesh_error_msg("ERROR:  This plot file was written by an unrecognized version of Tecplot!:\n" << this->version());

    } // end loop on zones
}

read_feblock_data()

void libMesh::PltLoader::read_feblock_data ( std::istream &  in, const unsigned int  zn  )

private

Read data for the zth zone in FEBLOCK unstructured format.

Definition at line 946 of file plt_loader_read.C.

References _conn, _data, data, DOUBLE, FLOAT, imax(), is_foreign(), jmax(), kmax(), n_vars(), n_zones(), NNodes, and var_type().

Referenced by read_data().

{
  libmesh_assert (in.good());

  // A byte-reverser in case the data is foreign
  Utility::ReverseBytes rb(this->is_foreign());

  // Read the variable values at each node.
  for (unsigned int var=0; var<this->n_vars(); var++)
    {
      switch (this->var_type(var))
        {

          // Read a single-precision variable
        case FLOAT:
          {
            std::vector<float> & data = _data[zone][var];

            data.clear();
            data.resize (this->imax(zone));

            in.read (reinterpret_cast<char *>(data.data()), LIBMESH_SIZEOF_FLOAT*data.size());

            for (std::size_t i=0; i<data.size(); i++)
              rb(data[i]);

            break;
          }

          // Read a double-precision variable
        case DOUBLE:
          {
            std::vector<double> ddata;
            std::vector<float> & data = _data[zone][var];

            data.clear();
            data.resize (this->imax(zone));
            ddata.resize (this->imax(zone));

            in.read (reinterpret_cast<char *>(ddata.data()), LIBMESH_SIZEOF_DOUBLE*ddata.size());

            for (std::size_t i=0; i<data.size(); i++)
              data[i] = float(rb(ddata[i]));

            break;
          }

        default:
          libmesh_error_msg("ERROR: Unsupported data type: " << this->var_type(var));
        }
    }

  // Read the connectivity
  {
    // Get the connectivity repetition flag
    int rep=0;
    in.read ((char *) &rep, LIBMESH_SIZEOF_INT);
    rb(rep);

    if (rep == 1 && this->n_zones() > 1)
      libmesh_error_msg("ERROR:  Repeated connectivity not supported!");

    // Read the connectivity
    else
      {
        libmesh_assert_less (zone, _conn.size());
        libmesh_assert_less (this->kmax(zone), 4);

        _conn[zone].resize (this->jmax(zone)*NNodes[this->kmax(zone)]);

        in.read (reinterpret_cast<char *>(_conn[zone].data()), LIBMESH_SIZEOF_INT*_conn[zone].size());

        for (std::size_t i=0; i<_conn[zone].size(); i++)
          rb(_conn[zone][i]);
      }
  }
}

read_fepoint_data()

void libMesh::PltLoader::read_fepoint_data ( std::istream &  in, const unsigned int  zn  )

private

Read data for the zth zone in FEPOINT unstructured format.

Definition at line 1026 of file plt_loader_read.C.

References _conn, _data, buf, data, DOUBLE, FLOAT, imax(), is_foreign(), jmax(), kmax(), n_vars(), NNodes, and var_type().

Referenced by read_data().

{
  libmesh_assert (in.good());

  // A byte-reverser in case the data is foreign
  Utility::ReverseBytes rb(this->is_foreign());

  // First allocate space
  for (unsigned int var=0; var<this->n_vars(); var++)
    {
      std::vector<float> & data = _data[zone][var];

      data.clear();
      data.reserve (this->imax(zone));
    }


  for (unsigned int i=0; i<this->imax(zone); i++)
    for (unsigned int var=0; var<this->n_vars(); var++)
      if (this->var_type(var) == FLOAT)
        {
          float f = 0.;

          libmesh_assert (in.good());

          in.read (buf, LIBMESH_SIZEOF_FLOAT);
          std::memcpy  (&f, buf, LIBMESH_SIZEOF_FLOAT);
          rb(f);

          _data[zone][var].push_back(f);
        }
      else if (this->var_type(var) == DOUBLE)
        {
          double d = 0.;

          libmesh_assert (in.good());

          in.read (buf, LIBMESH_SIZEOF_DOUBLE);
          std::memcpy  (&d, buf, LIBMESH_SIZEOF_DOUBLE);
          rb(d);

          _data[zone][var].push_back(float(d));
        }
      else
        libmesh_error_msg("ERROR: unsupported data type: " << this->var_type(var));

  // Read the connectivity
  {
    // Get the connectivity repetition flag
    int rep=0;

    in.read ((char *) &rep, LIBMESH_SIZEOF_INT);
    rb(rep);

    if (rep == 1)
      libmesh_error_msg("ERROR:  Repeated connectivity not supported!");

    // Read the connectivity
    else
      {
        libmesh_assert_less (zone, _conn.size());
        libmesh_assert_less (this->kmax(zone), 4);

        _conn[zone].resize (this->jmax(zone)*NNodes[this->kmax(zone)]);

        in.read (reinterpret_cast<char *>(_conn[zone].data()), LIBMESH_SIZEOF_INT*_conn[zone].size());

        for (std::size_t i=0; i<_conn[zone].size(); i++)
          rb(_conn[zone][i]);
      }
  }
}

read_header()

void libMesh::PltLoader::read_header ( std::istream &  in )

private

Read the header of the binary file.

Definition at line 62 of file plt_loader_read.C.

References buf, libMesh::err, imax(), is_foreign(), jmax(), kmax(), n_elem(), n_nodes(), n_vars(), n_zones(), libMesh::Quality::name(), ORDERED, libMesh::out, set_n_vars(), set_n_zones(), title(), var_name(), var_type(), verbose(), version(), zone_name(), zone_pack(), and zone_type().

Referenced by read().

{
  libmesh_assert (in.good());

  //----------------------------------------------------
  // Read the TECPLOT header

  // Read the version number
  {
    in.read (buf, 8);

    this->version().clear();

    for (unsigned int i=0; i<8; i++)
      this->version() += buf[i];

    if (this->verbose())
      libMesh::out << "Tecplot Version: "
                   << this->version()
                   << std::endl;
  }


  //----------------------------------------------------
  // Read plt files written by older versions of Tecplot
  if (this->version().rfind("V7") < this->version().size())
    {
      if (this->verbose())
        libMesh::out << "Reading legacy .plt format (<= v9) ..."
                     << std::endl;

      // Read the value of 1 to determine byte ordering
      {
        int one = 0;
        in.read (buf, LIBMESH_SIZEOF_INT);
        std::memcpy  (&one, buf, LIBMESH_SIZEOF_INT);

        if (one != 1)
          {
            if (this->verbose())
              libMesh::out << "Tecplot data is Foreign!"
                           << std::endl;
            this->is_foreign() = true;

            // Make sure one reversed is one
            Utility::ReverseBytes rb(this->is_foreign());
            libmesh_assert_equal_to (rb(one), 1);
          }
      }

      // A byte-reverser in case the data is foreign
      Utility::ReverseBytes rb(this->is_foreign());

      // Read the title
      {
        int i=0;

        this->title().clear();

        do
          {
            in.read (buf, LIBMESH_SIZEOF_INT);
            std::memcpy  (&i, buf, LIBMESH_SIZEOF_INT);
            rb(i);

            // Don't add trailing \0
            if (i)
              this->title() += static_cast<char>(i);
          }
        while (i);
      }

      // Read the number of variables in the data set
      {
        int nv;
        in.read (buf, LIBMESH_SIZEOF_INT);
        std::memcpy  (&nv, buf, LIBMESH_SIZEOF_INT);
        rb(nv);

        this->set_n_vars (nv);
      }

      // Read the variable names
      for (unsigned int v=0; v<this->n_vars(); v++)
        {
          int i=0;

          this->var_name(v).clear();

          do
            {
              in.read (buf, LIBMESH_SIZEOF_INT);
              std::memcpy  (&i, buf, LIBMESH_SIZEOF_INT);
              rb(i);

              // Don't add trailing \0
              if (i)
                this->var_name(v) += static_cast<char>(i);
            }
          while (i);
        }



      // Read zones from the header.
      // Continue reading until the end-of-header
      // marker (357.) is found.
      int nz=0;
      std::vector<std::string> zname;
      std::vector<int>         ztype, zimax, zjmax, zkmax;

      {
        float f=0.;

        do
          {
            // find the next Zone marker
            do
              {
                f = 0.;
                in.read (buf, LIBMESH_SIZEOF_FLOAT);
                std::memcpy  (&f, buf, LIBMESH_SIZEOF_FLOAT);
                rb(f);
              }
            while ((f != 299.) &&
                   (f != 357.) &&
                   in.good());


            // Did we overrun the file?
            if (!in.good())
              libmesh_error_msg("ERROR: Unexpected end-of-file!");

            // Found a Zone marker
            else if (f == 299.)
              {
                // Increment the Zone counter
                nz++;

                // Read the zone name
                {
                  int i=0;
                  std::string name;

                  do
                    {
                      in.read (buf, LIBMESH_SIZEOF_INT);
                      std::memcpy  (&i, buf, LIBMESH_SIZEOF_INT);
                      rb(i);

                      // Don't add trailing \0
                      if (i)
                        name += static_cast<char>(i);
                    }
                  while (i);

                  zname.push_back(name);
                }

                // Read the zone format
                {
                  int zt;
                  in.read (buf, LIBMESH_SIZEOF_INT);
                  std::memcpy  (&zt, buf, LIBMESH_SIZEOF_INT);
                  rb(zt);

                  ztype.push_back(zt);
                  //libMesh::out << "zone type=" << ztype.back() << std::endl;
                }

                // Read the zone color
                {
                  int zc=0;

                  in.read (buf, LIBMESH_SIZEOF_INT);
                  std::memcpy  (&zc, buf, LIBMESH_SIZEOF_INT);
                  rb(zc);

                  //libMesh::out << "zone color=" << zc << std::endl;
                }

                // Read in the block dimensions
                {
                  int
                    i_max=0,
                    j_max=0,
                    k_max=0;

                  in.read (buf, LIBMESH_SIZEOF_INT);
                  std::memcpy  (&i_max, buf, LIBMESH_SIZEOF_INT);
                  rb(i_max);

                  in.read (buf, LIBMESH_SIZEOF_INT);
                  std::memcpy  (&j_max, buf, LIBMESH_SIZEOF_INT);
                  rb(j_max);

                  in.read (buf, LIBMESH_SIZEOF_INT);
                  std::memcpy  (&k_max, buf, LIBMESH_SIZEOF_INT);
                  rb(k_max);

                  zimax.push_back (i_max);
                  zjmax.push_back (j_max);
                  zkmax.push_back (k_max);
                }
              } // else if (f == 299.)
          }
        while ((f != 357.) && in.good());
      }

      // Set the header data
      this->set_n_zones (nz);

      for (unsigned int z=0; z<this->n_zones(); z++)
        {
          this->zone_type(z) = ztype[z];
          this->zone_name(z) = zname[z];
          this->imax(z)      = zimax[z];
          this->jmax(z)      = zjmax[z];
          this->kmax(z)      = zkmax[z];
        }
    }


  //----------------------------------------------------
  // Read plt files written by newer versions of Tecplot
  else if (this->version().rfind("V1") < this->version().size())
    {
      if (this->verbose())
        libMesh::out << "Reading new .plt format (>= v10)..."
                     << std::endl;

      // Read the value of 1 to determine byte ordering
      {
        int one = 0;

        in.read (buf, LIBMESH_SIZEOF_INT);
        std::memcpy  (&one, buf, LIBMESH_SIZEOF_INT);

        if (one != 1)
          {
            if (this->verbose())
              libMesh::err << "Tecplot data is Foreign!"
                           << std::endl;
            this->is_foreign() = true;

            // Make sure one reversed is one
            Utility::ReverseBytes rb(this->is_foreign());
            libmesh_assert_equal_to (rb(one), 1);
          }
      }

      // A byte-reverser in case the data is foreign
      Utility::ReverseBytes rb(this->is_foreign());

      // Read the title
      {
        int i=0;

        this->title().clear();
        do
          {
            in.read (buf, LIBMESH_SIZEOF_INT);
            std::memcpy  (&i, buf, LIBMESH_SIZEOF_INT);
            rb(i);

            // Don't add trailing \0
            if (i)
              this->title() += static_cast<char>(i);
          }
        while (i);
      }

      // Read the number of variables in the data set
      {
        int nv;
        in.read (buf, LIBMESH_SIZEOF_INT);
        std::memcpy  (&nv, buf, LIBMESH_SIZEOF_INT);
        rb(nv);

        this->set_n_vars (nv);
      }

      // Read the variable names
      for (unsigned int v=0; v<this->n_vars(); v++)
        {
          int i=0;

          this->var_name(v).clear();

          do
            {
              in.read (buf, LIBMESH_SIZEOF_INT);
              std::memcpy  (&i, buf, LIBMESH_SIZEOF_INT);
              rb(i);

              // Don't add trailing \0
              if (i)
                this->var_name(v) += static_cast<char>(i);
            }
          while (i);
        }



      // Read zones from the header.
      // Continue reading until the end-of-header
      // marker (357.) is found.
      int nz=0;
      std::vector<std::string> zname;
      std::vector<int>         zpack, ztype, zimax, zjmax, zkmax;

      {
        float f=0.;

        do
          {
            // find the next Zone marker
            do
              {
                f = 0.;
                in.read (buf, LIBMESH_SIZEOF_FLOAT);
                std::memcpy  (&f, buf, LIBMESH_SIZEOF_FLOAT);
                rb(f);
              }
            while ((f != 299.) &&
                   (f != 357.) &&
                   in.good());


            // Did we overrun the file?
            if (!in.good())
              libmesh_error_msg("ERROR: Unexpected end-of-file!");

            // Found a Zone marker
            else if (f == 299.)
              {
                // Increment the Zone counter
                nz++;

                // Read the zone name
                {
                  int i=0;
                  std::string name;

                  do
                    {
                      in.read (buf, LIBMESH_SIZEOF_INT);
                      std::memcpy  (&i, buf, LIBMESH_SIZEOF_INT);
                      rb(i);

                      // Don't add trailing \0
                      if (i)
                        name += static_cast<char>(i);
                    }
                  while (i);

                  zname.push_back(name);
                }

                // Read the zone color
                {
                  int zc=0;
                  in.read (buf, LIBMESH_SIZEOF_INT);
                  std::memcpy  (&zc, buf, LIBMESH_SIZEOF_INT);
                  rb(zc);
                }

                // Read the zone format
                {
                  int zt;
                  in.read (buf, LIBMESH_SIZEOF_INT);
                  std::memcpy  (&zt, buf, LIBMESH_SIZEOF_INT);
                  rb(zt);

                  ztype.push_back(zt);
                }

                // Read the data packing flag
                {
                  int dp=0;
                  in.read (buf, LIBMESH_SIZEOF_INT);
                  std::memcpy (&dp, buf, LIBMESH_SIZEOF_INT);
                  rb(dp);

                  zpack.push_back (dp);
                }

                // Will we specify the variable location?
                {
                  int svl=0;
                  int  vl=0;
                  in.read (buf, LIBMESH_SIZEOF_INT);
                  std::memcpy  (&svl, buf, LIBMESH_SIZEOF_INT);
                  rb(svl);

                  if (svl)
                    for (unsigned int v=0; v<this->n_vars(); v++)
                      {
                        in.read (buf, LIBMESH_SIZEOF_INT);
                        std::memcpy  (&vl, buf, LIBMESH_SIZEOF_INT);
                        rb(vl);
                        libmesh_assert_equal_to (vl, 0); // Only know about node-based data
                        // right now
                      }

                }

                // Get the number of user-defined face-neighbors
                {
                  int fn=0;
                  in.read (buf, LIBMESH_SIZEOF_INT);
                  std::memcpy  (&fn, buf, LIBMESH_SIZEOF_INT);
                  rb(fn);
                }

                // Read in the block dimensions
                {
                  if (ztype.back() != ORDERED)
                    {
                      int np=0, ne=0;

                      in.read (buf, LIBMESH_SIZEOF_INT);
                      std::memcpy  (&np, buf, LIBMESH_SIZEOF_INT);
                      rb(np);

                      in.read (buf, LIBMESH_SIZEOF_INT);
                      std::memcpy  (&ne, buf, LIBMESH_SIZEOF_INT);
                      rb(ne);

                      zimax.push_back (np);
                      zjmax.push_back (ne);
                      zjmax.push_back (0);
                    }

                  int
                    i_max=0,
                    j_max=0,
                    k_max=0;

                  in.read (buf, LIBMESH_SIZEOF_INT);
                  std::memcpy  (&i_max, buf, LIBMESH_SIZEOF_INT);
                  rb(i_max);

                  in.read (buf, LIBMESH_SIZEOF_INT);
                  std::memcpy  (&j_max, buf, LIBMESH_SIZEOF_INT);
                  rb(j_max);

                  in.read (buf, LIBMESH_SIZEOF_INT);
                  std::memcpy  (&k_max, buf, LIBMESH_SIZEOF_INT);
                  rb(k_max);

                  // These are only useful for ordered data.  Otherwise
                  // we grabbed the relevant values above.
                  if (ztype.back() != ORDERED)
                    {
                      zimax.push_back (i_max);
                      zjmax.push_back (j_max);
                      zkmax.push_back (k_max);
                    }
                }
              } // else if (f == 299.)
          }
        while ((f != 357.) && in.good());
      }

      // Set the header data
      this->set_n_zones (nz);

      for (unsigned int z=0; z<this->n_zones(); z++)
        {
          this->zone_type(z) = ztype[z];
          this->zone_name(z) = zname[z];
          this->zone_pack(z) = zpack[z];
          this->imax(z)      = zimax[z];
          this->jmax(z)      = zjmax[z];
          this->kmax(z)      = zkmax[z];
        }
    }



  //----------------------------------------------------
  // Unrecognized Tecplot Version!
  else
    libmesh_error_msg("ERROR:  This plot file was written by an unrecognized version of Tecplot!:\n" << this->version());








  // Print the data to the screen.
  if (this->verbose())
    {
      libMesh::out << "Tecplot Header: "
                   << this->title() << std::endl;

      libMesh::out << "Variables: ";
      for (unsigned int v=0; v<this->n_vars(); v++)
        libMesh::out << "\"" << this->var_name (v) << "\"" << " ";
      libMesh::out << std::endl;

      libMesh::out << "Variable Types: ";
      for (unsigned int v=0; v<this->n_vars(); v++)
        libMesh::out << this->var_type (v) << " ";
      libMesh::out << std::endl;

      libMesh::out << "Zone Names: ";
      for (unsigned int z=0; z<this->n_zones(); z++)
        libMesh::out << "\"" << this->zone_name (z) << "\"" << " ";
      libMesh::out << std::endl;

      libMesh::out << "Zone Types: ";
      for (unsigned int z=0; z<this->n_zones(); z++)
        {
          libMesh::out << this->zone_type (z) << " ";

          if (this->zone_type (z) != ORDERED)
            libMesh::out << "(" << this->n_nodes(z) << "," << this->n_elem(z) << ") ";
        }
      libMesh::out << std::endl;

      libMesh::out << "Zone Dimensions: " << std::endl;
      for (unsigned int z=0; z<this->n_zones(); z++)
        libMesh::out << "  ("
                     << this->imax(z) << ","
                     << this->jmax(z) << ","
                     << this->kmax(z) << ")"
                     << std::endl;
    }
}

read_point_data()

void libMesh::PltLoader::read_point_data ( std::istream &  in, const unsigned int  zn  )

private

Read data for the zth zone in POINT structured format.

Definition at line 893 of file plt_loader_read.C.

References _data, buf, data, DOUBLE, FLOAT, imax(), is_foreign(), jmax(), kmax(), n_vars(), and var_type().

Referenced by read_data().

{
  libmesh_assert (in.good());

  // A byte-reverser in case the data is foreign
  Utility::ReverseBytes rb(this->is_foreign());

  // First allocate space
  for (unsigned int var=0; var<this->n_vars(); var++)
    {
      std::vector<float> & data = _data[zone][var];

      data.clear();
      data.reserve (this->imax(zone)*
                    this->jmax(zone)*
                    this->kmax(zone));
    }


  for (unsigned int k=0; k<this->kmax(zone); k++)
    for (unsigned int j=0; j<this->jmax(zone); j++)
      for (unsigned int i=0; i<this->imax(zone); i++)
        for (unsigned int var=0; var<this->n_vars(); var++)
          if (this->var_type(var) == FLOAT)
            {
              float f = 0.;

              libmesh_assert (in.good());

              in.read (buf, LIBMESH_SIZEOF_FLOAT);
              std::memcpy  (&f, buf, LIBMESH_SIZEOF_FLOAT);
              rb(f);

              _data[zone][var].push_back(f);
            }
          else if (this->var_type(var) == DOUBLE)
            {
              double d = 0.;

              libmesh_assert (in.good());

              in.read (buf, LIBMESH_SIZEOF_DOUBLE);
              std::memcpy  (&d, buf, LIBMESH_SIZEOF_DOUBLE);
              rb(d);

              _data[zone][var].push_back(float(d));
            }
          else
            libmesh_error_msg("ERROR: unsupported data type: " << this->var_type(var));
}

set_n_vars()

void libMesh::PltLoader::set_n_vars ( const unsigned int  nv )

private

Returns

The number of variables in the data set.

Definition at line 61 of file plt_loader.C.

References _data, _n_vars, _var_names, _var_types, n_vars(), and n_zones().

Referenced by read_header().

{
  _n_vars = nv;

  _var_types.resize (this->n_vars());
  _var_names.resize (this->n_vars());

  // Default to float data
  std::fill (_var_types.begin(), _var_types.end(), 1);

  // If the number of zones is set, resize the data.
  if (this->n_zones())
    {
      _data.resize  (this->n_zones());

      for (unsigned int z=0; z<this->n_zones(); z++)
        _data[z].resize  (this->n_vars());
    }
}

set_n_zones()

void libMesh::PltLoader::set_n_zones ( const unsigned int  nz )

private

Returns

The number of zones.

Definition at line 83 of file plt_loader.C.

References _conn, _data, _imax, _jmax, _kmax, _n_zones, _zone_names, _zone_pack, _zone_types, n_vars(), and n_zones().

Referenced by read_header().

{
  _n_zones = nz;

  _zone_types.resize (this->n_zones());
  _zone_names.resize (this->n_zones());
  _zone_pack.resize  (this->n_zones());

  _imax.resize (this->n_zones());
  _jmax.resize (this->n_zones());
  _kmax.resize (this->n_zones());

  _data.resize (this->n_zones());
  _conn.resize        (this->n_zones());

  // If the number of variables are set, resize the data.
  if (this->n_vars())
    for (unsigned int z=0; z<this->n_zones(); z++)
      _data[z].resize (this->n_vars());
}

title() [1/2]

const std::string& libMesh::PltLoader::title ( ) const

inline

Returns

The data set title

Definition at line 175 of file plt_loader.h.

References _title.

Referenced by read_header(), and write_dat().

{ return _title; }

title() [2/2]

std::string& libMesh::PltLoader::title ( )

inlineprivate

Returns

The data set title

Definition at line 307 of file plt_loader.h.

References _title.

{ return _title; }

var_name() [1/2]

const std::string & libMesh::PltLoader::var_name ( const unsigned int  v ) const

inline

Returns

The name of variable v.

Definition at line 479 of file plt_loader.h.

References _var_names, and n_vars().

Referenced by read_header(), and write_dat().

{
  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];
}

var_name() [2/2]

std::string & libMesh::PltLoader::var_name ( const unsigned int  v )

inlineprivate

Returns

The name of variable v.

Definition at line 491 of file plt_loader.h.

References _var_names, and n_vars().

{
  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];
}

var_type() [1/2]

unsigned int libMesh::PltLoader::var_type ( const unsigned int  v ) const

inline

Returns

The type of variable v

Definition at line 503 of file plt_loader.h.

References _var_types, and n_vars().

Referenced by read_block_data(), read_data(), read_feblock_data(), read_fepoint_data(), read_header(), and read_point_data().

{
  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];
}

var_type() [2/2]

unsigned int & libMesh::PltLoader::var_type ( const unsigned int  v )

inlineprivate

Returns

The type of variable v

Definition at line 515 of file plt_loader.h.

References _var_types, and n_vars().

{
  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];
}

verbose()

bool libMesh::PltLoader::verbose ( ) const

inline

Returns

The verbosity.

Definition at line 70 of file plt_loader.h.

References _verbose.

Referenced by read(), read_data(), and read_header().

{ return _verbose; }

version() [1/2]

const std::string& libMesh::PltLoader::version ( ) const

inline

Returns

The Tecplot version number string. This identifies the version of Tecplot (or preplot) that wrote the binary file. Currently, PltLoader understands versions "#!TDV7X " and "#!TDV1XX"

Definition at line 163 of file plt_loader.h.

References _version.

Referenced by read_data(), and read_header().

{ return _version; }

version() [2/2]

std::string& libMesh::PltLoader::version ( )

inlineprivate

Returns

The Tecplot version number string.

Definition at line 295 of file plt_loader.h.

References _version.

{ return _version; }

write_dat()

void libMesh::PltLoader::write_dat	(	const std::string &	name,
		const unsigned int	version = 10
	)		const

Writes an ASCII Tecplot file. The optional parameter version specifies the version format to write.

Definition at line 451 of file plt_loader_write.C.

References _data, BLOCK, imax(), jmax(), kmax(), n_vars(), n_zones(), libMesh::Quality::name(), POINT, title(), var_name(), zone_name(), and zone_type().

{
  std::ofstream out_stream (name.c_str());

  out_stream << "TITLE=\""
             << this->title()
             << "\""
             << '\n';

  out_stream << "VARIABLES = ";

  for (unsigned int v=0; v<this->n_vars(); v++)
    out_stream << "\"" << this->var_name(v) << "\"\n";

  for (unsigned int z=0; z<this->n_zones(); z++)
    {
      out_stream << "ZONE T=\"" << this->zone_name(z) << "\"\n";
      out_stream << " I="  << this->imax(z)
                 << ", J=" << this->jmax(z)
                 << ", K=" << this->kmax(z);

      // Write BLOCK data for this zone
      if (this->zone_type(z) == BLOCK)
        {
          if (version_in < 10)
            {
              out_stream << ", F=BLOCK\n";
            }
          else
            {
              out_stream << ", ZONETYPE=Ordered\n"
                         << "DATAPACKING=BLOCK\n";
            }

          out_stream << "DT=(";
          for (unsigned int v=0; v<this->n_vars(); v++)
            out_stream << "SINGLE ";
          out_stream << ")\n";

          out_stream.precision(9);

          for (unsigned int v=0; v<this->n_vars(); v++)
            {
              unsigned int l=0;

              for (unsigned int k=0; k<this->kmax(z); k++)
                for (unsigned int j=0; j<this->jmax(z); j++)
                  for (unsigned int i=0; i<this->imax(z); i++)
                    {
                      out_stream << std::scientific
                                 << _data[z][v][l++] << " ";

                      // Throw in a newline every 5 entries to
                      // avoid really long lines.
                      if (l%5 == 0)
                        out_stream << '\n';
                    }

              if (l%5 != 0)
                out_stream << '\n';
            }
        } // end if (this->zone_type(z) == BLOCK)

      // Write POINT data for this zone
      else if (this->zone_type(z) == POINT)
        {
          if (version_in < 10)
            {
              out_stream << ", F=POINT\n";
            }
          else
            {
              out_stream << ", ZONETYPE=Ordered\n"
                         << "DATAPACKING=POINT\n";
            }

          out_stream << "DT=(";
          for (unsigned int v=0; v<this->n_vars(); v++)
            out_stream << "SINGLE ";
          out_stream << ")\n";

          out_stream.precision(9);

          {
            unsigned int l=0;

            for (unsigned int k=0; k<this->kmax(z); k++)
              for (unsigned int j=0; j<this->jmax(z); j++)
                for (unsigned int i=0; i<this->imax(z); i++)
                  {
                    for (unsigned int v=0; v<this->n_vars(); v++)
                      out_stream << std::scientific
                                 << _data[z][v][l] << " ";

                    out_stream << '\n';

                    l++;
                  }
          }
        } // end else if (this->zone_type(z) == POINT)

      // Otherwise, unrecognized zone type
      else
        libmesh_error_msg("Unrecognized zone type: this->zone_type(z)==" << this->zone_type(z));
    }
}

zone_name() [1/2]

const std::string & libMesh::PltLoader::zone_name ( const unsigned int  z ) const

inline

Returns

The name of zone z.

Definition at line 551 of file plt_loader.h.

References _zone_names, and n_zones().

Referenced by read_header(), and write_dat().

{
  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];
}

zone_name() [2/2]

std::string & libMesh::PltLoader::zone_name ( const unsigned int  z )

inlineprivate

Returns

The name of zone z.

Definition at line 563 of file plt_loader.h.

References _zone_names, and n_zones().

{
  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];
}

zone_pack() [1/2]

unsigned int libMesh::PltLoader::zone_pack ( const unsigned int  z ) const

inline

Returns

The data packing flag for zone z.

Definition at line 575 of file plt_loader.h.

References _zone_pack, and n_zones().

Referenced by read_data(), and read_header().

{
  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];
}

zone_pack() [2/2]

unsigned int & libMesh::PltLoader::zone_pack ( const unsigned int  z )

inlineprivate

Returns

The data pack flag for zone z.

Definition at line 587 of file plt_loader.h.

References _zone_pack, and n_zones().

{
  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];
}

zone_type() [1/2]

unsigned int libMesh::PltLoader::zone_type ( const unsigned int  z ) const

inline

Returns

The type of zone z

Definition at line 527 of file plt_loader.h.

References _zone_types, and n_zones().

Referenced by elem_type(), n_elem(), n_nodes(), read_data(), read_header(), and write_dat().

{
  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];
}

zone_type() [2/2]

unsigned int & libMesh::PltLoader::zone_type ( const unsigned int  z )

inlineprivate

Returns

The type of zone z

Definition at line 539 of file plt_loader.h.

References _zone_types, and n_zones().

{
  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];
}

Member Data Documentation

_conn

std::vector<std::vector<int> > libMesh::PltLoader::_conn

private

Vectors to hold the connectivity for each zone (only for unstructured files).

Definition at line 436 of file plt_loader.h.

Referenced by clear(), read_feblock_data(), read_fepoint_data(), and set_n_zones().

_data

std::vector<std::vector<std::vector<float> > > libMesh::PltLoader::_data

private

Vector to hold the data.

Definition at line 430 of file plt_loader.h.

Referenced by clear(), get_data(), read_block_data(), read_feblock_data(), read_fepoint_data(), read_point_data(), set_n_vars(), set_n_zones(), and write_dat().

_imax

std::vector<unsigned int> libMesh::PltLoader::_imax

private

The (imax,jmax,kmax) value for each zone.

Definition at line 423 of file plt_loader.h.

Referenced by clear(), imax(), and set_n_zones().

_is_foreign

bool libMesh::PltLoader::_is_foreign

private

Is the data foreign?

Definition at line 377 of file plt_loader.h.

Referenced by clear(), and is_foreign().

_jmax

std::vector<unsigned int> libMesh::PltLoader::_jmax

private

Definition at line 424 of file plt_loader.h.

Referenced by clear(), jmax(), and set_n_zones().

_kmax

std::vector<unsigned int> libMesh::PltLoader::_kmax

private

Definition at line 425 of file plt_loader.h.

Referenced by clear(), kmax(), and set_n_zones().

_n_vars

unsigned int libMesh::PltLoader::_n_vars

private

The number of variables in the data set.

Definition at line 387 of file plt_loader.h.

Referenced by clear(), n_vars(), and set_n_vars().

_n_zones

unsigned int libMesh::PltLoader::_n_zones

private

The number of zones.

Definition at line 403 of file plt_loader.h.

Referenced by clear(), n_zones(), and set_n_zones().

_title

std::string libMesh::PltLoader::_title

private

The Tecplot data set title.

Definition at line 382 of file plt_loader.h.

Referenced by clear(), and title().

_var_names

std::vector<std::string> libMesh::PltLoader::_var_names

private

The name for each variable.

Definition at line 392 of file plt_loader.h.

Referenced by clear(), set_n_vars(), and var_name().

_var_types

std::vector<unsigned int> libMesh::PltLoader::_var_types

private

The type of each variable. Must be one of the enumerated DataType types.

Definition at line 398 of file plt_loader.h.

Referenced by clear(), set_n_vars(), and var_type().

_verbose

const bool libMesh::PltLoader::_verbose

private

Verbosity

Definition at line 367 of file plt_loader.h.

Referenced by verbose().

_version

std::string libMesh::PltLoader::_version

private

The Tecplot Version number string.

Definition at line 372 of file plt_loader.h.

Referenced by clear(), and version().

_zone_names

std::vector<std::string> libMesh::PltLoader::_zone_names

private

The name of each zone.

Definition at line 413 of file plt_loader.h.

Referenced by clear(), set_n_zones(), and zone_name().

_zone_pack

std::vector<unsigned int> libMesh::PltLoader::_zone_pack

private

The data packing for each zone (new version only)

Definition at line 418 of file plt_loader.h.

Referenced by clear(), set_n_zones(), and zone_pack().

_zone_types

std::vector<unsigned int> libMesh::PltLoader::_zone_types

private

The type of each zone.

Definition at line 408 of file plt_loader.h.

Referenced by clear(), set_n_zones(), and zone_type().

buf

char libMesh::PltLoader::buf[512]

mutableprivate

Scratch data & relevant sizes.

Definition at line 441 of file plt_loader.h.

Referenced by read_data(), read_fepoint_data(), read_header(), and read_point_data().

NNodes

const unsigned int libMesh::PltLoader::NNodes = {3, 4, 4, 8}

static

Enum defining the number of nodes for each element type.

Definition at line 250 of file plt_loader.h.

Referenced by read_feblock_data(), and read_fepoint_data().

---

The documentation for this class was generated from the following files:

• plt_loader.h
• plt_loader.C
• plt_loader_read.C
• plt_loader_write.C