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

unv_io.h

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



#ifndef LIBMESH_UNV_IO_H
#define LIBMESH_UNV_IO_H


// Local includes
#include "libmesh/mesh_input.h"
#include "libmesh/mesh_output.h"

// C++ inludes
#include <cstddef>
#include <map>
#include <string>
#include <vector>

namespace libMesh
{

// Forward declarations
class MeshBase;
class MeshData;

// ------------------------------------------------------------
// UNVIO class definition
class UNVIO : public MeshInput<MeshBase>,
              public MeshOutput<MeshBase>
{

 public:

  UNVIO (MeshBase& mesh, MeshData& mesh_data);

  UNVIO (const MeshBase& mesh, MeshData& mesh_data);

  virtual ~UNVIO ();

  virtual void read (const std::string& );

  virtual void write (const std::string& );

  bool & verbose ();


 private:


  void read_implementation (std::istream& in_stream);

  void write_implementation (std::ostream& out_stream);

  void clear();


  //-------------------------------------------------------------
  // read support methods
  void count_nodes (std::istream& in_file);

  void node_in (std::istream& in_file);

  void count_elements (std::istream& in_file);

  void element_in (std::istream& in_file);

  bool beginning_of_dataset (std::istream& in_file,
                             const std::string& ds_name) const;

  Real D_to_e (std::string& number) const;


  //-------------------------------------------------------------
  // write support methods
  void node_out (std::ostream& out_file);

  void element_out (std::ostream& out_file);


  //-------------------------------------------------------------
  // local data

  bool _verbose;

  std::vector<dof_id_type> _assign_nodes;

  std::map<std::string,std::streampos> _ds_position;

  dof_id_type _n_nodes;

  dof_id_type _n_elements;

  static const std::string _label_dataset_nodes;

  static const std::string _label_dataset_elements;

  bool _need_D_to_e;

  MeshData& _mesh_data;

};



// ------------------------------------------------------------
// MeshIO inline members
inline
UNVIO::UNVIO (MeshBase& mesh, MeshData& mesh_data) :
  MeshInput<MeshBase> (mesh),
  MeshOutput<MeshBase>(mesh),
  _verbose (false),
  _mesh_data (mesh_data)
{
}



inline
UNVIO::UNVIO (const MeshBase& mesh, MeshData& mesh_data) :
  MeshOutput<MeshBase> (mesh),
  _verbose (false),
  _mesh_data (mesh_data)
{
}



inline
UNVIO::~UNVIO ()
{
  this->clear ();
}



inline
bool & UNVIO::verbose ()
{
  return _verbose;
}



inline
bool UNVIO::beginning_of_dataset (std::istream& in_file,
                                  const std::string& ds_name) const
{
  libmesh_assert (in_file.good());
  libmesh_assert (!ds_name.empty());

  std::string olds, news;

  while (true)
    {
      in_file >> olds >> news;

      /*
       * a "-1" followed by a number means the beginning of a dataset
       * stop combing at the end of the file
       */
      while( ((olds != "-1") || (news == "-1") ) && !in_file.eof() )
        {
          olds = news;
          in_file >> news;
        }

      if (in_file.eof())
        return false;

      if (news == ds_name)
        return true;
    }

  // should never end up here
  libmesh_error();
  return false;
}



inline
Real UNVIO::D_to_e (std::string& number) const
{
  /* find "D" in string, start looking at
   * 6th element, to improve speed.
   * We dont expect a "D" earlier
   */

#ifdef __HP_aCC
  // Use an int instead of an unsigned int,
  // otherwise HP aCC may crash!
  const int position = number.find("D",6);
#else
  const std::string::size_type position = number.find("D",6);
#endif

  libmesh_assert (position != std::string::npos);
  number.replace(position, 1, "e");

  return std::atof (number.c_str());
}


} // namespace libMesh


#endif // LIBMESH_UNV_IO_H

---

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

Hosted By: