+// Copyright (C) 2010-2011 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// 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.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
#define CHRONODEF
#include "SMDS_UnstructuredGrid.hxx"
#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 alreadyCopied = 0;
- // if (this->Links)
- // {
- // this->Links->UnRegister(this);
- // this->Links = 0;
- // }
-
// --- if newNodeSize, create a new compacted vtkPoints
vtkPoints *newPoints = vtkPoints::New();
if (newNodeSize)
{
MESSAGE("-------------- compactGrid, newNodeSize " << newNodeSize);
- // rnv: to fix bug "21125: EDF 1233 SMESH: Degrardation of precision in a test case for quadratic conversion"
+ // 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();
int endBloc = i;
copyNodes(newPoints, idNodesOldToNew, alreadyCopied, startBloc, endBloc);
}
-// 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);
-// }
newPoints->Squeeze();
}
copyBloc(newTypes, idCellsOldToNew, idNodesOldToNew, newConnectivity, newLocations, pointsCell,
alreadyCopied, startBloc, endBloc);
}
-// 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);
-// }
newConnectivity->Squeeze();
- //newTypes->Squeeze();
- //newLocations->Squeeze();
if (1/*newNodeSize*/)
{
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
}
}
int SMDS_UnstructuredGrid::CellIdToDownId(int vtkCellId)
{
- // ASSERT((vtkCellId >= 0) && (vtkCellId < _cellIdToDownId.size()));
+ if((vtkCellId < 0) || (vtkCellId >= _cellIdToDownId.size()))
+ {
+ //MESSAGE("SMDS_UnstructuredGrid::CellIdToDownId structure not up to date: vtkCellId="
+ // << vtkCellId << " max="<< _cellIdToDownId.size());
+ return -1;
+ }
return _cellIdToDownId[vtkCellId];
}
_cellIdToDownId[vtkCellId] = downId;
}
+void SMDS_UnstructuredGrid::CleanDownwardConnectivity()
+{
+ for (int i = 0; i < _downArray.size(); i++)
+ {
+ if (_downArray[i])
+ delete _downArray[i];
+ _downArray[i] = 0;
+ }
+ _cellIdToDownId.clear();
+}
+
/*! Build downward connectivity: to do only when needed because heavy memory load.
* Downward connectivity is no more valid if vtkUnstructuredGrid is modified.
*
// --- erase previous data if any
- for (int i = 0; i < _downArray.size(); i++)
- {
- if (_downArray[i])
- delete _downArray[i];
- _downArray[i] = 0;
- }
- _cellIdToDownId.clear();
+ this->CleanDownwardConnectivity();
// --- create SMDS_Downward structures (in _downArray vector[vtkCellType])
{
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;
+ unsigned char cellTypes[1000];
+ int downCellId[1000];
+ if (dim == 1)
+ {
+ int downId = this->CellIdToDownId(vtkId);
+ if (downId < 0)
+ {
+ MESSAGE("Downward structure not up to date: new edge not taken into account");
+ return 0;
+ }
+ 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++)
+ {
+ cellTypes[i] = upTypes[i];
+ downCellId[i] = upCells[i];
+ }
+ }
+ else if (dim == 2)
+ {
+ nbFaces = 1;
+ cellTypes[0] = this->GetCellType(vtkId);
+ int downId = this->CellIdToDownId(vtkId);
+ if (downId < 0)
+ {
+ MESSAGE("Downward structure not up to date: new face not taken into account");
+ return 0;
+ }
+ 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 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;
+ 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++)
+ {
+ 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<vtkIdType>& orderedNodes)
{
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;
+}
