1 // Copyright (C) 2007-2013 CEA/DEN, EDF R&D, OPEN CASCADE
3 // Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
6 // This library is free software; you can redistribute it and/or
7 // modify it under the terms of the GNU Lesser General Public
8 // License as published by the Free Software Foundation; either
9 // version 2.1 of the License.
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 // Lesser General Public License for more details.
16 // You should have received a copy of the GNU Lesser General Public
17 // License along with this library; if not, write to the Free Software
18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
23 // SMESH SMESHDS : management of mesh data and SMESH document
24 // File : SMESH_Mesh.cxx
25 // Author : Yves FRICAUD, OCC
28 #include "SMESHDS_Mesh.hxx"
30 #include "SMESHDS_Group.hxx"
31 #include "SMDS_VertexPosition.hxx"
32 #include "SMDS_EdgePosition.hxx"
33 #include "SMDS_FacePosition.hxx"
34 #include "SMDS_SpacePosition.hxx"
35 #include "SMDS_Downward.hxx"
36 #include "SMESHDS_GroupOnGeom.hxx"
37 #include "SMESHDS_Script.hxx"
39 #include <Standard_ErrorHandler.hxx>
40 #include <Standard_OutOfRange.hxx>
42 #include <TopExp_Explorer.hxx>
43 #include <TopoDS_Edge.hxx>
44 #include <TopoDS_Face.hxx>
45 #include <TopoDS_Iterator.hxx>
46 #include <TopoDS_Shell.hxx>
47 #include <TopoDS_Solid.hxx>
48 #include <TopoDS_Vertex.hxx>
50 #include "utilities.h"
54 //=======================================================================
57 //=======================================================================
58 SMESHDS_Mesh::SMESHDS_Mesh(int theMeshID, bool theIsEmbeddedMode):
60 myIsEmbeddedMode(theIsEmbeddedMode),
63 myScript = new SMESHDS_Script(theIsEmbeddedMode);
65 SetPersistentId(theMeshID);
68 //=======================================================================
69 bool SMESHDS_Mesh::IsEmbeddedMode()
71 return myIsEmbeddedMode;
74 //================================================================================
76 * \brief Store ID persistent during lifecycle
78 * Initially it was used to have a persistent reference to the mesh from the hypothesis
80 //================================================================================
82 void SMESHDS_Mesh::SetPersistentId(int id)
87 //================================================================================
89 * \brief Return ID persistent during lifecycle
91 //================================================================================
93 int SMESHDS_Mesh::GetPersistentId() const
95 return myPersistentID;
98 //=======================================================================
99 //function : ShapeToMesh
101 //=======================================================================
102 void SMESHDS_Mesh::ShapeToMesh(const TopoDS_Shape & S)
104 if ( !myShape.IsNull() && S.IsNull() )
106 // removal of a shape to mesh, delete ...
108 myShapeToHypothesis.Clear();
109 // - shape indices in SMDS_Position of nodes
110 map<int,SMESHDS_SubMesh*>::iterator i_sub = myShapeIndexToSubMesh.begin();
111 for ( ; i_sub != myShapeIndexToSubMesh.end(); i_sub++ ) {
112 if ( !i_sub->second->IsComplexSubmesh() ) {
113 SMDS_NodeIteratorPtr nIt = i_sub->second->GetNodes();
114 while ( nIt->more() )
115 i_sub->second->RemoveNode(nIt->next(), false);
119 TShapeIndexToSubMesh::iterator i_sm = myShapeIndexToSubMesh.begin();
120 for ( ; i_sm != myShapeIndexToSubMesh.end(); ++i_sm )
122 myShapeIndexToSubMesh.clear();
123 myIndexToShape.Clear();
124 // - groups on geometry
125 set<SMESHDS_GroupBase*>::iterator gr = myGroups.begin();
126 while ( gr != myGroups.end() ) {
127 if ( dynamic_cast<SMESHDS_GroupOnGeom*>( *gr ))
128 myGroups.erase( gr++ );
136 TopExp::MapShapes(myShape, myIndexToShape);
140 //=======================================================================
141 //function : AddHypothesis
143 //=======================================================================
145 bool SMESHDS_Mesh::AddHypothesis(const TopoDS_Shape & SS,
146 const SMESHDS_Hypothesis * H)
148 if (!myShapeToHypothesis.IsBound(SS.Oriented(TopAbs_FORWARD))) {
149 list<const SMESHDS_Hypothesis *> aList;
150 myShapeToHypothesis.Bind(SS.Oriented(TopAbs_FORWARD), aList);
152 list<const SMESHDS_Hypothesis *>& alist =
153 myShapeToHypothesis(SS.Oriented(TopAbs_FORWARD)); // ignore orientation of SS
155 //Check if the Hypothesis is still present
156 list<const SMESHDS_Hypothesis*>::iterator ith = find(alist.begin(),alist.end(), H );
158 if (alist.end() != ith) return false;
164 //=======================================================================
165 //function : RemoveHypothesis
167 //=======================================================================
169 bool SMESHDS_Mesh::RemoveHypothesis(const TopoDS_Shape & S,
170 const SMESHDS_Hypothesis * H)
172 if( myShapeToHypothesis.IsBound( S.Oriented(TopAbs_FORWARD) ) )
174 list<const SMESHDS_Hypothesis *>& alist=myShapeToHypothesis.ChangeFind( S.Oriented(TopAbs_FORWARD) );
175 list<const SMESHDS_Hypothesis*>::iterator ith=find(alist.begin(),alist.end(), H );
176 if (ith != alist.end())
185 //=======================================================================
188 //=======================================================================
189 SMDS_MeshNode* SMESHDS_Mesh::AddNode(double x, double y, double z){
190 SMDS_MeshNode* node = SMDS_Mesh::AddNode(x, y, z);
191 if(node!=NULL) myScript->AddNode(node->GetID(), x, y, z);
195 SMDS_MeshNode* SMESHDS_Mesh::AddNodeWithID(double x, double y, double z, int ID){
196 SMDS_MeshNode* node = SMDS_Mesh::AddNodeWithID(x,y,z,ID);
197 if(node!=NULL) myScript->AddNode(node->GetID(), x, y, z);
201 //=======================================================================
202 //function : MoveNode
204 //=======================================================================
205 void SMESHDS_Mesh::MoveNode(const SMDS_MeshNode *n, double x, double y, double z)
207 SMDS_MeshNode * node=const_cast<SMDS_MeshNode*>(n);
209 myScript->MoveNode(n->GetID(), x, y, z);
212 //=======================================================================
213 //function : ChangeElementNodes
215 //=======================================================================
217 bool SMESHDS_Mesh::ChangeElementNodes(const SMDS_MeshElement * elem,
218 const SMDS_MeshNode * nodes[],
221 //MESSAGE("SMESHDS_Mesh::ChangeElementNodes");
222 if ( ! SMDS_Mesh::ChangeElementNodes( elem, nodes, nbnodes ))
225 vector<int> IDs( nbnodes );
226 for ( int i = 0; i < nbnodes; i++ )
227 IDs [ i ] = nodes[ i ]->GetID();
228 myScript->ChangeElementNodes( elem->GetID(), &IDs[0], nbnodes);
233 //=======================================================================
234 //function : ChangePolygonNodes
236 //=======================================================================
237 bool SMESHDS_Mesh::ChangePolygonNodes
238 (const SMDS_MeshElement * elem,
239 vector<const SMDS_MeshNode*> nodes)
241 ASSERT(nodes.size() > 3);
243 return ChangeElementNodes(elem, &nodes[0], nodes.size());
246 //=======================================================================
247 //function : ChangePolyhedronNodes
249 //=======================================================================
250 bool SMESHDS_Mesh::ChangePolyhedronNodes
251 (const SMDS_MeshElement * elem,
252 std::vector<const SMDS_MeshNode*> nodes,
253 std::vector<int> quantities)
255 ASSERT(nodes.size() > 3);
257 if (!SMDS_Mesh::ChangePolyhedronNodes(elem, nodes, quantities))
260 int i, len = nodes.size();
261 std::vector<int> nodes_ids (len);
262 for (i = 0; i < len; i++) {
263 nodes_ids[i] = nodes[i]->GetID();
265 myScript->ChangePolyhedronNodes(elem->GetID(), nodes_ids, quantities);
270 //=======================================================================
271 //function : Renumber
273 //=======================================================================
275 void SMESHDS_Mesh::Renumber (const bool isNodes, const int startID, const int deltaID)
277 // TODO not possible yet to have node numbers not starting to O and continuous.
278 if (!this->isCompacted())
280 // SMDS_Mesh::Renumber( isNodes, startID, deltaID );
281 // myScript->Renumber( isNodes, startID, deltaID );
284 //=======================================================================
285 //function : Add0DElement
287 //=======================================================================
288 SMDS_Mesh0DElement* SMESHDS_Mesh::Add0DElementWithID(int nodeID, int ID)
290 SMDS_Mesh0DElement* anElem = SMDS_Mesh::Add0DElementWithID(nodeID, ID);
291 if (anElem) myScript->Add0DElement(ID, nodeID);
295 SMDS_Mesh0DElement* SMESHDS_Mesh::Add0DElementWithID
296 (const SMDS_MeshNode * node, int ID)
298 return Add0DElementWithID(node->GetID(), ID);
301 SMDS_Mesh0DElement* SMESHDS_Mesh::Add0DElement(const SMDS_MeshNode * node)
303 SMDS_Mesh0DElement* anElem = SMDS_Mesh::Add0DElement(node);
304 if (anElem) myScript->Add0DElement(anElem->GetID(), node->GetID());
308 //=======================================================================
309 //function :AddBallWithID
311 //=======================================================================
313 SMDS_BallElement* SMESHDS_Mesh::AddBallWithID(int node, double diameter, int ID)
315 SMDS_BallElement* anElem = SMDS_Mesh::AddBallWithID(node,diameter,ID);
316 if (anElem) myScript->AddBall(anElem->GetID(), node, diameter);
320 SMDS_BallElement* SMESHDS_Mesh::AddBallWithID(const SMDS_MeshNode * node,
324 SMDS_BallElement* anElem = SMDS_Mesh::AddBallWithID(node,diameter,ID);
325 if (anElem) myScript->AddBall(anElem->GetID(), node->GetID(), diameter);
329 SMDS_BallElement* SMESHDS_Mesh::AddBall (const SMDS_MeshNode * node,
332 SMDS_BallElement* anElem = SMDS_Mesh::AddBall(node,diameter);
333 if (anElem) myScript->AddBall(anElem->GetID(), node->GetID(), diameter);
337 //=======================================================================
338 //function :AddEdgeWithID
340 //=======================================================================
342 SMDS_MeshEdge* SMESHDS_Mesh::AddEdgeWithID(int n1, int n2, int ID)
344 SMDS_MeshEdge* anElem = SMDS_Mesh::AddEdgeWithID(n1,n2,ID);
345 if(anElem) myScript->AddEdge(ID,n1,n2);
349 SMDS_MeshEdge* SMESHDS_Mesh::AddEdgeWithID(const SMDS_MeshNode * n1,
350 const SMDS_MeshNode * n2,
353 return AddEdgeWithID(n1->GetID(),
358 SMDS_MeshEdge* SMESHDS_Mesh::AddEdge(const SMDS_MeshNode * n1,
359 const SMDS_MeshNode * n2)
361 SMDS_MeshEdge* anElem = SMDS_Mesh::AddEdge(n1,n2);
362 if(anElem) myScript->AddEdge(anElem->GetID(),
368 //=======================================================================
371 //=======================================================================
372 SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(int n1, int n2, int n3, int ID)
374 SMDS_MeshFace *anElem = SMDS_Mesh::AddFaceWithID(n1, n2, n3, ID);
375 if(anElem) myScript->AddFace(ID,n1,n2,n3);
379 SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
380 const SMDS_MeshNode * n2,
381 const SMDS_MeshNode * n3,
384 return AddFaceWithID(n1->GetID(),
390 SMDS_MeshFace* SMESHDS_Mesh::AddFace( const SMDS_MeshNode * n1,
391 const SMDS_MeshNode * n2,
392 const SMDS_MeshNode * n3)
394 SMDS_MeshFace *anElem = SMDS_Mesh::AddFace(n1, n2, n3);
395 if(anElem) myScript->AddFace(anElem->GetID(),
402 //=======================================================================
405 //=======================================================================
406 SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(int n1, int n2, int n3, int n4, int ID)
408 SMDS_MeshFace *anElem = SMDS_Mesh::AddFaceWithID(n1, n2, n3, n4, ID);
409 if(anElem) myScript->AddFace(ID, n1, n2, n3, n4);
413 SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
414 const SMDS_MeshNode * n2,
415 const SMDS_MeshNode * n3,
416 const SMDS_MeshNode * n4,
419 return AddFaceWithID(n1->GetID(),
426 SMDS_MeshFace* SMESHDS_Mesh::AddFace(const SMDS_MeshNode * n1,
427 const SMDS_MeshNode * n2,
428 const SMDS_MeshNode * n3,
429 const SMDS_MeshNode * n4)
431 SMDS_MeshFace *anElem = SMDS_Mesh::AddFace(n1, n2, n3, n4);
432 if(anElem) myScript->AddFace(anElem->GetID(),
440 //=======================================================================
441 //function :AddVolume
443 //=======================================================================
444 SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4, int ID)
446 SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, ID);
447 if(anElem) myScript->AddVolume(ID, n1, n2, n3, n4);
451 SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
452 const SMDS_MeshNode * n2,
453 const SMDS_MeshNode * n3,
454 const SMDS_MeshNode * n4,
457 return AddVolumeWithID(n1->GetID(),
464 SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
465 const SMDS_MeshNode * n2,
466 const SMDS_MeshNode * n3,
467 const SMDS_MeshNode * n4)
469 SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolume(n1, n2, n3, n4);
470 if(anElem) myScript->AddVolume(anElem->GetID(),
478 //=======================================================================
479 //function :AddVolume
481 //=======================================================================
482 SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4, int n5, int ID)
484 SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, ID);
485 if(anElem) myScript->AddVolume(ID, n1, n2, n3, n4, n5);
489 SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
490 const SMDS_MeshNode * n2,
491 const SMDS_MeshNode * n3,
492 const SMDS_MeshNode * n4,
493 const SMDS_MeshNode * n5,
496 return AddVolumeWithID(n1->GetID(),
504 SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
505 const SMDS_MeshNode * n2,
506 const SMDS_MeshNode * n3,
507 const SMDS_MeshNode * n4,
508 const SMDS_MeshNode * n5)
510 SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolume(n1, n2, n3, n4, n5);
511 if(anElem) myScript->AddVolume(anElem->GetID(),
520 //=======================================================================
521 //function :AddVolume
523 //=======================================================================
524 SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4, int n5, int n6, int ID)
526 SMDS_MeshVolume *anElem= SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, n6, ID);
527 if(anElem) myScript->AddVolume(ID, n1, n2, n3, n4, n5, n6);
531 SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
532 const SMDS_MeshNode * n2,
533 const SMDS_MeshNode * n3,
534 const SMDS_MeshNode * n4,
535 const SMDS_MeshNode * n5,
536 const SMDS_MeshNode * n6,
539 return AddVolumeWithID(n1->GetID(),
548 SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
549 const SMDS_MeshNode * n2,
550 const SMDS_MeshNode * n3,
551 const SMDS_MeshNode * n4,
552 const SMDS_MeshNode * n5,
553 const SMDS_MeshNode * n6)
555 SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolume(n1, n2, n3, n4, n5, n6);
556 if(anElem) myScript->AddVolume(anElem->GetID(),
566 //=======================================================================
567 //function :AddVolume
569 //=======================================================================
570 SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4, int n5, int n6, int n7, int n8, int ID)
572 SMDS_MeshVolume *anElem= SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, n6, n7, n8, ID);
573 if(anElem) myScript->AddVolume(ID, n1, n2, n3, n4, n5, n6, n7, n8);
577 SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
578 const SMDS_MeshNode * n2,
579 const SMDS_MeshNode * n3,
580 const SMDS_MeshNode * n4,
581 const SMDS_MeshNode * n5,
582 const SMDS_MeshNode * n6,
583 const SMDS_MeshNode * n7,
584 const SMDS_MeshNode * n8,
587 return AddVolumeWithID(n1->GetID(),
598 SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
599 const SMDS_MeshNode * n2,
600 const SMDS_MeshNode * n3,
601 const SMDS_MeshNode * n4,
602 const SMDS_MeshNode * n5,
603 const SMDS_MeshNode * n6,
604 const SMDS_MeshNode * n7,
605 const SMDS_MeshNode * n8)
607 SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolume(n1, n2, n3, n4, n5, n6, n7, n8);
608 if(anElem) myScript->AddVolume(anElem->GetID(),
621 //=======================================================================
622 //function :AddVolume
623 //purpose : add hexagonal prism
624 //=======================================================================
625 SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4,
626 int n5, int n6, int n7, int n8,
627 int n9, int n10, int n11, int n12,
630 SMDS_MeshVolume *anElem= SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, n6, n7, n8, n9, n10, n11, n12, ID);
631 if(anElem) myScript->AddVolume(ID, n1, n2, n3, n4, n5, n6, n7, n8, n9, n10, n11, n12);
635 SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
636 const SMDS_MeshNode * n2,
637 const SMDS_MeshNode * n3,
638 const SMDS_MeshNode * n4,
639 const SMDS_MeshNode * n5,
640 const SMDS_MeshNode * n6,
641 const SMDS_MeshNode * n7,
642 const SMDS_MeshNode * n8,
643 const SMDS_MeshNode * n9,
644 const SMDS_MeshNode * n10,
645 const SMDS_MeshNode * n11,
646 const SMDS_MeshNode * n12,
649 return AddVolumeWithID(n1->GetID(),
664 SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
665 const SMDS_MeshNode * n2,
666 const SMDS_MeshNode * n3,
667 const SMDS_MeshNode * n4,
668 const SMDS_MeshNode * n5,
669 const SMDS_MeshNode * n6,
670 const SMDS_MeshNode * n7,
671 const SMDS_MeshNode * n8,
672 const SMDS_MeshNode * n9,
673 const SMDS_MeshNode * n10,
674 const SMDS_MeshNode * n11,
675 const SMDS_MeshNode * n12)
677 SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolume(n1, n2, n3, n4, n5, n6, n7, n8, n9, n10, n11, n12);
678 if(anElem) myScript->AddVolume(anElem->GetID(),
695 //=======================================================================
696 //function : AddPolygonalFace
698 //=======================================================================
699 SMDS_MeshFace* SMESHDS_Mesh::AddPolygonalFaceWithID (const std::vector<int>& nodes_ids,
702 SMDS_MeshFace *anElem = SMDS_Mesh::AddPolygonalFaceWithID(nodes_ids, ID);
704 myScript->AddPolygonalFace(ID, nodes_ids);
709 SMDS_MeshFace* SMESHDS_Mesh::AddPolygonalFaceWithID
710 (const std::vector<const SMDS_MeshNode*>& nodes,
713 SMDS_MeshFace *anElem = SMDS_Mesh::AddPolygonalFaceWithID(nodes, ID);
715 int i, len = nodes.size();
716 std::vector<int> nodes_ids (len);
717 for (i = 0; i < len; i++) {
718 nodes_ids[i] = nodes[i]->GetID();
720 myScript->AddPolygonalFace(ID, nodes_ids);
725 SMDS_MeshFace* SMESHDS_Mesh::AddPolygonalFace
726 (const std::vector<const SMDS_MeshNode*>& nodes)
728 SMDS_MeshFace *anElem = SMDS_Mesh::AddPolygonalFace(nodes);
730 int i, len = nodes.size();
731 std::vector<int> nodes_ids (len);
732 for (i = 0; i < len; i++) {
733 nodes_ids[i] = nodes[i]->GetID();
735 myScript->AddPolygonalFace(anElem->GetID(), nodes_ids);
740 //=======================================================================
741 //function : AddPolyhedralVolume
743 //=======================================================================
744 SMDS_MeshVolume* SMESHDS_Mesh::AddPolyhedralVolumeWithID (const std::vector<int>& nodes_ids,
745 const std::vector<int>& quantities,
748 SMDS_MeshVolume *anElem = SMDS_Mesh::AddPolyhedralVolumeWithID(nodes_ids, quantities, ID);
750 myScript->AddPolyhedralVolume(ID, nodes_ids, quantities);
755 SMDS_MeshVolume* SMESHDS_Mesh::AddPolyhedralVolumeWithID
756 (const std::vector<const SMDS_MeshNode*>& nodes,
757 const std::vector<int>& quantities,
760 SMDS_MeshVolume *anElem = SMDS_Mesh::AddPolyhedralVolumeWithID(nodes, quantities, ID);
762 int i, len = nodes.size();
763 std::vector<int> nodes_ids (len);
764 for (i = 0; i < len; i++) {
765 nodes_ids[i] = nodes[i]->GetID();
767 myScript->AddPolyhedralVolume(ID, nodes_ids, quantities);
772 SMDS_MeshVolume* SMESHDS_Mesh::AddPolyhedralVolume
773 (const std::vector<const SMDS_MeshNode*>& nodes,
774 const std::vector<int>& quantities)
776 SMDS_MeshVolume *anElem = SMDS_Mesh::AddPolyhedralVolume(nodes, quantities);
778 int i, len = nodes.size();
779 std::vector<int> nodes_ids (len);
780 for (i = 0; i < len; i++) {
781 nodes_ids[i] = nodes[i]->GetID();
783 myScript->AddPolyhedralVolume(anElem->GetID(), nodes_ids, quantities);
788 //=======================================================================
789 //function : removeFromContainers
791 //=======================================================================
793 static void removeFromContainers (map<int,SMESHDS_SubMesh*>& theSubMeshes,
794 set<SMESHDS_GroupBase*>& theGroups,
795 list<const SMDS_MeshElement*>& theElems,
798 if ( theElems.empty() )
802 // Element can belong to several groups
803 if ( !theGroups.empty() )
805 set<SMESHDS_GroupBase*>::iterator GrIt = theGroups.begin();
806 for ( ; GrIt != theGroups.end(); GrIt++ )
808 SMESHDS_Group* group = dynamic_cast<SMESHDS_Group*>( *GrIt );
809 if ( !group || group->IsEmpty() ) continue;
811 list<const SMDS_MeshElement *>::iterator elIt = theElems.begin();
812 for ( ; elIt != theElems.end(); elIt++ )
814 group->SMDSGroup().Remove( *elIt );
815 if ( group->IsEmpty() ) break;
820 const bool deleted=true;
822 // Rm from sub-meshes
823 // Element should belong to only one sub-mesh
824 if ( !theSubMeshes.empty() )
826 SMESHDS_Mesh* mesh = theSubMeshes.begin()->second->GetParent();
827 list<const SMDS_MeshElement *>::iterator elIt = theElems.begin();
829 for ( ; elIt != theElems.end(); ++elIt )
830 if ( SMESHDS_SubMesh* sm = mesh->MeshElements( (*elIt)->getshapeId() ))
831 sm->RemoveNode( static_cast<const SMDS_MeshNode*> (*elIt), deleted );
834 for ( ; elIt != theElems.end(); ++elIt )
835 if ( SMESHDS_SubMesh* sm = mesh->MeshElements( (*elIt)->getshapeId() ))
836 sm->RemoveElement( *elIt, deleted );
841 //=======================================================================
842 //function : RemoveNode
844 //=======================================================================
845 void SMESHDS_Mesh::RemoveNode(const SMDS_MeshNode * n)
847 if ( n->NbInverseElements() == 0 && !(hasConstructionEdges() || hasConstructionFaces()))
849 SMESHDS_SubMesh* subMesh=0;
850 map<int,SMESHDS_SubMesh*>::iterator SubIt =
851 myShapeIndexToSubMesh.find( n->getshapeId() );
852 if ( SubIt != myShapeIndexToSubMesh.end() )
853 subMesh = SubIt->second;
855 SubIt = myShapeIndexToSubMesh.begin();
856 for ( ; !subMesh && SubIt != myShapeIndexToSubMesh.end(); SubIt++ )
857 if (!SubIt->second->IsComplexSubmesh() && SubIt->second->Contains( n ))
858 subMesh = SubIt->second;
860 RemoveFreeNode( n, subMesh, true);
864 myScript->RemoveNode(n->GetID());
866 list<const SMDS_MeshElement *> removedElems;
867 list<const SMDS_MeshElement *> removedNodes;
869 SMDS_Mesh::RemoveElement( n, removedElems, removedNodes, true );
871 removeFromContainers( myShapeIndexToSubMesh, myGroups, removedElems, false );
872 removeFromContainers( myShapeIndexToSubMesh, myGroups, removedNodes, true );
875 //=======================================================================
876 //function : RemoveFreeNode
878 //=======================================================================
879 void SMESHDS_Mesh::RemoveFreeNode(const SMDS_MeshNode * n,
880 SMESHDS_SubMesh * subMesh,
883 myScript->RemoveNode(n->GetID());
886 // Node can belong to several groups
887 if (fromGroups && !myGroups.empty()) {
888 set<SMESHDS_GroupBase*>::iterator GrIt = myGroups.begin();
889 for (; GrIt != myGroups.end(); GrIt++) {
890 SMESHDS_Group* group = dynamic_cast<SMESHDS_Group*>(*GrIt);
891 if (!group || group->IsEmpty()) continue;
892 group->SMDSGroup().Remove(n);
897 // Node should belong to only one sub-mesh
899 subMesh->RemoveNode(n,/*deleted=*/false);
901 SMDS_Mesh::RemoveFreeElement(n);
904 //=======================================================================
905 //function : RemoveElement
907 //========================================================================
908 void SMESHDS_Mesh::RemoveElement(const SMDS_MeshElement * elt)
910 if (elt->GetType() == SMDSAbs_Node)
912 RemoveNode( static_cast<const SMDS_MeshNode*>( elt ));
915 if (!hasConstructionEdges() && !hasConstructionFaces())
917 SMESHDS_SubMesh* subMesh=0;
918 map<int,SMESHDS_SubMesh*>::iterator SubIt = myShapeIndexToSubMesh.begin();
919 for ( ; !subMesh && SubIt != myShapeIndexToSubMesh.end(); SubIt++ )
920 if (!SubIt->second->IsComplexSubmesh() && SubIt->second->Contains( elt ))
921 subMesh = SubIt->second;
922 //MESSAGE("subMesh " << elt->getshapeId());
923 RemoveFreeElement( elt, subMesh, true);
927 myScript->RemoveElement(elt->GetID());
929 list<const SMDS_MeshElement *> removedElems;
930 list<const SMDS_MeshElement *> removedNodes;
932 SMDS_Mesh::RemoveElement(elt, removedElems, removedNodes, false);
934 removeFromContainers( myShapeIndexToSubMesh, myGroups, removedElems, false );
937 //=======================================================================
938 //function : RemoveFreeElement
940 //========================================================================
941 void SMESHDS_Mesh::RemoveFreeElement(const SMDS_MeshElement * elt,
942 SMESHDS_SubMesh * subMesh,
945 //MESSAGE(" --------------------------------> SMESHDS_Mesh::RemoveFreeElement " << subMesh << " " << fromGroups);
946 if (elt->GetType() == SMDSAbs_Node) {
947 RemoveFreeNode( static_cast<const SMDS_MeshNode*>(elt), subMesh);
951 if (hasConstructionEdges() || hasConstructionFaces())
952 // this methods is only for meshes without descendants
955 myScript->RemoveElement(elt->GetID());
958 // Node can belong to several groups
959 if ( fromGroups && !myGroups.empty() ) {
960 set<SMESHDS_GroupBase*>::iterator GrIt = myGroups.begin();
961 for (; GrIt != myGroups.end(); GrIt++) {
962 SMESHDS_Group* group = dynamic_cast<SMESHDS_Group*>(*GrIt);
963 if (group && !group->IsEmpty())
964 group->SMDSGroup().Remove(elt);
969 // Element should belong to only one sub-mesh
971 subMesh->RemoveElement(elt, /*deleted=*/false);
973 SMDS_Mesh::RemoveFreeElement(elt);
976 //================================================================================
978 * \brief Remove all data from the mesh
980 //================================================================================
982 void SMESHDS_Mesh::ClearMesh()
984 myScript->ClearMesh();
988 map<int,SMESHDS_SubMesh*>::iterator sub, subEnd = myShapeIndexToSubMesh.end();
989 for ( sub = myShapeIndexToSubMesh.begin(); sub != subEnd; ++sub )
990 sub->second->Clear();
993 TGroups::iterator group, groupEnd = myGroups.end();
994 for ( group = myGroups.begin(); group != groupEnd; ++group ) {
995 if ( SMESHDS_Group* g = dynamic_cast<SMESHDS_Group*>(*group)) {
996 SMDSAbs_ElementType groupType = g->GetType();
998 g->SetType( groupType );
1003 //================================================================================
1005 * \brief return submesh by shape
1006 * \param shape - the sub-shape
1007 * \retval SMESHDS_SubMesh* - the found submesh
1009 * search of submeshes is optimized
1011 //================================================================================
1013 SMESHDS_SubMesh* SMESHDS_Mesh::getSubmesh( const TopoDS_Shape & shape )
1015 if ( shape.IsNull() )
1018 if ( !myCurSubShape.IsNull() && shape.IsSame( myCurSubShape ))
1019 return myCurSubMesh;
1021 getSubmesh( ShapeToIndex( shape ));
1022 myCurSubShape = shape;
1023 return myCurSubMesh;
1026 //================================================================================
1028 * \brief return submesh by sub-shape index
1029 * \param Index - the sub-shape index
1030 * \retval SMESHDS_SubMesh* - the found submesh
1031 * search of submeshes is optimized
1033 //================================================================================
1035 SMESHDS_SubMesh* SMESHDS_Mesh::getSubmesh( const int Index )
1037 //Update or build submesh
1038 if ( Index != myCurSubID ) {
1039 map<int,SMESHDS_SubMesh*>::iterator it = myShapeIndexToSubMesh.find( Index );
1040 if ( it == myShapeIndexToSubMesh.end() )
1041 it = myShapeIndexToSubMesh.insert( make_pair(Index, new SMESHDS_SubMesh(this, Index) )).first;
1042 myCurSubMesh = it->second;
1044 myCurSubShape.Nullify(); // myCurSubShape no more corresponds to submesh
1046 return myCurSubMesh;
1049 //================================================================================
1051 * \brief Add element or node to submesh
1052 * \param elem - element to add
1053 * \param subMesh - submesh to be filled in
1055 //================================================================================
1057 bool SMESHDS_Mesh::add(const SMDS_MeshElement* elem, SMESHDS_SubMesh* subMesh )
1059 if ( elem && subMesh ) {
1060 if ( elem->GetType() == SMDSAbs_Node )
1061 subMesh->AddNode( static_cast<const SMDS_MeshNode* >( elem ));
1063 subMesh->AddElement( elem );
1069 //=======================================================================
1070 //function : SetNodeOnVolume
1072 //=======================================================================
1073 void SMESHDS_Mesh::SetNodeInVolume(SMDS_MeshNode * aNode,
1074 const TopoDS_Shell & S)
1076 if ( add( aNode, getSubmesh(S) ))
1077 aNode->SetPosition ( SMDS_SpacePosition::originSpacePosition() );
1080 //=======================================================================
1081 //function : SetNodeOnVolume
1083 //=======================================================================
1084 void SMESHDS_Mesh::SetNodeInVolume(SMDS_MeshNode * aNode,
1085 const TopoDS_Solid & S)
1087 if ( add( aNode, getSubmesh(S) ))
1088 aNode->SetPosition ( SMDS_SpacePosition::originSpacePosition() );
1091 //=======================================================================
1092 //function : SetNodeOnFace
1094 //=======================================================================
1095 void SMESHDS_Mesh::SetNodeOnFace(SMDS_MeshNode * aNode,
1096 const TopoDS_Face & S,
1100 if ( add( aNode, getSubmesh(S) ))
1101 aNode->SetPosition(SMDS_PositionPtr(new SMDS_FacePosition( u, v)));
1104 //=======================================================================
1105 //function : SetNodeOnEdge
1107 //=======================================================================
1108 void SMESHDS_Mesh::SetNodeOnEdge(SMDS_MeshNode * aNode,
1109 const TopoDS_Edge & S,
1112 if ( add( aNode, getSubmesh(S) ))
1113 aNode->SetPosition(SMDS_PositionPtr(new SMDS_EdgePosition(u)));
1116 //=======================================================================
1117 //function : SetNodeOnVertex
1119 //=======================================================================
1120 void SMESHDS_Mesh::SetNodeOnVertex(SMDS_MeshNode * aNode,
1121 const TopoDS_Vertex & S)
1123 if ( add( aNode, getSubmesh(S) ))
1124 aNode->SetPosition(SMDS_PositionPtr(new SMDS_VertexPosition()));
1127 //=======================================================================
1128 //function : UnSetNodeOnShape
1130 //=======================================================================
1131 void SMESHDS_Mesh::UnSetNodeOnShape(const SMDS_MeshNode* aNode)
1133 int shapeId = aNode->getshapeId();
1136 map<int, SMESHDS_SubMesh*>::iterator it = myShapeIndexToSubMesh.find(shapeId);
1137 if (it != myShapeIndexToSubMesh.end())
1138 it->second->RemoveNode(aNode, /*deleted=*/false);
1142 //=======================================================================
1143 //function : SetMeshElementOnShape
1145 //=======================================================================
1146 void SMESHDS_Mesh::SetMeshElementOnShape(const SMDS_MeshElement * anElement,
1147 const TopoDS_Shape & S)
1149 add( anElement, getSubmesh(S) );
1152 //=======================================================================
1153 //function : UnSetMeshElementOnShape
1155 //=======================================================================
1156 void SMESHDS_Mesh::UnSetMeshElementOnShape(const SMDS_MeshElement * elem,
1157 const TopoDS_Shape & S)
1159 int Index = myIndexToShape.FindIndex(S);
1161 map<int,SMESHDS_SubMesh*>::iterator it = myShapeIndexToSubMesh.find( Index );
1162 if ( it != myShapeIndexToSubMesh.end() )
1164 if (elem->GetType() == SMDSAbs_Node)
1165 it->second->RemoveNode(static_cast<const SMDS_MeshNode*> (elem), /*deleted=*/false);
1167 it->second->RemoveElement(elem, /*deleted=*/false);
1171 //=======================================================================
1172 //function : ShapeToMesh
1174 //=======================================================================
1175 TopoDS_Shape SMESHDS_Mesh::ShapeToMesh() const
1180 //=======================================================================
1181 //function : IsGroupOfSubShapes
1182 //purpose : return true if at least one sub-shape of theShape is a sub-shape
1183 // of myShape or theShape == myShape
1184 //=======================================================================
1186 bool SMESHDS_Mesh::IsGroupOfSubShapes (const TopoDS_Shape& theShape) const
1188 if ( myIndexToShape.Contains(theShape) )
1191 for ( TopoDS_Iterator it( theShape ); it.More(); it.Next() )
1192 if (IsGroupOfSubShapes( it.Value() ))
1198 ///////////////////////////////////////////////////////////////////////////////
1199 /// Return the sub mesh linked to the a given TopoDS_Shape or NULL if the given
1200 /// TopoDS_Shape is unknown
1201 ///////////////////////////////////////////////////////////////////////////////
1202 SMESHDS_SubMesh * SMESHDS_Mesh::MeshElements(const TopoDS_Shape & S) const
1204 int Index = ShapeToIndex(S);
1205 TShapeIndexToSubMesh::const_iterator anIter = myShapeIndexToSubMesh.find(Index);
1206 if (anIter != myShapeIndexToSubMesh.end())
1207 return anIter->second;
1212 ///////////////////////////////////////////////////////////////////////////////
1213 /// Return the sub mesh by Id of shape it is linked to
1214 ///////////////////////////////////////////////////////////////////////////////
1215 SMESHDS_SubMesh * SMESHDS_Mesh::MeshElements(const int Index) const
1217 TShapeIndexToSubMesh::const_iterator anIter = myShapeIndexToSubMesh.find(Index);
1218 if (anIter != myShapeIndexToSubMesh.end())
1219 return anIter->second;
1224 //=======================================================================
1225 //function : SubMeshIndices
1227 //=======================================================================
1228 list<int> SMESHDS_Mesh::SubMeshIndices() const
1230 list<int> anIndices;
1231 std::map<int,SMESHDS_SubMesh*>::const_iterator anIter = myShapeIndexToSubMesh.begin();
1232 for (; anIter != myShapeIndexToSubMesh.end(); anIter++) {
1233 anIndices.push_back((*anIter).first);
1238 //=======================================================================
1239 //function : GetHypothesis
1241 //=======================================================================
1243 const list<const SMESHDS_Hypothesis*>&
1244 SMESHDS_Mesh::GetHypothesis(const TopoDS_Shape & S) const
1246 if ( myShapeToHypothesis.IsBound( S.Oriented(TopAbs_FORWARD) ) ) // ignore orientation of S
1247 return myShapeToHypothesis.Find( S.Oriented(TopAbs_FORWARD) );
1249 static list<const SMESHDS_Hypothesis*> empty;
1253 //================================================================================
1255 * \brief returns true if the hypothesis is assigned to any sub-shape
1257 //================================================================================
1259 bool SMESHDS_Mesh::IsUsedHypothesis(const SMESHDS_Hypothesis * H) const
1261 ShapeToHypothesis::Iterator s2h( myShapeToHypothesis );
1262 for ( ; s2h.More(); s2h.Next() )
1263 if ( std::find( s2h.Value().begin(), s2h.Value().end(), H ) != s2h.Value().end() )
1268 //=======================================================================
1269 //function : GetScript
1271 //=======================================================================
1272 SMESHDS_Script* SMESHDS_Mesh::GetScript()
1277 //=======================================================================
1278 //function : ClearScript
1280 //=======================================================================
1281 void SMESHDS_Mesh::ClearScript()
1286 //=======================================================================
1287 //function : HasMeshElements
1289 //=======================================================================
1290 bool SMESHDS_Mesh::HasMeshElements(const TopoDS_Shape & S) const
1292 if (myShape.IsNull()) MESSAGE("myShape is NULL");
1293 int Index = myIndexToShape.FindIndex(S);
1294 return myShapeIndexToSubMesh.find(Index)!=myShapeIndexToSubMesh.end();
1297 //=======================================================================
1298 //function : HasHypothesis
1300 //=======================================================================
1301 bool SMESHDS_Mesh::HasHypothesis(const TopoDS_Shape & S)
1303 return myShapeToHypothesis.IsBound(S.Oriented(TopAbs_FORWARD));
1306 //=======================================================================
1307 //function : NewSubMesh
1309 //=======================================================================
1310 SMESHDS_SubMesh * SMESHDS_Mesh::NewSubMesh(int Index)
1312 SMESHDS_SubMesh* SM = 0;
1313 TShapeIndexToSubMesh::iterator anIter = myShapeIndexToSubMesh.find(Index);
1314 if (anIter == myShapeIndexToSubMesh.end())
1316 SM = new SMESHDS_SubMesh(this, Index);
1317 myShapeIndexToSubMesh[Index]=SM;
1320 SM = anIter->second;
1324 //=======================================================================
1325 //function : AddCompoundSubmesh
1327 //=======================================================================
1329 int SMESHDS_Mesh::AddCompoundSubmesh(const TopoDS_Shape& S,
1330 TopAbs_ShapeEnum type)
1333 if ( IsGroupOfSubShapes( S ))
1335 aMainIndex = myIndexToShape.Add( S );
1336 bool all = ( type == TopAbs_SHAPE );
1337 if ( all ) // corresponding simple submesh may exist
1338 aMainIndex = -aMainIndex;
1339 //MESSAGE("AddCompoundSubmesh index = " << aMainIndex );
1340 SMESHDS_SubMesh * aNewSub = NewSubMesh( aMainIndex );
1341 if ( !aNewSub->IsComplexSubmesh() ) // is empty
1343 int shapeType = Max( TopAbs_SOLID, all ? myShape.ShapeType() : type );
1344 int typeLimit = all ? TopAbs_VERTEX : type;
1345 for ( ; shapeType <= typeLimit; shapeType++ )
1347 TopExp_Explorer exp( S, TopAbs_ShapeEnum( shapeType ));
1348 for ( ; exp.More(); exp.Next() )
1350 int index = myIndexToShape.FindIndex( exp.Current() );
1352 aNewSub->AddSubMesh( NewSubMesh( index ));
1360 //=======================================================================
1361 //function : IndexToShape
1363 //=======================================================================
1364 const TopoDS_Shape& SMESHDS_Mesh::IndexToShape(int ShapeIndex) const
1368 return myIndexToShape.FindKey(ShapeIndex);
1370 catch ( Standard_OutOfRange )
1373 static TopoDS_Shape nullShape;
1377 //================================================================================
1379 * \brief Return max index of sub-mesh
1381 //================================================================================
1383 int SMESHDS_Mesh::MaxSubMeshIndex() const
1385 return myShapeIndexToSubMesh.empty() ? 0 : myShapeIndexToSubMesh.rbegin()->first;
1388 //=======================================================================
1389 //function : ShapeToIndex
1391 //=======================================================================
1392 int SMESHDS_Mesh::ShapeToIndex(const TopoDS_Shape & S) const
1394 if (myShape.IsNull())
1395 MESSAGE("myShape is NULL");
1397 int index = myIndexToShape.FindIndex(S);
1402 //=======================================================================
1403 //function : SetNodeOnVolume
1405 //=======================================================================
1406 void SMESHDS_Mesh::SetNodeInVolume(const SMDS_MeshNode* aNode, int Index)
1408 //add(aNode, getSubmesh(Index));
1409 if ( add( aNode, getSubmesh( Index )))
1410 ((SMDS_MeshNode*) aNode)->SetPosition( SMDS_SpacePosition::originSpacePosition());
1413 //=======================================================================
1414 //function : SetNodeOnFace
1416 //=======================================================================
1417 void SMESHDS_Mesh::SetNodeOnFace(SMDS_MeshNode* aNode, int Index, double u, double v)
1419 //Set Position on Node
1420 if ( add( aNode, getSubmesh( Index )))
1421 aNode->SetPosition(SMDS_PositionPtr(new SMDS_FacePosition( u, v)));
1424 //=======================================================================
1425 //function : SetNodeOnEdge
1427 //=======================================================================
1428 void SMESHDS_Mesh::SetNodeOnEdge(SMDS_MeshNode* aNode,
1432 //Set Position on Node
1433 if ( add( aNode, getSubmesh( Index )))
1434 aNode->SetPosition(SMDS_PositionPtr(new SMDS_EdgePosition(u)));
1437 //=======================================================================
1438 //function : SetNodeOnVertex
1440 //=======================================================================
1441 void SMESHDS_Mesh::SetNodeOnVertex(SMDS_MeshNode* aNode, int Index)
1443 //Set Position on Node
1444 if ( add( aNode, getSubmesh( Index )))
1445 aNode->SetPosition(SMDS_PositionPtr(new SMDS_VertexPosition()));
1448 //=======================================================================
1449 //function : SetMeshElementOnShape
1451 //=======================================================================
1452 void SMESHDS_Mesh::SetMeshElementOnShape(const SMDS_MeshElement* anElement,
1455 add( anElement, getSubmesh( Index ));
1458 //=======================================================================
1459 //function : ~SMESHDS_Mesh
1461 //=======================================================================
1462 SMESHDS_Mesh::~SMESHDS_Mesh()
1467 TShapeIndexToSubMesh::iterator i_sm = myShapeIndexToSubMesh.begin();
1468 for ( ; i_sm != myShapeIndexToSubMesh.end(); ++i_sm )
1469 delete i_sm->second;
1473 //********************************************************************
1474 //********************************************************************
1475 //******** *********
1476 //***** Methods for addition of quadratic elements ******
1477 //******** *********
1478 //********************************************************************
1479 //********************************************************************
1481 //=======================================================================
1482 //function : AddEdgeWithID
1484 //=======================================================================
1485 SMDS_MeshEdge* SMESHDS_Mesh::AddEdgeWithID(int n1, int n2, int n12, int ID)
1487 SMDS_MeshEdge* anElem = SMDS_Mesh::AddEdgeWithID(n1,n2,n12,ID);
1488 if(anElem) myScript->AddEdge(ID,n1,n2,n12);
1492 //=======================================================================
1493 //function : AddEdge
1495 //=======================================================================
1496 SMDS_MeshEdge* SMESHDS_Mesh::AddEdge(const SMDS_MeshNode* n1,
1497 const SMDS_MeshNode* n2,
1498 const SMDS_MeshNode* n12)
1500 SMDS_MeshEdge* anElem = SMDS_Mesh::AddEdge(n1,n2,n12);
1501 if(anElem) myScript->AddEdge(anElem->GetID(),
1508 //=======================================================================
1509 //function : AddEdgeWithID
1511 //=======================================================================
1512 SMDS_MeshEdge* SMESHDS_Mesh::AddEdgeWithID(const SMDS_MeshNode * n1,
1513 const SMDS_MeshNode * n2,
1514 const SMDS_MeshNode * n12,
1517 return AddEdgeWithID(n1->GetID(),
1524 //=======================================================================
1525 //function : AddFace
1527 //=======================================================================
1528 SMDS_MeshFace* SMESHDS_Mesh::AddFace(const SMDS_MeshNode * n1,
1529 const SMDS_MeshNode * n2,
1530 const SMDS_MeshNode * n3,
1531 const SMDS_MeshNode * n12,
1532 const SMDS_MeshNode * n23,
1533 const SMDS_MeshNode * n31)
1535 SMDS_MeshFace *anElem = SMDS_Mesh::AddFace(n1,n2,n3,n12,n23,n31);
1536 if(anElem) myScript->AddFace(anElem->GetID(),
1537 n1->GetID(), n2->GetID(), n3->GetID(),
1538 n12->GetID(), n23->GetID(), n31->GetID());
1542 //=======================================================================
1543 //function : AddFaceWithID
1545 //=======================================================================
1546 SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(int n1, int n2, int n3,
1547 int n12,int n23,int n31, int ID)
1549 SMDS_MeshFace *anElem = SMDS_Mesh::AddFaceWithID(n1,n2,n3,n12,n23,n31,ID);
1550 if(anElem) myScript->AddFace(ID,n1,n2,n3,n12,n23,n31);
1554 //=======================================================================
1555 //function : AddFaceWithID
1557 //=======================================================================
1558 SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
1559 const SMDS_MeshNode * n2,
1560 const SMDS_MeshNode * n3,
1561 const SMDS_MeshNode * n12,
1562 const SMDS_MeshNode * n23,
1563 const SMDS_MeshNode * n31,
1566 return AddFaceWithID(n1->GetID(), n2->GetID(), n3->GetID(),
1567 n12->GetID(), n23->GetID(), n31->GetID(),
1572 //=======================================================================
1573 //function : AddFace
1575 //=======================================================================
1576 SMDS_MeshFace* SMESHDS_Mesh::AddFace(const SMDS_MeshNode * n1,
1577 const SMDS_MeshNode * n2,
1578 const SMDS_MeshNode * n3,
1579 const SMDS_MeshNode * n4,
1580 const SMDS_MeshNode * n12,
1581 const SMDS_MeshNode * n23,
1582 const SMDS_MeshNode * n34,
1583 const SMDS_MeshNode * n41)
1585 SMDS_MeshFace *anElem = SMDS_Mesh::AddFace(n1,n2,n3,n4,n12,n23,n34,n41);
1586 if(anElem) myScript->AddFace(anElem->GetID(),
1587 n1->GetID(), n2->GetID(), n3->GetID(), n4->GetID(),
1588 n12->GetID(), n23->GetID(), n34->GetID(), n41->GetID());
1592 //=======================================================================
1593 //function : AddFaceWithID
1595 //=======================================================================
1596 SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(int n1, int n2, int n3, int n4,
1597 int n12,int n23,int n34,int n41, int ID)
1599 SMDS_MeshFace *anElem = SMDS_Mesh::AddFaceWithID(n1,n2,n3,n4,n12,n23,n34,n41,ID);
1600 if(anElem) myScript->AddFace(ID,n1,n2,n3,n4,n12,n23,n34,n41);
1604 //=======================================================================
1605 //function : AddFaceWithID
1607 //=======================================================================
1608 SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
1609 const SMDS_MeshNode * n2,
1610 const SMDS_MeshNode * n3,
1611 const SMDS_MeshNode * n4,
1612 const SMDS_MeshNode * n12,
1613 const SMDS_MeshNode * n23,
1614 const SMDS_MeshNode * n34,
1615 const SMDS_MeshNode * n41,
1618 return AddFaceWithID(n1->GetID(), n2->GetID(), n3->GetID(), n4->GetID(),
1619 n12->GetID(), n23->GetID(), n34->GetID(), n41->GetID(),
1624 //=======================================================================
1625 //function : AddFace
1627 //=======================================================================
1628 SMDS_MeshFace* SMESHDS_Mesh::AddFace(const SMDS_MeshNode * n1,
1629 const SMDS_MeshNode * n2,
1630 const SMDS_MeshNode * n3,
1631 const SMDS_MeshNode * n4,
1632 const SMDS_MeshNode * n12,
1633 const SMDS_MeshNode * n23,
1634 const SMDS_MeshNode * n34,
1635 const SMDS_MeshNode * n41,
1636 const SMDS_MeshNode * nCenter)
1638 SMDS_MeshFace *anElem = SMDS_Mesh::AddFace(n1,n2,n3,n4,n12,n23,n34,n41,nCenter);
1639 if(anElem) myScript->AddFace(anElem->GetID(),
1640 n1->GetID(), n2->GetID(), n3->GetID(), n4->GetID(),
1641 n12->GetID(), n23->GetID(), n34->GetID(), n41->GetID(),
1646 //=======================================================================
1647 //function : AddFaceWithID
1649 //=======================================================================
1650 SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(int n1, int n2, int n3, int n4,
1651 int n12,int n23,int n34,int n41,
1652 int nCenter, int ID)
1654 SMDS_MeshFace *anElem = SMDS_Mesh::AddFaceWithID(n1,n2,n3,n4,n12,n23,n34,n41,nCenter,ID);
1655 if(anElem) myScript->AddFace(ID,n1,n2,n3,n4,n12,n23,n34,n41,nCenter);
1659 //=======================================================================
1660 //function : AddFaceWithID
1662 //=======================================================================
1663 SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
1664 const SMDS_MeshNode * n2,
1665 const SMDS_MeshNode * n3,
1666 const SMDS_MeshNode * n4,
1667 const SMDS_MeshNode * n12,
1668 const SMDS_MeshNode * n23,
1669 const SMDS_MeshNode * n34,
1670 const SMDS_MeshNode * n41,
1671 const SMDS_MeshNode * nCenter,
1674 return AddFaceWithID(n1->GetID(), n2->GetID(), n3->GetID(), n4->GetID(),
1675 n12->GetID(), n23->GetID(), n34->GetID(), n41->GetID(),
1676 nCenter->GetID(), ID);
1680 //=======================================================================
1681 //function : AddVolume
1683 //=======================================================================
1684 SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
1685 const SMDS_MeshNode * n2,
1686 const SMDS_MeshNode * n3,
1687 const SMDS_MeshNode * n4,
1688 const SMDS_MeshNode * n12,
1689 const SMDS_MeshNode * n23,
1690 const SMDS_MeshNode * n31,
1691 const SMDS_MeshNode * n14,
1692 const SMDS_MeshNode * n24,
1693 const SMDS_MeshNode * n34)
1695 SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolume(n1,n2,n3,n4,n12,n23,n31,n14,n24,n34);
1696 if(anElem) myScript->AddVolume(anElem->GetID(),
1697 n1->GetID(), n2->GetID(), n3->GetID(), n4->GetID(),
1698 n12->GetID(), n23->GetID(), n31->GetID(),
1699 n14->GetID(), n24->GetID(), n34->GetID());
1703 //=======================================================================
1704 //function : AddVolumeWithID
1706 //=======================================================================
1707 SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4,
1708 int n12,int n23,int n31,
1709 int n14,int n24,int n34, int ID)
1711 SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolumeWithID(n1,n2,n3,n4,n12,n23,
1712 n31,n14,n24,n34,ID);
1713 if(anElem) myScript->AddVolume(ID,n1,n2,n3,n4,n12,n23,n31,n14,n24,n34);
1717 //=======================================================================
1718 //function : AddVolumeWithID
1719 //purpose : 2d order tetrahedron of 10 nodes
1720 //=======================================================================
1721 SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
1722 const SMDS_MeshNode * n2,
1723 const SMDS_MeshNode * n3,
1724 const SMDS_MeshNode * n4,
1725 const SMDS_MeshNode * n12,
1726 const SMDS_MeshNode * n23,
1727 const SMDS_MeshNode * n31,
1728 const SMDS_MeshNode * n14,
1729 const SMDS_MeshNode * n24,
1730 const SMDS_MeshNode * n34,
1733 return AddVolumeWithID(n1->GetID(), n2->GetID(), n3->GetID(), n4->GetID(),
1734 n12->GetID(), n23->GetID(), n31->GetID(),
1735 n14->GetID(), n24->GetID(), n34->GetID(), ID);
1739 //=======================================================================
1740 //function : AddVolume
1742 //=======================================================================
1743 SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
1744 const SMDS_MeshNode * n2,
1745 const SMDS_MeshNode * n3,
1746 const SMDS_MeshNode * n4,
1747 const SMDS_MeshNode * n5,
1748 const SMDS_MeshNode * n12,
1749 const SMDS_MeshNode * n23,
1750 const SMDS_MeshNode * n34,
1751 const SMDS_MeshNode * n41,
1752 const SMDS_MeshNode * n15,
1753 const SMDS_MeshNode * n25,
1754 const SMDS_MeshNode * n35,
1755 const SMDS_MeshNode * n45)
1757 SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolume(n1,n2,n3,n4,n5,n12,n23,n34,n41,
1760 myScript->AddVolume(anElem->GetID(), n1->GetID(), n2->GetID(),
1761 n3->GetID(), n4->GetID(), n5->GetID(),
1762 n12->GetID(), n23->GetID(), n34->GetID(), n41->GetID(),
1763 n15->GetID(), n25->GetID(), n35->GetID(), n45->GetID());
1767 //=======================================================================
1768 //function : AddVolumeWithID
1770 //=======================================================================
1771 SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4, int n5,
1772 int n12,int n23,int n34,int n41,
1773 int n15,int n25,int n35,int n45, int ID)
1775 SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolumeWithID(n1,n2,n3,n4,n5,
1777 n15,n25,n35,n45,ID);
1778 if(anElem) myScript->AddVolume(ID,n1,n2,n3,n4,n5,n12,n23,n34,n41,
1783 //=======================================================================
1784 //function : AddVolumeWithID
1785 //purpose : 2d order pyramid of 13 nodes
1786 //=======================================================================
1787 SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
1788 const SMDS_MeshNode * n2,
1789 const SMDS_MeshNode * n3,
1790 const SMDS_MeshNode * n4,
1791 const SMDS_MeshNode * n5,
1792 const SMDS_MeshNode * n12,
1793 const SMDS_MeshNode * n23,
1794 const SMDS_MeshNode * n34,
1795 const SMDS_MeshNode * n41,
1796 const SMDS_MeshNode * n15,
1797 const SMDS_MeshNode * n25,
1798 const SMDS_MeshNode * n35,
1799 const SMDS_MeshNode * n45,
1802 return AddVolumeWithID(n1->GetID(), n2->GetID(), n3->GetID(),
1803 n4->GetID(), n5->GetID(),
1804 n12->GetID(), n23->GetID(), n34->GetID(), n41->GetID(),
1805 n15->GetID(), n25->GetID(), n35->GetID(), n45->GetID(),
1810 //=======================================================================
1811 //function : AddVolume
1813 //=======================================================================
1814 SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
1815 const SMDS_MeshNode * n2,
1816 const SMDS_MeshNode * n3,
1817 const SMDS_MeshNode * n4,
1818 const SMDS_MeshNode * n5,
1819 const SMDS_MeshNode * n6,
1820 const SMDS_MeshNode * n12,
1821 const SMDS_MeshNode * n23,
1822 const SMDS_MeshNode * n31,
1823 const SMDS_MeshNode * n45,
1824 const SMDS_MeshNode * n56,
1825 const SMDS_MeshNode * n64,
1826 const SMDS_MeshNode * n14,
1827 const SMDS_MeshNode * n25,
1828 const SMDS_MeshNode * n36)
1830 SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolume(n1,n2,n3,n4,n5,n6,n12,n23,n31,
1831 n45,n56,n64,n14,n25,n36);
1833 myScript->AddVolume(anElem->GetID(), n1->GetID(), n2->GetID(),
1834 n3->GetID(), n4->GetID(), n5->GetID(), n6->GetID(),
1835 n12->GetID(), n23->GetID(), n31->GetID(),
1836 n45->GetID(), n56->GetID(), n64->GetID(),
1837 n14->GetID(), n25->GetID(), n36->GetID());
1841 //=======================================================================
1842 //function : AddVolumeWithID
1844 //=======================================================================
1845 SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(int n1, int n2, int n3,
1846 int n4, int n5, int n6,
1847 int n12,int n23,int n31,
1848 int n45,int n56,int n64,
1849 int n14,int n25,int n36, int ID)
1851 SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolumeWithID(n1,n2,n3,n4,n5,n6,
1855 if(anElem) myScript->AddVolume(ID,n1,n2,n3,n4,n5,n6,n12,n23,n31,
1856 n45,n56,n64,n14,n25,n36);
1860 //=======================================================================
1861 //function : AddVolumeWithID
1862 //purpose : 2d order Pentahedron with 15 nodes
1863 //=======================================================================
1864 SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
1865 const SMDS_MeshNode * n2,
1866 const SMDS_MeshNode * n3,
1867 const SMDS_MeshNode * n4,
1868 const SMDS_MeshNode * n5,
1869 const SMDS_MeshNode * n6,
1870 const SMDS_MeshNode * n12,
1871 const SMDS_MeshNode * n23,
1872 const SMDS_MeshNode * n31,
1873 const SMDS_MeshNode * n45,
1874 const SMDS_MeshNode * n56,
1875 const SMDS_MeshNode * n64,
1876 const SMDS_MeshNode * n14,
1877 const SMDS_MeshNode * n25,
1878 const SMDS_MeshNode * n36,
1881 return AddVolumeWithID(n1->GetID(), n2->GetID(), n3->GetID(),
1882 n4->GetID(), n5->GetID(), n6->GetID(),
1883 n12->GetID(), n23->GetID(), n31->GetID(),
1884 n45->GetID(), n56->GetID(), n64->GetID(),
1885 n14->GetID(), n25->GetID(), n36->GetID(),
1890 //=======================================================================
1891 //function : AddVolume
1892 //purpose : add quadratic hexahedron
1893 //=======================================================================
1894 SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
1895 const SMDS_MeshNode * n2,
1896 const SMDS_MeshNode * n3,
1897 const SMDS_MeshNode * n4,
1898 const SMDS_MeshNode * n5,
1899 const SMDS_MeshNode * n6,
1900 const SMDS_MeshNode * n7,
1901 const SMDS_MeshNode * n8,
1902 const SMDS_MeshNode * n12,
1903 const SMDS_MeshNode * n23,
1904 const SMDS_MeshNode * n34,
1905 const SMDS_MeshNode * n41,
1906 const SMDS_MeshNode * n56,
1907 const SMDS_MeshNode * n67,
1908 const SMDS_MeshNode * n78,
1909 const SMDS_MeshNode * n85,
1910 const SMDS_MeshNode * n15,
1911 const SMDS_MeshNode * n26,
1912 const SMDS_MeshNode * n37,
1913 const SMDS_MeshNode * n48)
1915 SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolume(n1,n2,n3,n4,n5,n6,n7,n8,
1920 myScript->AddVolume(anElem->GetID(), n1->GetID(), n2->GetID(),
1921 n3->GetID(), n4->GetID(), n5->GetID(),
1922 n6->GetID(), n7->GetID(), n8->GetID(),
1923 n12->GetID(), n23->GetID(), n34->GetID(), n41->GetID(),
1924 n56->GetID(), n67->GetID(), n78->GetID(), n85->GetID(),
1925 n15->GetID(), n26->GetID(), n37->GetID(), n48->GetID());
1929 //=======================================================================
1930 //function : AddVolumeWithID
1932 //=======================================================================
1933 SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4,
1934 int n5, int n6, int n7, int n8,
1935 int n12,int n23,int n34,int n41,
1936 int n56,int n67,int n78,int n85,
1937 int n15,int n26,int n37,int n48, int ID)
1939 SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolumeWithID(n1,n2,n3,n4,n5,n6,n7,n8,
1942 n15,n26,n37,n48,ID);
1943 if(anElem) myScript->AddVolume(ID,n1,n2,n3,n4,n5,n6,n7,n8,n12,n23,n34,n41,
1944 n56,n67,n78,n85,n15,n26,n37,n48);
1948 //=======================================================================
1949 //function : AddVolumeWithID
1950 //purpose : 2d order Hexahedrons with 20 nodes
1951 //=======================================================================
1952 SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
1953 const SMDS_MeshNode * n2,
1954 const SMDS_MeshNode * n3,
1955 const SMDS_MeshNode * n4,
1956 const SMDS_MeshNode * n5,
1957 const SMDS_MeshNode * n6,
1958 const SMDS_MeshNode * n7,
1959 const SMDS_MeshNode * n8,
1960 const SMDS_MeshNode * n12,
1961 const SMDS_MeshNode * n23,
1962 const SMDS_MeshNode * n34,
1963 const SMDS_MeshNode * n41,
1964 const SMDS_MeshNode * n56,
1965 const SMDS_MeshNode * n67,
1966 const SMDS_MeshNode * n78,
1967 const SMDS_MeshNode * n85,
1968 const SMDS_MeshNode * n15,
1969 const SMDS_MeshNode * n26,
1970 const SMDS_MeshNode * n37,
1971 const SMDS_MeshNode * n48,
1974 return AddVolumeWithID(n1->GetID(), n2->GetID(), n3->GetID(), n4->GetID(),
1975 n5->GetID(), n6->GetID(), n7->GetID(), n8->GetID(),
1976 n12->GetID(), n23->GetID(), n34->GetID(), n41->GetID(),
1977 n56->GetID(), n67->GetID(), n78->GetID(), n85->GetID(),
1978 n15->GetID(), n26->GetID(), n37->GetID(), n48->GetID(),
1982 //=======================================================================
1983 //function : AddVolume
1984 //purpose : add tri-quadratic hexahedron of 27 nodes
1985 //=======================================================================
1987 SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
1988 const SMDS_MeshNode * n2,
1989 const SMDS_MeshNode * n3,
1990 const SMDS_MeshNode * n4,
1991 const SMDS_MeshNode * n5,
1992 const SMDS_MeshNode * n6,
1993 const SMDS_MeshNode * n7,
1994 const SMDS_MeshNode * n8,
1995 const SMDS_MeshNode * n12,
1996 const SMDS_MeshNode * n23,
1997 const SMDS_MeshNode * n34,
1998 const SMDS_MeshNode * n41,
1999 const SMDS_MeshNode * n56,
2000 const SMDS_MeshNode * n67,
2001 const SMDS_MeshNode * n78,
2002 const SMDS_MeshNode * n85,
2003 const SMDS_MeshNode * n15,
2004 const SMDS_MeshNode * n26,
2005 const SMDS_MeshNode * n37,
2006 const SMDS_MeshNode * n48,
2007 const SMDS_MeshNode * n1234,
2008 const SMDS_MeshNode * n1256,
2009 const SMDS_MeshNode * n2367,
2010 const SMDS_MeshNode * n3478,
2011 const SMDS_MeshNode * n1458,
2012 const SMDS_MeshNode * n5678,
2013 const SMDS_MeshNode * nCenter)
2015 SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolume(n1,n2,n3,n4,n5,n6,n7,n8,
2019 n1234,n1256,n2367,n3478,n1458,n5678,nCenter);
2021 myScript->AddVolume(anElem->GetID(), n1->GetID(), n2->GetID(),
2022 n3->GetID(), n4->GetID(), n5->GetID(),
2023 n6->GetID(), n7->GetID(), n8->GetID(),
2024 n12->GetID(), n23->GetID(), n34->GetID(), n41->GetID(),
2025 n56->GetID(), n67->GetID(), n78->GetID(), n85->GetID(),
2026 n15->GetID(), n26->GetID(), n37->GetID(), n48->GetID(),
2027 n1234->GetID(),n1256->GetID(),n2367->GetID(),n3478->GetID(),
2028 n1458->GetID(),n5678->GetID(),nCenter->GetID());
2032 SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4,
2033 int n5, int n6, int n7, int n8,
2034 int n12,int n23,int n34,int n41,
2035 int n56,int n67,int n78,int n85,
2036 int n15,int n26,int n37,int n48,
2037 int n1234,int n1256,int n2367,int n3478,
2038 int n1458,int n5678,int nCenter,
2041 SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolumeWithID(n1,n2,n3,n4,n5,n6,n7,n8,
2045 n1234, n1256, n2367, n3478,
2046 n1458, n5678, nCenter,
2048 if(anElem) myScript->AddVolume(ID,n1,n2,n3,n4,n5,n6,n7,n8,n12,n23,n34,n41,
2049 n56,n67,n78,n85,n15,n26,n37,n48,
2050 n1234, n1256, n2367, n3478,
2051 n1458, n5678, nCenter);
2055 SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
2056 const SMDS_MeshNode * n2,
2057 const SMDS_MeshNode * n3,
2058 const SMDS_MeshNode * n4,
2059 const SMDS_MeshNode * n5,
2060 const SMDS_MeshNode * n6,
2061 const SMDS_MeshNode * n7,
2062 const SMDS_MeshNode * n8,
2063 const SMDS_MeshNode * n12,
2064 const SMDS_MeshNode * n23,
2065 const SMDS_MeshNode * n34,
2066 const SMDS_MeshNode * n41,
2067 const SMDS_MeshNode * n56,
2068 const SMDS_MeshNode * n67,
2069 const SMDS_MeshNode * n78,
2070 const SMDS_MeshNode * n85,
2071 const SMDS_MeshNode * n15,
2072 const SMDS_MeshNode * n26,
2073 const SMDS_MeshNode * n37,
2074 const SMDS_MeshNode * n48,
2075 const SMDS_MeshNode * n1234,
2076 const SMDS_MeshNode * n1256,
2077 const SMDS_MeshNode * n2367,
2078 const SMDS_MeshNode * n3478,
2079 const SMDS_MeshNode * n1458,
2080 const SMDS_MeshNode * n5678,
2081 const SMDS_MeshNode * nCenter,
2084 return AddVolumeWithID(n1->GetID(), n2->GetID(), n3->GetID(), n4->GetID(),
2085 n5->GetID(), n6->GetID(), n7->GetID(), n8->GetID(),
2086 n12->GetID(), n23->GetID(), n34->GetID(), n41->GetID(),
2087 n56->GetID(), n67->GetID(), n78->GetID(), n85->GetID(),
2088 n15->GetID(), n26->GetID(), n37->GetID(), n48->GetID(),
2089 n1234->GetID(),n1256->GetID(),n2367->GetID(),n3478->GetID(),
2090 n1458->GetID(),n5678->GetID(),nCenter->GetID(), ID);
2093 void SMESHDS_Mesh::compactMesh()
2095 int newNodeSize = 0;
2096 int nbNodes = myNodes.size();
2097 int nbVtkNodes = myGrid->GetNumberOfPoints();
2098 MESSAGE("nbNodes=" << nbNodes << " nbVtkNodes=" << nbVtkNodes);
2099 int nbNodeTemp = nbVtkNodes;
2100 if (nbNodes > nbVtkNodes)
2101 nbNodeTemp = nbNodes;
2102 vector<int> idNodesOldToNew;
2103 idNodesOldToNew.clear();
2104 idNodesOldToNew.resize(nbNodeTemp, -1); // all unused id will be -1
2106 for (int i = 0; i < nbNodes; i++)
2110 int vtkid = myNodes[i]->getVtkId();
2111 idNodesOldToNew[vtkid] = i; // old vtkId --> old smdsId (valid smdsId are >= 0)
2115 bool areNodesModified = (newNodeSize < nbVtkNodes);
2116 MESSAGE("------------------------- compactMesh Nodes Modified: " << areNodesModified);
2117 areNodesModified = true;
2119 int newCellSize = 0;
2120 int nbCells = myCells.size();
2121 int nbVtkCells = myGrid->GetNumberOfCells();
2122 MESSAGE("nbCells=" << nbCells << " nbVtkCells=" << nbVtkCells);
2123 int nbCellTemp = nbVtkCells;
2124 if (nbCells > nbVtkCells)
2125 nbCellTemp = nbCells;
2126 vector<int> idCellsOldToNew;
2127 idCellsOldToNew.clear();
2128 idCellsOldToNew.resize(nbCellTemp, -1); // all unused id will be -1
2130 for (int i = 0; i < nbCells; i++)
2134 // //idCellsOldToNew[i] = myCellIdVtkToSmds[i]; // valid vtk indexes are > = 0
2135 // int vtkid = myCells[i]->getVtkId();
2136 // idCellsOldToNew[vtkid] = i; // old vtkId --> old smdsId (not used in input)
2140 if (areNodesModified)
2141 myGrid->compactGrid(idNodesOldToNew, newNodeSize, idCellsOldToNew, newCellSize);
2143 myGrid->compactGrid(idNodesOldToNew, 0, idCellsOldToNew, newCellSize);
2145 int nbVtkPts = myGrid->GetNumberOfPoints();
2146 nbVtkCells = myGrid->GetNumberOfCells();
2147 if (nbVtkPts != newNodeSize)
2149 MESSAGE("===> nbVtkPts != newNodeSize " << nbVtkPts << " " << newNodeSize);
2150 if (nbVtkPts > newNodeSize) newNodeSize = nbVtkPts; // several points with same SMDS Id
2152 if (nbVtkCells != newCellSize)
2154 MESSAGE("===> nbVtkCells != newCellSize " << nbVtkCells << " " << newCellSize);
2155 if (nbVtkCells > newCellSize) newCellSize = nbVtkCells; // several cells with same SMDS Id
2158 // --- SMDS_MeshNode and myNodes (id in SMDS and in VTK are the same), myNodeIdFactory
2160 if (areNodesModified)
2162 MESSAGE("-------------- modify myNodes");
2163 SetOfNodes newNodes;
2164 newNodes.resize(newNodeSize+1,0); // 0 not used, SMDS numbers 1..n
2166 for (int i = 0; i < nbNodes; i++)
2170 newSmdsId++; // SMDS id start to 1
2171 int oldVtkId = myNodes[i]->getVtkId();
2172 int newVtkId = idNodesOldToNew[oldVtkId];
2173 //MESSAGE("myNodes["<< i << "] vtkId " << oldVtkId << " --> " << newVtkId);
2174 myNodes[i]->setVtkId(newVtkId);
2175 myNodes[i]->setId(newSmdsId);
2176 newNodes[newSmdsId] = myNodes[i];
2177 //MESSAGE("myNodes["<< i << "] --> newNodes[" << newSmdsId << "]");
2180 myNodes.swap(newNodes);
2181 this->myNodeIDFactory->emptyPool(newSmdsId); // newSmdsId = number of nodes
2182 MESSAGE("myNodes.size " << myNodes.size());
2185 // --- SMDS_MeshCell, myCellIdVtkToSmds, myCellIdSmdsToVtk, myCells
2187 int vtkIndexSize = myCellIdVtkToSmds.size();
2189 for (int oldVtkId = 0; oldVtkId < vtkIndexSize; oldVtkId++)
2191 int oldSmdsId = this->myCellIdVtkToSmds[oldVtkId];
2194 int newVtkId = idCellsOldToNew[oldVtkId];
2195 if (newVtkId > maxVtkId)
2196 maxVtkId = newVtkId;
2197 //MESSAGE("myCells["<< oldSmdsId << "] vtkId " << oldVtkId << " --> " << newVtkId);
2198 myCells[oldSmdsId]->setVtkId(newVtkId);
2201 // MESSAGE("myCells.size()=" << myCells.size()
2202 // << " myCellIdSmdsToVtk.size()=" << myCellIdSmdsToVtk.size()
2203 // << " myCellIdVtkToSmds.size()=" << myCellIdVtkToSmds.size() );
2205 SetOfCells newCells;
2206 //vector<int> newSmdsToVtk;
2207 vector<int> newVtkToSmds;
2209 assert(maxVtkId < newCellSize);
2210 newCells.resize(newCellSize+1, 0); // 0 not used, SMDS numbers 1..n
2211 //newSmdsToVtk.resize(newCellSize+1, -1);
2212 newVtkToSmds.resize(newCellSize+1, -1);
2214 int myCellsSize = myCells.size();
2216 for (int i = 0; i < myCellsSize; i++)
2220 newSmdsId++; // SMDS id start to 1
2221 assert(newSmdsId <= newCellSize);
2222 newCells[newSmdsId] = myCells[i];
2223 newCells[newSmdsId]->setId(newSmdsId);
2224 //MESSAGE("myCells["<< i << "] --> newCells[" << newSmdsId << "]");
2225 int idvtk = myCells[i]->getVtkId();
2226 //newSmdsToVtk[newSmdsId] = idvtk;
2227 assert(idvtk < newCellSize);
2228 newVtkToSmds[idvtk] = newSmdsId;
2232 myCells.swap(newCells);
2233 //myCellIdSmdsToVtk.swap(newSmdsToVtk);
2234 myCellIdVtkToSmds.swap(newVtkToSmds);
2235 MESSAGE("myCells.size()=" << myCells.size()
2236 << " myCellIdVtkToSmds.size()=" << myCellIdVtkToSmds.size() );
2237 this->myElementIDFactory->emptyPool(newSmdsId);
2239 this->myScript->SetModified(true); // notify GUI client for buildPrs when update
2241 // --- compact list myNodes and myElements in submeshes
2243 map<int,SMESHDS_SubMesh*>::iterator it = myShapeIndexToSubMesh.begin();
2244 for(; it != myShapeIndexToSubMesh.end(); ++it)
2246 (*it).second->compactList();
2251 void SMESHDS_Mesh::CleanDownWardConnectivity()
2253 myGrid->CleanDownwardConnectivity();
2256 void SMESHDS_Mesh::BuildDownWardConnectivity(bool withEdges)
2258 myGrid->BuildDownwardConnectivity(withEdges);
2261 /*! change some nodes in cell without modifying type or internal connectivity.
2262 * Nodes inverse connectivity is maintained up to date.
2263 * @param vtkVolId vtk id of the cell.
2264 * @param localClonedNodeIds map old node id to new node id.
2265 * @return ok if success.
2267 bool SMESHDS_Mesh::ModifyCellNodes(int vtkVolId, std::map<int,int> localClonedNodeIds)
2269 myGrid->ModifyCellNodes(vtkVolId, localClonedNodeIds);