UnstructuredElemSeq.cpp

Go to the documentation of this file.

#include "UnstructuredElemSeq.hpp"
#include "SequenceData.hpp"
#include "moab/CN.hpp"
 
namespace moab
{
 
UnstructuredElemSeq::UnstructuredElemSeq( EntityHandle shandle,
 EntityID entity_count,
 unsigned nodes_per_entity,
 SequenceData* dat )
 : ElementSequence( shandle, entity_count, nodes_per_entity, dat )
{
}
 
UnstructuredElemSeq::UnstructuredElemSeq( EntityHandle shandle,
 EntityID entity_count,
 unsigned nodes_per_entity,
 EntityID data_size )
 : ElementSequence( shandle,
 entity_count,
 nodes_per_entity,
 new SequenceData( 1, shandle, shandle + data_size - 1 ) )
{
 data()->create_sequence_data( 0, nodes_per_entity * sizeof( EntityHandle ) );
}
 
UnstructuredElemSeq::~UnstructuredElemSeq() {}
 
int UnstructuredElemSeq::values_per_entity() const
{
 return nodes_per_element();
}
 
EntitySequence* UnstructuredElemSeq::split( EntityHandle here )
{
 if( here <= start_handle() || here > end_handle() ) return 0;
 
 return new UnstructuredElemSeq( *this, here );
}
 
SequenceData* UnstructuredElemSeq::create_data_subset( EntityHandle start, EntityHandle end ) const
{
 int esize = nodes_per_element() * sizeof( EntityHandle );
 return data()->subset( start, end, &esize );
}
 
void UnstructuredElemSeq::get_const_memory_use( unsigned long& bytes_per_entity, unsigned long& size_of_sequence ) const
{
 bytes_per_entity = nodes_per_element() * sizeof( EntityHandle );
 size_of_sequence = sizeof( *this );
}
 
ErrorCode UnstructuredElemSeq::get_connectivity( EntityHandle handle,
 std::vector< EntityHandle >& connect,
 bool topological ) const
{
 EntityHandle const* conn = get_array() + nodes_per_element() * ( handle - start_handle() );
 int len = topological ? CN::VerticesPerEntity( type() ) : nodes_per_element();
 connect.reserve( connect.size() + len );
 std::copy( conn, conn + len, std::back_inserter( connect ) );
 return MB_SUCCESS;
}
 
ErrorCode UnstructuredElemSeq::get_connectivity( EntityHandle handle,
 EntityHandle const*& conn_ptr,
 int& len,
 bool topological,
 std::vector< EntityHandle >* ) const
{
 conn_ptr = get_array() + nodes_per_element() * ( handle - start_handle() );
 len = topological ? CN::VerticesPerEntity( type() ) : nodes_per_element();
 return MB_SUCCESS;
}
 
ErrorCode UnstructuredElemSeq::set_connectivity( EntityHandle handle, EntityHandle const* connect, int connect_length )
{
 if( (unsigned)connect_length != nodes_per_element() ) return MB_INDEX_OUT_OF_RANGE;
 EntityHandle* conn_ptr = get_array() + nodes_per_element() * ( handle - start_handle() );
 std::copy( connect, connect + connect_length, conn_ptr );
 return MB_SUCCESS;
}
 
EntityHandle* UnstructuredElemSeq::get_connectivity_array()
{
 return get_array();
}
 
ErrorCode UnstructuredElemSeq::push_back( EntityID count )
{
 return EntitySequence::append_entities( count );
}
 
ErrorCode UnstructuredElemSeq::push_front( EntityID count )
{
 return EntitySequence::prepend_entities( count );
}
 
} // namespace moab