$extrastylesheet
Public Types | Public Member Functions | Protected Attributes | Private Attributes
libMesh::XdrSOLN Class Reference

#include <xdr_soln.h>

Inheritance diagram for libMesh::XdrSOLN:
Inheritance graph
[legend]

List of all members.

Public Types

enum  XdrIO_TYPE {
  UNKNOWN = -1, ENCODE = 0, DECODE, W_ASCII,
  R_ASCII
}

Public Member Functions

 XdrSOLN ()
void init (XdrIO_TYPE type, const char *fn, int icnt)
 ~XdrSOLN ()
int header (XdrSHEAD *hd)
int values (Real *array, int size)
void init (XdrIO_TYPE t, const char *fn, const char *type, int icnt)
void fini ()
int dataBlk (int *array, int numvar, int size)
int dataBlk (Real *array, int numvar, int size)
LegacyXdrIO::FileFormat get_orig_flag () const
void set_orig_flag (LegacyXdrIO::FileFormat in_orig_flag)
void set_num_levels (unsigned int num_levels)
unsigned int get_num_levels ()

Protected Attributes

unsigned int _num_levels
XdrIO_TYPE m_type
XDR * mp_xdr_handle
LegacyXdrIO::FileFormat orig_flag
std::ifstream mp_in
std::ofstream mp_out

Private Attributes

int m_wrtVar

Detailed Description

The XdrSOLN class. This class is responsible for reading/writing information about the solution to xdr style binary files.

Author:
Bill Barth, Robert McLay.

Definition at line 41 of file xdr_soln.h.

Member Enumeration Documentation

enum libMesh::XdrMGF::XdrIO_TYPE [inherited]

This enum specifies the access permission which will be acquired for the current xdr file. Note that it is only possible to read (DECODE) or write (ENCODE) but not both. For ASCII type files, use WRITE or READ instead!

Enumerator:
UNKNOWN 
ENCODE 
DECODE 
W_ASCII 
R_ASCII 

Definition at line 98 of file xdr_mgf.h.

                  {UNKNOWN = -1, ENCODE=0, DECODE,
                   W_ASCII , R_ASCII};

Constructor & Destructor Documentation

libMesh::XdrSOLN::XdrSOLN ( ) [inline]

Constructor. Initializes m_wrtVar to -1.

Definition at line 48 of file xdr_soln.h.

: m_wrtVar(-1) {}
libMesh::XdrSOLN::~XdrSOLN ( ) [inline]

Destructor.

Definition at line 65 of file xdr_soln.h.

{}

Member Function Documentation

int libMesh::XdrMGF::dataBlk ( int *  array,
int  numvar,
int  size 
) [inherited]

Reads/Writes a block of ints to/from the current xdr file/file handle.

Parameters:
arrayPointer to data to be read/written
numvarThe total number of variables (size of the array)
sizeThe size of each individual variable in the array

Definition at line 264 of file xdr_mgf.C.

References libMesh::XdrMGF::DECODE, libMesh::XdrMGF::ENCODE, libMesh::libmesh_assert(), libMesh::XdrMGF::m_type, libMesh::XdrMGF::mp_in, libMesh::XdrMGF::mp_out, libMesh::XdrMGF::mp_xdr_handle, libMesh::XdrMGF::R_ASCII, and libMesh::XdrMGF::W_ASCII.

Referenced by libMesh::XdrMESH::BC(), libMesh::XdrMESH::coord(), libMesh::XdrMESH::Icon(), and values().

{
  int totalSize = numvar*size;

  switch (m_type)
    {

#ifdef LIBMESH_HAVE_XDR

    case (XdrMGF::DECODE):
    case (XdrMGF::ENCODE):
      {
        xdr_vector(mp_xdr_handle,
                   (char *) &array[0],
                   totalSize,
                   sizeof(int),
                   (xdrproc_t) xdr_int);
        break;
      }

#endif

    case (XdrMGF::W_ASCII):
      {
        for (int i=0; i<size; i++)
          {
            for (int j=0; j<numvar; j++)
              mp_out << array[i*numvar + j] << " ";

            mp_out << '\n';
          }

        mp_out.flush();
        break;
      }

    case (XdrMGF::R_ASCII):
      {
        libmesh_assert (mp_in.good());

        for (int i=0; i<size; i++)
          {
            for (int j=0; j<numvar; j++)
              {
                mp_in >> array[i*numvar + j];
              }

            mp_in.ignore(); // Read newline
          }

        break;
      }

    default:
      // Unknown access type
      libmesh_error_msg("Unknown m_type" << m_type);
    }

  return totalSize;
}
int libMesh::XdrMGF::dataBlk ( Real *  array,
int  numvar,
int  size 
) [inherited]

