includeLinks/MeshImplData.hpp

Go to the documentation of this file.

/* ***************************************************************** 
    MESQUITE -- The Mesh Quality Improvement Toolkit

    Copyright 2004 Lawrence Livermore National Laboratory.  Under 
    the terms of Contract B545069 with the University of Wisconsin -- 
    Madison, Lawrence Livermore National Laboratory retains certain
    rights in this software.

    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 
    (lgpl.txt) along with this library; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
    kraftche@cae.wisc.edu    
   
  ***************************************************************** */

#ifndef MESQUITE_MESH_IMPL_DATA_HPP
#define MESQUITE_MESH_IMPL_DATA_HPP

#include "Mesquite.hpp"
#include "Vector3D.hpp"
#include "MeshInterface.hpp"

#ifdef MSQ_USE_OLD_STD_HEADERS
#  include <vector.h>
#else
#  include <vector>
#endif

#include <sys/types.h>

namespace Mesquite {

class MsqError;

class MeshImplData {
  
  public:

    void clear();

    size_t num_vertices() const;
    size_t num_elements() const;
    size_t num_vertex_uses() const;
    
    size_t max_vertex_index() const { return vertexList.size(); }
    size_t max_element_index() const { return elementList.size(); }
    
    void copy_mesh( size_t* vertex_handle_array,
                    size_t* element_hanlde_array,
                    size_t* element_conn_offsets,
                    size_t* element_conn_indices );
    
    void all_vertices( msq_std::vector<size_t>& list, MsqError& err ) const;
    
    void all_elements( msq_std::vector<size_t>& list, MsqError& err ) const;
    
    inline bool is_vertex_valid( size_t index ) const
    {return index < vertexList.size() && vertexList[index].valid; }
    
    inline bool is_element_valid( size_t index ) const
      { return index < elementList.size() &&
               !elementList[index].connectivity.empty(); }

    bool is_mid_node( size_t index ) const;
    bool is_corner_node( size_t index ) const;

    const Vector3D& get_vertex_coords( size_t index, MsqError& err ) const;
    
    void set_vertex_coords( size_t index, 
                            const Vector3D& coords,
                            MsqError& err );
    
    bool vertex_is_fixed( size_t index, MsqError& err ) const;
    
    void fix_vertex( size_t index, bool flag, MsqError& err );
    
    unsigned char get_vertex_byte( size_t index, MsqError& err ) const;
    
    void set_vertex_byte( size_t index, unsigned char value, MsqError& err );
    
    EntityTopology element_topology( size_t index, MsqError& err ) const;
    
    void element_topology( size_t index, EntityTopology type, MsqError& err );
    
    const msq_std::vector<size_t>& element_connectivity( size_t index, MsqError& err ) const;
    
    const msq_std::vector<size_t>& vertex_adjacencies( size_t index, MsqError& err ) const;
    
    void allocate_vertices( size_t count, MsqError& err );
    
    void allocate_elements( size_t count, MsqError& err );
    
    void reset_vertex( size_t index, 
                       const Vector3D& coords, 
                       bool fixed, 
                       MsqError& err );
    
    void reset_element( size_t index, 
                        const msq_std::vector<size_t>& vertices,
                        EntityTopology topology,
                        MsqError& err  );
    
    size_t add_vertex( const Vector3D& coords, bool fixed, MsqError& err );
    size_t add_element( const msq_std::vector<size_t>& vertices,
                        EntityTopology topology,
                        MsqError& err  );
    
    void delete_vertex( size_t index, MsqError& err );
    void delete_element( size_t index, MsqError& err );
    
    void copy_higher_order( msq_std::vector<size_t>& mid_nodes,
                            msq_std::vector<size_t>& vertices,
                            msq_std::vector<size_t>& vertex_indices,
                            msq_std::vector<size_t>& index_offsets,
                            MsqError& err );
    
    void get_adjacent_elements( msq_std::vector<size_t>::const_iterator nodes,
                                msq_std::vector<size_t>::const_iterator nodes_end,
                                msq_std::vector<size_t>& elems_out,
                                MsqError& err );
    
    void skin( msq_std::vector<size_t>& sides, MsqError& err );
    
    
  private:
  
    bool has_adjacent_elements( size_t elem,
                                const msq_std::vector<size_t>& nodes,
                                MsqError& err );
     
  
    void clear_element( size_t index, MsqError& err );
    
    void set_element( size_t index, 
                      const msq_std::vector<size_t>& vertices,
                      EntityTopology topology,
                      MsqError& err  );
  
    struct Vertex {
      Vertex( const Vector3D& pos, bool is_fixed )
        : coords(pos), midcount(0), fixed(is_fixed), valid(true), byte('\0') {}
        
      Vertex() : midcount(0), valid(false), byte('\0') {}
    
      Vector3D coords;                     
      msq_std::vector<size_t> adjacencies; 
      unsigned midcount;                   
      bool fixed;                          
      bool valid;                          
      unsigned char byte;                  
    };
    
    struct Element {
      msq_std::vector<size_t> connectivity; 
      EntityTopology topology;             
      Element()
          : topology(MIXED)
        {}
      
    };
    
    msq_std::vector<Vertex> vertexList;     
    msq_std::vector<Element> elementList;   
    msq_std::vector<size_t> deletedVertexList;
    msq_std::vector<size_t> deletedElementList;
};

class MeshImplVertIter : public VertexIterator
{
  private:
    MeshImplData* mesh;
    size_t index;
    
  public:
    
    MeshImplVertIter( MeshImplData* data )
      : mesh(data) { restart(); }
    
    virtual ~MeshImplVertIter();
    
    virtual void restart();
    
    virtual void operator++();
    
    virtual Mesh::VertexHandle operator*() const;
    
    virtual bool is_at_end() const;
    
};


class MeshImplElemIter : public ElementIterator
{
  private:
    MeshImplData* mesh;
    size_t index;
    
  public:
    
    MeshImplElemIter( MeshImplData* data )
      : mesh(data) { restart(); }
    
    virtual ~MeshImplElemIter();
    
    virtual void restart();
    
    virtual void operator++();
    
    virtual Mesh::ElementHandle operator*() const;
    
    virtual bool is_at_end() const;
    
};



} // namespace Mesquite

#endif