moab
|
#include <MixedCellConnectivity.h>
Classes | |
struct | RunLengthInfo |
Public Member Functions | |
MixedCellConnectivity (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, vtkIdType *cellLocations, unsigned char *cellTypes) const |
Private Types | |
typedef std::vector < EntityHandle > ::const_iterator | EntityConstIterator |
typedef std::vector < EntityHandle * > ::const_iterator | ConnConstIterator |
typedef std::vector < RunLengthInfo > ::const_iterator | InfoConstIterator |
Private Attributes | |
std::vector< EntityHandle * > | Connectivity |
std::vector< EntityHandle > | UniquePoints |
std::vector< RunLengthInfo > | Info |
Definition at line 59 of file MixedCellConnectivity.h.
typedef std::vector<EntityHandle*>::const_iterator smoab::MixedCellConnectivity::ConnConstIterator [private] |
Definition at line 267 of file MixedCellConnectivity.h.
typedef std::vector<EntityHandle>::const_iterator smoab::MixedCellConnectivity::EntityConstIterator [private] |
Definition at line 266 of file MixedCellConnectivity.h.
typedef std::vector<RunLengthInfo>::const_iterator smoab::MixedCellConnectivity::InfoConstIterator [private] |
Definition at line 268 of file MixedCellConnectivity.h.
smoab::MixedCellConnectivity::MixedCellConnectivity | ( | smoab::Range const & | cells, |
moab::Interface * | moab | ||
) | [inline] |
Definition at line 62 of file MixedCellConnectivity.h.
: 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) { break; } //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); //while all these cells are contiously of the same type, //quadric hexs in vtk have 20 points, but moab has 21 so we //need to store this difference int numVTKVerts = numVerts; int vtkCellType = smoab::vtkCellType(type,numVTKVerts); RunLengthInfo info = { vtkCellType, numVerts, (numVerts-numVTKVerts), iterationCount }; this->Info.push_back(info); this->Connectivity.push_back(connectivity); count += iterationCount; } }
void smoab::MixedCellConnectivity::compactIds | ( | vtkIdType & | numCells, |
vtkIdType & | connectivityLength | ||
) | [inline] |
Definition at line 104 of file MixedCellConnectivity.h.
{ //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::MixedCellConnectivity::copyConnectivity | ( | std::vector< EntityHandle > & | output | ) | const [inline] |
Definition at line 146 of file MixedCellConnectivity.h.
{ //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; if(numUnusedPoints==0) { const int connLength = (*i).numCells * (*i).numVerts; std::copy(*c,*c+connLength,std::back_inserter(output)); } else { //we have cell connectivity that we need to skip, //so we have to manual copy each cells connectivity const int size = (*i).numCells; const int numPoints = (*i).numVerts; for(int i=0; i < size; ++i) { std::copy(*c,*c+numPoints,std::back_inserter(output)); } c+=numPoints + (*i).numUnusedVerts; } } }
void smoab::MixedCellConnectivity::copyToVtkCellInfo | ( | vtkIdType * | cellArray, |
vtkIdType * | cellLocations, | ||
unsigned char * | cellTypes | ||
) | const [inline] |
Definition at line 182 of file MixedCellConnectivity.h.
{ vtkIdType currentVtkConnectivityIndex = 0; 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; std::fill_n(cellTypes, numCells, static_cast<unsigned char>((*i).type)); //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 EntityHandle* moabConnectivity = *c; for(int j=0;j < numCells; ++j) { cellLocations[j]= currentVtkConnectivityIndex; //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); } //skip any extra unused points, which is currnetly only //the extra center point in moab quadratic hex moabConnectivity+=(*i).numUnusedVerts; currentVtkConnectivityIndex += numVerts+1; cellArray += numVerts+1; } //For Tri-Quadratic-Hex and Quadratric-Wedge Moab and VTK //Differ on the order of the edge ids. For wedge we need to swap //indices 9,10,11 with 12,13,14 for each cell. For Hex we sawp //12,13,14,15 with 16,17,18,19 int vtkCellType = (*i).type; vtkIdType* connectivity = cellArray - (numCells * (numVerts+1)); if(vtkCellType == VTK_TRIQUADRATIC_HEXAHEDRON) { ::QuadratricOrdering<VTK_TRIQUADRATIC_HEXAHEDRON> newOrdering; ::FixQuadraticIdOrdering(connectivity, numCells, newOrdering); } else if(vtkCellType == VTK_QUADRATIC_WEDGE) { ::QuadratricOrdering<VTK_QUADRATIC_WEDGE> newOrdering; ::FixQuadraticIdOrdering(connectivity, numCells, newOrdering); } cellLocations += numCells; cellTypes += numCells; } }
void smoab::MixedCellConnectivity::moabPoints | ( | smoab::Range & | range | ) | const [inline] |
Definition at line 135 of file MixedCellConnectivity.h.
{ //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)); }
std::vector<EntityHandle*> smoab::MixedCellConnectivity::Connectivity [private] |
Definition at line 260 of file MixedCellConnectivity.h.
std::vector<RunLengthInfo> smoab::MixedCellConnectivity::Info [private] |
Definition at line 264 of file MixedCellConnectivity.h.
std::vector<EntityHandle> smoab::MixedCellConnectivity::UniquePoints [private] |
Definition at line 261 of file MixedCellConnectivity.h.