MeshSetSequence.cpp

Go to the documentation of this file.

/*
 * MOAB, a Mesh-Oriented datABase, is a software component for creating,
 * storing and accessing finite element mesh data.
 *
 * Copyright 2004 Sandia Corporation. Under the terms of Contract
 * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government
 * retains certain rights in this software.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 */
 
/**\file MeshSetSequence.cpp
 *\author Jason Kraftcheck ([email protected])
 *\date 2007-04-30
 */
 
#include "MeshSetSequence.hpp"
#include "SequenceManager.hpp"
 
namespace moab
{
 
MeshSetSequence::MeshSetSequence( EntityHandle start, EntityID count, const unsigned* flags, SequenceData* dat )
 : EntitySequence( start, count, dat )
{
 initialize( flags );
}
 
MeshSetSequence::MeshSetSequence( EntityHandle start, EntityID count, unsigned flags, SequenceData* dat )
 : EntitySequence( start, count, dat )
{
 std::vector< unsigned > vect( count, flags );
 initialize( &vect[0] );
}
 
MeshSetSequence::MeshSetSequence( EntityHandle start, EntityID count, const unsigned* flags, EntityID data_size )
 : EntitySequence( start, count, new SequenceData( 1, start, start + data_size - 1 ) )
{
 initialize( flags );
}
 
MeshSetSequence::MeshSetSequence( EntityHandle start, EntityID count, unsigned flags, EntityID data_size )
 : EntitySequence( start, count, new SequenceData( 1, start, start + data_size - 1 ) )
{
 std::vector< unsigned > vect( count, flags );
 initialize( &vect[0] );
}
 
void MeshSetSequence::initialize( const unsigned* flags )
{
 if( !data()->get_sequence_data( 0 ) ) data()->create_sequence_data( 0, SET_SIZE );
 
 EntityID offset = start_handle() - data()->start_handle();
 for( EntityID i = 0; i < size(); ++i )
 allocate_set( flags[i], i + offset );
}
 
MeshSetSequence::~MeshSetSequence()
{
 EntityID offset = start_handle() - data()->start_handle();
 EntityID count = size();
 for( EntityID i = 0; i < count; ++i )
 deallocate_set( i + offset );
}
 
EntitySequence* MeshSetSequence::split( EntityHandle here )
{
 return new MeshSetSequence( *this, here );
}
 
ErrorCode MeshSetSequence::pop_back( EntityID count )
{
 EntityID offset = end_handle() + 1 - count - data()->start_handle();
 ErrorCode rval = EntitySequence::pop_back( count );
 if( MB_SUCCESS == rval )
 for( EntityID i = 0; i < count; ++i )
 deallocate_set( i + offset );
 return rval;
}
 
ErrorCode MeshSetSequence::pop_front( EntityID count )
{
 EntityID offset = start_handle() - data()->start_handle();
 ErrorCode rval = EntitySequence::pop_front( count );
 if( MB_SUCCESS == rval )
 for( EntityID i = 0; i < count; ++i )
 deallocate_set( i + offset );
 return rval;
}
 
ErrorCode MeshSetSequence::push_back( EntityID count, const unsigned* flags )
{
 EntityID offset = end_handle() + 1 - data()->start_handle();
 ErrorCode rval = EntitySequence::append_entities( count );
 if( MB_SUCCESS == rval )
 for( EntityID i = 0; i < count; ++i )
 allocate_set( flags[i], i + offset );
 return rval;
}
 
ErrorCode MeshSetSequence::push_front( EntityID count, const unsigned* flags )
{
 EntityID offset = start_handle() - data()->start_handle() - count;
 ErrorCode rval = EntitySequence::prepend_entities( count );
 if( MB_SUCCESS == rval )
 for( EntityID i = 0; i < count; ++i )
 allocate_set( flags[i], i + offset );
 return rval;
}
 
void MeshSetSequence::get_const_memory_use( unsigned long& per_ent, unsigned long& seq_size ) const
{
 per_ent = SET_SIZE;
 seq_size = sizeof( *this );
}
 
unsigned long MeshSetSequence::get_per_entity_memory_use( EntityHandle first, EntityHandle last ) const
{
 if( first < start_handle() ) first = start_handle();
 if( last > end_handle() ) last = end_handle();
 
 unsigned long sum = 0;
 for( EntityHandle h = first; h <= last; ++h )
 sum += get_set( h )->get_memory_use();
 return sum;
}
 
ErrorCode MeshSetSequence::get_entities( const SequenceManager* seqman,
 EntityHandle handle,
 Range& entities,
 bool recursive ) const
{
 if( !recursive )
 {
 get_set( handle )->get_entities( entities );
 return MB_SUCCESS;
 }
 else
 {
 std::vector< const MeshSet* > list;
 ErrorCode rval = recursive_get_sets( handle, seqman, &list );
 for( std::vector< const MeshSet* >::iterator i = list.begin(); i != list.end(); ++i )
 ( *i )->get_non_set_entities( entities );
 return rval;
 }
}
 
ErrorCode MeshSetSequence::get_entities( EntityHandle handle, std::vector< EntityHandle >& entities ) const
{
 get_set( handle )->get_entities( entities );
 return MB_SUCCESS;
}
 
ErrorCode MeshSetSequence::get_dimension( const SequenceManager* seqman,
 EntityHandle handle,
 int dimension,
 std::vector< EntityHandle >& entities,
 bool recursive ) const
{
 if( !recursive )
 {
 get_set( handle )->get_entities_by_dimension( dimension, entities );
 return MB_SUCCESS;
 }
 else
 {
 std::vector< const MeshSet* > list;
 ErrorCode rval = recursive_get_sets( handle, seqman, &list );
 for( std::vector< const MeshSet* >::iterator i = list.begin(); i != list.end(); ++i )
 ( *i )->get_entities_by_dimension( dimension, entities );
 return rval;
 }
}
 
ErrorCode MeshSetSequence::get_dimension( const SequenceManager* seqman,
 EntityHandle handle,
 int dimension,
 Range& entities,
 bool recursive ) const
{
 if( !recursive )
 {
 get_set( handle )->get_entities_by_dimension( dimension, entities );
 return MB_SUCCESS;
 }
 else
 {
 std::vector< const MeshSet* > list;
 ErrorCode rval = recursive_get_sets( handle, seqman, &list );
 for( std::vector< const MeshSet* >::iterator i = list.begin(); i != list.end(); ++i )
 ( *i )->get_entities_by_dimension( dimension, entities );
 return rval;
 }
}
 
ErrorCode MeshSetSequence::get_type( const SequenceManager* seqman,
 EntityHandle handle,
 EntityType tp,
 std::vector< EntityHandle >& entities,
 bool recursive ) const
{
 if( !recursive )
 {
 get_set( handle )->get_entities_by_type( tp, entities );
 return MB_SUCCESS;
 }
 else if( tp == MBENTITYSET )
 {
 return recursive_get_sets( handle, seqman, 0, 0, &entities );
 }
 else if( tp == MBMAXTYPE )
 {
 Range tmp;
 ErrorCode rval = get_entities( seqman, handle, tmp, recursive );
 if( MB_SUCCESS == rval )
 {
#ifdef MOAB_NO_VECTOR_TEMPLATE_INSERT
 std::copy( tmp.begin(), tmp.end(), std::back_inserter( entities ) );
#else
 entities.insert( entities.end(), tmp.begin(), tmp.end() );
#endif
 }
 return rval;
 }
 else
 {
 std::vector< const MeshSet* > list;
 ErrorCode rval = recursive_get_sets( handle, seqman, &list );
 for( std::vector< const MeshSet* >::iterator i = list.begin(); i != list.end(); ++i )
 ( *i )->get_entities_by_type( tp, entities );
 return rval;
 }
}
 
ErrorCode MeshSetSequence::get_type( const SequenceManager* seqman,
 EntityHandle handle,
 EntityType tp,
 Range& entities,
 bool recursive ) const
{
 if( !recursive )
 {
 get_set( handle )->get_entities_by_type( tp, entities );
 return MB_SUCCESS;
 }
 else if( tp == MBENTITYSET )
 {
 return recursive_get_sets( handle, seqman, 0, &entities );
 }
 else if( tp == MBMAXTYPE )
 {
 std::vector< const MeshSet* > list;
 ErrorCode rval = recursive_get_sets( handle, seqman, &list );
 for( std::vector< const MeshSet* >::iterator i = list.begin(); i != list.end(); ++i )
 ( *i )->get_non_set_entities( entities );
 return rval;
 }
 else
 {
 std::vector< const MeshSet* > list;
 ErrorCode rval = recursive_get_sets( handle, seqman, &list );
 for( std::vector< const MeshSet* >::iterator i = list.begin(); i != list.end(); ++i )
 ( *i )->get_entities_by_type( tp, entities );
 return rval;
 }
}
 
ErrorCode MeshSetSequence::num_entities( const SequenceManager* seqman,
 EntityHandle handle,
 int& number,
 bool recursive ) const
{
 if( !recursive )
 {
 number = get_set( handle )->num_entities();
 return MB_SUCCESS;
 }
 else
 {
 Range range;
 ErrorCode result = get_entities( seqman, handle, range, true );
 number = range.size();
 return result;
 }
}
 
ErrorCode MeshSetSequence::num_dimension( const SequenceManager* seqman,
 EntityHandle handle,
 int dimension,
 int& number,
 bool recursive ) const
{
 if( !recursive )
 {
 number = get_set( handle )->num_entities_by_dimension( dimension );
 return MB_SUCCESS;
 }
 else
 {
 Range range;
 ErrorCode result = get_dimension( seqman, handle, dimension, range, true );
 number = range.size();
 return result;
 }
}
 
ErrorCode MeshSetSequence::num_type( const SequenceManager* seqman,
 EntityHandle handle,
 EntityType tp,
 int& number,
 bool recursive ) const
{
 if( !recursive )
 {
 number = get_set( handle )->num_entities_by_type( tp );
 return MB_SUCCESS;
 }
 else
 {
 Range range;
 ErrorCode result = get_type( seqman, handle, tp, range, true );
 number = range.size();
 return result;
 }
}
 
ErrorCode MeshSetSequence::recursive_get_sets( EntityHandle start_set,
 const SequenceManager* seq_sets,
 std::vector< const MeshSet* >* sets,
 Range* set_handles,
 std::vector< EntityHandle >* set_vector )
{
 std::set< EntityHandle > visited;
 std::vector< EntityHandle > stack;
 stack.push_back( start_set );
 bool remove_start_set = true;
 while( !stack.empty() )
 {
 EntityHandle handle = stack.back();
 stack.pop_back();
 
 if( !visited.insert( handle ).second )
 {
 if( handle == start_set ) remove_start_set = false;
 continue;
 }
 
 const EntitySequence* seq;
 ErrorCode rval = seq_sets->find( handle, seq );
 if( MB_SUCCESS != rval ) return rval;
 
 const MeshSetSequence* mseq = reinterpret_cast< const MeshSetSequence* >( seq );
 const MeshSet* ms_ptr = mseq->get_set( handle );
 if( sets ) sets->push_back( ms_ptr );
 
 Range tmp_range;
 ms_ptr->get_entities_by_type( MBENTITYSET, tmp_range );
 std::copy( tmp_range.begin(), tmp_range.end(), std::back_inserter( stack ) );
 }
 
 if( set_handles )
 {
 if( remove_start_set ) visited.erase( start_set );
 Range::iterator hint = set_handles->begin();
 std::set< EntityHandle >::iterator it;
 for( it = visited.begin(); it != visited.end(); ++it )
 hint = set_handles->insert( hint, *it, *it );
 }
 
 if( set_vector )
 {
 if( remove_start_set ) visited.erase( start_set );
 std::copy( visited.begin(), visited.end(), std::back_inserter( *set_vector ) );
 }
 
 return MB_SUCCESS;
}
 
ErrorCode MeshSetSequence::recursive_get_sets( EntityHandle start_set,
 SequenceManager* seq_sets,
 std::vector< MeshSet* >& sets )
{
 std::set< EntityHandle > visited;
 std::vector< EntityHandle > stack;
 stack.push_back( start_set );
 while( !stack.empty() )
 {
 EntityHandle handle = stack.back();
 stack.pop_back();
 
 if( !visited.insert( handle ).second ) continue;
 
 EntitySequence* seq;
 ErrorCode rval = seq_sets->find( handle, seq );
 if( MB_SUCCESS != rval ) return rval;
 
 MeshSetSequence* mseq = reinterpret_cast< MeshSetSequence* >( seq );
 MeshSet* ms_ptr = mseq->get_set( handle );
 sets.push_back( ms_ptr );
 
 Range tmp_range;
 ms_ptr->get_entities_by_type( MBENTITYSET, tmp_range );
 std::copy( tmp_range.begin(), tmp_range.end(), std::back_inserter( stack ) );
 }
 
 return MB_SUCCESS;
}
 
ErrorCode MeshSetSequence::get_parent_child_meshsets( EntityHandle meshset,
 const SequenceManager* seq_sets,
 std::vector< EntityHandle >& results,
 int num_hops,
 SearchType link_type ) const
{
 ErrorCode result = MB_SUCCESS;
 std::vector< EntityHandle >::iterator i;
 const EntityHandle *tmp_array = 0, *end;
 EntityHandle s, e;
 int count = 0;
 size_t n;
 
 // Skip any meshsets already in input vector (yes, don't
 // get their children either even if num_hops would indicate
 // that we should.) There is an exception to that if the
 // input meshset is in the list, which is handled by the order
 // of checks in the main loop below.
 std::set< EntityHandle > visited;
 for( i = results.begin(); i != results.end(); ++i )
 visited.insert( *i );
 
 // Two lists for breadth-first search
 std::vector< EntityHandle > lists[2];
 int index = 0; // which list to read from (write to lists[1-index])
 lists[index].push_back( meshset ); // begin with input set
 // loop for num_hops (or until no more sets)
 for( ; num_hops && !lists[index].empty(); --num_hops )
 {
 // for each set at the current num_hops
 for( i = lists[index].begin(); i != lists[index].end(); ++i )
 {
 // get meshset from handle
 const EntitySequence* seq;
 ErrorCode rval = seq_sets->find( *i, seq );
 if( MB_SUCCESS != rval ) return rval;
 const MeshSet* ms_ptr = reinterpret_cast< const MeshSetSequence* >( seq )->get_set( *i );
 
 switch( link_type )
 {
 case CONTAINED:
 tmp_array = ms_ptr->get_contents( n );
 end = tmp_array + n;
 if( ms_ptr->vector_based() )
 {
 for( ; tmp_array != end; ++tmp_array )
 if( MBENTITYSET == TYPE_FROM_HANDLE( *tmp_array ) && visited.insert( *tmp_array ).second )
 lists[1 - index].push_back( *tmp_array );
 }
 else
 {
 assert( n % 2 == 0 );
 tmp_array = std::lower_bound( tmp_array, tmp_array + n, FIRST_HANDLE( MBENTITYSET ) );
 // only part of first block is of type
 if( ( end - tmp_array ) % 2 )
 {
 ++tmp_array;
 s = FIRST_HANDLE( MBENTITYSET );
 e = *tmp_array;
 for( ; s <= e; ++s )
 if( visited.insert( s ).second ) lists[1 - index].push_back( s );
 }
 while( tmp_array < end )
 {
 s = *tmp_array++;
 e = *tmp_array++;
 for( ; s <= e; ++s )
 if( visited.insert( s ).second ) lists[1 - index].push_back( s );
 }
 }
 continue;
 case PARENTS:
 tmp_array = ms_ptr->get_parents( count );
 break;
 case CHILDREN:
 tmp_array = ms_ptr->get_children( count );
 break;
 }
 
 // copy any parents/children we haven't visited yet into list
 for( end = tmp_array + count; tmp_array != end; ++tmp_array )
 if( visited.insert( *tmp_array ).second ) lists[1 - index].push_back( *tmp_array );
 }
 
 // iterate
 lists[index].clear();
 index = 1 - index;
 // append each level of sets to the output list.
 // note: to make a more useful search (e.g. get entities 3 hops away,
 // rather than entities up to and including 3 hops) move this outside
 // the loop, but then need to handle the get all (num_hops < 0) case
 // specially.
 std::copy( lists[index].begin(), lists[index].end(), std::back_inserter( results ) );
 }
 
 return result;
}
 
ErrorCode MeshSetSequence::get_parents( const SequenceManager* seqman,
 EntityHandle handle,
 std::vector< EntityHandle >& parents,
 int num_hops ) const
{
 if( num_hops == 1 )
 {
 int count;
 const EntityHandle* tmp_array = get_set( handle )->get_parents( count );
 if( parents.empty() )
 {
 parents.resize( count );
 std::copy( tmp_array, tmp_array + count, parents.begin() );
 return MB_SUCCESS;
 }
 else if( !count )
 {
 return MB_SUCCESS;
 }
 }
 
 if( num_hops > 0 )
 return get_parent_child_meshsets( handle, seqman, parents, num_hops, PARENTS );
 else
 return get_parent_child_meshsets( handle, seqman, parents, -1, PARENTS );
}
 
ErrorCode MeshSetSequence::get_children( const SequenceManager* seqman,
 EntityHandle handle,
 std::vector< EntityHandle >& children,
 int num_hops ) const
{
 if( num_hops == 1 )
 {
 int count;
 const EntityHandle* tmp_array = get_set( handle )->get_children( count );
 if( children.empty() )
 {
 children.resize( count );
 std::copy( tmp_array, tmp_array + count, children.begin() );
 return MB_SUCCESS;
 }
 else if( !count )
 {
 return MB_SUCCESS;
 }
 }
 
 if( num_hops > 0 )
 return get_parent_child_meshsets( handle, seqman, children, num_hops, CHILDREN );
 else
 return get_parent_child_meshsets( handle, seqman, children, -1, CHILDREN );
}
 
ErrorCode MeshSetSequence::get_contained_sets( const SequenceManager* seqman,
 EntityHandle handle,
 std::vector< EntityHandle >& contained,
 int num_hops ) const
{
 if( num_hops == 1 && contained.empty() )
 {
 return get_set( handle )->get_entities_by_type( MBENTITYSET, contained );
 }
 
 if( num_hops > 0 )
 return get_parent_child_meshsets( handle, seqman, contained, num_hops, CONTAINED );
 else
 return get_parent_child_meshsets( handle, seqman, contained, -1, CONTAINED );
}
 
ErrorCode MeshSetSequence::num_parents( const SequenceManager* seqman,
 EntityHandle handle,
 int& number,
 int num_hops ) const
{
 if( num_hops == 1 )
 {
 number = get_set( handle )->num_parents();
 return MB_SUCCESS;
 }
 
 std::vector< EntityHandle > parents;
 ErrorCode result = get_parents( seqman, handle, parents, num_hops );
 number = parents.size();
 return result;
}
 
ErrorCode MeshSetSequence::num_children( const SequenceManager* seqman,
 EntityHandle handle,
 int& number,
 int num_hops ) const
{
 if( num_hops == 1 )
 {
 number = get_set( handle )->num_children();
 return MB_SUCCESS;
 }
 
 std::vector< EntityHandle > children;
 ErrorCode result = get_children( seqman, handle, children, num_hops );
 number = children.size();
 return result;
}
 
ErrorCode MeshSetSequence::num_contained_sets( const SequenceManager* seqman,
 EntityHandle handle,
 int& number,
 int num_hops ) const
{
 if( num_hops == 1 )
 {
 number = get_set( handle )->num_entities_by_type( MBENTITYSET );
 return MB_SUCCESS;
 }
 
 std::vector< EntityHandle > contained;
 ErrorCode result = get_contained_sets( seqman, handle, contained, num_hops );
 number = contained.size();
 return result;
}
 
} // namespace moab