Read/Writes a block of Reals to/from the current xdr file/file handle.

Definition at line 327 of file xdr_mgf.C.

References libMesh::XdrMGF::DECODE, libMesh::XdrMGF::ENCODE, libMesh::libmesh_assert(), libMesh::XdrMGF::m_type, libMesh::XdrMGF::mp_in, libMesh::XdrMGF::mp_out, libMesh::XdrMGF::mp_xdr_handle, libMesh::XdrMGF::R_ASCII, libMesh::Real, and libMesh::XdrMGF::W_ASCII.

{
  int totalSize = numvar*size;

  // If this function is called by coord(),
  // numvar is the problem dimension, and
  // size is the number of nodes in the problem.

  //libMesh::out << "Total amount of data to be written: " << totalSize << std::endl;

  switch (m_type)
    {

#ifdef LIBMESH_HAVE_XDR

    case (XdrMGF::DECODE):
    case (XdrMGF::ENCODE):
      {
        // FIXME - this is probably broken for Real == long double
        // RHS
        xdr_vector(mp_xdr_handle,
                   (char *) &array[0],
                   totalSize,
                   sizeof(Real),
                   (xdrproc_t) xdr_REAL);
      }

#endif

    case (XdrMGF::W_ASCII):
      {
        // Save stream flags
        std::ios_base::fmtflags out_flags = mp_out.flags();

        // We will use scientific notation with a precision of 16
        // digits in the following output.  The desired precision and
        // format will automatically determine the width.
        mp_out << std::scientific
               << std::setprecision(16);

        for (int i=0; i<size; i++)
          {
            for (int j=0; j<numvar; j++)
              mp_out << array[i*numvar + j] << " \t";

            mp_out << '\n';
          }

        // Restore stream flags
        mp_out.flags(out_flags);

        mp_out.flush();
        break;
      }

    case (XdrMGF::R_ASCII):
      {
        libmesh_assert (mp_in.good());

        for (int i=0; i<size; i++)
          {
            libmesh_assert (mp_in.good());

            for (int j=0; j<numvar; j++)
              mp_in >> array[i*numvar + j];

            mp_in.ignore(); // Read newline
          }

        break;
      }

    default:
      // Unknown access type
      libmesh_error_msg("Unknown m_type" << m_type);
    }

  return totalSize;
}
void libMesh::XdrMGF::fini ( ) [inherited]

Finalizes operations on the current xdr file handle, and closes the xdr file.

Uses xdr_destroy found in rpc/rpc.h.

Definition at line 35 of file xdr_mgf.C.

References libMesh::XdrMGF::mp_fp, and libMesh::XdrMGF::mp_xdr_handle.

Referenced by libMesh::XdrMGF::init(), and libMesh::XdrMGF::~XdrMGF().

{

#ifdef LIBMESH_HAVE_XDR

  if (mp_xdr_handle)
    {
      //libMesh::out << "Destroying XDR file handle." << std::endl;
      xdr_destroy(mp_xdr_handle);
    }

  //libMesh::out << "Deleting the file handle pointer." << std::endl;
  delete mp_xdr_handle;

  mp_xdr_handle = NULL;

#endif

  if (mp_fp)
    {
      //libMesh::out << "Closing file." << std::endl;
      std::fflush(mp_fp);
      std::fclose(mp_fp);
    }

  mp_fp = NULL;
}
unsigned int libMesh::XdrMGF::get_num_levels ( ) [inline, inherited]

Get number of levels

Definition at line 190 of file xdr_mgf.h.

References libMesh::XdrMGF::_num_levels.

Referenced by libMesh::XdrMESH::header(), libMesh::XdrMGF::init(), and libMesh::LegacyXdrIO::read_mesh().

{ return _num_levels; }
LegacyXdrIO::FileFormat libMesh::XdrMGF::get_orig_flag ( ) const [inline, inherited]

Get the originator flag.

Definition at line 174 of file xdr_mgf.h.

References libMesh::XdrMGF::orig_flag.

Referenced by libMesh::XdrMGF::init(), libMesh::LegacyXdrIO::read_mesh(), and libMesh::LegacyXdrIO::write_mesh().

{ return orig_flag; }
int libMesh::XdrSOLN::header ( XdrSHEAD *  hd)

