MOAB: Mesh Oriented datABase  (version 5.4.0)
ArrayMesh.hpp
Go to the documentation of this file.
00001 /* *****************************************************************
00002     MESQUITE -- The Mesh Quality Improvement Toolkit
00003 
00004     Copyright 2007 Sandia National Laboratories.  Developed at the
00005     University of Wisconsin--Madison under SNL contract number
00006     624796.  The U.S. Government and the University of Wisconsin
00007     retain certain rights to this software.
00008 
00009     This library is free software; you can redistribute it and/or
00010     modify it under the terms of the GNU Lesser General Public
00011     License as published by the Free Software Foundation; either
00012     version 2.1 of the License, or (at your option) any later version.
00013 
00014     This library is distributed in the hope that it will be useful,
00015     but WITHOUT ANY WARRANTY; without even the implied warranty of
00016     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00017     Lesser General Public License for more details.
00018 
00019     You should have received a copy of the GNU Lesser General Public License
00020     (lgpl.txt) along with this library; if not, write to the Free Software
00021     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
00022 
00023     (2007) kraftche@cae.wisc.edu
00024 
00025   ***************************************************************** */
00026 
00027 /** \file ArrayMesh.hpp
00028  *  \brief Access mesh stored in arrays
00029  *  \author Jason Kraftcheck
00030  */
00031 
00032 #ifndef MSQ_ARRAY_MESH_HPP
00033 #define MSQ_ARRAY_MESH_HPP
00034 
00035 #include "Mesquite.hpp"
00036 #include "MeshInterface.hpp"
00037 
00038 namespace MBMesquite
00039 {
00040 
00041 class ArrayMesh : public Mesh
00042 {
00043   public:
00044     /** Create a MBMesquite::Mesh instance that wraps application-provided
00045      *  arrays.
00046      *
00047      * Note:  An instance of this class will reference the passed in
00048      *        arrays.  It will not copy them.
00049      *
00050      *\param coords_per_vertex Dimension of the mesh (2 or 3)
00051      *\param num_vertices      Number of vertices in the mesh
00052      *\param interleaved_vertex_coords Vertex coordinates.  Ordered as
00053      *                         [x1, y1, z1, x2, y2, z2, ...]
00054      *\param vertex_fixed_flags One value per vertex.  Zero if vertex is
00055      *                         free, one if the position is fixed.
00056      *\param num_elements      Number of elements in the mesh
00057      *\param element_type      The type of the elements
00058      *\param element_connectivity_array Element connectivity, specified
00059      *                         as vertex indices such that the location
00060      *                         of the vertex coordinates in vertex_coords
00061      *                         is at 3 times the value in this array.
00062      *\param one_based_conn_indices Use one-based (Fortran) array indexing.
00063      *\param nodes_per_element Number of nodes in each element.  If not
00064      *                         specified, number of nodes in a linear
00065      *                         element with the type 'element_type' is
00066      *                         assumed.
00067      *\param vertex_slaved_flags One value per vertex.  Zero if vertex is
00068      *                         free, one if the vertex is slaved to the
00069      *                         logical position of the element mapping/shape
00070      *                         function..
00071      */
00072     ArrayMesh( int coords_per_vertex,
00073                unsigned long num_vertices,
00074                double* interleaved_vertex_coords,
00075                const int* vertex_fixed_flags,
00076                unsigned long num_elements,
00077                EntityTopology element_type,
00078                const unsigned long* element_connectivity_array,
00079                bool one_based_conn_indices    = false,
00080                unsigned nodes_per_element     = 0,
00081                const int* vertex_slaved_flags = 0 );
00082 
00083     /** Create a MBMesquite::Mesh instance that wraps application-provided
00084      *  arrays.
00085      *
00086      * Note:  An instance of this class will reference the passed in
00087      *        arrays.  It will not copy them.
00088      *
00089      *\param coords_per_vertex Dimension of the mesh (2 or 3)
00090      *\param num_vertices      Number of vertices in the mesh
00091      *\param interleaved_vertex_coords Vertex coordinates.  Ordered as
00092      *                         [x1, y1, z1, x2, y2, z2, ...]
00093      *\param vertex_fixed_flags One value per vertex.  Zero if vertex is
00094      *                         free, one if the poistion is fixed.
00095      *\param num_elements      Number of elements in the mesh
00096      *\param element_types     The topological type for each element.
00097      *\param element_connectivity_array Element connectivity, specified
00098      *                         as vertex indices such that the location
00099      *                         of the vertex coordinates in vertex_coords
00100      *                         is at 3 times the value in this array.
00101      *\param element_connectivity_offsets An optional array of length one greater
00102      *                         than num_elements.  Each entry other than
00103      *                         the last should contain the value of the
00104      *                         index into element_connectivity_array at
00105      *                         which the connectivity data for the
00106      *                         corresponding element begins.  The last
00107      *                         entry in the array must be the next-to-last
00108      *                         entry plus the length of the connectivity
00109      *                         data for the last element, such that the
00110      *                         length of the connectivity data for any
00111      *                         element 'e' can be calculated with:
00112      *                           n = element_connectivity_offsets[e+1] -
00113      *element_connectivity_offsets[e]
00114      *
00115      *                         If this array is not specified, then it
00116      *                         will be assumed that the length of the
00117      *                         connectivity data for each element is the
00118      *                         number of corners necessary to represent
00119      *                         its topological type (that it has no higher-order
00120      *                         nodes.)
00121      *\param one_based_conn_indices Use one-based (Fortran) array indexing.
00122      *\param vertex_slaved_flags One value per vertex.  Zero if vertex is
00123      *                         free, one if the vertex is slaved to the
00124      *                         logical position of the element mapping/shape
00125      *                         function..
00126      */
00127     ArrayMesh( int coords_per_vertex,
00128                unsigned long num_vertices,
00129                double* interleaved_vertex_coords,
00130                const int* vertex_fixed_flags,
00131                unsigned long num_elements,
00132                const EntityTopology* element_types,
00133                const unsigned long* element_connectivity_array,
00134                const unsigned long* element_connectivity_offsets = NULL,
00135                bool one_based_conn_indices                       = false,
00136                const int* vertex_slaved_flags                    = 0 );
00137 
00138     ArrayMesh();
00139 
00140     ~ArrayMesh();
00141 
00142     void clear_mesh();
00143     void set_mesh( int coords_per_vertex,
00144                    unsigned long num_vertices,
00145                    double* interleaved_vertex_coords,
00146                    const int* vertex_fixed_flags,
00147                    unsigned long num_elements,
00148                    EntityTopology element_type,
00149                    const unsigned long* element_connectivity_array,
00150                    bool one_based_conn_indices    = false,
00151                    unsigned nodes_per_element     = 0,
00152                    const int* vertex_slaved_flags = 0 );
00153 
00154     /**\brief Give mesquite access to per-entity application data via a tag
00155      *
00156      * Allow mesquite to access application-owned per-element and/or per-vertex
00157      * data by assigning a tag name to said data.  Mesquite will be allowed
00158      * to read application-owned data.  Any attempt by Mesquite to modify
00159      * the data will result in an internal error condition.
00160      *
00161      *\param tag_name  Tag name through which Mesquite can access the data
00162      *\param data_type The type of the data
00163      *\param vals_per_entity Number of values of type \c data_type that each entity has
00164      *                       Data is assumed to be interleaved such that all values
00165      *                       associated with a a single entity are adjacent in memory
00166      *\param vertex_data     A pointer to the region of memory in which per-vertex
00167      *                       values are stored.  May be NULL if per-vertex data is
00168      *                       not available.  Values are assumed to be in the same
00169      *                       order as the vertex coordinates passed to the constructor
00170      *                       or \c set_mesh.
00171      *\param vertex_data     A pointer to the region of memory in which per-element
00172      *                       values are stored.  May be NULL if per-element data is
00173      *                       not available.  Values are assumed to be in the same
00174      *                       order as the element connetivity passed to the constructor
00175      *                       or \c set_mesh.
00176      *\param default_value   Value to return for all vertices and/or all elements
00177      *                       if the cooresponding data array is null.  May be
00178      *                       NULL if no default value.
00179      */
00180     TagHandle add_read_only_tag_data( const char* tag_name,
00181                                       TagType data_type,
00182                                       int vals_per_entity,
00183                                       const void* vertex_data,
00184                                       const void* element_data,
00185                                       const void* default_value,
00186                                       MsqError& err );
00187 
00188     /**\brief Give mesquite access to per-entity application data via a tag
00189      *
00190      * Allow mesquite to access and/or set application-owned per-element
00191      * and/or per-vertex data by assigning a tag name to said data.
00192      *
00193      *\param tag_name  Tag name through which Mesquite can access the data
00194      *\param data_type The type of the data
00195      *\param vals_per_entity Number of values of type \c data_type that each entity has
00196      *                       Data is assumed to be interleaved such that all values
00197      *                       associated with a a single entity are adjacent in memory
00198      *\param vertex_data     A pointer to the region of memory in which per-vertex
00199      *                       values are stored.  May be NULL if per-vertex data is
00200      *                       not available.  Values are assumed to be in the same
00201      *                       order as the vertex coordinates passed to the constructor
00202      *                       or \c set_mesh.
00203      *\param vertex_data     A pointer to the region of memory in which per-element
00204      *                       values are stored.  May be NULL if per-element data is
00205      *                       not available.  Values are assumed to be in the same
00206      *                       order as the element connetivity passed to the constructor
00207      *                       or \c set_mesh.
00208      *\param default_value   Value to return for all vertices and/or all elements
00209      *                       if the cooresponding data array is null.  May be
00210      *                       NULL if no default value.
00211      */
00212     TagHandle add_writable_tag_data( const char* tag_name,
00213                                      TagType tag_data_type,
00214                                      int vals_per_entity,
00215                                      void* vertex_data,
00216                                      void* element_data,
00217                                      const void* default_value,
00218                                      MsqError& err );
00219 
00220     virtual int get_geometric_dimension( MsqError& err );
00221 
00222     virtual void get_all_elements( std::vector< ElementHandle >& elements, MsqError& err );
00223     virtual void get_all_vertices( std::vector< VertexHandle >& vertices, MsqError& err );
00224 
00225     virtual VertexIterator* vertex_iterator( MsqError& err );
00226     virtual ElementIterator* element_iterator( MsqError& err );
00227 
00228     virtual void vertices_get_fixed_flag( const VertexHandle vert_array[],
00229                                           std::vector< bool >& fixed_flag_array,
00230                                           size_t num_vtx,
00231                                           MsqError& err );
00232     virtual void vertices_get_slaved_flag( const VertexHandle vert_array[],
00233                                            std::vector< bool >& slaved_flag_array,
00234                                            size_t num_vtx,
00235                                            MsqError& err );
00236     virtual void vertices_get_coordinates( const VertexHandle vert_array[],
00237                                            MsqVertex* coordinates,
00238                                            size_t num_vtx,
00239                                            MsqError& err );
00240     virtual void vertex_set_coordinates( VertexHandle vertex, const Vector3D& coordinates, MsqError& err );
00241 
00242     virtual void vertex_set_byte( VertexHandle vertex, unsigned char byte, MsqError& err );
00243     virtual void vertices_set_byte( const VertexHandle* vert_array,
00244                                     const unsigned char* byte_array,
00245                                     size_t array_size,
00246                                     MsqError& err );
00247 
00248     virtual void vertex_get_byte( const VertexHandle vertex, unsigned char* byte, MsqError& err );
00249     virtual void vertices_get_byte( const VertexHandle* vertex,
00250                                     unsigned char* byte_array,
00251                                     size_t array_size,
00252                                     MsqError& err );
00253 
00254     virtual void vertices_get_attached_elements( const VertexHandle* vertex_array,
00255                                                  size_t num_vertex,
00256                                                  std::vector< ElementHandle >& elements,
00257                                                  std::vector< size_t >& offsets,
00258                                                  MsqError& err );
00259 
00260     virtual void elements_get_attached_vertices( const ElementHandle* elem_handles,
00261                                                  size_t num_elems,
00262                                                  std::vector< VertexHandle >& vert_handles,
00263                                                  std::vector< size_t >& offsets,
00264                                                  MsqError& err );
00265 
00266     virtual void elements_get_topologies( const ElementHandle* element_handle_array,
00267                                           EntityTopology* element_topologies,
00268                                           size_t num_elements,
00269                                           MsqError& err );
00270 
00271     virtual TagHandle tag_create( const std::string& tag_name,
00272                                   TagType type,
00273                                   unsigned length,
00274                                   const void* default_value,
00275                                   MsqError& err );
00276 
00277     virtual void tag_delete( TagHandle handle, MsqError& err );
00278 
00279     virtual TagHandle tag_get( const std::string& name, MsqError& err );
00280 
00281     virtual void tag_properties( TagHandle handle,
00282                                  std::string& name_out,
00283                                  TagType& type_out,
00284                                  unsigned& length_out,
00285                                  MsqError& err );
00286 
00287     virtual void tag_set_element_data( TagHandle handle,
00288                                        size_t num_elems,
00289                                        const ElementHandle* elem_array,
00290                                        const void* tag_data,
00291                                        MsqError& err );
00292 
00293     virtual void tag_set_vertex_data( TagHandle handle,
00294                                       size_t num_elems,
00295                                       const VertexHandle* node_array,
00296                                       const void* tag_data,
00297                                       MsqError& err );
00298 
00299     virtual void tag_get_element_data( TagHandle handle,
00300                                        size_t num_elems,
00301                                        const ElementHandle* elem_array,
00302                                        void* tag_data,
00303                                        MsqError& err );
00304 
00305     virtual void tag_get_vertex_data( TagHandle handle,
00306                                       size_t num_elems,
00307                                       const VertexHandle* node_array,
00308                                       void* tag_data,
00309                                       MsqError& err );
00310 
00311     virtual void release_entity_handles( const EntityHandle* handle_array, size_t num_handles, MsqError& err );
00312 
00313     virtual void release();
00314 
00315   private:
00316     inline const unsigned long* elem_verts( size_t elem_index, int& num_vertex ) const;
00317 
00318     void build_vertex_adjacency_list();
00319 
00320     int mDimension;                  //!< Coordinates per vertex
00321     unsigned long vertexCount;       //!< Number of vertices
00322     double* coordArray;              //!< Interleaved vertex coordinates
00323     const int* fixedFlags;           //!< Vertex fixed flags
00324     const int* slavedFlags;          //!< Vertex slaved flags
00325     unsigned char* vertexByteArray;  //!< Vertex bytes
00326 
00327     unsigned long elementCount;          //!< Number of elements
00328     const unsigned long* connArray;      //!< Element connectivity
00329     const unsigned long* connOffsets;    //!< Offsets into connectivity array
00330                                          //!< for each element.  If NULL, then
00331                                          //!< all elements are of the same type
00332                                          //!< and have the same number of vertices.
00333     unsigned long* allocConnOffsets;     //!< Same as connOffsets if allocated
00334                                          //!< by constructor.  NULL if connOffsets
00335                                          //!< is either NULL or application-provided
00336                                          //!< data.
00337     EntityTopology elementType;          //!< Type for all elements if connOffsets is NULL
00338     const EntityTopology* elementTypes;  //!< Type for each element type if connOffsets is not NULL
00339     unsigned nodesPerElement;            //!< Nodes per element if connOffsets is NULL
00340     bool oneBasedArrays;                 //!< FORTRAN-style array indexing
00341 
00342     unsigned long* vertexAdjacencyList;
00343     unsigned long* vertexAdjacencyOffsets;
00344 
00345     static unsigned bytes( TagType type );
00346 
00347     static void fill( unsigned char* buffer, const unsigned char* value, size_t size, size_t count );
00348 
00349     struct Tag
00350     {
00351         char* name;                       //!< Tag name (null-terminated string)
00352         TagType type;                     //!< tag data type
00353         unsigned size;                    //!< number of *bytes* per entity
00354         bool owned;                       //!< true if memory for tag storage is owned by this class
00355         unsigned char* vtxWritePtr;       //!< pointer to writable tag data (NULL if read-only)
00356         const unsigned char* vtxReadPtr;  //!< pointer to tag data
00357         unsigned char* eleWritePtr;       //!< pointer to writable tag data (NULL if read-only)
00358         const unsigned char* eleReadPtr;  //!< pointer to tag data
00359         unsigned char* defaultValue;      //!< Default value
00360         Tag* next;                        //!< Linked-list next pointer
00361     };
00362 
00363     Tag* allocate_tag( const char* name,
00364                        bool owned,
00365                        TagType type,
00366                        unsigned size,
00367                        const void* vertex_ro_data,
00368                        void* vertex_rw_data,
00369                        const void* element_ro_data,
00370                        void* element_rw_data,
00371                        const void* default_value,
00372                        MsqError& err );
00373 
00374     Tag* tagList;
00375 
00376     bool valid() const;
00377 };
00378 
00379 }  // namespace MBMesquite
00380 
00381 #endif
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines