MesqPane_1_1.h

Go to the documentation of this file.

/* *******************************************************************
 * Rocstar Simulation Suite                                          *
 * Copyright@2015, Illinois Rocstar LLC. All rights reserved.        *
 *                                                                   *
 * Illinois Rocstar LLC                                              *
 * Champaign, IL                                                     *
 * www.illinoisrocstar.com                                           *
 * sales@illinoisrocstar.com                                         *
 *                                                                   *
 * License: See LICENSE file in top level of distribution package or *
 * http://opensource.org/licenses/NCSA                               *
 *********************************************************************/
/* *******************************************************************
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,   *
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES   *
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND          *
 * NONINFRINGEMENT.  IN NO EVENT SHALL THE CONTRIBUTORS OR           *
 * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER       *
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,   *
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE    *
 * USE OR OTHER DEALINGS WITH THE SOFTWARE.                          *
 *********************************************************************/
// $Id: MesqPane_1_1.h,v 1.3 2008/12/06 08:45:24 mtcampbe Exp $
#ifndef MESQPANE_H
#define MESQPANE_H

#ifndef USE_STD_INCLUDES
#define USE_STD_INCLUDES 1
#endif

#ifndef USE_C_PREFIX_INCLUDES 
#define USE_C_PREFIX_INCLUDES 1
#endif

// MESQUITE INCLUDES
#include "Mesquite.hpp"
#include "TopologyInfo.hpp"

// ROCCOM INCLUDES
#include "roccom_devel.h"
#include "Pane.h"
#include "Pane_boundary.h"
#include "Dual_connectivity.h"
#include "roccom_devel.h"

// ROCMOP INCLUDES
#include "mopbasic.h"

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

#include <string>

#define MESQUITE_BEGIN_NAMESPACE namespace Mesquite{
#define MESQUITE_END_NAMESPACE }

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

//using namespace Mesquite;
using namespace std;
using std::string;
USE_MOP_NAMESPACE
MESQUITE_BEGIN_NAMESPACE

class EntityIterator;
class MsqError;
class MsqVertex;
class Vector3D;
typedef EntityIterator VertexIterator;
typedef EntityIterator ElementIterator;


class MesqPane : public Mesquite::Mesh {

  inline size_t vertices_in_topology(EntityTopology);

public:
  //************ Type Definitions **************
  typedef void* EntityHandle;
  typedef void* TagHandle;        

  // 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;


  void invert(int conn_type);


  MesqPane(COM::Pane* p, bool with_ghost = true) 
    : _pane(p), _verb(0), _with_ghost(with_ghost){
    init();
  }
  
  void set_verb(int verb){
    _verb = verb;
  }

  virtual ~MesqPane();


  void init();

  //************ Operations on entire mesh ****************
  virtual int get_geometric_dimension(MsqError &err) {
    if(_verb >1) 
      std::cout << "MesqPane::get_geometric_dimension\n";
    return 3;  
  }

  // NEW
    virtual void get_all_elements( msq_std::vector<ElementHandle>& elements,
                                   MsqError& err );
    
  // NEW
    virtual void get_all_vertices( msq_std::vector<VertexHandle>& vertices,
                                   MsqError& err );
    
