MeshInterface.hpp

Go to the documentation of this file.

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

    Copyright 2004 Sandia Corporation and Argonne National
    Laboratory.  Under the terms of Contract DE-AC04-94AL85000 
    with Sandia Corporation, the U.S. Government 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
 
    diachin2@llnl.gov, djmelan@sandia.gov, mbrewer@sandia.gov, 
    pknupp@sandia.gov, tleurent@mcs.anl.gov, tmunson@mcs.anl.gov,
    kraftche@cae.wisc.edu
   
  ***************************************************************** */
#ifndef MESQUITE_INTERFACE_HPP
#define MESQUITE_INTERFACE_HPP

#include "Mesquite.hpp"
#include "TopologyInfo.hpp"

#ifdef MSQ_USE_OLD_C_HEADERS
#  include <stddef.h>
#else
#  include <cstddef>
#endif

#include <string>

namespace Mesquite
{
  class EntityIterator;
  class MsqError;
  class MsqVertex;
  class Vector3D;
  typedef EntityIterator VertexIterator;
  typedef EntityIterator ElementIterator;
    
  typedef void* TagHandle;

  inline size_t vertices_in_topology(EntityTopology);

  class Mesh
  {
  public:
//************ Type Definitions **************
    typedef void* EntityHandle;
    
    
      // We typedef specific types of EntityHandles just
      // to make it clear what kind of entity is to be
      // returned or used as a function parameter, but the
      // different handle types are not actually distinct.
    typedef EntityHandle VertexHandle;
    typedef EntityHandle ElementHandle;

//************ Operations on entire mesh ****************
    virtual int get_geometric_dimension(MsqError &err) = 0;
    
    virtual void get_all_sizes( size_t& vertex_count,
                                size_t& element_count,
                                size_t& vertex_use_count,
                                MsqError& err ) = 0;
    
    virtual void get_all_mesh( VertexHandle*  vert_array, size_t vert_len,
                               ElementHandle* elem_array, size_t elem_len,
                               size_t* elem_conn_offsets, size_t offset_len,
                               size_t* elem_conn_indices, size_t index_len,
                               MsqError& err ) = 0;
    
    virtual VertexIterator* vertex_iterator(MsqError &err) = 0;
    
    virtual ElementIterator* element_iterator(MsqError &err) = 0;

//************ Vertex Properties ********************
    virtual bool vertex_is_fixed(VertexHandle vertex, MsqError &err) = 0;

    virtual void vertices_are_on_boundary(VertexHandle vert_array[], bool on_bnd[],
                                  size_t num_vtx, MsqError &err) = 0;
    
    virtual void vertices_get_coordinates(const VertexHandle vert_array[],
                                        MsqVertex* coordinates,
                                        size_t num_vtx,
                                        MsqError &err) = 0;
    virtual void vertex_set_coordinates(VertexHandle vertex,
                                        const Vector3D &coordinates,
                                        MsqError &err) = 0;
    
    virtual void vertex_set_byte (VertexHandle vertex,
                                  unsigned char byte, MsqError &err) = 0;
    virtual void vertices_set_byte (VertexHandle *vert_array,
                                    unsigned char *byte_array,
                                    size_t array_size, MsqError &err) = 0;
    
    virtual void vertex_get_byte(VertexHandle vertex,
                                 unsigned char *byte, MsqError &err) = 0;
    virtual void vertices_get_byte(VertexHandle *vertex,
                                   unsigned char *byte_array,
                                   size_t array_size, MsqError &err) = 0;
    
//**************** Vertex Topology *****************    
    virtual size_t vertex_get_attached_element_count(VertexHandle vertex,
                                                     MsqError &err) = 0;
    
    virtual void vertex_get_attached_elements(VertexHandle vertex,
                                              ElementHandle* elem_array,
                                              size_t sizeof_elem_array,
                                              MsqError &err) = 0;
    
//*************** Element Topology *************
    
    virtual size_t element_get_attached_vertex_count(ElementHandle elem,
                                                     MsqError &err) = 0;
    virtual size_t get_vertex_use_count( ElementHandle* handle_array,
                                         size_t num_handles,
                                         MsqError& err ) = 0;