Read/Write the solution header. Uses xdr_int found in rpc/rpc.h.

Parameters:
hdPointer to an xdr solution header object
Returns:
1 on success

Definition at line 32 of file xdr_soln.C.

References libMesh::XdrMGF::DECODE, libMesh::XdrMGF::ENCODE, libMesh::XdrHEAD::getId(), libMesh::XdrHEAD::getTitle(), libMesh::XdrSHEAD::getUserTitle(), libMesh::XdrSHEAD::getVarTitle(), libMesh::libmesh_assert(), libMesh::XdrHEAD::m_kstep, libMesh::XdrHEAD::m_meshCnt, libMesh::XdrHEAD::m_numNodes, libMesh::XdrHEAD::m_numvar, libMesh::XdrHEAD::m_strSize, libMesh::XdrHEAD::m_time, libMesh::XdrMGF::m_type, m_wrtVar, libMesh::XdrHEAD::m_wrtVar, libMesh::XdrHEAD::mp_id, libMesh::XdrMGF::mp_in, libMesh::XdrMGF::mp_out, libMesh::XdrHEAD::mp_title, libMesh::XdrHEAD::mp_userTitle, libMesh::XdrHEAD::mp_varTitle, libMesh::XdrMGF::mp_xdr_handle, libMesh::XdrMGF::R_ASCII, libMesh::XdrHEAD::setId(), libMesh::XdrHEAD::setTitle(), libMesh::XdrSHEAD::setUserTitle(), libMesh::XdrSHEAD::setVarTitle(), and libMesh::XdrMGF::W_ASCII.

Referenced by libMesh::LegacyXdrIO::read_soln(), and libMesh::LegacyXdrIO::write_soln().

