mesh_data.h

Go to the documentation of this file.

// The libMesh Finite Element Library.
// Copyright (C) 2002-2014 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_MESH_DATA_H
#define LIBMESH_MESH_DATA_H

// Local Includes
#include "libmesh/libmesh.h"
#include "libmesh/enum_xdr_mode.h"

// C++ includes
#include <cstddef>
#include <map>
#include <vector>

namespace libMesh
{


// Forward Declarations
class Node;
class Elem;
class MeshBase;
class MeshDataUnvHeader;


// ------------------------------------------------------------
// MeshData class definition
class MeshData
{
public:


  //----------------------------------------------------------
  // convenient typedefs
  typedef std::map<const Node*, std::vector<Number> >::const_iterator const_node_data_iterator;

  typedef std::map<const Elem*, std::vector<Number> >::const_iterator const_elem_data_iterator;


  //----------------------------------------------------------
  MeshData (const MeshBase& m);

  ~MeshData ();

  void activate (const std::string& descriptor="");

  void enable_compatibility_mode (const std::string& descriptor="");

  void clear ();

  void slim (const bool node_id_map = true,
             const bool elem_id_map = true);

  void translate (const MeshBase& out_mesh,
                  std::vector<Number>& data_values,
                  std::vector<std::string>& data_names) const;

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

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

  std::string get_info () const;

  void print_info (std::ostream& os=libMesh::out) const;

  friend std::ostream& operator << (std::ostream& os, const MeshData& m);


  //----------------------------------------------------------
  // Node-associated data
  Number operator() (const Node* node,
                     const unsigned int i=0) const;

  bool has_data (const Node* node) const;

  const std::vector<Number>& get_data (const Node* node) const;

  void set_data (const Node* node, const std::vector<Number>& val);

  unsigned int n_val_per_node () const;

  dof_id_type n_node_data () const;

  const_node_data_iterator node_data_begin () const;

  const_node_data_iterator node_data_end () const;

  void insert_node_data (std::map<const Node*,
                         std::vector<Number> >& nd,
                         const bool close_elem_data = true);


  //----------------------------------------------------------
  // Element-associated data
  Number operator() (const Elem* elem,
                     const unsigned int i=0) const;

  bool has_data (const Elem* elem) const;

  const std::vector<Number>& get_data (const Elem* elem) const;

  void set_data (const Elem* elem, const std::vector<Number> &val);

  unsigned int n_val_per_elem () const;

  dof_id_type n_elem_data () const;

  const_elem_data_iterator elem_data_begin () const;

  const_elem_data_iterator elem_data_end () const;

  void insert_elem_data (std::map<const Elem*,
                         std::vector<Number> >& ed,
                         const bool close_node_data = true);


  //----------------------------------------------------------
  bool active () const;
  bool compatibility_mode () const;

  bool elem_initialized () const;

  bool node_initialized () const;


  //----------------------------------------------------------
  // Methods for accessing the node and element maps.
  // Heavily used by the \p read() and \p write() methods.
  const Node* foreign_id_to_node (const unsigned int fid) const;

  const Elem* foreign_id_to_elem (const unsigned int fid) const;

  unsigned int node_to_foreign_id (const Node* n) const;

  unsigned int elem_to_foreign_id (const Elem* n) const;

  //----------------------------------------------------------
  // Methods for the header information in universal formated
  // datasets.

  const MeshDataUnvHeader & get_unv_header() const;

  void set_unv_header(MeshDataUnvHeader* unv_header);


  void assign (const MeshData& omd);


  //----------------------------------------------------------
  // Methods used by mesh importes to communicate node/element
  // labels to this \p MeshData

  void add_foreign_node_id (const Node* node,
                            const unsigned int foreign_node_id);

  void add_foreign_elem_id (const Elem* elem,
                            const unsigned int foreign_elem_id);

  void close_foreign_id_maps ();


protected:


  //----------------------------------------------------------
  // read/write Methods
  void read_tetgen (const std::string& name);

  void read_unv (const std::string& file_name);