    virtual void elements_get_attached_vertices(ElementHandle *elem_handles,
                                                size_t num_elems,
                                                VertexHandle *vert_handles,
                                                size_t &sizeof_vert_handles,
                                                size_t *csr_data,
                                                size_t &sizeof_csr_data,
                                                size_t *csr_offsets,
                                                MsqError &err) = 0;
    
    
    virtual EntityTopology element_get_topology(ElementHandle entity_handle,
                                              MsqError &err) = 0;
    virtual void elements_get_topologies(ElementHandle *element_handle_array,
                                         EntityTopology *element_topologies,
                                         size_t num_elements, MsqError &err) = 0;

    
//***************  Tags  ***********
    
    enum TagType { BYTE, BOOL, INT, DOUBLE, HANDLE };

    virtual TagHandle tag_create( const msq_std::string& tag_name,
                                  TagType type, unsigned length,
                                  const void* default_value,
                                  MsqError &err) = 0;
    
    virtual void tag_delete( TagHandle handle, MsqError& err ) = 0;
    
    
    virtual TagHandle tag_get( const msq_std::string& name, 
                               MsqError& err ) = 0;
     
    virtual void tag_properties( TagHandle handle,
                                 msq_std::string& name_out,
                                 TagType& type_out,
                                 unsigned& length_out,
                                 MsqError& err ) = 0;
    
    virtual void tag_set_element_data( TagHandle handle,
                                       size_t num_elems,
                                       const ElementHandle* elem_array,
                                       const void* tag_data,
                                       MsqError& err ) = 0;

    virtual void tag_set_vertex_data ( TagHandle handle,
                                       size_t num_elems,
                                       const VertexHandle* node_array,
                                       const void* tag_data,
                                       MsqError& err ) = 0;
    
    
    virtual void tag_get_element_data( TagHandle handle,
                                       size_t num_elems,
                                       const ElementHandle* elem_array,
                                       void* tag_data,
                                       MsqError& err ) = 0;
    
    virtual void tag_get_vertex_data ( TagHandle handle,
                                       size_t num_elems,
                                       const VertexHandle* node_array,
                                       void* tag_data,
                                       MsqError& err ) = 0;

    
    
//**************** Memory Management ****************
    virtual void release_entity_handles(EntityHandle *handle_array,
                                        size_t num_handles, MsqError &err) = 0;
    
    virtual void release() = 0;
    
  protected:
    virtual ~Mesh()
      {}
  };
  
  class EntityIterator
  {
  public:
    virtual ~EntityIterator()
      {}

    virtual void restart() = 0;
    
    virtual Mesh::EntityHandle operator*() const = 0;
    
    virtual void operator++() = 0;
    
    virtual bool is_at_end() const = 0;
  };
  

  enum DomainHint {
    NO_DOMAIN_HINT,     //< Do not make any assumptions about the domain.
    PLANAR_DOMAIN,      //< Domain is planar
    LOCAL_PALANAR,      //< Domain is close to planar 
    SMOOTH_DOMAIN       //< Domain is C1-continuous
 };
  class MeshDomain
  {
  public:
    virtual ~MeshDomain()
      {}
      
    virtual DomainHint hint() const = 0;

    virtual void snap_to(Mesh::EntityHandle entity_handle,
                         Vector3D &coordinate) const = 0;
    
    virtual void normal_at(Mesh::EntityHandle entity_handle,
                           Vector3D &coordinate) const = 0;
                           
    virtual void normal_at( Mesh::EntityHandle handle,
                            Vector3D coordinates[],
                            unsigned count,
                            MsqError& err ) const = 0;
                            
    virtual void closest_point( Mesh::EntityHandle handle,
                                const Vector3D& position,
                                Vector3D& closest,
                                Vector3D& normal,
                                MsqError& err ) const = 0;
       
  };
}

inline size_t Mesquite::vertices_in_topology(Mesquite::EntityTopology topo)
{
  return TopologyInfo::corners( topo );
}

#endif