{

  switch (m_type)
    {

#ifdef LIBMESH_HAVE_XDR

    case (XdrMGF::ENCODE):
    case (XdrMGF::DECODE):
      {

        xdr_int(mp_xdr_handle,  &(hd->m_wrtVar));
        xdr_int(mp_xdr_handle,  &(hd->m_numvar));
        xdr_int(mp_xdr_handle,  &(hd->m_numNodes));
        xdr_int(mp_xdr_handle,  &(hd->m_meshCnt));
        xdr_int(mp_xdr_handle,  &(hd->m_kstep));
        xdr_int(mp_xdr_handle,  &(hd->m_strSize));
        xdr_REAL(mp_xdr_handle, &(hd->m_time));

        m_wrtVar=hd->m_wrtVar;

        char* temp = const_cast<char *>(hd->getId());
        xdr_string(mp_xdr_handle,&(temp),
                   ((m_type == XdrMGF::ENCODE) ? std::strlen(temp)    : hd->m_strSize));
        hd->setId(temp);

        temp = const_cast<char *>(hd->getTitle());
        xdr_string(mp_xdr_handle,&(temp),
                   ((m_type == XdrMGF::ENCODE) ? std::strlen(temp) : hd->m_strSize));
        hd->setTitle(temp);

        temp = const_cast<char *>(hd->getUserTitle());
        xdr_string(mp_xdr_handle,&(temp),
                   ((m_type == XdrMGF::ENCODE) ? std::strlen(temp) : hd->m_strSize));
        hd->setUserTitle(temp);


        char * tempTitle = new char[hd->m_strSize*m_wrtVar];


        if (m_type == XdrMGF::DECODE)
          {
            xdr_string(mp_xdr_handle, &tempTitle, hd->m_strSize*m_wrtVar);
            std::size_t olen= std::strlen(tempTitle);
            char *top = tempTitle;
            for (int ivar = 0; ivar < m_wrtVar; ++ivar)
              {
                char *p = strchr(tempTitle,' ');
                *p = '\0';
                std::size_t tempSize = std::strlen(tempTitle) ;
                tempTitle+=tempSize+1;
              }
            tempTitle = top;
            hd->mp_varTitle = new char[olen];
            std::memcpy(hd->mp_varTitle,tempTitle,olen*sizeof(char));
          }
        else if (m_type == XdrMGF::ENCODE)
          {
            char *p = hd->mp_varTitle;
            char *top = tempTitle;
            for (int ivar = 0; ivar < m_wrtVar; ++ivar)
              {
                std::size_t tempSize = std::strlen(p) + 1;
                std::memcpy(tempTitle,p,tempSize*sizeof(char));
                tempSize = std::strlen(tempTitle);
                tempTitle[tempSize] = ' ';
                tempTitle += tempSize+1;
                p += tempSize+1;
              }
            tempTitle = top;
            xdr_string(mp_xdr_handle, &tempTitle, hd->m_strSize*m_wrtVar);
          }
        delete [] tempTitle;

        return 0;
      }
#endif


    case (XdrMGF::R_ASCII):
      {
        // Temporary variables to facilitate stream reading
        const int comm_len= 80;
        char comment[comm_len];

        libmesh_assert (mp_in.good());

        mp_in >> hd->m_numNodes ; mp_in.getline(comment, comm_len);
        mp_in >> hd->m_wrtVar   ; mp_in.getline(comment, comm_len);
        mp_in >> hd->m_strSize  ; mp_in.getline(comment, comm_len);
        mp_in >> hd->m_time     ; mp_in.getline(comment, comm_len);

        mp_in.getline(comment, comm_len);
        hd->setId(comment);

        mp_in.getline(comment, comm_len);
        hd->setTitle(comment);

        mp_in.getline(comment, comm_len);
        hd->setUserTitle(comment);

        m_wrtVar = hd->m_wrtVar;

        // Read the variable names
        {
          std::string var_name;
          char* titles = new char[hd->m_wrtVar*hd->m_strSize];
          unsigned int c=0;

          for (int var=0; var < hd->m_wrtVar; var++)
            {
              mp_in >> var_name;

              for (unsigned int l=0; l<var_name.size(); l++)
                titles[c++] = var_name[l];

              titles[c++] = '\0';
            }

          mp_in.getline(comment, comm_len);

          hd->setVarTitle(titles, c);

          delete [] titles;
        }


        return 0;
      }


    case (XdrMGF::W_ASCII):
      {
        mp_out << hd->m_numNodes   << "\t # Num. Nodes\n";
        mp_out << hd->m_wrtVar     << "\t # Num. of Vars\n";
        mp_out << hd->m_strSize    << "\t # String Size (ignore)\n";
        mp_out << hd->m_time       << "\t # Current Time\n";
        mp_out << hd->mp_id        << '\n';
        mp_out << hd->mp_title     << '\n';
        mp_out << hd->mp_userTitle << '\n';

        // write the variable names
        {
          const char* p = hd->getVarTitle();

          for (int var=0; var<hd->m_wrtVar ; var++)
            {
              mp_out << p << " ";
              p += std::strlen(p)+1;
            }
          mp_out << "\t # Variable Names\n";
        }

        m_wrtVar = hd->m_wrtVar;

        return 0;
      }



    default:
      // Unknown access type
      libmesh_error_msg("Unknown m_type" << m_type);
    }

  return 1;
}
void libMesh::XdrSOLN::init ( XdrIO_TYPE  type,
const char *  fn,
int  icnt 
) [inline]

Calls the init method in the parent class, XdrMGF with the appropriate parameters.

Parameters:
typeOne of: UNKNOWN, ENCODE, DECODE
fnconst char pointer to a file name
icntNumber to be appended to file e.g. name.soln.0000

Definition at line 59 of file xdr_soln.h.

Referenced by libMesh::LegacyXdrIO::read_soln(), and libMesh::LegacyXdrIO::write_soln().

  {XdrMGF::init (type, fn, "soln",icnt);}
void libMesh::XdrMGF::init ( XdrMGF::XdrIO_TYPE  t,
const char *  fn,
const char *  type,
int  icnt 
) [inherited]

Initialization of the xdr file. This function performs the following operations: {itemize} Closes the old xdr file if necessary.

Creates a new xdr file name and opens this file.

Opens the appropriate xdr file handle.

Reads/Writes a signature to the file.

{itemize}

Definition at line 68 of file xdr_mgf.C.

References libMesh::LegacyXdrIO::DEAL, libMesh::XdrMGF::DECODE, libMesh::XdrMGF::ENCODE, libMesh::XdrMGF::fini(), libMesh::XdrMGF::get_num_levels(), libMesh::XdrMGF::get_orig_flag(), libMesh::LegacyXdrIO::LIBM, libMesh::XdrMGF::m_type, libMesh::LegacyXdrIO::MGF, libMesh::XdrMGF::mp_fp, libMesh::XdrMGF::mp_in, libMesh::XdrMGF::mp_out, libMesh::XdrMGF::mp_xdr_handle, libMesh::Quality::name(), libMesh::XdrMGF::orig_flag, libMesh::out, libMesh::XdrMGF::R_ASCII, libMesh::XdrMGF::tokenize_first_line(), and libMesh::XdrMGF::W_ASCII.