  void read_unv_implementation (std::istream& in_file);

  void write_unv (const std::string& file_name);

  void write_unv_implementation (std::ostream& out_file);


  void read_xdr (const std::string& name,
                 const XdrMODE mode = READ);

  void write_xdr (const std::string& name,
                  const XdrMODE mode = WRITE);


  const MeshBase& _mesh;

  std::string _data_descriptor;


  //--------------------------------------------------
  // node associated data & maps
  std::map<const Node*,
           std::vector<Number> > _node_data;

  std::map<const Node*,
           unsigned int> _node_id;

  std::map<unsigned int,
           const Node*> _id_node;



  //--------------------------------------------------
  // element associated data & maps
  std::map<const Elem*,
           std::vector<Number> > _elem_data;

  std::map<const Elem*,
           unsigned int> _elem_id;
  std::map<unsigned int,
           const Elem*> _id_elem;



  //--------------------------------------------------------
  bool _node_id_map_closed;

  bool _node_data_closed;


  //--------------------------------------------------------
  bool _elem_id_map_closed;

  bool _elem_data_closed;


  //--------------------------------------------------------
  bool _active;

  bool _compatibility_mode;

  MeshDataUnvHeader* _unv_header;

  friend class MeshDataUnvHeader;

};



//-----------------------------------------------------------
// MeshDataUnvHeader class definition

class MeshDataUnvHeader
{
public:

  MeshDataUnvHeader ();

  ~MeshDataUnvHeader ();

  void which_dataset (const unsigned int ds_label);

  void operator = (const MeshDataUnvHeader& omduh);

  bool operator == (const MeshDataUnvHeader& omduh) const;

  unsigned int dataset_label;

  std::string dataset_name;

  unsigned int dataset_location;

  std::vector<std::string> id_lines_1_to_5;

  unsigned int model_type,
    analysis_type,
    data_characteristic,
    result_type;

  unsigned int data_type;

  unsigned int nvaldc;

  std::vector<int> record_10,
    record_11;

  std::vector<Real> record_12,
    record_13;


protected:

  bool read (std::istream& in_file);

  void write (std::ostream& out_file);


private:

  unsigned int _desired_dataset_label;

  static bool need_D_to_e (std::string& number);

