#include "SMDS_Mesh.hxx"
#include "SMDS_MeshInfo.hxx"
#include "SMDS_Downward.hxx"
+#include "SMDS_MeshVolume.hxx"
#include "utilities.h"
#include <vtkUnsignedCharArray.h>
#include <list>
+#include <climits>
using namespace std;
void SMDS_UnstructuredGrid::compactGrid(std::vector<int>& idNodesOldToNew, int newNodeSize,
std::vector<int>& idCellsOldToNew, int newCellSize)
{
- // TODO utiliser mieux vtk pour faire plus simple (plus couteux ?)
-
MESSAGE("------------------------- SMDS_UnstructuredGrid::compactGrid " << newNodeSize << " " << newCellSize);CHRONO(1);
- int startHole = 0;
- int endHole = 0;
- int startBloc = 0;
- int endBloc = 0;
int alreadyCopied = 0;
- int holes = 0;
-
- typedef enum
- {
- lookHoleStart, lookHoleEnd, lookBlocEnd
- } enumState;
- enumState compactState = lookHoleStart;
-
- // if (this->Links)
- // {
- // this->Links->UnRegister(this);
- // this->Links = 0;
- // }
// --- if newNodeSize, create a new compacted vtkPoints
- vtkPoints *newPoints = 0;
+ vtkPoints *newPoints = vtkPoints::New();
+ newPoints->SetDataType(VTK_DOUBLE);
+ newPoints->SetNumberOfPoints(newNodeSize);
if (newNodeSize)
{
MESSAGE("-------------- compactGrid, newNodeSize " << newNodeSize);
- newPoints = vtkPoints::New();
- newPoints->Initialize();
- newPoints->Allocate(newNodeSize);
- newPoints->SetNumberOfPoints(newNodeSize);
+ // rnv: to fix bug "21125: EDF 1233 SMESH: Degradation of precision in a test case for quadratic conversion"
+ // using double type for storing coordinates of nodes instead float.
int oldNodeSize = idNodesOldToNew.size();
- for (int i = 0; i < oldNodeSize; i++)
- {
- //MESSAGE(" " << i << " " << idNodesOldToNew[i]);
- switch (compactState)
- {
- case lookHoleStart:
- if (idNodesOldToNew[i] < 0)
- {
- MESSAGE("-------------- newNodeSize, startHole " << i << " " << oldNodeSize);
- startHole = i;
- if (!alreadyCopied) // copy the first bloc
- {
- MESSAGE("--------- copy first nodes before hole " << i << " " << oldNodeSize);
- copyNodes(newPoints, idNodesOldToNew, alreadyCopied, 0, startHole);
- }
- compactState = lookHoleEnd;
- }
- break;
- case lookHoleEnd:
- if (idNodesOldToNew[i] >= 0)
- {
- MESSAGE("-------------- newNodeSize, endHole " << i << " " << oldNodeSize);
- endHole = i;
- startBloc = i;
- compactState = lookBlocEnd;
- }
- break;
- case lookBlocEnd:
- if (idNodesOldToNew[i] < 0)
- endBloc = i; // see nbPoints below
- else if (i == (oldNodeSize - 1))
- endBloc = i + 1;
- if (endBloc)
- {
- MESSAGE("-------------- newNodeSize, endbloc " << endBloc << " " << oldNodeSize);
- copyNodes(newPoints, idNodesOldToNew, alreadyCopied, startBloc, endBloc);
- compactState = lookHoleEnd;
- startHole = i;
- endHole = 0;
- startBloc = 0;
- endBloc = 0;
- }
- break;
- }
- }
- if (!alreadyCopied) // no hole, but shorter, no need to modify idNodesOldToNew
- {
- MESSAGE("------------- newNodeSize, shorter " << oldNodeSize);
- copyNodes(newPoints, idNodesOldToNew, alreadyCopied, 0, newNodeSize);
- }
+ int i = 0;
+ while ( i < oldNodeSize )
+ {
+ // skip a hole if any
+ while ( i < oldNodeSize && idNodesOldToNew[i] < 0 )
+ ++i;
+ int startBloc = i;
+ // look for a block end
+ while ( i < oldNodeSize && idNodesOldToNew[i] >= 0 )
+ ++i;
+ int endBloc = i;
+ copyNodes(newPoints, idNodesOldToNew, alreadyCopied, startBloc, endBloc);
+ }
newPoints->Squeeze();
}
newLocations->Initialize();
newLocations->SetNumberOfValues(newCellSize);
- startHole = 0;
- endHole = 0;
- startBloc = 0;
- endBloc = 0;
- alreadyCopied = 0;
- holes = 0;
- compactState = lookHoleStart;
-
// TODO some polyhedron may be huge (only in some tests)
vtkIdType tmpid[NBMAXNODESINCELL];
vtkIdType *pointsCell = &tmpid[0]; // --- points id to fill a new cell
- for (int i = 0; i < oldCellSize; i++)
- {
- switch (compactState)
- {
- case lookHoleStart:
- if (this->Types->GetValue(i) == VTK_EMPTY_CELL)
- {
- MESSAGE(" -------- newCellSize, startHole " << i << " " << oldCellSize);
- startHole = i;
- compactState = lookHoleEnd;
- if (!alreadyCopied) // copy the first bloc
- {
- MESSAGE("--------- copy first bloc before hole " << i << " " << oldCellSize);
- copyBloc(newTypes, idCellsOldToNew, idNodesOldToNew, newConnectivity, newLocations, pointsCell,
- alreadyCopied, 0, startHole);
- }
- }
- break;
- case lookHoleEnd:
- if (this->Types->GetValue(i) != VTK_EMPTY_CELL)
- {
- MESSAGE(" -------- newCellSize, EndHole " << i << " " << oldCellSize);
- endHole = i;
- startBloc = i;
- compactState = lookBlocEnd;
- holes += endHole - startHole;
- }
- break;
- case lookBlocEnd:
- endBloc = 0;
- if (this->Types->GetValue(i) == VTK_EMPTY_CELL)
- endBloc = i;
- else if (i == (oldCellSize - 1))
- endBloc = i + 1;
- if (endBloc)
- {
- MESSAGE(" -------- newCellSize, endBloc " << endBloc << " " << oldCellSize);
- copyBloc(newTypes, idCellsOldToNew, idNodesOldToNew, newConnectivity, newLocations, pointsCell,
- alreadyCopied, startBloc, endBloc);
- compactState = lookHoleEnd;
- }
- break;
- }
- }
- if (!alreadyCopied) // no hole, but shorter
- {
- MESSAGE(" -------- newCellSize, shorter " << oldCellSize);
- copyBloc(newTypes, idCellsOldToNew, idNodesOldToNew, newConnectivity, newLocations, pointsCell, alreadyCopied, 0,
- oldCellSize);
- }
+ alreadyCopied = 0;
+ int i = 0;
+ while ( i < oldCellSize )
+ {
+ // skip a hole if any
+ while ( i < oldCellSize && this->Types->GetValue(i) == VTK_EMPTY_CELL )
+ ++i;
+ int startBloc = i;
+ // look for a block end
+ while ( i < oldCellSize && this->Types->GetValue(i) != VTK_EMPTY_CELL )
+ ++i;
+ int endBloc = i;
+ if ( endBloc > startBloc )
+ copyBloc(newTypes, idCellsOldToNew, idNodesOldToNew, newConnectivity, newLocations, pointsCell,
+ alreadyCopied, startBloc, endBloc);
+ }
newConnectivity->Squeeze();
- //newTypes->Squeeze();
- //newLocations->Squeeze();
- if (newNodeSize)
+ if (1/*newNodeSize*/)
{
MESSAGE("------- newNodeSize, setPoints");
this->SetPoints(newPoints);
else
this->SetCells(newTypes, newLocations, newConnectivity, FaceLocations, Faces);
+ newPoints->Delete();
newTypes->Delete();
newLocations->Delete();
newConnectivity->Delete();
int nbPoints = end - start;
if (nbPoints > 0)
{
- memcpy(target, source, 3 * sizeof(float) * nbPoints);
+ memcpy(target, source, 3 * sizeof(double) * nbPoints);
for (int j = start; j < end; j++)
idNodesOldToNew[j] = alreadyCopied++; // old vtkId --> new vtkId
- //idNodesOldToNew[alreadyCopied++] = idNodesOldToNew[j]; // new vtkId --> old SMDS id
}
}
pointsCell[l] = idNodesOldToNew[oldval];
//MESSAGE(" " << oldval << " " << pointsCell[l]);
}
- int newcnt = newConnectivity->InsertNextCell(nbpts, pointsCell);
+ /*int newcnt = */newConnectivity->InsertNextCell(nbpts, pointsCell);
int newLoc = newConnectivity->GetInsertLocation(nbpts);
//MESSAGE(newcnt << " " << newLoc);
newLocations->SetValue(alreadyCopied, newLoc);
int vtkVolId = i;
// MESSAGE("vtk volume " << vtkVolId);
//ASSERT(_downArray[vtkType]);
- int connVolId = _downArray[vtkType]->addCell(vtkVolId);
+ /*int connVolId = */_downArray[vtkType]->addCell(vtkVolId);
// --- find all the faces of the volume, describe the faces by their nodes
{
int vtkType = this->GetCellType(vtkId);
int cellDim = SMDS_Downward::getCellDimension(vtkType);
- if (cellDim != 3)
- return 0; // TODO voisins des faces ou edges
+ if (cellDim <2)
+ return 0; // TODO voisins des edges = edges connectees
int cellId = this->_cellIdToDownId[vtkId];
int nbCells = _downArray[vtkType]->getNumberOfDownCells(cellId);
const int *downCells = _downArray[vtkType]->getDownCells(cellId);
const unsigned char* downTyp = _downArray[vtkType]->getDownTypes(cellId);
- // --- iteration on faces of the 3D cell.
+ // --- iteration on faces of the 3D cell (or edges on the 2D cell).
int nb = 0;
for (int i = 0; i < nbCells; i++)
const int *upCells = _downArray[cellType]->getUpCells(downId);
const unsigned char* upTypes = _downArray[cellType]->getUpTypes(downId);
- // --- max 2 upCells, one is this cell, the other is a neighbor
+ // ---for a volume, max 2 upCells, one is this cell, the other is a neighbor
+ // for a face, number of neighbors (connected faces) not known
for (int j = 0; j < nbUp; j++)
{
return nb;
}
+/*! get the volumes containing a face or an edge of the grid
+ * The edge or face belongs to the vtkUnstructuredGrid
+ * @param volVtkIds vector of parent volume ids to fill (reserve enough space!)
+ * @param vtkId vtk id of the face or edge
+ */
+int SMDS_UnstructuredGrid::GetParentVolumes(int* volVtkIds, int vtkId)
+{
+ int vtkType = this->GetCellType(vtkId);
+ int dim = SMDS_Downward::getCellDimension(vtkType);
+ int nbFaces = 0;
+ int faces[1000];
+ unsigned char cellTypes[1000];
+ int downCellId[1000];
+ if (dim == 1)
+ {
+ int downId = this->CellIdToDownId(vtkId);
+ nbFaces = _downArray[vtkType]->getNumberOfUpCells(downId);
+ const int *upCells = _downArray[vtkType]->getUpCells(downId);
+ const unsigned char* upTypes = _downArray[vtkType]->getUpTypes(downId);
+ for (int i=0; i< nbFaces; i++)
+ {
+ faces[i] = _downArray[upTypes[i]]->getVtkCellId(upCells[i]);
+ cellTypes[i] = upTypes[i];
+ downCellId[i] = upCells[i];
+ }
+ }
+ else if (dim == 2)
+ {
+ nbFaces = 1;
+ faces[0] = vtkId;
+ cellTypes[0] = this->GetCellType(vtkId);
+ downCellId[0] = this->CellIdToDownId(vtkId);
+ }
+
+ int nbvol =0;
+ for (int i=0; i<nbFaces; i++)
+ {
+ int vtkTypeFace = cellTypes[i];
+ int downId = downCellId[i];
+ int nv = _downArray[vtkTypeFace]->getNumberOfUpCells(downId);
+ const int *upCells = _downArray[vtkTypeFace]->getUpCells(downId);
+ const unsigned char* upTypes = _downArray[vtkTypeFace]->getUpTypes(downId);
+ for (int j=0; j<nv; j++)
+ {
+ int vtkVolId = _downArray[upTypes[j]]->getVtkCellId(upCells[j]);
+ if (vtkVolId >= 0)
+ volVtkIds[nbvol++] = vtkVolId;
+ }
+ }
+ return nbvol;
+}
+
+/*! get the volumes containing a face or an edge of the downward structure
+ * The edge or face does not necessary belong to the vtkUnstructuredGrid
+ * @param volVtkIds vector of parent volume ids to fill (reserve enough space!)
+ * @param downId id in the downward structure
+ * @param downType type of cell
+ */
+int SMDS_UnstructuredGrid::GetParentVolumes(int* volVtkIds, int downId, unsigned char downType)
+{
+ int vtkType = downType;
+ int dim = SMDS_Downward::getCellDimension(vtkType);
+ int nbFaces = 0;
+ int faces[1000];
+ unsigned char cellTypes[1000];
+ int downCellId[1000];
+ if (dim == 1)
+ {
+ nbFaces = _downArray[vtkType]->getNumberOfUpCells(downId);
+ const int *upCells = _downArray[vtkType]->getUpCells(downId);
+ const unsigned char* upTypes = _downArray[vtkType]->getUpTypes(downId);
+ for (int i=0; i< nbFaces; i++)
+ {
+ faces[i] = _downArray[upTypes[i]]->getVtkCellId(upCells[i]);
+ cellTypes[i] = upTypes[i];
+ downCellId[i] = upCells[i];
+ }
+ }
+ else if (dim == 2)
+ {
+ nbFaces = 1;
+ cellTypes[0] = vtkType;
+ downCellId[0] = downId;
+ }
+
+ int nbvol =0;
+ for (int i=0; i<nbFaces; i++)
+ {
+ int vtkTypeFace = cellTypes[i];
+ int downId = downCellId[i];
+ int nv = _downArray[vtkTypeFace]->getNumberOfUpCells(downId);
+ const int *upCells = _downArray[vtkTypeFace]->getUpCells(downId);
+ const unsigned char* upTypes = _downArray[vtkTypeFace]->getUpTypes(downId);
+ for (int j=0; j<nv; j++)
+ {
+ int vtkVolId = _downArray[upTypes[j]]->getVtkCellId(upCells[j]);
+ if (vtkVolId >= 0)
+ volVtkIds[nbvol++] = vtkVolId;
+ }
+ }
+ return nbvol;
+}
+
/*! get the node id's of a cell.
* The cell is defined by it's downward connectivity id and type.
* @param nodeSet set of of vtk node id's to fill.
}
}
-/*! Create a volume (prism or hexahedron) by duplication of a face.
- * the nodes of the new face are already created.
+/*! reorder the nodes of a face
* @param vtkVolId vtk id of a volume containing the face, to get an orientation for the face.
- * @param localClonedNodeIds map old node id to new node id.
- * @return vtk id of the new volume.
+ * @param orderedNodes list of nodes to reorder (in out)
+ * @return size of the list
*/
-int SMDS_UnstructuredGrid::getOrderedNodesOfFace(int vtkVolId, std::vector<int>& orderedNodes)
+int SMDS_UnstructuredGrid::getOrderedNodesOfFace(int vtkVolId, std::vector<vtkIdType>& orderedNodes)
{
int vtkType = this->GetCellType(vtkVolId);
int cellDim = SMDS_Downward::getCellDimension(vtkType);
this->Links->BuildLinks(this, this->Connectivity);
this->Links->Delete();
}
+
+/*! Create a volume (prism or hexahedron) by duplication of a face.
+ * Designed for use in creation of flat elements separating volume domains.
+ * A face separating two domains is shared by two volume cells.
+ * All the nodes are already created (for the two faces).
+ * Each original Node is associated to corresponding nodes in the domains.
+ * Some nodes may be duplicated for more than two domains, when domain separations intersect.
+ * In that case, even some of the nodes to use for the original face may be changed.
+ * @param vtkVolId: vtk id of a volume containing the face, to get an orientation for the face.
+ * @param domain1: domain of the original face
+ * @param domain2: domain of the duplicated face
+ * @param originalNodes: the vtk node ids of the original face
+ * @param nodeDomains: map(original id --> map(domain --> duplicated node id))
+ * @return ok if success.
+ */
+SMDS_MeshVolume* SMDS_UnstructuredGrid::extrudeVolumeFromFace(int vtkVolId,
+ int domain1,
+ int domain2,
+ std::set<int>& originalNodes,
+ std::map<int, std::map<int, int> >& nodeDomains,
+ std::map<int, std::map<long, int> >& nodeQuadDomains)
+{
+ //MESSAGE("extrudeVolumeFromFace " << vtkVolId);
+ vector<vtkIdType> orderedOriginals;
+ orderedOriginals.clear();
+ set<int>::const_iterator it = originalNodes.begin();
+ for (; it != originalNodes.end(); ++it)
+ orderedOriginals.push_back(*it);
+
+ int nbNodes = this->getOrderedNodesOfFace(vtkVolId, orderedOriginals);
+ vector<vtkIdType> orderedNodes;
+
+ switch (orderedOriginals.size())
+ {
+ case 3:
+ case 4:
+ for (int i = 0; i < nbNodes; i++)
+ orderedNodes.push_back(nodeDomains[orderedOriginals[i]][domain1]);
+ for (int i = 0; i < nbNodes; i++)
+ orderedNodes.push_back(nodeDomains[orderedOriginals[i]][domain2]);
+ break;
+ case 6:
+ case 8:
+ {
+ long dom1 = domain1;
+ long dom2 = domain2;
+ long dom1_2; // for nodeQuadDomains
+ if (domain1 < domain2)
+ dom1_2 = dom1 + INT_MAX * dom2;
+ else
+ dom1_2 = dom2 + INT_MAX * dom1;
+ //cerr << "dom1=" << dom1 << " dom2=" << dom2 << " dom1_2=" << dom1_2 << endl;
+ int ima = orderedOriginals.size();
+ int mid = orderedOriginals.size() / 2;
+ //cerr << "ima=" << ima << " mid=" << mid << endl;
+ for (int i = 0; i < mid; i++)
+ orderedNodes.push_back(nodeDomains[orderedOriginals[i]][domain1]);
+ for (int i = 0; i < mid; i++)
+ orderedNodes.push_back(nodeDomains[orderedOriginals[i]][domain2]);
+ for (int i = mid; i < ima; i++)
+ orderedNodes.push_back(nodeDomains[orderedOriginals[i]][domain1]);
+ for (int i = mid; i < ima; i++)
+ orderedNodes.push_back(nodeDomains[orderedOriginals[i]][domain2]);
+ for (int i = 0; i < mid; i++)
+ {
+ int oldId = orderedOriginals[i];
+ int newId;
+ if (nodeQuadDomains.count(oldId) && nodeQuadDomains[oldId].count(dom1_2))
+ newId = nodeQuadDomains[oldId][dom1_2];
+ else
+ {
+ double *coords = this->GetPoint(oldId);
+ SMDS_MeshNode *newNode = _mesh->AddNode(coords[0], coords[1], coords[2]);
+ newId = newNode->getVtkId();
+ std::map<long, int> emptyMap;
+ nodeQuadDomains[oldId] = emptyMap;
+ nodeQuadDomains[oldId][dom1_2] = newId;
+ }
+ orderedNodes.push_back(newId);
+ }
+ }
+ break;
+ default:
+ ASSERT(0);
+ }
+
+ SMDS_MeshVolume *vol = _mesh->AddVolumeFromVtkIds(orderedNodes);
+
+ // TODO update subshape list of elements and nodes
+ return vol;
+}