{
  m_type=t;

  // Close old file if necessary
  if (mp_fp) this->fini();


  // Open file
  switch (m_type)
    {

#ifdef LIBMESH_HAVE_XDR

    case (XdrMGF::ENCODE):
    case (XdrMGF::DECODE):
      {
        mp_fp = fopen (fn, (m_type == ENCODE) ? "w" : "r");

        // Make sure the file is ready for use
        if (!mp_fp)
          libmesh_error_msg("XDR Error: Accessing file: " << fn << " failed.");

        // Create the XDR handle
        mp_xdr_handle = new XDR;
        xdrstdio_create(mp_xdr_handle,
                        mp_fp,
                        ((m_type == ENCODE) ? XDR_ENCODE : XDR_DECODE));

        break;
      }

#endif

    case (XdrMGF::R_ASCII):
      {
        mp_in.open(fn, std::ios::in);

        // Make sure it opened correctly
        if (!mp_in.good())
          libmesh_file_error(fn);

        break;
      }

    case (XdrMGF::W_ASCII):
      {
        mp_out.open(fn, std::ios::out);

        // Make sure it opened correctly
        if (!mp_out.good())
          libmesh_file_error(fn);

        break;
      }

    default:
      libmesh_error_msg("Unrecognized file access type!");
    }





  // Read/Write the file signature
  const int  bufLen = 12;
  char       buf[bufLen+1];

  switch (m_type)
    {

#ifdef LIBMESH_HAVE_XDR

    case (XdrMGF::ENCODE):
      {
        char* p = &buf[0];
        const LegacyXdrIO::FileFormat orig = this->get_orig_flag();

        std::ostringstream name;
        if (orig == LegacyXdrIO::DEAL)
          name << "DEAL 003:003";

        else if (orig == LegacyXdrIO::MGF)
          name << "MGF  002:000";

        else if (orig == LegacyXdrIO::LIBM)
          name << "LIBM " << this->get_num_levels();

        else
          libmesh_error_msg("Unknown orig " << orig);

        // Fill the buffer
        std::sprintf(&buf[0], "%s", name.str().c_str());

        xdr_string(mp_xdr_handle, &p, bufLen);  // Writes binary signature

        break;
      }

    case (XdrMGF::DECODE):
      {
        char* p = &buf[0];
        xdr_string(mp_xdr_handle, &p, bufLen); // Reads binary signature

        // Set the number of levels used in the mesh
        this->tokenize_first_line(p);

        break;
      }

#endif

    case (XdrMGF::W_ASCII):
      {
        const LegacyXdrIO::FileFormat orig = this->get_orig_flag();

        if (orig == LegacyXdrIO::DEAL)
          std::sprintf(&buf[0], "%s %03d:%03d", "DEAL", 3, 3);

        else if (orig == LegacyXdrIO::MGF)
          std::sprintf(&buf[0], "%s %03d:%03d", "MGF ", 2, 0);

        else if (orig == LegacyXdrIO::LIBM)
          std::sprintf(&buf[0], "%s %d", "LIBM", this->get_num_levels());

        mp_out << buf << '\n';

        break;
      }

    case (XdrMGF::R_ASCII):
      {

#ifdef __HP_aCC
        // weirdly, _only_ here aCC
        // is not fond of mp_in.getline()
        // however, using mp_in.getline()
        // further below is ok...
        std::string buf_buf;
        std::getline (mp_in, buf_buf, '\n');
        libmesh_assert_less_equal (buf_buf.size(), bufLen);

        buf_buf.copy (buf, std::string::npos);
#else

        // Here we first use getline() to grab the very
        // first line of the file into a char buffer.  Then
        // this line is tokenized to look for:
        // 1.) The name LIBM, which specifies the new Mesh style.
        // 2.) The number of levels in the Mesh which is being read.
        // Note that "buf" will be further processed below, here we
        // are just attempting to get the number of levels.
        mp_in.getline(buf, bufLen+1);

#endif

        // Determine the number of levels in this mesh
        this->tokenize_first_line(buf);

        break;
      }

    default:
      libmesh_error_msg("Unknown m_type" << m_type);
    }



  // If you are reading or decoding, process the signature
  if ((m_type == R_ASCII) || (m_type == DECODE))
    {
      char name[5];
      std::strncpy(name, &buf[0], 4);
      name[4] = '\0';

      if (std::strcmp (name, "DEAL") == 0)
        {
          this->orig_flag = LegacyXdrIO::DEAL; // 0 is the DEAL identifier by definition
        }
      else if (std::strcmp (name, "MGF ") == 0)
        {
          this->orig_flag = LegacyXdrIO::MGF; // 1 is the MGF identifier by definition
        }
      else if (std::strcmp (name, "LIBM") == 0)
        {
          this->orig_flag = LegacyXdrIO::LIBM; // the New and Improved XDA
        }

      else
        libmesh_error_msg("ERROR: No originating software can be determined for header string '" << name);
    }

}
void libMesh::XdrMGF::set_num_levels ( unsigned int  num_levels) [inline, inherited]