  friend class MeshData;

};



// ------------------------------------------------------------
// MeshData inline methods

//-------------------------------------------------------------
// element data inline methods
inline
Number MeshData::operator() (const Node* node,
                             const unsigned int i) const
{
  libmesh_assert (_active || _compatibility_mode);
  libmesh_assert (_node_data_closed);

  std::map<const Node*,
    std::vector<Number> >::const_iterator pos = _node_data.find(node);

  if (pos == _node_data.end())
    return libMesh::zero;

  // we only get here when pos != _node_data.end()
  libmesh_assert_less (i, pos->second.size());
  return pos->second[i];
}



inline
bool MeshData::has_data (const Node* node) const
{
  libmesh_assert (_active || _compatibility_mode);
  libmesh_assert (_node_data_closed);

  std::map<const Node*,
    std::vector<Number> >::const_iterator pos = _node_data.find(node);

  return (pos != _node_data.end());
}



inline
const std::vector<Number>& MeshData::get_data (const Node* node) const
{
  libmesh_assert (_active || _compatibility_mode);
  libmesh_assert (_node_data_closed);

  std::map<const Node*,
    std::vector<Number> >::const_iterator pos = _node_data.find(node);

#ifdef DEBUG
  if (pos == _node_data.end())
    libmesh_error_msg("ERROR: No data for this node.  Use has_data() first!");
#endif

  return pos->second;
}



inline
void MeshData::set_data (const Node* node,
                         const std::vector<Number> &val)
{
  this->_node_data[node] = val;
}



inline
MeshData::const_node_data_iterator MeshData::node_data_begin () const
{
  return _node_data.begin();
}



inline
MeshData::const_node_data_iterator MeshData::node_data_end () const
{
  return _node_data.end();
}



//-------------------------------------------------------------
// element data inline methods
inline
Number MeshData::operator() (const Elem* elem,
                             const unsigned int i) const
{
  libmesh_assert (_active || _compatibility_mode);
  libmesh_assert (_elem_data_closed);

  std::map<const Elem*,
    std::vector<Number> >::const_iterator pos = _elem_data.find(elem);

  if (pos == _elem_data.end())
    return libMesh::zero;

  // we only get here when pos != _elem_data.end()
  libmesh_assert_less (i, pos->second.size());
  return pos->second[i];
}



inline
bool MeshData::has_data (const Elem* elem) const
{
  libmesh_assert (_active || _compatibility_mode);
  libmesh_assert (_elem_data_closed);

  std::map<const Elem*,
    std::vector<Number> >::const_iterator pos = _elem_data.find(elem);

  return (pos != _elem_data.end());
}



inline
const std::vector<Number>& MeshData::get_data (const Elem* elem) const
{
  libmesh_assert (_active || _compatibility_mode);
  libmesh_assert (_elem_data_closed);

  std::map<const Elem*,
    std::vector<Number> >::const_iterator pos = _elem_data.find(elem);

#ifdef DEBUG
  if (pos == _elem_data.end())
    libmesh_error_msg("ERROR: No data for this element.  Use has_data() first!");
#endif

  return pos->second;
}



inline
void MeshData::set_data (const Elem* elem,
                         const std::vector<Number> &val)
{
  this->_elem_data[elem] = val;
}



inline
MeshData::const_elem_data_iterator MeshData::elem_data_begin () const
{
  return _elem_data.begin();
}



inline
MeshData::const_elem_data_iterator MeshData::elem_data_end () const
{
  return _elem_data.end();
}



//-------------------------------------------------------------
// other inline methods
inline
bool MeshData::active() const
{
  return _active;
}



inline
bool MeshData::compatibility_mode() const
{
  return _compatibility_mode;
}



inline
bool MeshData::elem_initialized() const
{
  return (_active && _elem_data_closed);
}



inline
bool MeshData::node_initialized() const
{
  return (_active && _node_data_closed);
}



inline
void MeshData::add_foreign_node_id (const Node* node,
                                    const unsigned int foreign_node_id)
{
  if (_active)
    {
      libmesh_assert (!_node_id_map_closed);
      libmesh_assert(node);
      libmesh_assert (_node_id.find(node) == _node_id.end());
      libmesh_assert (_id_node.find(foreign_node_id) == _id_node.end());

      /*
       * _always_ insert in _id_node and _node_id.  If we would
       * use the mesh.node(unsigned int) method or the node.id()
       * to get Node* and unsigned int, respectively, we would not
       * be safe any more when the mesh gets refined or re-numbered
       * within libMesh. And we could get in big trouble that would
       * be hard to find when importing data _after_ having refined...
       */
      _node_id.insert(std::make_pair(node, foreign_node_id));
      _id_node.insert(std::make_pair(foreign_node_id, node));
    }
}



inline
void MeshData::add_foreign_elem_id (const Elem* elem,
                                    const unsigned int foreign_elem_id)
{
  if (_active)
    {
      libmesh_assert (!_elem_id_map_closed);
      libmesh_assert(elem);
      libmesh_assert (_elem_id.find(elem) == _elem_id.end());
      libmesh_assert (_id_elem.find(foreign_elem_id) == _id_elem.end());

      _elem_id.insert(std::make_pair(elem, foreign_elem_id));
      _id_elem.insert(std::make_pair(foreign_elem_id, elem));
    }
}


inline
const MeshDataUnvHeader & MeshData::get_unv_header () const
{
  libmesh_assert(this->_unv_header);
  return *this->_unv_header;
}


inline
void MeshData::set_unv_header (MeshDataUnvHeader* unv_header)
{
  libmesh_assert(unv_header);
  this->_unv_header = unv_header;
}


//-----------------------------------------------------------
// MeshDataUnvHeader inline methods


} // namespace libMesh

#endif // LIBMESH_MESH_DATA_H