  virtual void get_all_sizes( size_t& vertex_count,
                              size_t& element_count,
                              size_t& vertex_use_count,
                              MsqError& err ){
    vertex_count = _with_ghost ? _pane->size_of_nodes() : 
      _pane->size_of_real_nodes();
    element_count = _with_ghost ? _pane->size_of_elements() : 
      _pane->size_of_real_elements();
    std::vector<const COM::Connectivity*> conns;
    _pane->connectivities(conns);
    vertex_use_count = 0;
    for(int i=0, ni = conns.size(); i<ni; ++i){
      vertex_use_count += conns[i]->size_of_nodes_pe() *
        (_with_ghost ? conns[i]->size_of_elements() :
         conns[i]->size_of_real_elements());
    }
  }
    
  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 );
    
  virtual VertexIterator* vertex_iterator(MsqError &err);
    
  virtual ElementIterator* element_iterator(MsqError &err);

  //************ Vertex Properties ********************
  
    // NEW
  virtual void vertices_get_fixed_flag( const VertexHandle vert_array[], 
                                        bool fixed_flag_array[],
                                        size_t num_vtx, 
                                        MsqError &err );
  
  virtual bool vertex_is_fixed(VertexHandle vertex, MsqError &err);

  virtual void vertices_are_on_boundary(VertexHandle vert_array[], bool on_bnd[],
                                        size_t num_vtx, MsqError &err);
    
  virtual void vertices_get_coordinates(const VertexHandle vert_array[],
                                        MsqVertex* coordinates,
                                        size_t num_vtx,
                                        MsqError &err);

  virtual void vertex_set_coordinates(VertexHandle vertex,
                                      const Vector3D &coordinates,
                                      MsqError &err);
    
  virtual void vertex_set_byte (VertexHandle vertex,
                                unsigned char byte, MsqError &err);

  virtual void vertices_set_byte (VertexHandle *vert_array,
                                  unsigned char *byte_array,
                                  size_t array_size, MsqError &err);

  // NEW
  virtual void vertices_set_byte( const VertexHandle *vert_array,
                                  const unsigned char *byte_array,
                                  size_t array_size, 
                                  MsqError &err );
  
  virtual void vertex_get_byte(VertexHandle vertex,
                               unsigned char *byte, MsqError &err);
  virtual void vertices_get_byte(VertexHandle *vertex,
                                 unsigned char *byte_array,
                                 size_t array_size, MsqError &err);
  
  // NEW
  virtual void vertices_get_byte( const VertexHandle *vertex,
                                  unsigned char *byte_array,
                                  size_t array_size, 
                                  MsqError &err ){;}

    
  //**************** Vertex Topology *****************    
  virtual size_t vertex_get_attached_element_count(VertexHandle vertex,
                                                   MsqError &err);
    
  virtual void vertex_get_attached_elements(VertexHandle vertex,
                                            ElementHandle* elem_array,
                                            size_t sizeof_elem_array,
                                            MsqError &err);

  // NEW
  virtual void 
  vertices_get_attached_elements(const VertexHandle* vertex_array,
                                 size_t num_vertex,
                                 msq_std::vector<ElementHandle>& elements,
                                 msq_std::vector<size_t>& offsets,
                                 MsqError& err );

  //*************** Element Topology *************
    

  virtual size_t element_get_attached_vertex_count(ElementHandle elem,
                                                   MsqError &err);

  virtual size_t get_vertex_use_count( ElementHandle* handle_array,
                                       size_t num_handles,
                                       MsqError& err );

  // NEW

    virtual void elements_get_attached_vertices(
                                                const ElementHandle *elem_handles,
                                   size_t num_elems,
                                   msq_std::vector<VertexHandle>& vert_handles,
                                   msq_std::vector<size_t>& offsets, 
                                                MsqError &err);
  
  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);
    
  virtual EntityTopology element_get_topology(ElementHandle entity_handle,
                                              MsqError &err);

  virtual void elements_get_topologies(ElementHandle *element_handle_array,
                                       EntityTopology *element_topologies,
                                       size_t num_elements, MsqError &err);

  //NEW
  
  virtual void elements_get_topologies(const ElementHandle *element_handle_array,
                                       EntityTopology *element_topologies,
                                       size_t num_elements, MsqError &err);
    
  //***************  Tags  ***********

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

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

    
    
  //**************** Memory Management ****************

    // NEW
  virtual void release_entity_handles( const EntityHandle *handle_array,
                                       size_t num_handles, 
                                       MsqError &err);

  virtual void release_entity_handles(EntityHandle *handle_array,
                                      size_t num_handles, MsqError &err);
    
  virtual void release();

protected:
  COM::Pane* _pane;
  MAP::Pane_dual_connectivity* _dc;
  std::vector<bool> _is_border;
  std::vector<unsigned char> _vertexBytes;
    
  int  _verb; // 1 for function start/end
  // 2 for all information
  // 0 = nothing
    
  bool _with_ghost; // If true(default), then use ghost information.
  
  struct tagStruct {
    unsigned size; // tag size: # of values per entity
    TagType  type; // tag type
    void *  edata; // elemental data
    void *  ndata; // nodal data
    msq_std::string name;
  };

#if 0
  tagStruct::tagStruct()
    : size(0), type(0), edata(NULL), ndata(NULL), dval(NULL)
  {
    ;
  }
#endif

  std::map<msq_std::string,tagStruct> s_to_t;

};
  

#if 0
inline size_t Mesquite::vertices_in_topology(Mesquite::EntityTopology topo)
{
  return TopologyInfo::corners( topo );
}
#endif

class MyEntityIterator : public Mesquite::EntityIterator{
public:
  
  MyEntityIterator(uint size){ _cur = 1; _size = size;}

  virtual ~MyEntityIterator()
  {_cur = 0;
    _size = 0;
  }
  
  virtual void restart(){
    _cur = 1;
  };
  
  virtual Mesh::EntityHandle operator*() const {
    if (_cur > _size)
      return 0;
    else
      return (char*)NULL+_cur;
  }
  
  virtual void operator++(){
    _cur ++;
  }
  

  virtual bool is_at_end() const{
    if (_cur <= _size) return 0;
    else return 1;
  }
private:
  uint  _cur; // The current node's position.
  uint  _size;// The size of the element array
};

MESQUITE_END_NAMESPACE

#endif