MOAB: Mesh Oriented datABase  (version 5.4.1)
smoab::detail::LinearCellConnectivity Class Reference

#include <LinearCellConnectivity.h>

Public Member Functions

 LinearCellConnectivity (smoab::Range const &cells, moab::Interface *moab)
void compactIds (vtkIdType &numCells, vtkIdType &connectivityLength)
void moabPoints (smoab::Range &range) const
void copyConnectivity (std::vector< EntityHandle > &output) const
void copyToVtkCellInfo (vtkIdType *cellArray) const

Private Types

typedef std::vector
< EntityHandle >
typedef std::vector
< internal::SubsetArray >
typedef std::vector
< detail::ContinousCellInfo >

Private Attributes

< internal::SubsetArray
std::vector< EntityHandleUniquePoints
< detail::ContinousCellInfo

Detailed Description

Definition at line 67 of file LinearCellConnectivity.h.

Member Typedef Documentation

typedef std::vector< internal::SubsetArray >::const_iterator smoab::detail::LinearCellConnectivity::ConnConstIterator [private]

Definition at line 203 of file LinearCellConnectivity.h.

typedef std::vector< EntityHandle >::const_iterator smoab::detail::LinearCellConnectivity::EntityConstIterator [private]

Definition at line 202 of file LinearCellConnectivity.h.

Definition at line 204 of file LinearCellConnectivity.h.

Constructor & Destructor Documentation

Definition at line 70 of file LinearCellConnectivity.h.

References moab::Range::begin(), moab::Interface::connect_iterate(), Connectivity, moab::Range::end(), Info, moab::Range::size(), moab::Interface::type_from_handle(), smoab::detail::vtkCellType(), and smoab::detail::vtkLinearCellType().

            : Connectivity(), UniquePoints(), Info()
            int count                  = 0;
            const std::size_t cellSize = cells.size();
            while( count != cellSize )
                EntityHandle* connectivity;
                int numVerts = 0, iterationCount = 0;
                //use the highly efficent calls, since we know that are of the same dimension
                moab->connect_iterate( cells.begin() + count, cells.end(), connectivity, numVerts, iterationCount );
                //if we didn't read anything, break!
                if( iterationCount == 0 )

                //identify the cell type that we currently have,
                //store that along with the connectivity in a temp storage vector
                const moab::EntityType type = moab->type_from_handle( *cells.begin() + count );

                int vtkNumVerts;
                int vtkCellType = smoab::detail::vtkLinearCellType( type, vtkNumVerts );

                ContinousCellInfo info = { vtkCellType, vtkNumVerts, 0, iterationCount };
                this->Info.push_back( info );

                //we need to copy only a subset of the connectivity array
                internal::SubsetArray conn( connectivity, iterationCount, numVerts, vtkNumVerts );
                this->Connectivity.push_back( conn );

                count += iterationCount;

Member Function Documentation

void smoab::detail::LinearCellConnectivity::compactIds ( vtkIdType &  numCells,
vtkIdType &  connectivityLength 
) [inline]

Definition at line 106 of file LinearCellConnectivity.h.

References copyConnectivity(), Info, and UniquePoints.

Referenced by smoab::detail::LoadPoly::fill().

            //converts all the ids to be ordered starting at zero, and also
            //keeping the orginal logical ordering. Stores the result of this
            //operation in the unstrucutred grid that is passed in

            //lets determine the total length of the connectivity
            connectivityLength = 0;
            numCells           = 0;
            for( InfoConstIterator i = this->Info.begin(); i != this->Info.end(); ++i )
                connectivityLength += ( *i ).numCells * ( *i ).numVerts;
                numCells += ( *i ).numCells;

            this->UniquePoints.reserve( connectivityLength );

            this->copyConnectivity( this->UniquePoints );
            std::sort( this->UniquePoints.begin(), this->UniquePoints.end() );

            typedef std::vector< EntityHandle >::iterator EntityIterator;
            EntityIterator newEnd = std::unique( this->UniquePoints.begin(), this->UniquePoints.end() );

            const std::size_t newSize = std::distance( this->UniquePoints.begin(), newEnd );
            this->UniquePoints.resize( newSize );
void smoab::detail::LinearCellConnectivity::copyConnectivity ( std::vector< EntityHandle > &  output) const [inline]

Definition at line 143 of file LinearCellConnectivity.h.

References Connectivity, and Info.

Referenced by compactIds().

            //walk the info to find the length of each sub connectivity array,
            //and insert them into the vector, ordering is implied by the order
            //the connecitivy sub array are added to this class
            ConnConstIterator c = this->Connectivity.begin();
            for( InfoConstIterator i = this->Info.begin(); i != this->Info.end(); ++i, ++c )
                //remember our Connectivity is a vector of pointers whose
                //length is held in the info vector.
                const int numUnusedPoints = ( *i ).numUnusedVerts;
                const int connLength      = ( *i ).numCells * ( *i ).numVerts;
                std::copy( c->begin(), c->end(), std::back_inserter( output ) );
void smoab::detail::LinearCellConnectivity::copyToVtkCellInfo ( vtkIdType *  cellArray) const [inline]

Definition at line 161 of file LinearCellConnectivity.h.

References Connectivity, Info, and UniquePoints.

Referenced by smoab::detail::LoadPoly::addGridsTopology().

            ConnConstIterator c = this->Connectivity.begin();
            for( InfoConstIterator i = this->Info.begin(); i != this->Info.end(); ++i, ++c )
                //for this group of the same cell type we need to fill the cellTypes
                const int numCells = ( *i ).numCells;
                const int numVerts = ( *i ).numVerts;

                //for each cell in this collection that have the same type
                //grab the raw array now, so we can properly increment for each vert in each cell
                internal::SubsetArray::const_iterator moabConnectivity = c->begin();
                for( int j = 0; j < numCells; ++j )
                    //cell arrays start and end are different, since we
                    //have to account for element that states the length of each cell
                    cellArray[0] = numVerts;

                    for( int k = 0; k < numVerts; ++k, ++moabConnectivity )
                        //this is going to be a root of some failures when we start
                        //reading really large datasets under 32bit.

                        //fyi, don't use a range ds for unique points, distance
                        //function is horribly slow they need to override it
                        EntityConstIterator result =
                            std::lower_bound( this->UniquePoints.begin(), this->UniquePoints.end(), *moabConnectivity );
                        std::size_t newId = std::distance( this->UniquePoints.begin(), result );
                        cellArray[k + 1]  = static_cast< vtkIdType >( newId );
                    cellArray += numVerts + 1;

Definition at line 134 of file LinearCellConnectivity.h.

References UniquePoints.

Referenced by smoab::detail::LoadPoly::addCoordinates().

            //from the documentation a reverse iterator is the fastest way
            //to insert into a range.
            std::copy( this->UniquePoints.rbegin(), this->UniquePoints.rend(), moab::range_inserter( range ) );

Member Data Documentation

List of all members.

The documentation for this class was generated from the following file:
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines