Home
Publications
Presentations
Support
Download
Examples
Developers
Class Docs
Namespaces
Classes
Files
Mailing Lists
Gallery
Wiki

mesh_data_xdr_support.C

Go to the documentation of this file.

// The libMesh Finite Element Library.
// Copyright (C) 2002-2012 Benjamin S. Kirk, John W. Peterson, Roy H. Stogner

// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.

// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA



// C++ includes
#include <fstream>

// Local includes
#include "libmesh/mesh_data.h"
#include "libmesh/mesh_base.h"
#include "libmesh/xdr_cxx.h"
#include "libmesh/elem.h"

namespace libMesh
{


//------------------------------------------------------
// MeshData functions
void MeshData::read_xdr (const std::string& name,
                         const XdrMODE mode)
{
  // we should better be active or in compatibility mode
  libmesh_assert (_active || _compatibility_mode);


  // make sure the id maps are ready
  libmesh_assert (_node_id_map_closed);
  libmesh_assert (_elem_id_map_closed);


  this->clear();


  Xdr io(name, mode);


  /*
   * all processors read the data in the same format,
   * but only the processor that owns the element stores
   * element-associated data.  For nodes, i haven't come
   * up with such asmart idea, yet... :-P
   */
  const unsigned int proc_id = _mesh.processor_id();



  {
    std::string desc = "";
    io.data (desc);
    this->_data_descriptor = desc;
  }



  {
    std::string vtype="";
    io.data (vtype);
#ifdef LIBMESH_USE_COMPLEX_NUMBERS
    if (vtype != "COMPLEX")
      {
        libMesh::err << "ERROR: File does not contain complex-valued data!"
                      << std::endl;
        libmesh_error();
      }
#elif LIBMESH_USE_REAL_NUMBERS
    if (vtype != "REAL")
      {
        libMesh::err << "ERROR: File does not contain real-valued data!"
                      << std::endl;
        libmesh_error();
      }
#else
    /*
     * What number type is this?
     */
    libmesh_error();
#endif
  }



  unsigned int n_node = 0;
  io.data (n_node);


  unsigned int n_elem = 0;
  io.data (n_elem);

#ifdef DEBUG
  unsigned int previous_values_size = 0;
#endif

  for (unsigned int n_cnt=0; n_cnt < n_node; n_cnt++)
    {
      unsigned int f_id = 0;
      io.data (f_id);

      const Node* node = foreign_id_to_node(f_id);


      {
        std::vector<Number> values;
        io.data (values);


#ifdef DEBUG
        /*
         * make sure the size of the values vectors
         * are identical for all nodes
         */
        if (n_cnt == 0)
            previous_values_size = values.size();
        else
          {
            if (previous_values_size != values.size())
              {
                libMesh::err << "ERROR: Size mismatch for n_cnt = " << n_cnt << std::endl;
                libmesh_error();
              }
          }
#endif


        _node_data.insert (std::make_pair(node, values));
      }
    }



#ifdef DEBUG
  previous_values_size = 0;
#endif

  for (unsigned int n_cnt=0; n_cnt < n_elem; n_cnt++)
    {
      unsigned int f_id = 0;
      io.data (f_id);

      const Elem* elem = foreign_id_to_elem(f_id);


      {
        std::vector<Number> values;
        io.data (values);


#ifdef DEBUG
        /*
         * make sure the size of the values vectors
         * are identical for all elements
         */
        if (n_cnt == 0)
            previous_values_size = values.size();
        else
          {
            if (previous_values_size != values.size())
              {
                libMesh::err << "ERROR: Size mismatch for n_cnt = " << n_cnt << std::endl;
                libmesh_error();
              }
          }
#endif


        if (elem->processor_id() == proc_id)
          _elem_data.insert (std::make_pair(elem, values));
      }
    }


  /*
   * finished reading.  Now ready for use, provided
   * there was any data contained in the file.
   */
  libmesh_assert ((this->_node_data.size() != 0) || (this->_elem_data.size() != 0));

  this->_node_data_closed = true;
  this->_elem_data_closed = true;
}






void MeshData::write_xdr (const std::string& name,
                          const XdrMODE mode)
{
  /*
   * make sure the id maps are ready
   * and that we have data to write
   */
  libmesh_assert (_node_id_map_closed);
  libmesh_assert (_elem_id_map_closed);

  libmesh_assert (_node_data_closed);
  libmesh_assert (_elem_data_closed);


  Xdr io(name, mode);


  // all processors write the data in the same format
  //const unsigned int proc_id = _mesh.processor_id();

  {
    std::string desc = this->_data_descriptor;
    io.data (desc, "# Data description");
  }



  {
#ifdef LIBMESH_USE_COMPLEX_NUMBERS
    std::string desc = "COMPLEX";
#elif LIBMESH_USE_REAL_NUMBERS
    std::string desc = "REAL";
#else
better_you_choke_this...
#endif
    io.data (desc, "# type of values");
  }



  {
    unsigned int n_node = this->_node_data.size();
    io.data (n_node, "# No. of nodes for which data is stored");
  }


  {
    unsigned int n_elem = this->_elem_data.size();
    io.data (n_elem, "# No. of elements for which data is stored");
  }




  std::map<const Node*,
           std::vector<Number> >::const_iterator nit = _node_data.begin ();

  for (; nit != _node_data.end(); ++nit)
    {
      const Node* node = (*nit).first;

      {
        unsigned int f_id = node_to_foreign_id (node);
        io.data (f_id, "# Foreign node id");
      }


      {
        /*
         * since we are iterating over our @e own
         * map, this libmesh_assert should never break...
         */
        libmesh_assert (this->has_data(node));

        const std::vector<Number>& values = this->get_data(node);

        /*
         * copy the data to a local buf, since
         * the Xdr class needs write access, even
         * when only reading data
         */
        std::vector<Number> buf = values;
        io.data (buf, "# Values");
      }
    }







  std::map<const Elem*,
           std::vector<Number> >::const_iterator eit = _elem_data.begin ();

  for (; eit != _elem_data.end(); ++eit)
    {
      const Elem* elem = (*eit).first;

      {
        unsigned int f_id = elem_to_foreign_id (elem);
        io.data (f_id, "# Foreign element id");
      }


      {
        /*
         * since we are iterating over our @e own
         * map, this libmesh_assert should never break...
         */
        libmesh_assert (this->has_data(elem));

        const std::vector<Number>& values = this->get_data(elem);

        /*
         * copy the data to a local buf, since
         * the Xdr class needs write access, even
         * when only reading data
         */
        std::vector<Number> buf = values;
        io.data (buf, "# Values");
      }
    }
}

} // namespace libMesh

---

Site Created By: libMesh Developers
Last modified: February 05 2013 19:54:47 UTC

Hosted By: