MesqPane.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.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

#include "Mesquite.hpp"
#include "MeshInterface.hpp"
#include "MesquiteError.hpp"
#include "InstructionQueue.hpp"
#include "MeshSet.hpp"
#include "TerminationCriterion.hpp"
#include "QualityAssessor.hpp"

// algorithms
#include "MeanRatioQualityMetric.hpp"
#include "EdgeLengthQualityMetric.hpp"
#include "LPtoPTemplate.hpp"
#include "FeasibleNewton.hpp"
#include "ConjugateGradient.hpp"
#include "MsqMessage.hpp"
using namespace Mesquite;
#include "MeshInterface.hpp"
#include "MesquiteError.hpp"
#include "MsqVertex.hpp"

#include "Pane.h"
#include "Pane_boundary.h"
#include "Dual_connectivity.h"
#include "mopbasic.h"
#include "roccom_devel.h"

#define MESQUITE_BEGIN_NAMESPACE namespace Mesquite{
#define MESQUITE_END_NAMESPACE }

using namespace std;
USE_MOP_NAMESPACE
MESQUITE_BEGIN_NAMESPACE

using std::string;

class EntityIterator;
typedef EntityIterator VertexIterator;
typedef EntityIterator ElementIterator;


class MesqPane : public Mesquite::Mesh {
  
  inline size_t vertices_in_topology(EntityTopology);
  
public:


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

  virtual ~MesqPane();

  //\}
  // end of Constructors and Destructors


  void invert();
  

  void init();

  void set_verb(int verb){
    _verb = verb;
  }

  //\} End of Miscellaneous functions
  
  
  virtual int get_geometric_dimension(MsqError &err) const {
    if(_verb >1) std::cout << "MesqPane::get_geometric_dimension" << std::endl;
    return 3;  
  }
  
  virtual size_t get_total_vertex_count(MsqError &err) const {
    if(_verb >1) std::cout << "MesqPane::get_total_vertex_count" << std::endl;
    return _with_ghost ? _pane->size_of_nodes() : _pane->size_of_real_nodes();  
  }

  virtual size_t get_total_element_count(MsqError &err) const {
    if(_verb >1) std::cout << "MesqPane::get_total_element_count" << std::endl;
    return _with_ghost ? _pane->size_of_elements() : _pane->size_of_real_elements();  }

  

  virtual void get_all_vertices(VertexHandle *vert_array,
                                size_t array_size, MsqError &err);


  virtual void get_all_elements(ElementHandle *elem_array,
                                size_t array_size, MsqError &err);
  


  virtual VertexIterator* vertex_iterator(MsqError &err);
  

  virtual ElementIterator* element_iterator(MsqError &err);

  //\}
  // end Inherited Operations on Entire Mesh
  

  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(VertexHandle vert_array[],
                                        Mesquite::MsqVertex* const &coordinates,
                                        const 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);
  

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

  //\}
  // end Inherited Vertex Properties
  
  virtual size_t vertex_get_attached_element_count(VertexHandle vertex,
                                                   MsqError &err) const;
  
  virtual void vertex_get_attached_elements(VertexHandle vertex,
                                            ElementHandle* elem_array,
                                            size_t sizeof_elem_array,
                                            MsqError &err);
  
  //\}
  // end Inherited Vertex Topology

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

  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 void elements_get_attached_vertex_indices(ElementHandle element[],
                                                    size_t num_elems,
                                                    size_t index_array[],
                                                    size_t array_size,
                                                    size_t* offsets,
                                                    MsqError &err);
  
  virtual EntityTopology element_get_topology(ElementHandle entity_handle,
                                              MsqError &err) const;


  virtual void elements_get_topologies(ElementHandle *element_handle_array,
                                       EntityTopology *element_topologies,
                                       size_t num_elements, MsqError &err);
  
  //\}
  // end Inherited Element Topology


  virtual void element_tag_create(const string tag_name,
                                  int tag_size,
                                  TagHandle& tag_handle,
                                  MsqError &err);
    
   virtual void* tag_get_handle(const string tag_name, MsqError &err);
  
  

  virtual void elements_set_tag_data(const size_t num_elements, 
                                     const TagHandle tag_handle,
                                     TagDataPt const tag_data_array,
                                     const int& tag_size,
                                     MsqError &err);
  

  virtual void elements_get_tag_data(const size_t num_elements,
                                     const TagHandle tag_handle,
                                     TagDataPt &tag_data_array,
                                     int& tag_size,
                                     MsqError &err);
  //\}
  // end Inherited Tags
  
  virtual void release_entity_handles(EntityHandle *handle_array,
                                      size_t num_handles, MsqError &err);
  

  virtual void release();
  
  //\}
  // end of Inherited Memory Management.


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 tag {
    void* pt; // points to the beginning of the dense tag array
    int size; // size is the increment to use to go from one tag to the next
  };
  std::map<std::string, MesqPane::tag> denseTags; 
};

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 
// end namespace MESQUITE
#endif