SweptElementSeq.hpp

Go to the documentation of this file.

#ifndef SWEPT_ELEMENT_SEQUENCE
#define SWEPT_ELEMENT_SEQUENCE

//
// Class: SweptElementSequence
//
// Purpose: represent a swept element of mesh
//

#include "ElementSequence.hpp"
#include "ScdElementData.hpp"

namespace moab {

class SweptElementSeq : public ElementSequence
{
public:

  SweptElementSeq(
          EntityHandle start_handle,
          const int imin, const int jmin, const int kmin,
          const int imax, const int jmax, const int kmax,
          const int* Cq );
  
  virtual ~SweptElementSeq();

  ScdElementData* sdata()  
  { return reinterpret_cast<ScdElementData*>(data()); } 
  ScdElementData const* sdata() const  
  { return reinterpret_cast<const ScdElementData*>(data()); } 
 
  EntityHandle get_vertex(const int i, const int j, const int k) const 
  { return get_vertex( HomCoord(i,j,k) ); } 
   
  inline EntityHandle get_vertex(const HomCoord &coords) const 
  { return sdata()->get_vertex(coords); } 
   
  EntityHandle get_element(const int i, const int j, const int k) const 
  { return sdata()->get_element( i, j, k ); } 
   
  EntityHandle get_element(const HomCoord &coords) const 
  { return sdata()->get_element( coords.i(), coords.j(), coords.k() ); } 
   
  const HomCoord &min_params() const 
  { return sdata()->min_params(); } 
  void min_params(HomCoord &coords) const 
  { coords = min_params(); } 
  void min_params(int &i, int &j, int &k) const 
  { i = min_params().i(); j = min_params().j(); k = min_params().k(); } 
 
  const HomCoord &max_params() const 
  { return sdata()->max_params(); } 
  void max_params(HomCoord &coords) const 
  { coords = max_params(); } 
  void max_params(int &i, int &j, int &k) const 
  { i = max_params().i(); j = max_params().j(); k = max_params().k(); } 
   
  void param_extents(int &di, int &dj, int &dk) const 
  { sdata()->param_extents( di, dj, dk ); } 
 
  ErrorCode get_params(const EntityHandle ehandle, 
                         int &i, int &j, int &k) const 
  { return sdata()->get_params( ehandle, i, j, k ); } 
   
  int i_min() const {return min_params().i();} 
  int j_min() const {return min_params().j();} 
  int k_min() const {return min_params().k();} 
  int i_max() const {return max_params().i();} 
  int j_max() const {return max_params().j();} 
  int k_max() const {return max_params().k();} 
 
  inline bool boundary_complete() const 
  { return sdata()->boundary_complete(); } 
 
  bool contains(const int i, const int j, const int k) const 
  { return sdata()->contains(HomCoord(i,j,k)); } 
  inline bool contains(const HomCoord &coords) const 
  { return sdata()->contains(coords); } 
 
  ErrorCode get_params_connectivity(const int i, const int j, const int k, 
                                      std::vector<EntityHandle>& connectivity) const 
  { return sdata()->get_params_connectivity( i, j, k, connectivity ); } 
   
    /***************** Methods from ElementSeq *****************/

  virtual ErrorCode get_connectivity( EntityHandle handle,
                                        std::vector<EntityHandle>& connect,
                                        bool topological = false ) const;
  
  virtual ErrorCode get_connectivity( EntityHandle handle,
                                        EntityHandle const*& connect,
                                        int &connect_length,
                                        bool topological = false,
                                        std::vector<EntityHandle>* storage = 0
                                       ) const;

  virtual ErrorCode set_connectivity( EntityHandle handle,
                                        EntityHandle const* connect,
                                        int connect_length );
  
  virtual EntityHandle* get_connectivity_array();
 
   /***************** Methods from EntitySequence *****************/

    /* Replace the ElementSequence implementation of this method with
     * one that always returns zero, because we cannot re-use handles
     * that are within a ScdElementData
     */
  virtual int values_per_entity() const;

  virtual EntitySequence* split( EntityHandle here );

  virtual SequenceData* create_data_subset( EntityHandle start_handle,
                                            EntityHandle end_handle ) const;

  virtual void get_const_memory_use( unsigned long& bytes_per_entity,
                                     unsigned long& size_of_sequence ) const;

protected:
  SweptElementSeq( SweptElementSeq& split_from, EntityHandle here )
    : ElementSequence( split_from, here )
    {}
};

} // namespace moab

#endif