Set number of levels

Definition at line 185 of file xdr_mgf.h.

References libMesh::XdrMGF::_num_levels.

Referenced by libMesh::LegacyXdrIO::write_mesh().

{ _num_levels = num_levels; }
void libMesh::XdrMGF::set_orig_flag ( LegacyXdrIO::FileFormat  in_orig_flag) [inline, inherited]

Set the originator flag.

Definition at line 179 of file xdr_mgf.h.

References libMesh::XdrMGF::orig_flag.

Referenced by libMesh::LegacyXdrIO::read_mesh(), and libMesh::LegacyXdrIO::write_mesh().

{ orig_flag = in_orig_flag; }
int libMesh::XdrSOLN::values ( Real *  array,
int  size 
) [inline]

Read/Write solution values.

Parameters:
arrayPointer to array of Reals to be read/written
sizeSize of individual variables to be written
Returns:
m_wrtVar*size

Definition at line 84 of file xdr_soln.h.

References libMesh::XdrMGF::dataBlk(), and m_wrtVar.

Referenced by libMesh::LegacyXdrIO::read_soln(), and libMesh::LegacyXdrIO::write_soln().

{ return dataBlk(array, m_wrtVar, size);}

Member Data Documentation

unsigned int libMesh::XdrMGF::_num_levels [protected, inherited]

Number of levels of refinement in the mesh

Definition at line 197 of file xdr_mgf.h.

Referenced by libMesh::XdrMGF::get_num_levels(), libMesh::XdrMGF::set_num_levels(), and libMesh::XdrMGF::tokenize_first_line().

XdrIO_TYPE libMesh::XdrMGF::m_type [protected, inherited]

Specifies the read/write permission for the current xdr file. Possibilities are: {itemize} UNKNOWN = -1 ENCODE = 0 DECODE = 1 {itemize}

Definition at line 210 of file xdr_mgf.h.

Referenced by libMesh::XdrMGF::dataBlk(), header(), libMesh::XdrMESH::header(), and libMesh::XdrMGF::init().

int libMesh::XdrSOLN::m_wrtVar [private]

Definition at line 87 of file xdr_soln.h.

Referenced by header(), and values().

std::ifstream libMesh::XdrMGF::mp_in [protected, inherited]

An input file stream object

Definition at line 244 of file xdr_mgf.h.

Referenced by libMesh::XdrMGF::dataBlk(), header(), libMesh::XdrMESH::header(), and libMesh::XdrMGF::init().

std::ofstream libMesh::XdrMGF::mp_out [protected, inherited]

An output file stream object.

Definition at line 249 of file xdr_mgf.h.

Referenced by libMesh::XdrMGF::dataBlk(), header(), libMesh::XdrMESH::header(), and libMesh::XdrMGF::init().

XDR* libMesh::XdrMGF::mp_xdr_handle [protected, inherited]

Pointer to the standard {xdr} struct. See the standard header file rpc/rpc.h for more information.

Definition at line 220 of file xdr_mgf.h.

Referenced by libMesh::XdrMGF::dataBlk(), libMesh::XdrMGF::fini(), header(), libMesh::XdrMESH::header(), and libMesh::XdrMGF::init().

LegacyXdrIO::FileFormat libMesh::XdrMGF::orig_flag [protected, inherited]

Flag indicating how much checking we need to do. We can read in mgf meshes more quickly because there is only one type of element in these meshes. Deal meshes on the other hand will require a check for each element to find out what type it is. Possible values are: {itemize} 0: It's an DEAL style mesh 1: It's a MGF style mesh {itemize}

Definition at line 239 of file xdr_mgf.h.

Referenced by libMesh::XdrMGF::get_orig_flag(), libMesh::XdrMESH::header(), libMesh::XdrMGF::init(), and libMesh::XdrMGF::set_orig_flag().

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