src/SMESHDS/SMESHDS_Mesh.cxx

   1 // Copyright (C) 2007-2013  CEA/DEN, EDF R&D, OPEN CASCADE
   2 //
   3 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   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.
  10 //
  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.
  15 //
  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
  19 //
  20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22
  23 //  SMESH SMESHDS : management of mesh data and SMESH document
  24 //  File   : SMESH_Mesh.cxx
  25 //  Author : Yves FRICAUD, OCC
  26 //  Module : SMESH
  27 //
  28 #include "SMESHDS_Mesh.hxx"
  29
  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"
  38
  39 #include <Standard_ErrorHandler.hxx>
  40 #include <Standard_OutOfRange.hxx>
  41 #include <TopExp.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>
  49
  50 #include "utilities.h"
  51
  52 using namespace std;
  53
  54 //=======================================================================
  55 //function : Create
  56 //purpose  :
  57 //=======================================================================
  58 SMESHDS_Mesh::SMESHDS_Mesh(int theMeshID, bool theIsEmbeddedMode):
  59   myMeshID(theMeshID),
  60   myIsEmbeddedMode(theIsEmbeddedMode),
  61   myCurSubID(-1)
  62 {
  63   myScript = new SMESHDS_Script(theIsEmbeddedMode);
  64   myCurSubMesh = 0;
  65   SetPersistentId(theMeshID);
  66 }
  67
  68 //=======================================================================
  69 bool SMESHDS_Mesh::IsEmbeddedMode()
  70 {
  71   return myIsEmbeddedMode;
  72 }
  73
  74 //================================================================================
  75 /*!
  76  * \brief Store ID persistent during lifecycle
  77  *
  78  * Initially it was used to have a persistent reference to the mesh from the hypothesis
  79  */
  80 //================================================================================
  81
  82 void SMESHDS_Mesh::SetPersistentId(int id)
  83 {
  84   if (NbNodes() == 0)
  85     myPersistentID = id;
  86 }
  87 //================================================================================
  88 /*!
  89  * \brief Return ID persistent during lifecycle
  90  */
  91 //================================================================================
  92
  93 int SMESHDS_Mesh::GetPersistentId() const
  94 {
  95   return myPersistentID;
  96 }
  97
  98 //=======================================================================
  99 //function : ShapeToMesh
 100 //purpose  :
 101 //=======================================================================
 102 void SMESHDS_Mesh::ShapeToMesh(const TopoDS_Shape & S)
 103 {
 104   if ( !myShape.IsNull() && S.IsNull() )
 105   {
 106     // removal of a shape to mesh, delete ...
 107     // - hypotheses
 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);
 116       }
 117     }
 118     // - sub-meshes
 119     TShapeIndexToSubMesh::iterator i_sm = myShapeIndexToSubMesh.begin();
 120     for ( ; i_sm != myShapeIndexToSubMesh.end(); ++i_sm )
 121       delete i_sm->second;
 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++ );
 129       else
 130         gr++;
 131     }
 132   }
 133   else {
 134     myShape = S;
 135     if ( !S.IsNull() )
 136       TopExp::MapShapes(myShape, myIndexToShape);
 137   }
 138 }
 139
 140 //=======================================================================
 141 //function : AddHypothesis
 142 //purpose  :
 143 //=======================================================================
 144
 145 bool SMESHDS_Mesh::AddHypothesis(const TopoDS_Shape & SS,
 146                                  const SMESHDS_Hypothesis * H)
 147 {
 148   if (!myShapeToHypothesis.IsBound(SS.Oriented(TopAbs_FORWARD))) {
 149     list<const SMESHDS_Hypothesis *> aList;
 150     myShapeToHypothesis.Bind(SS.Oriented(TopAbs_FORWARD), aList);
 151   }
 152   list<const SMESHDS_Hypothesis *>& alist =
 153     myShapeToHypothesis(SS.Oriented(TopAbs_FORWARD)); // ignore orientation of SS
 154
 155   //Check if the Hypothesis is still present
 156   list<const SMESHDS_Hypothesis*>::iterator ith = find(alist.begin(),alist.end(), H );
 157
 158   if (alist.end() != ith) return false;
 159
 160   alist.push_back(H);
 161   return true;
 162 }
 163
 164 //=======================================================================
 165 //function : RemoveHypothesis
 166 //purpose  :
 167 //=======================================================================
 168
 169 bool SMESHDS_Mesh::RemoveHypothesis(const TopoDS_Shape &       S,
 170                                     const SMESHDS_Hypothesis * H)
 171 {
 172   if( myShapeToHypothesis.IsBound( S.Oriented(TopAbs_FORWARD) ) )
 173   {
 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())
 177     {
 178       alist.erase(ith);
 179       return true;
 180     }
 181   }
 182   return false;
 183 }
 184
 185 //=======================================================================
 186 //function : AddNode
 187 //purpose  :
 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);
 192   return node;
 193 }
 194
 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);
 198   return node;
 199 }
 200
 201 //=======================================================================
 202 //function : MoveNode
 203 //purpose  :
 204 //=======================================================================
 205
 206 void SMESHDS_Mesh::MoveNode(const SMDS_MeshNode *n, double x, double y, double z)
 207 {
 208   SMDS_Mesh::MoveNode( n, x, y, z );
 209   myScript->MoveNode(n->GetID(), x, y, z);
 210 }
 211
 212 //=======================================================================
 213 //function : ChangeElementNodes
 214 //purpose  :
 215 //=======================================================================
 216
 217 bool SMESHDS_Mesh::ChangeElementNodes(const SMDS_MeshElement * elem,
 218                                       const SMDS_MeshNode    * nodes[],
 219                                       const int                nbnodes)
 220 {
 221   //MESSAGE("SMESHDS_Mesh::ChangeElementNodes");
 222   if ( ! SMDS_Mesh::ChangeElementNodes( elem, nodes, nbnodes ))
 223     return false;
 224
 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);
 229
 230   return true;
 231 }
 232
 233 //=======================================================================
 234 //function : ChangePolygonNodes
 235 //purpose  :
 236 //=======================================================================
 237 bool SMESHDS_Mesh::ChangePolygonNodes
 238                    (const SMDS_MeshElement *     elem,
 239                     vector<const SMDS_MeshNode*> nodes)
 240 {
 241   ASSERT(nodes.size() > 3);
 242
 243   return ChangeElementNodes(elem, &nodes[0], nodes.size());
 244 }
 245
 246 //=======================================================================
 247 //function : ChangePolyhedronNodes
 248 //purpose  :
 249 //=======================================================================
 250 bool SMESHDS_Mesh::ChangePolyhedronNodes
 251                    (const SMDS_MeshElement * elem,
 252                     std::vector<const SMDS_MeshNode*> nodes,
 253                     std::vector<int>                  quantities)
 254 {
 255   ASSERT(nodes.size() > 3);
 256
 257   if (!SMDS_Mesh::ChangePolyhedronNodes(elem, nodes, quantities))
 258     return false;
 259
 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();
 264   }
 265   myScript->ChangePolyhedronNodes(elem->GetID(), nodes_ids, quantities);
 266
 267   return true;
 268 }
 269
 270 //=======================================================================
 271 //function : Renumber
 272 //purpose  :
 273 //=======================================================================
 274
 275 void SMESHDS_Mesh::Renumber (const bool isNodes, const int startID, const int deltaID)
 276 {
 277   // TODO not possible yet to have node numbers not starting to O and continuous.
 278   if (!this->isCompacted())
 279     this->compactMesh();
 280 //  SMDS_Mesh::Renumber( isNodes, startID, deltaID );
 281 //  myScript->Renumber( isNodes, startID, deltaID );
 282 }
 283
 284 //=======================================================================
 285 //function : Add0DElement
 286 //purpose  :
 287 //=======================================================================
 288 SMDS_Mesh0DElement* SMESHDS_Mesh::Add0DElementWithID(int nodeID, int ID)
 289 {
 290   SMDS_Mesh0DElement* anElem = SMDS_Mesh::Add0DElementWithID(nodeID, ID);
 291   if (anElem) myScript->Add0DElement(ID, nodeID);
 292   return anElem;
 293 }
 294
 295 SMDS_Mesh0DElement* SMESHDS_Mesh::Add0DElementWithID
 296                                   (const SMDS_MeshNode * node, int ID)
 297 {
 298   return Add0DElementWithID(node->GetID(), ID);
 299 }
 300
 301 SMDS_Mesh0DElement* SMESHDS_Mesh::Add0DElement(const SMDS_MeshNode * node)
 302 {
 303   SMDS_Mesh0DElement* anElem = SMDS_Mesh::Add0DElement(node);
 304   if (anElem) myScript->Add0DElement(anElem->GetID(), node->GetID());
 305   return anElem;
 306 }
 307
 308 //=======================================================================
 309 //function :AddBallWithID
 310 //purpose  :
 311 //=======================================================================
 312
 313 SMDS_BallElement* SMESHDS_Mesh::AddBallWithID(int node, double diameter, int ID)
 314 {
 315   SMDS_BallElement* anElem = SMDS_Mesh::AddBallWithID(node,diameter,ID);
 316   if (anElem) myScript->AddBall(anElem->GetID(), node, diameter);
 317   return anElem;
 318 }
 319
 320 SMDS_BallElement* SMESHDS_Mesh::AddBallWithID(const SMDS_MeshNode * node,
 321                                               double                diameter,
 322                                               int                   ID)
 323 {
 324   SMDS_BallElement* anElem = SMDS_Mesh::AddBallWithID(node,diameter,ID);
 325   if (anElem) myScript->AddBall(anElem->GetID(), node->GetID(), diameter);
 326   return anElem;
 327 }
 328
 329 SMDS_BallElement* SMESHDS_Mesh::AddBall (const SMDS_MeshNode * node,
 330                                          double                diameter)
 331 {
 332   SMDS_BallElement* anElem = SMDS_Mesh::AddBall(node,diameter);
 333   if (anElem) myScript->AddBall(anElem->GetID(), node->GetID(), diameter);
 334   return anElem;
 335 }
 336
 337 //=======================================================================
 338 //function :AddEdgeWithID
 339 //purpose  :
 340 //=======================================================================
 341
 342 SMDS_MeshEdge* SMESHDS_Mesh::AddEdgeWithID(int n1, int n2, int ID)
 343 {
 344   SMDS_MeshEdge* anElem = SMDS_Mesh::AddEdgeWithID(n1,n2,ID);
 345   if(anElem) myScript->AddEdge(ID,n1,n2);
 346   return anElem;
 347 }
 348
 349 SMDS_MeshEdge* SMESHDS_Mesh::AddEdgeWithID(const SMDS_MeshNode * n1,
 350                                            const SMDS_MeshNode * n2,
 351                                            int ID)
 352 {
 353   return AddEdgeWithID(n1->GetID(),
 354                        n2->GetID(),
 355                        ID);
 356 }
 357
 358 SMDS_MeshEdge* SMESHDS_Mesh::AddEdge(const SMDS_MeshNode * n1,
 359                                      const SMDS_MeshNode * n2)
 360 {
 361   SMDS_MeshEdge* anElem = SMDS_Mesh::AddEdge(n1,n2);
 362   if(anElem) myScript->AddEdge(anElem->GetID(),
 363                                n1->GetID(),
 364                                n2->GetID());
 365   return anElem;
 366 }
 367
 368 //=======================================================================
 369 //function :AddFace
 370 //purpose  :
 371 //=======================================================================
 372 SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(int n1, int n2, int n3, int ID)
 373 {
 374   SMDS_MeshFace *anElem = SMDS_Mesh::AddFaceWithID(n1, n2, n3, ID);
 375   if(anElem) myScript->AddFace(ID,n1,n2,n3);
 376   return anElem;
 377 }
 378
 379 SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
 380                                            const SMDS_MeshNode * n2,
 381                                            const SMDS_MeshNode * n3,
 382                                            int ID)
 383 {
 384   return AddFaceWithID(n1->GetID(),
 385                        n2->GetID(),
 386                        n3->GetID(),
 387                        ID);
 388 }
 389
 390 SMDS_MeshFace* SMESHDS_Mesh::AddFace( const SMDS_MeshNode * n1,
 391                                       const SMDS_MeshNode * n2,
 392                                       const SMDS_MeshNode * n3)
 393 {
 394   SMDS_MeshFace *anElem = SMDS_Mesh::AddFace(n1, n2, n3);
 395   if(anElem) myScript->AddFace(anElem->GetID(),
 396                                n1->GetID(),
 397                                n2->GetID(),
 398                                n3->GetID());
 399   return anElem;
 400 }
 401
 402 //=======================================================================
 403 //function :AddFace
 404 //purpose  :
 405 //=======================================================================
 406 SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(int n1, int n2, int n3, int n4, int ID)
 407 {
 408   SMDS_MeshFace *anElem = SMDS_Mesh::AddFaceWithID(n1, n2, n3, n4, ID);
 409   if(anElem) myScript->AddFace(ID, n1, n2, n3, n4);
 410   return anElem;
 411 }
 412
 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,
 417                                            int ID)
 418 {
 419   return AddFaceWithID(n1->GetID(),
 420                        n2->GetID(),
 421                        n3->GetID(),
 422                        n4->GetID(),
 423                        ID);
 424 }
 425
 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)
 430 {
 431   SMDS_MeshFace *anElem = SMDS_Mesh::AddFace(n1, n2, n3, n4);
 432   if(anElem) myScript->AddFace(anElem->GetID(),
 433                                n1->GetID(),
 434                                n2->GetID(),
 435                                n3->GetID(),
 436                                n4->GetID());
 437   return anElem;
 438 }
 439
 440 //=======================================================================
 441 //function :AddVolume
 442 //purpose  :
 443 //=======================================================================
 444 SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4, int ID)
 445 {
 446   SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, ID);
 447   if(anElem) myScript->AddVolume(ID, n1, n2, n3, n4);
 448   return anElem;
 449 }
 450
 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,
 455                                                int ID)
 456 {
 457   return AddVolumeWithID(n1->GetID(),
 458                          n2->GetID(),
 459                          n3->GetID(),
 460                          n4->GetID(),
 461                          ID);
 462 }
 463
 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)
 468 {
 469   SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolume(n1, n2, n3, n4);
 470   if(anElem) myScript->AddVolume(anElem->GetID(),
 471                                  n1->GetID(),
 472                                  n2->GetID(),
 473                                  n3->GetID(),
 474                                  n4->GetID());
 475   return anElem;
 476 }
 477
 478 //=======================================================================
 479 //function :AddVolume
 480 //purpose  :
 481 //=======================================================================
 482 SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4, int n5, int ID)
 483 {
 484   SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, ID);
 485   if(anElem) myScript->AddVolume(ID, n1, n2, n3, n4, n5);
 486   return anElem;
 487 }
 488
 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,
 494                                                int ID)
 495 {
 496   return AddVolumeWithID(n1->GetID(),
 497                          n2->GetID(),
 498                          n3->GetID(),
 499                          n4->GetID(),
 500                          n5->GetID(),
 501                          ID);
 502 }
 503
 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)
 509 {
 510   SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolume(n1, n2, n3, n4, n5);
 511   if(anElem) myScript->AddVolume(anElem->GetID(),
 512                                  n1->GetID(),
 513                                  n2->GetID(),
 514                                  n3->GetID(),
 515                                  n4->GetID(),
 516                                  n5->GetID());
 517   return anElem;
 518 }
 519
 520 //=======================================================================
 521 //function :AddVolume
 522 //purpose  :
 523 //=======================================================================
 524 SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4, int n5, int n6, int ID)
 525 {
 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);
 528   return anElem;
 529 }
 530
 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,
 537                                                int ID)
 538 {
 539   return AddVolumeWithID(n1->GetID(),
 540                          n2->GetID(),
 541                          n3->GetID(),
 542                          n4->GetID(),
 543                          n5->GetID(),
 544                          n6->GetID(),
 545                          ID);
 546 }
 547
 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)
 554 {
 555   SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolume(n1, n2, n3, n4, n5, n6);
 556   if(anElem) myScript->AddVolume(anElem->GetID(),
 557                                  n1->GetID(),
 558                                  n2->GetID(),
 559                                  n3->GetID(),
 560                                  n4->GetID(),
 561                                  n5->GetID(),
 562                                  n6->GetID());
 563   return anElem;
 564 }
 565
 566 //=======================================================================
 567 //function :AddVolume
 568 //purpose  :
 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)
 571 {
 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);
 574   return anElem;
 575 }
 576
 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,
 585                                                int ID)
 586 {
 587   return AddVolumeWithID(n1->GetID(),
 588                          n2->GetID(),
 589                          n3->GetID(),
 590                          n4->GetID(),
 591                          n5->GetID(),
 592                          n6->GetID(),
 593                          n7->GetID(),
 594                          n8->GetID(),
 595                          ID);
 596 }
 597
 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)
 606 {
 607   SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolume(n1, n2, n3, n4, n5, n6, n7, n8);
 608   if(anElem) myScript->AddVolume(anElem->GetID(),
 609                                  n1->GetID(),
 610                                  n2->GetID(),
 611                                  n3->GetID(),
 612                                  n4->GetID(),
 613                                  n5->GetID(),
 614                                  n6->GetID(),
 615                                  n7->GetID(),
 616                                  n8->GetID());
 617   return anElem;
 618 }
 619
 620
 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,
 628                                                int ID)
 629 {
 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);
 632   return anElem;
 633 }
 634
 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,
 647                                                int ID)
 648 {
 649   return AddVolumeWithID(n1->GetID(),
 650                          n2->GetID(),
 651                          n3->GetID(),
 652                          n4->GetID(),
 653                          n5->GetID(),
 654                          n6->GetID(),
 655                          n7->GetID(),
 656                          n8->GetID(),
 657                          n9->GetID(),
 658                          n10->GetID(),
 659                          n11->GetID(),
 660                          n12->GetID(),
 661                          ID);
 662 }
 663
 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)
 676 {
 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(),
 679                                  n1->GetID(),
 680                                  n2->GetID(),
 681                                  n3->GetID(),
 682                                  n4->GetID(),
 683                                  n5->GetID(),
 684                                  n6->GetID(),
 685                                  n7->GetID(),
 686                                  n8->GetID(),
 687                                  n9->GetID(),
 688                                  n10->GetID(),
 689                                  n11->GetID(),
 690                                  n12->GetID());
 691   return anElem;
 692 }
 693
 694
 695 //=======================================================================
 696 //function : AddPolygonalFace
 697 //purpose  :
 698 //=======================================================================
 699 SMDS_MeshFace* SMESHDS_Mesh::AddPolygonalFaceWithID (const std::vector<int>& nodes_ids,
 700                                                      const int               ID)
 701 {
 702   SMDS_MeshFace *anElem = SMDS_Mesh::AddPolygonalFaceWithID(nodes_ids, ID);
 703   if (anElem) {
 704     myScript->AddPolygonalFace(ID, nodes_ids);
 705   }
 706   return anElem;
 707 }
 708
 709 SMDS_MeshFace* SMESHDS_Mesh::AddPolygonalFaceWithID
 710                              (const std::vector<const SMDS_MeshNode*>& nodes,
 711                               const int                                ID)
 712 {
 713   SMDS_MeshFace *anElem = SMDS_Mesh::AddPolygonalFaceWithID(nodes, ID);
 714   if (anElem) {
 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();
 719     }
 720     myScript->AddPolygonalFace(ID, nodes_ids);
 721   }
 722   return anElem;
 723 }
 724
 725 SMDS_MeshFace* SMESHDS_Mesh::AddPolygonalFace
 726                              (const std::vector<const SMDS_MeshNode*>& nodes)
 727 {
 728   SMDS_MeshFace *anElem = SMDS_Mesh::AddPolygonalFace(nodes);
 729   if (anElem) {
 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();
 734     }
 735     myScript->AddPolygonalFace(anElem->GetID(), nodes_ids);
 736   }
 737   return anElem;
 738 }
 739
 740 //=======================================================================
 741 //function : AddPolyhedralVolume
 742 //purpose  :
 743 //=======================================================================
 744 SMDS_MeshVolume* SMESHDS_Mesh::AddPolyhedralVolumeWithID (const std::vector<int>& nodes_ids,
 745                                                           const std::vector<int>& quantities,
 746                                                           const int               ID)
 747 {
 748   SMDS_MeshVolume *anElem = SMDS_Mesh::AddPolyhedralVolumeWithID(nodes_ids, quantities, ID);
 749   if (anElem) {
 750     myScript->AddPolyhedralVolume(ID, nodes_ids, quantities);
 751   }
 752   return anElem;
 753 }
 754
 755 SMDS_MeshVolume* SMESHDS_Mesh::AddPolyhedralVolumeWithID
 756                                (const std::vector<const SMDS_MeshNode*>& nodes,
 757                                 const std::vector<int>&                  quantities,
 758                                 const int                                ID)
 759 {
 760   SMDS_MeshVolume *anElem = SMDS_Mesh::AddPolyhedralVolumeWithID(nodes, quantities, ID);
 761   if (anElem) {
 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();
 766     }
 767     myScript->AddPolyhedralVolume(ID, nodes_ids, quantities);
 768   }
 769   return anElem;
 770 }
 771
 772 SMDS_MeshVolume* SMESHDS_Mesh::AddPolyhedralVolume
 773                                (const std::vector<const SMDS_MeshNode*>& nodes,
 774                                 const std::vector<int>&                  quantities)
 775 {
 776   SMDS_MeshVolume *anElem = SMDS_Mesh::AddPolyhedralVolume(nodes, quantities);
 777   if (anElem) {
 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();
 782     }
 783     myScript->AddPolyhedralVolume(anElem->GetID(), nodes_ids, quantities);
 784   }
 785   return anElem;
 786 }
 787
 788 //=======================================================================
 789 //function : removeFromContainers
 790 //purpose  :
 791 //=======================================================================
 792
 793 static void removeFromContainers (map<int,SMESHDS_SubMesh*>&     theSubMeshes,
 794                                   set<SMESHDS_GroupBase*>&       theGroups,
 795                                   list<const SMDS_MeshElement*>& theElems,
 796                                   const bool                     isNode)
 797 {
 798   if ( theElems.empty() )
 799     return;
 800
 801   // Rm from group
 802   // Element can belong to several groups
 803   if ( !theGroups.empty() )
 804   {
 805     set<SMESHDS_GroupBase*>::iterator GrIt = theGroups.begin();
 806     for ( ; GrIt != theGroups.end(); GrIt++ )
 807     {
 808       SMESHDS_Group* group = dynamic_cast<SMESHDS_Group*>( *GrIt );
 809       if ( !group || group->IsEmpty() ) continue;
 810
 811       list<const SMDS_MeshElement *>::iterator elIt = theElems.begin();
 812       for ( ; elIt != theElems.end(); elIt++ )
 813       {
 814         group->SMDSGroup().Remove( *elIt );
 815         if ( group->IsEmpty() ) break;
 816       }
 817     }
 818   }
 819
 820   const bool deleted=true;
 821
 822   // Rm from sub-meshes
 823   // Element should belong to only one sub-mesh
 824   if ( !theSubMeshes.empty() )
 825   {
 826     SMESHDS_Mesh* mesh = theSubMeshes.begin()->second->GetParent();
 827     list<const SMDS_MeshElement *>::iterator elIt = theElems.begin();
 828     if ( isNode ) {
 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 );
 832     }
 833     else {
 834       for ( ; elIt != theElems.end(); ++elIt )
 835         if ( SMESHDS_SubMesh* sm = mesh->MeshElements( (*elIt)->getshapeId() ))
 836           sm->RemoveElement( *elIt, deleted );
 837     }
 838   }
 839 }
 840
 841 //=======================================================================
 842 //function : RemoveNode
 843 //purpose  :
 844 //=======================================================================
 845 void SMESHDS_Mesh::RemoveNode(const SMDS_MeshNode * n)
 846 {
 847   if ( n->NbInverseElements() == 0 && !(hasConstructionEdges() || hasConstructionFaces()))
 848   {
 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;
 854     else
 855       SubIt = myShapeIndexToSubMesh.begin();
 856     for ( ; !subMesh && SubIt != myShapeIndexToSubMesh.end(); SubIt++ )
 857       if (!SubIt->second->IsComplexSubmesh() && SubIt->second->Contains( n ))
 858         subMesh = SubIt->second;
 859
 860     RemoveFreeNode( n, subMesh, true);
 861     return;
 862   }
 863
 864   myScript->RemoveNode(n->GetID());
 865
 866   list<const SMDS_MeshElement *> removedElems;
 867   list<const SMDS_MeshElement *> removedNodes;
 868
 869   SMDS_Mesh::RemoveElement( n, removedElems, removedNodes, true );
 870
 871   removeFromContainers( myShapeIndexToSubMesh, myGroups, removedElems, false );
 872   removeFromContainers( myShapeIndexToSubMesh, myGroups, removedNodes, true );
 873 }
 874
 875 //=======================================================================
 876 //function : RemoveFreeNode
 877 //purpose  :
 878 //=======================================================================
 879 void SMESHDS_Mesh::RemoveFreeNode(const SMDS_MeshNode * n,
 880                                   SMESHDS_SubMesh *     subMesh,
 881                                   bool                  fromGroups)
 882 {
 883   myScript->RemoveNode(n->GetID());
 884
 885   // Rm from group
 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);
 893     }
 894   }
 895
 896   // Rm from sub-mesh
 897   // Node should belong to only one sub-mesh
 898   if( subMesh )
 899     subMesh->RemoveNode(n,/*deleted=*/false);
 900
 901   SMDS_Mesh::RemoveFreeElement(n);
 902 }
 903
 904 //=======================================================================
 905 //function : RemoveElement
 906 //purpose  :
 907 //========================================================================
 908 void SMESHDS_Mesh::RemoveElement(const SMDS_MeshElement * elt)
 909 {
 910   if (elt->GetType() == SMDSAbs_Node)
 911   {
 912     RemoveNode( static_cast<const SMDS_MeshNode*>( elt ));
 913     return;
 914   }
 915   if (!hasConstructionEdges() && !hasConstructionFaces())
 916   {
 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);
 924     return;
 925   }
 926
 927   myScript->RemoveElement(elt->GetID());
 928
 929   list<const SMDS_MeshElement *> removedElems;
 930   list<const SMDS_MeshElement *> removedNodes;
 931
 932   SMDS_Mesh::RemoveElement(elt, removedElems, removedNodes, false);
 933
 934   removeFromContainers( myShapeIndexToSubMesh, myGroups, removedElems, false );
 935 }
 936
 937 //=======================================================================
 938 //function : RemoveFreeElement
 939 //purpose  :
 940 //========================================================================
 941 void SMESHDS_Mesh::RemoveFreeElement(const SMDS_MeshElement * elt,
 942                                      SMESHDS_SubMesh *        subMesh,
 943                                      bool                     fromGroups)
 944 {
 945   //MESSAGE(" --------------------------------> SMESHDS_Mesh::RemoveFreeElement " << subMesh << " " << fromGroups);
 946   if (elt->GetType() == SMDSAbs_Node) {
 947     RemoveFreeNode( static_cast<const SMDS_MeshNode*>(elt), subMesh);
 948     return;
 949   }
 950
 951   if (hasConstructionEdges() || hasConstructionFaces())
 952     // this methods is only for meshes without descendants
 953     return;
 954
 955   myScript->RemoveElement(elt->GetID());
 956
 957   // Rm from group
 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);
 965     }
 966   }
 967
 968   // Rm from sub-mesh
 969   // Element should belong to only one sub-mesh
 970   if( subMesh )
 971     subMesh->RemoveElement(elt, /*deleted=*/false);
 972
 973   SMDS_Mesh::RemoveFreeElement(elt);
 974 }
 975
 976 //================================================================================
 977 /*!
 978  * \brief Remove all data from the mesh
 979  */
 980 //================================================================================
 981
 982 void SMESHDS_Mesh::ClearMesh()
 983 {
 984   myScript->ClearMesh();
 985   SMDS_Mesh::Clear();
 986
 987   // clear submeshes
 988   map<int,SMESHDS_SubMesh*>::iterator sub, subEnd = myShapeIndexToSubMesh.end();
 989   for ( sub = myShapeIndexToSubMesh.begin(); sub != subEnd; ++sub )
 990     sub->second->Clear();
 991
 992   // clear groups
 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();
 997       g->Clear();
 998       g->SetType( groupType );
 999     }
1000   }
1001 }
1002
1003 //================================================================================
1004 /*!
1005  * \brief return submesh by shape
1006   * \param shape - the sub-shape
1007   * \retval SMESHDS_SubMesh* - the found submesh
1008   *
1009  * search of submeshes is optimized
1010  */
1011 //================================================================================
1012
1013 SMESHDS_SubMesh* SMESHDS_Mesh::getSubmesh( const TopoDS_Shape & shape )
1014 {
1015   if ( shape.IsNull() )
1016     return 0;
1017
1018   if ( !myCurSubShape.IsNull() && shape.IsSame( myCurSubShape ))
1019     return myCurSubMesh;
1020
1021   getSubmesh( ShapeToIndex( shape ));
1022   myCurSubShape = shape;
1023   return myCurSubMesh;
1024 }
1025
1026 //================================================================================
1027 /*!
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
1032  */
1033 //================================================================================
1034
1035 SMESHDS_SubMesh* SMESHDS_Mesh::getSubmesh( const int Index )
1036 {
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;
1043     myCurSubID = Index;
1044     myCurSubShape.Nullify(); // myCurSubShape no more corresponds to submesh
1045   }
1046   return myCurSubMesh;
1047 }
1048
1049 //================================================================================
1050 /*!
1051  * \brief Add element or node to submesh
1052   * \param elem - element to add
1053   * \param subMesh - submesh to be filled in
1054  */
1055 //================================================================================
1056
1057 bool SMESHDS_Mesh::add(const SMDS_MeshElement* elem, SMESHDS_SubMesh* subMesh )
1058 {
1059   if ( elem && subMesh ) {
1060     if ( elem->GetType() == SMDSAbs_Node )
1061       subMesh->AddNode( static_cast<const SMDS_MeshNode* >( elem ));
1062     else
1063       subMesh->AddElement( elem );
1064     return true;
1065   }
1066   return false;
1067 }
1068
1069 //=======================================================================
1070 //function : SetNodeOnVolume
1071 //purpose  :
1072 //=======================================================================
1073 void SMESHDS_Mesh::SetNodeInVolume(const SMDS_MeshNode* aNode,
1074                                    const TopoDS_Shell & S)
1075 {
1076   if ( add( aNode, getSubmesh(S) ))
1077     const_cast< SMDS_MeshNode* >
1078       ( aNode )->SetPosition( SMDS_SpacePosition::originSpacePosition() );
1079 }
1080
1081 //=======================================================================
1082 //function : SetNodeOnVolume
1083 //purpose  :
1084 //=======================================================================
1085 void SMESHDS_Mesh::SetNodeInVolume(const SMDS_MeshNode *      aNode,
1086                                    const TopoDS_Solid & S)
1087 {
1088   if ( add( aNode, getSubmesh(S) ))
1089     const_cast< SMDS_MeshNode* >
1090       ( aNode )->SetPosition( SMDS_SpacePosition::originSpacePosition() );
1091 }
1092
1093 //=======================================================================
1094 //function : SetNodeOnFace
1095 //purpose  :
1096 //=======================================================================
1097 void SMESHDS_Mesh::SetNodeOnFace(const SMDS_MeshNode *     aNode,
1098                                  const TopoDS_Face & S,
1099                                  double              u,
1100                                  double              v)
1101 {
1102   if ( add( aNode, getSubmesh(S) ))
1103     const_cast< SMDS_MeshNode* >
1104       ( aNode )->SetPosition(SMDS_PositionPtr(new SMDS_FacePosition( u, v)));
1105 }
1106
1107 //=======================================================================
1108 //function : SetNodeOnEdge
1109 //purpose  :
1110 //=======================================================================
1111 void SMESHDS_Mesh::SetNodeOnEdge(const SMDS_MeshNode *     aNode,
1112                                  const TopoDS_Edge & S,
1113                                  double              u)
1114 {
1115   if ( add( aNode, getSubmesh(S) ))
1116     const_cast< SMDS_MeshNode* >
1117       ( aNode )->SetPosition(SMDS_PositionPtr(new SMDS_EdgePosition(u)));
1118 }
1119
1120 //=======================================================================
1121 //function : SetNodeOnVertex
1122 //purpose  :
1123 //=======================================================================
1124 void SMESHDS_Mesh::SetNodeOnVertex(const SMDS_MeshNode *       aNode,
1125                                    const TopoDS_Vertex & S)
1126 {
1127   if ( add( aNode, getSubmesh(S) ))
1128     const_cast< SMDS_MeshNode* >
1129       ( aNode )->SetPosition(SMDS_PositionPtr(new SMDS_VertexPosition()));
1130 }
1131
1132 //=======================================================================
1133 //function : UnSetNodeOnShape
1134 //purpose  :
1135 //=======================================================================
1136 void SMESHDS_Mesh::UnSetNodeOnShape(const SMDS_MeshNode* aNode)
1137 {
1138   int shapeId = aNode->getshapeId();
1139   if (shapeId >= 0)
1140     {
1141       map<int, SMESHDS_SubMesh*>::iterator it = myShapeIndexToSubMesh.find(shapeId);
1142       if (it != myShapeIndexToSubMesh.end())
1143         it->second->RemoveNode(aNode, /*deleted=*/false);
1144     }
1145 }
1146
1147 //=======================================================================
1148 //function : SetMeshElementOnShape
1149 //purpose  :
1150 //=======================================================================
1151 void SMESHDS_Mesh::SetMeshElementOnShape(const SMDS_MeshElement * anElement,
1152                                          const TopoDS_Shape &     S)
1153 {
1154   add( anElement, getSubmesh(S) );
1155 }
1156
1157 //=======================================================================
1158 //function : UnSetMeshElementOnShape
1159 //purpose  :
1160 //=======================================================================
1161 void SMESHDS_Mesh::UnSetMeshElementOnShape(const SMDS_MeshElement * elem,
1162                                            const TopoDS_Shape &     S)
1163 {
1164   int Index = myIndexToShape.FindIndex(S);
1165
1166   map<int,SMESHDS_SubMesh*>::iterator it = myShapeIndexToSubMesh.find( Index );
1167   if ( it != myShapeIndexToSubMesh.end() )
1168     {
1169       if (elem->GetType() == SMDSAbs_Node)
1170         it->second->RemoveNode(static_cast<const SMDS_MeshNode*> (elem), /*deleted=*/false);
1171       else
1172         it->second->RemoveElement(elem, /*deleted=*/false);
1173     }
1174 }
1175
1176 //=======================================================================
1177 //function : ShapeToMesh
1178 //purpose  :
1179 //=======================================================================
1180 TopoDS_Shape SMESHDS_Mesh::ShapeToMesh() const
1181 {
1182         return myShape;
1183 }
1184
1185 //=======================================================================
1186 //function : IsGroupOfSubShapes
1187 //purpose  : return true if at least one sub-shape of theShape is a sub-shape
1188 //           of myShape or theShape == myShape
1189 //=======================================================================
1190
1191 bool SMESHDS_Mesh::IsGroupOfSubShapes (const TopoDS_Shape& theShape) const
1192 {
1193   if ( myIndexToShape.Contains(theShape) )
1194     return true;
1195
1196   for ( TopoDS_Iterator it( theShape ); it.More(); it.Next() )
1197     if (IsGroupOfSubShapes( it.Value() ))
1198       return true;
1199
1200   return false;
1201 }
1202
1203 ///////////////////////////////////////////////////////////////////////////////
1204 /// Return the sub mesh linked to the a given TopoDS_Shape or NULL if the given
1205 /// TopoDS_Shape is unknown
1206 ///////////////////////////////////////////////////////////////////////////////
1207 SMESHDS_SubMesh * SMESHDS_Mesh::MeshElements(const TopoDS_Shape & S) const
1208 {
1209   int Index = ShapeToIndex(S);
1210   TShapeIndexToSubMesh::const_iterator anIter = myShapeIndexToSubMesh.find(Index);
1211   if (anIter != myShapeIndexToSubMesh.end())
1212     return anIter->second;
1213   else
1214     return NULL;
1215 }
1216
1217 ///////////////////////////////////////////////////////////////////////////////
1218 /// Return the sub mesh by Id of shape it is linked to
1219 ///////////////////////////////////////////////////////////////////////////////
1220 SMESHDS_SubMesh * SMESHDS_Mesh::MeshElements(const int Index) const
1221 {
1222   TShapeIndexToSubMesh::const_iterator anIter = myShapeIndexToSubMesh.find(Index);
1223   if (anIter != myShapeIndexToSubMesh.end())
1224     return anIter->second;
1225   else
1226     return NULL;
1227 }
1228
1229 //=======================================================================
1230 //function : SubMeshIndices
1231 //purpose  :
1232 //=======================================================================
1233 list<int> SMESHDS_Mesh::SubMeshIndices() const
1234 {
1235   list<int> anIndices;
1236   std::map<int,SMESHDS_SubMesh*>::const_iterator anIter = myShapeIndexToSubMesh.begin();
1237   for (; anIter != myShapeIndexToSubMesh.end(); anIter++) {
1238     anIndices.push_back((*anIter).first);
1239   }
1240   return anIndices;
1241 }
1242
1243 //=======================================================================
1244 //function : GetHypothesis
1245 //purpose  :
1246 //=======================================================================
1247
1248 const list<const SMESHDS_Hypothesis*>&
1249 SMESHDS_Mesh::GetHypothesis(const TopoDS_Shape & S) const
1250 {
1251   if ( myShapeToHypothesis.IsBound( S.Oriented(TopAbs_FORWARD) ) ) // ignore orientation of S
1252      return myShapeToHypothesis.Find( S.Oriented(TopAbs_FORWARD) );
1253
1254   static list<const SMESHDS_Hypothesis*> empty;
1255   return empty;
1256 }
1257
1258 //================================================================================
1259 /*!
1260  * \brief returns true if the hypothesis is assigned to any sub-shape
1261  */
1262 //================================================================================
1263
1264 bool SMESHDS_Mesh::IsUsedHypothesis(const SMESHDS_Hypothesis * H) const
1265 {
1266   ShapeToHypothesis::Iterator s2h( myShapeToHypothesis );
1267   for ( ; s2h.More(); s2h.Next() )
1268     if ( std::find( s2h.Value().begin(), s2h.Value().end(), H ) != s2h.Value().end() )
1269       return true;
1270   return false;
1271 }
1272
1273 //=======================================================================
1274 //function : GetScript
1275 //purpose  :
1276 //=======================================================================
1277 SMESHDS_Script* SMESHDS_Mesh::GetScript()
1278 {
1279         return myScript;
1280 }
1281
1282 //=======================================================================
1283 //function : ClearScript
1284 //purpose  :
1285 //=======================================================================
1286 void SMESHDS_Mesh::ClearScript()
1287 {
1288         myScript->Clear();
1289 }
1290
1291 //=======================================================================
1292 //function : HasMeshElements
1293 //purpose  :
1294 //=======================================================================
1295 bool SMESHDS_Mesh::HasMeshElements(const TopoDS_Shape & S) const
1296 {
1297         if (myShape.IsNull()) MESSAGE("myShape is NULL");
1298         int Index = myIndexToShape.FindIndex(S);
1299         return myShapeIndexToSubMesh.find(Index)!=myShapeIndexToSubMesh.end();
1300 }
1301
1302 //=======================================================================
1303 //function : HasHypothesis
1304 //purpose  :
1305 //=======================================================================
1306 bool SMESHDS_Mesh::HasHypothesis(const TopoDS_Shape & S)
1307 {
1308   return myShapeToHypothesis.IsBound(S.Oriented(TopAbs_FORWARD));
1309 }
1310
1311 //=======================================================================
1312 //function : NewSubMesh
1313 //purpose  :
1314 //=======================================================================
1315 SMESHDS_SubMesh * SMESHDS_Mesh::NewSubMesh(int Index)
1316 {
1317   SMESHDS_SubMesh* SM = 0;
1318   TShapeIndexToSubMesh::iterator anIter = myShapeIndexToSubMesh.find(Index);
1319   if (anIter == myShapeIndexToSubMesh.end())
1320   {
1321     SM = new SMESHDS_SubMesh(this, Index);
1322     myShapeIndexToSubMesh[Index]=SM;
1323   }
1324   else
1325     SM = anIter->second;
1326   return SM;
1327 }
1328
1329 //=======================================================================
1330 //function : AddCompoundSubmesh
1331 //purpose  :
1332 //=======================================================================
1333
1334 int SMESHDS_Mesh::AddCompoundSubmesh(const TopoDS_Shape& S,
1335                                      TopAbs_ShapeEnum    type)
1336 {
1337   int aMainIndex = 0;
1338   if ( IsGroupOfSubShapes( S ))
1339   {
1340     aMainIndex = myIndexToShape.Add( S );
1341     bool all = ( type == TopAbs_SHAPE );
1342     if ( all ) // corresponding simple submesh may exist
1343       aMainIndex = -aMainIndex;
1344     //MESSAGE("AddCompoundSubmesh index = " << aMainIndex );
1345     SMESHDS_SubMesh * aNewSub = NewSubMesh( aMainIndex );
1346     if ( !aNewSub->IsComplexSubmesh() ) // is empty
1347     {
1348       int shapeType = Max( TopAbs_SOLID, all ? myShape.ShapeType() : type );
1349       int typeLimit = all ? TopAbs_VERTEX : type;
1350       for ( ; shapeType <= typeLimit; shapeType++ )
1351       {
1352         TopExp_Explorer exp( S, TopAbs_ShapeEnum( shapeType ));
1353         for ( ; exp.More(); exp.Next() )
1354         {
1355           int index = myIndexToShape.FindIndex( exp.Current() );
1356           if ( index )
1357             aNewSub->AddSubMesh( NewSubMesh( index ));
1358         }
1359       }
1360     }
1361   }
1362   return aMainIndex;
1363 }
1364
1365 //=======================================================================
1366 //function : IndexToShape
1367 //purpose  :
1368 //=======================================================================
1369 const TopoDS_Shape& SMESHDS_Mesh::IndexToShape(int ShapeIndex) const
1370 {
1371   try
1372   {
1373     return myIndexToShape.FindKey(ShapeIndex);
1374   }
1375   catch ( Standard_OutOfRange )
1376   {
1377   }
1378   static TopoDS_Shape nullShape;
1379   return nullShape;
1380 }
1381
1382 //================================================================================
1383 /*!
1384  * \brief Return max index of sub-mesh
1385  */
1386 //================================================================================
1387
1388 int SMESHDS_Mesh::MaxSubMeshIndex() const
1389 {
1390   return myShapeIndexToSubMesh.empty() ? 0 : myShapeIndexToSubMesh.rbegin()->first;
1391 }
1392
1393 //=======================================================================
1394 //function : ShapeToIndex
1395 //purpose  :
1396 //=======================================================================
1397 int SMESHDS_Mesh::ShapeToIndex(const TopoDS_Shape & S) const
1398 {
1399   if (myShape.IsNull())
1400     MESSAGE("myShape is NULL");
1401
1402   int index = myIndexToShape.FindIndex(S);
1403
1404   return index;
1405 }
1406
1407 //=======================================================================
1408 //function : SetNodeOnVolume
1409 //purpose  :
1410 //=======================================================================
1411 void SMESHDS_Mesh::SetNodeInVolume(const SMDS_MeshNode* aNode, int Index)
1412 {
1413   //add(aNode, getSubmesh(Index));
1414   if ( add( aNode, getSubmesh( Index )))
1415     ((SMDS_MeshNode*) aNode)->SetPosition( SMDS_SpacePosition::originSpacePosition());
1416 }
1417
1418 //=======================================================================
1419 //function : SetNodeOnFace
1420 //purpose  :
1421 //=======================================================================
1422 void SMESHDS_Mesh::SetNodeOnFace(const SMDS_MeshNode* aNode, int Index, double u, double v)
1423 {
1424   //Set Position on Node
1425   if ( add( aNode, getSubmesh( Index )))
1426     const_cast< SMDS_MeshNode* >
1427       ( aNode )->SetPosition(SMDS_PositionPtr(new SMDS_FacePosition( u, v)));
1428 }
1429
1430 //=======================================================================
1431 //function : SetNodeOnEdge
1432 //purpose  :
1433 //=======================================================================
1434 void SMESHDS_Mesh::SetNodeOnEdge(const SMDS_MeshNode* aNode,
1435                                  int                  Index,
1436                                  double               u)
1437 {
1438   //Set Position on Node
1439   if ( add( aNode, getSubmesh( Index )))
1440     const_cast< SMDS_MeshNode* >
1441       ( aNode )->SetPosition(SMDS_PositionPtr(new SMDS_EdgePosition(u)));
1442 }
1443
1444 //=======================================================================
1445 //function : SetNodeOnVertex
1446 //purpose  :
1447 //=======================================================================
1448 void SMESHDS_Mesh::SetNodeOnVertex(const SMDS_MeshNode* aNode, int Index)
1449 {
1450   //Set Position on Node
1451   if ( add( aNode, getSubmesh( Index )))
1452     const_cast< SMDS_MeshNode* >
1453       ( aNode )->SetPosition(SMDS_PositionPtr(new SMDS_VertexPosition()));
1454 }
1455
1456 //=======================================================================
1457 //function : SetMeshElementOnShape
1458 //purpose  :
1459 //=======================================================================
1460 void SMESHDS_Mesh::SetMeshElementOnShape(const SMDS_MeshElement* anElement,
1461                                          int                     Index)
1462 {
1463   add( anElement, getSubmesh( Index ));
1464 }
1465
1466 //=======================================================================
1467 //function : ~SMESHDS_Mesh
1468 //purpose  :
1469 //=======================================================================
1470 SMESHDS_Mesh::~SMESHDS_Mesh()
1471 {
1472   // myScript
1473   delete myScript;
1474   // submeshes
1475   TShapeIndexToSubMesh::iterator i_sm = myShapeIndexToSubMesh.begin();
1476   for ( ; i_sm != myShapeIndexToSubMesh.end(); ++i_sm )
1477     delete i_sm->second;
1478 }
1479
1480
1481 //********************************************************************
1482 //********************************************************************
1483 //********                                                   *********
1484 //*****       Methods for addition of quadratic elements        ******
1485 //********                                                   *********
1486 //********************************************************************
1487 //********************************************************************
1488
1489 //=======================================================================
1490 //function : AddEdgeWithID
1491 //purpose  :
1492 //=======================================================================
1493 SMDS_MeshEdge* SMESHDS_Mesh::AddEdgeWithID(int n1, int n2, int n12, int ID)
1494 {
1495   SMDS_MeshEdge* anElem = SMDS_Mesh::AddEdgeWithID(n1,n2,n12,ID);
1496   if(anElem) myScript->AddEdge(ID,n1,n2,n12);
1497   return anElem;
1498 }
1499
1500 //=======================================================================
1501 //function : AddEdge
1502 //purpose  :
1503 //=======================================================================
1504 SMDS_MeshEdge* SMESHDS_Mesh::AddEdge(const SMDS_MeshNode* n1,
1505                                      const SMDS_MeshNode* n2,
1506                                      const SMDS_MeshNode* n12)
1507 {
1508   SMDS_MeshEdge* anElem = SMDS_Mesh::AddEdge(n1,n2,n12);
1509   if(anElem) myScript->AddEdge(anElem->GetID(),
1510                                n1->GetID(),
1511                                n2->GetID(),
1512                                n12->GetID());
1513   return anElem;
1514 }
1515
1516 //=======================================================================
1517 //function : AddEdgeWithID
1518 //purpose  :
1519 //=======================================================================
1520 SMDS_MeshEdge* SMESHDS_Mesh::AddEdgeWithID(const SMDS_MeshNode * n1,
1521                                            const SMDS_MeshNode * n2,
1522                                            const SMDS_MeshNode * n12,
1523                                            int ID)
1524 {
1525   return AddEdgeWithID(n1->GetID(),
1526                        n2->GetID(),
1527                        n12->GetID(),
1528                        ID);
1529 }
1530
1531
1532 //=======================================================================
1533 //function : AddFace
1534 //purpose  :
1535 //=======================================================================
1536 SMDS_MeshFace* SMESHDS_Mesh::AddFace(const SMDS_MeshNode * n1,
1537                                      const SMDS_MeshNode * n2,
1538                                      const SMDS_MeshNode * n3,
1539                                      const SMDS_MeshNode * n12,
1540                                      const SMDS_MeshNode * n23,
1541                                      const SMDS_MeshNode * n31)
1542 {
1543   SMDS_MeshFace *anElem = SMDS_Mesh::AddFace(n1,n2,n3,n12,n23,n31);
1544   if(anElem) myScript->AddFace(anElem->GetID(),
1545                                n1->GetID(), n2->GetID(), n3->GetID(),
1546                                n12->GetID(), n23->GetID(), n31->GetID());
1547   return anElem;
1548 }
1549
1550 //=======================================================================
1551 //function : AddFaceWithID
1552 //purpose  :
1553 //=======================================================================
1554 SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(int n1, int n2, int n3,
1555                                            int n12,int n23,int n31, int ID)
1556 {
1557   SMDS_MeshFace *anElem = SMDS_Mesh::AddFaceWithID(n1,n2,n3,n12,n23,n31,ID);
1558   if(anElem) myScript->AddFace(ID,n1,n2,n3,n12,n23,n31);
1559   return anElem;
1560 }
1561
1562 //=======================================================================
1563 //function : AddFaceWithID
1564 //purpose  :
1565 //=======================================================================
1566 SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
1567                                            const SMDS_MeshNode * n2,
1568                                            const SMDS_MeshNode * n3,
1569                                            const SMDS_MeshNode * n12,
1570                                            const SMDS_MeshNode * n23,
1571                                            const SMDS_MeshNode * n31,
1572                                            int ID)
1573 {
1574   return AddFaceWithID(n1->GetID(), n2->GetID(), n3->GetID(),
1575                        n12->GetID(), n23->GetID(), n31->GetID(),
1576                        ID);
1577 }
1578
1579 //=======================================================================
1580 //function : AddFace
1581 //purpose  :
1582 //=======================================================================
1583 SMDS_MeshFace* SMESHDS_Mesh::AddFace(const SMDS_MeshNode * n1,
1584                                      const SMDS_MeshNode * n2,
1585                                      const SMDS_MeshNode * n3,
1586                                      const SMDS_MeshNode * n12,
1587                                      const SMDS_MeshNode * n23,
1588                                      const SMDS_MeshNode * n31,
1589                                      const SMDS_MeshNode * nCenter)
1590 {
1591   SMDS_MeshFace *anElem = SMDS_Mesh::AddFace(n1,n2,n3,n12,n23,n31,nCenter);
1592   if(anElem) myScript->AddFace(anElem->GetID(),
1593                                n1->GetID(), n2->GetID(), n3->GetID(),
1594                                n12->GetID(), n23->GetID(), n31->GetID(),
1595                                nCenter->GetID());
1596   return anElem;
1597 }
1598
1599 //=======================================================================
1600 //function : AddFaceWithID
1601 //purpose  :
1602 //=======================================================================
1603 SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(int n1, int n2, int n3,
1604                                            int n12,int n23,int n31, int nCenter, int ID)
1605 {
1606   SMDS_MeshFace *anElem = SMDS_Mesh::AddFaceWithID(n1,n2,n3,n12,n23,n31,nCenter,ID);
1607   if(anElem) myScript->AddFace(ID,n1,n2,n3,n12,n23,n31,nCenter);
1608   return anElem;
1609 }
1610
1611 //=======================================================================
1612 //function : AddFaceWithID
1613 //purpose  :
1614 //=======================================================================
1615 SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
1616                                            const SMDS_MeshNode * n2,
1617                                            const SMDS_MeshNode * n3,
1618                                            const SMDS_MeshNode * n12,
1619                                            const SMDS_MeshNode * n23,
1620                                            const SMDS_MeshNode * n31,
1621                                            const SMDS_MeshNode * nCenter,
1622                                            int ID)
1623 {
1624   return AddFaceWithID(n1->GetID(), n2->GetID(), n3->GetID(),
1625                        n12->GetID(), n23->GetID(), n31->GetID(),
1626                        nCenter->GetID(), ID);
1627 }
1628
1629
1630 //=======================================================================
1631 //function : AddFace
1632 //purpose  :
1633 //=======================================================================
1634 SMDS_MeshFace* SMESHDS_Mesh::AddFace(const SMDS_MeshNode * n1,
1635                                      const SMDS_MeshNode * n2,
1636                                      const SMDS_MeshNode * n3,
1637                                      const SMDS_MeshNode * n4,
1638                                      const SMDS_MeshNode * n12,
1639                                      const SMDS_MeshNode * n23,
1640                                      const SMDS_MeshNode * n34,
1641                                      const SMDS_MeshNode * n41)
1642 {
1643   SMDS_MeshFace *anElem = SMDS_Mesh::AddFace(n1,n2,n3,n4,n12,n23,n34,n41);
1644   if(anElem) myScript->AddFace(anElem->GetID(),
1645                                n1->GetID(), n2->GetID(), n3->GetID(), n4->GetID(),
1646                                n12->GetID(), n23->GetID(), n34->GetID(), n41->GetID());
1647   return anElem;
1648 }
1649
1650 //=======================================================================
1651 //function : AddFaceWithID
1652 //purpose  :
1653 //=======================================================================
1654 SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(int n1, int n2, int n3, int n4,
1655                                            int n12,int n23,int n34,int n41, int ID)
1656 {
1657   SMDS_MeshFace *anElem = SMDS_Mesh::AddFaceWithID(n1,n2,n3,n4,n12,n23,n34,n41,ID);
1658   if(anElem) myScript->AddFace(ID,n1,n2,n3,n4,n12,n23,n34,n41);
1659   return anElem;
1660 }
1661
1662 //=======================================================================
1663 //function : AddFaceWithID
1664 //purpose  :
1665 //=======================================================================
1666 SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
1667                                            const SMDS_MeshNode * n2,
1668                                            const SMDS_MeshNode * n3,
1669                                            const SMDS_MeshNode * n4,
1670                                            const SMDS_MeshNode * n12,
1671                                            const SMDS_MeshNode * n23,
1672                                            const SMDS_MeshNode * n34,
1673                                            const SMDS_MeshNode * n41,
1674                                            int ID)
1675 {
1676   return AddFaceWithID(n1->GetID(), n2->GetID(), n3->GetID(), n4->GetID(),
1677                        n12->GetID(), n23->GetID(), n34->GetID(), n41->GetID(),
1678                        ID);
1679 }
1680
1681
1682 //=======================================================================
1683 //function : AddFace
1684 //purpose  :
1685 //=======================================================================
1686 SMDS_MeshFace* SMESHDS_Mesh::AddFace(const SMDS_MeshNode * n1,
1687                                      const SMDS_MeshNode * n2,
1688                                      const SMDS_MeshNode * n3,
1689                                      const SMDS_MeshNode * n4,
1690                                      const SMDS_MeshNode * n12,
1691                                      const SMDS_MeshNode * n23,
1692                                      const SMDS_MeshNode * n34,
1693                                      const SMDS_MeshNode * n41,
1694                                      const SMDS_MeshNode * nCenter)
1695 {
1696   SMDS_MeshFace *anElem = SMDS_Mesh::AddFace(n1,n2,n3,n4,n12,n23,n34,n41,nCenter);
1697   if(anElem) myScript->AddFace(anElem->GetID(),
1698                                n1->GetID(), n2->GetID(), n3->GetID(), n4->GetID(),
1699                                n12->GetID(), n23->GetID(), n34->GetID(), n41->GetID(),
1700                                nCenter->GetID());
1701   return anElem;
1702 }
1703
1704 //=======================================================================
1705 //function : AddFaceWithID
1706 //purpose  :
1707 //=======================================================================
1708 SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(int n1, int n2, int n3, int n4,
1709                                            int n12,int n23,int n34,int n41,
1710                                            int nCenter, int ID)
1711 {
1712   SMDS_MeshFace *anElem = SMDS_Mesh::AddFaceWithID(n1,n2,n3,n4,n12,n23,n34,n41,nCenter,ID);
1713   if(anElem) myScript->AddFace(ID,n1,n2,n3,n4,n12,n23,n34,n41,nCenter);
1714   return anElem;
1715 }
1716
1717 //=======================================================================
1718 //function : AddFaceWithID
1719 //purpose  :
1720 //=======================================================================
1721 SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(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 * n34,
1728                                            const SMDS_MeshNode * n41,
1729                                            const SMDS_MeshNode * nCenter,
1730                                            int ID)
1731 {
1732   return AddFaceWithID(n1->GetID(), n2->GetID(), n3->GetID(), n4->GetID(),
1733                        n12->GetID(), n23->GetID(), n34->GetID(), n41->GetID(),
1734                        nCenter->GetID(), ID);
1735 }
1736
1737
1738 //=======================================================================
1739 //function : AddVolume
1740 //purpose  :
1741 //=======================================================================
1742 SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
1743                                          const SMDS_MeshNode * n2,
1744                                          const SMDS_MeshNode * n3,
1745                                          const SMDS_MeshNode * n4,
1746                                          const SMDS_MeshNode * n12,
1747                                          const SMDS_MeshNode * n23,
1748                                          const SMDS_MeshNode * n31,
1749                                          const SMDS_MeshNode * n14,
1750                                          const SMDS_MeshNode * n24,
1751                                          const SMDS_MeshNode * n34)
1752 {
1753   SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolume(n1,n2,n3,n4,n12,n23,n31,n14,n24,n34);
1754   if(anElem) myScript->AddVolume(anElem->GetID(),
1755                                  n1->GetID(), n2->GetID(), n3->GetID(), n4->GetID(),
1756                                  n12->GetID(), n23->GetID(), n31->GetID(),
1757                                  n14->GetID(), n24->GetID(), n34->GetID());
1758   return anElem;
1759 }
1760
1761 //=======================================================================
1762 //function : AddVolumeWithID
1763 //purpose  :
1764 //=======================================================================
1765 SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4,
1766                                                int n12,int n23,int n31,
1767                                                int n14,int n24,int n34, int ID)
1768 {
1769   SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolumeWithID(n1,n2,n3,n4,n12,n23,
1770                                                        n31,n14,n24,n34,ID);
1771   if(anElem) myScript->AddVolume(ID,n1,n2,n3,n4,n12,n23,n31,n14,n24,n34);
1772   return anElem;
1773 }
1774
1775 //=======================================================================
1776 //function : AddVolumeWithID
1777 //purpose  : 2d order tetrahedron of 10 nodes
1778 //=======================================================================
1779 SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
1780                                                const SMDS_MeshNode * n2,
1781                                                const SMDS_MeshNode * n3,
1782                                                const SMDS_MeshNode * n4,
1783                                                const SMDS_MeshNode * n12,
1784                                                const SMDS_MeshNode * n23,
1785                                                const SMDS_MeshNode * n31,
1786                                                const SMDS_MeshNode * n14,
1787                                                const SMDS_MeshNode * n24,
1788                                                const SMDS_MeshNode * n34,
1789                                                int ID)
1790 {
1791   return AddVolumeWithID(n1->GetID(), n2->GetID(), n3->GetID(), n4->GetID(),
1792                          n12->GetID(), n23->GetID(), n31->GetID(),
1793                          n14->GetID(), n24->GetID(), n34->GetID(), ID);
1794 }
1795
1796
1797 //=======================================================================
1798 //function : AddVolume
1799 //purpose  :
1800 //=======================================================================
1801 SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
1802                                          const SMDS_MeshNode * n2,
1803                                          const SMDS_MeshNode * n3,
1804                                          const SMDS_MeshNode * n4,
1805                                          const SMDS_MeshNode * n5,
1806                                          const SMDS_MeshNode * n12,
1807                                          const SMDS_MeshNode * n23,
1808                                          const SMDS_MeshNode * n34,
1809                                          const SMDS_MeshNode * n41,
1810                                          const SMDS_MeshNode * n15,
1811                                          const SMDS_MeshNode * n25,
1812                                          const SMDS_MeshNode * n35,
1813                                          const SMDS_MeshNode * n45)
1814 {
1815   SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolume(n1,n2,n3,n4,n5,n12,n23,n34,n41,
1816                                                  n15,n25,n35,n45);
1817   if(anElem)
1818     myScript->AddVolume(anElem->GetID(), n1->GetID(), n2->GetID(),
1819                         n3->GetID(), n4->GetID(), n5->GetID(),
1820                         n12->GetID(), n23->GetID(), n34->GetID(), n41->GetID(),
1821                         n15->GetID(), n25->GetID(), n35->GetID(), n45->GetID());
1822   return anElem;
1823 }
1824
1825 //=======================================================================
1826 //function : AddVolumeWithID
1827 //purpose  :
1828 //=======================================================================
1829 SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4, int n5,
1830                                                int n12,int n23,int n34,int n41,
1831                                                int n15,int n25,int n35,int n45, int ID)
1832 {
1833   SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolumeWithID(n1,n2,n3,n4,n5,
1834                                                        n12,n23,n34,n41,
1835                                                        n15,n25,n35,n45,ID);
1836   if(anElem) myScript->AddVolume(ID,n1,n2,n3,n4,n5,n12,n23,n34,n41,
1837                                  n15,n25,n35,n45);
1838   return anElem;
1839 }
1840
1841 //=======================================================================
1842 //function : AddVolumeWithID
1843 //purpose  : 2d order pyramid of 13 nodes
1844 //=======================================================================
1845 SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
1846                                                const SMDS_MeshNode * n2,
1847                                                const SMDS_MeshNode * n3,
1848                                                const SMDS_MeshNode * n4,
1849                                                const SMDS_MeshNode * n5,
1850                                                const SMDS_MeshNode * n12,
1851                                                const SMDS_MeshNode * n23,
1852                                                const SMDS_MeshNode * n34,
1853                                                const SMDS_MeshNode * n41,
1854                                                const SMDS_MeshNode * n15,
1855                                                const SMDS_MeshNode * n25,
1856                                                const SMDS_MeshNode * n35,
1857                                                const SMDS_MeshNode * n45,
1858                                                int ID)
1859 {
1860   return AddVolumeWithID(n1->GetID(), n2->GetID(), n3->GetID(),
1861                          n4->GetID(), n5->GetID(),
1862                          n12->GetID(), n23->GetID(), n34->GetID(), n41->GetID(),
1863                          n15->GetID(), n25->GetID(), n35->GetID(), n45->GetID(),
1864                          ID);
1865 }
1866
1867
1868 //=======================================================================
1869 //function : AddVolume
1870 //purpose  :
1871 //=======================================================================
1872 SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
1873                                          const SMDS_MeshNode * n2,
1874                                          const SMDS_MeshNode * n3,
1875                                          const SMDS_MeshNode * n4,
1876                                          const SMDS_MeshNode * n5,
1877                                          const SMDS_MeshNode * n6,
1878                                          const SMDS_MeshNode * n12,
1879                                          const SMDS_MeshNode * n23,
1880                                          const SMDS_MeshNode * n31,
1881                                          const SMDS_MeshNode * n45,
1882                                          const SMDS_MeshNode * n56,
1883                                          const SMDS_MeshNode * n64,
1884                                          const SMDS_MeshNode * n14,
1885                                          const SMDS_MeshNode * n25,
1886                                          const SMDS_MeshNode * n36)
1887 {
1888   SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolume(n1,n2,n3,n4,n5,n6,n12,n23,n31,
1889                                                  n45,n56,n64,n14,n25,n36);
1890   if(anElem)
1891     myScript->AddVolume(anElem->GetID(), n1->GetID(), n2->GetID(),
1892                         n3->GetID(), n4->GetID(), n5->GetID(), n6->GetID(),
1893                         n12->GetID(), n23->GetID(), n31->GetID(),
1894                         n45->GetID(), n56->GetID(), n64->GetID(),
1895                         n14->GetID(), n25->GetID(), n36->GetID());
1896   return anElem;
1897 }
1898
1899 //=======================================================================
1900 //function : AddVolumeWithID
1901 //purpose  :
1902 //=======================================================================
1903 SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(int n1, int n2, int n3,
1904                                                int n4, int n5, int n6,
1905                                                int n12,int n23,int n31,
1906                                                int n45,int n56,int n64,
1907                                                int n14,int n25,int n36, int ID)
1908 {
1909   SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolumeWithID(n1,n2,n3,n4,n5,n6,
1910                                                        n12,n23,n31,
1911                                                        n45,n56,n64,
1912                                                        n14,n25,n36,ID);
1913   if(anElem) myScript->AddVolume(ID,n1,n2,n3,n4,n5,n6,n12,n23,n31,
1914                                  n45,n56,n64,n14,n25,n36);
1915   return anElem;
1916 }
1917
1918 //=======================================================================
1919 //function : AddVolumeWithID
1920 //purpose  : 2d order Pentahedron with 15 nodes
1921 //=======================================================================
1922 SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
1923                                                const SMDS_MeshNode * n2,
1924                                                const SMDS_MeshNode * n3,
1925                                                const SMDS_MeshNode * n4,
1926                                                const SMDS_MeshNode * n5,
1927                                                const SMDS_MeshNode * n6,
1928                                                const SMDS_MeshNode * n12,
1929                                                const SMDS_MeshNode * n23,
1930                                                const SMDS_MeshNode * n31,
1931                                                const SMDS_MeshNode * n45,
1932                                                const SMDS_MeshNode * n56,
1933                                                const SMDS_MeshNode * n64,
1934                                                const SMDS_MeshNode * n14,
1935                                                const SMDS_MeshNode * n25,
1936                                                const SMDS_MeshNode * n36,
1937                                                int ID)
1938 {
1939   return AddVolumeWithID(n1->GetID(), n2->GetID(), n3->GetID(),
1940                          n4->GetID(), n5->GetID(), n6->GetID(),
1941                          n12->GetID(), n23->GetID(), n31->GetID(),
1942                          n45->GetID(), n56->GetID(), n64->GetID(),
1943                          n14->GetID(), n25->GetID(), n36->GetID(),
1944                          ID);
1945 }
1946
1947
1948 //=======================================================================
1949 //function : AddVolume
1950 //purpose  : add quadratic hexahedron
1951 //=======================================================================
1952 SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(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)
1972 {
1973   SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolume(n1,n2,n3,n4,n5,n6,n7,n8,
1974                                                  n12,n23,n34,n41,
1975                                                  n56,n67,n78,n85,
1976                                                  n15,n26,n37,n48);
1977   if(anElem)
1978     myScript->AddVolume(anElem->GetID(), n1->GetID(), n2->GetID(),
1979                         n3->GetID(), n4->GetID(), n5->GetID(),
1980                         n6->GetID(), n7->GetID(), n8->GetID(),
1981                         n12->GetID(), n23->GetID(), n34->GetID(), n41->GetID(),
1982                         n56->GetID(), n67->GetID(), n78->GetID(), n85->GetID(),
1983                         n15->GetID(), n26->GetID(), n37->GetID(), n48->GetID());
1984   return anElem;
1985 }
1986
1987 //=======================================================================
1988 //function : AddVolumeWithID
1989 //purpose  :
1990 //=======================================================================
1991 SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4,
1992                                                int n5, int n6, int n7, int n8,
1993                                                int n12,int n23,int n34,int n41,
1994                                                int n56,int n67,int n78,int n85,
1995                                                int n15,int n26,int n37,int n48, int ID)
1996 {
1997   SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolumeWithID(n1,n2,n3,n4,n5,n6,n7,n8,
1998                                                        n12,n23,n34,n41,
1999                                                        n56,n67,n78,n85,
2000                                                        n15,n26,n37,n48,ID);
2001   if(anElem) myScript->AddVolume(ID,n1,n2,n3,n4,n5,n6,n7,n8,n12,n23,n34,n41,
2002                                  n56,n67,n78,n85,n15,n26,n37,n48);
2003   return anElem;
2004 }
2005
2006 //=======================================================================
2007 //function : AddVolumeWithID
2008 //purpose  : 2d order Hexahedrons with 20 nodes
2009 //=======================================================================
2010 SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
2011                                                const SMDS_MeshNode * n2,
2012                                                const SMDS_MeshNode * n3,
2013                                                const SMDS_MeshNode * n4,
2014                                                const SMDS_MeshNode * n5,
2015                                                const SMDS_MeshNode * n6,
2016                                                const SMDS_MeshNode * n7,
2017                                                const SMDS_MeshNode * n8,
2018                                                const SMDS_MeshNode * n12,
2019                                                const SMDS_MeshNode * n23,
2020                                                const SMDS_MeshNode * n34,
2021                                                const SMDS_MeshNode * n41,
2022                                                const SMDS_MeshNode * n56,
2023                                                const SMDS_MeshNode * n67,
2024                                                const SMDS_MeshNode * n78,
2025                                                const SMDS_MeshNode * n85,
2026                                                const SMDS_MeshNode * n15,
2027                                                const SMDS_MeshNode * n26,
2028                                                const SMDS_MeshNode * n37,
2029                                                const SMDS_MeshNode * n48,
2030                                                int ID)
2031 {
2032   return AddVolumeWithID(n1->GetID(), n2->GetID(), n3->GetID(), n4->GetID(),
2033                          n5->GetID(), n6->GetID(), n7->GetID(), n8->GetID(),
2034                          n12->GetID(), n23->GetID(), n34->GetID(), n41->GetID(),
2035                          n56->GetID(), n67->GetID(), n78->GetID(), n85->GetID(),
2036                          n15->GetID(), n26->GetID(), n37->GetID(), n48->GetID(),
2037                          ID);
2038 }
2039
2040 //=======================================================================
2041 //function : AddVolume
2042 //purpose  : add tri-quadratic hexahedron of 27 nodes
2043 //=======================================================================
2044
2045 SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
2046                                          const SMDS_MeshNode * n2,
2047                                          const SMDS_MeshNode * n3,
2048                                          const SMDS_MeshNode * n4,
2049                                          const SMDS_MeshNode * n5,
2050                                          const SMDS_MeshNode * n6,
2051                                          const SMDS_MeshNode * n7,
2052                                          const SMDS_MeshNode * n8,
2053                                          const SMDS_MeshNode * n12,
2054                                          const SMDS_MeshNode * n23,
2055                                          const SMDS_MeshNode * n34,
2056                                          const SMDS_MeshNode * n41,
2057                                          const SMDS_MeshNode * n56,
2058                                          const SMDS_MeshNode * n67,
2059                                          const SMDS_MeshNode * n78,
2060                                          const SMDS_MeshNode * n85,
2061                                          const SMDS_MeshNode * n15,
2062                                          const SMDS_MeshNode * n26,
2063                                          const SMDS_MeshNode * n37,
2064                                          const SMDS_MeshNode * n48,
2065                                          const SMDS_MeshNode * n1234,
2066                                          const SMDS_MeshNode * n1256,
2067                                          const SMDS_MeshNode * n2367,
2068                                          const SMDS_MeshNode * n3478,
2069                                          const SMDS_MeshNode * n1458,
2070                                          const SMDS_MeshNode * n5678,
2071                                          const SMDS_MeshNode * nCenter)
2072 {
2073   SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolume(n1,n2,n3,n4,n5,n6,n7,n8,
2074                                                  n12,n23,n34,n41,
2075                                                  n56,n67,n78,n85,
2076                                                  n15,n26,n37,n48,
2077                                                  n1234,n1256,n2367,n3478,n1458,n5678,nCenter);
2078   if(anElem)
2079     myScript->AddVolume(anElem->GetID(), n1->GetID(), n2->GetID(),
2080                         n3->GetID(), n4->GetID(), n5->GetID(),
2081                         n6->GetID(), n7->GetID(), n8->GetID(),
2082                         n12->GetID(), n23->GetID(), n34->GetID(), n41->GetID(),
2083                         n56->GetID(), n67->GetID(), n78->GetID(), n85->GetID(),
2084                         n15->GetID(), n26->GetID(), n37->GetID(), n48->GetID(),
2085                         n1234->GetID(),n1256->GetID(),n2367->GetID(),n3478->GetID(),
2086                         n1458->GetID(),n5678->GetID(),nCenter->GetID());
2087   return anElem;
2088 }
2089
2090 SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4,
2091                                                int n5, int n6, int n7, int n8,
2092                                                int n12,int n23,int n34,int n41,
2093                                                int n56,int n67,int n78,int n85,
2094                                                int n15,int n26,int n37,int n48,
2095                                                int n1234,int n1256,int n2367,int n3478,
2096                                                int n1458,int n5678,int nCenter,
2097                                                int ID)
2098 {
2099   SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolumeWithID(n1,n2,n3,n4,n5,n6,n7,n8,
2100                                                        n12,n23,n34,n41,
2101                                                        n56,n67,n78,n85,
2102                                                        n15,n26,n37,n48,
2103                                                        n1234, n1256, n2367, n3478,
2104                                                        n1458, n5678, nCenter,
2105                                                        ID);
2106   if(anElem) myScript->AddVolume(ID,n1,n2,n3,n4,n5,n6,n7,n8,n12,n23,n34,n41,
2107                                  n56,n67,n78,n85,n15,n26,n37,n48,
2108                                  n1234, n1256, n2367, n3478,
2109                                  n1458, n5678, nCenter);
2110   return anElem;
2111 }
2112
2113 SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
2114                                                const SMDS_MeshNode * n2,
2115                                                const SMDS_MeshNode * n3,
2116                                                const SMDS_MeshNode * n4,
2117                                                const SMDS_MeshNode * n5,
2118                                                const SMDS_MeshNode * n6,
2119                                                const SMDS_MeshNode * n7,
2120                                                const SMDS_MeshNode * n8,
2121                                                const SMDS_MeshNode * n12,
2122                                                const SMDS_MeshNode * n23,
2123                                                const SMDS_MeshNode * n34,
2124                                                const SMDS_MeshNode * n41,
2125                                                const SMDS_MeshNode * n56,
2126                                                const SMDS_MeshNode * n67,
2127                                                const SMDS_MeshNode * n78,
2128                                                const SMDS_MeshNode * n85,
2129                                                const SMDS_MeshNode * n15,
2130                                                const SMDS_MeshNode * n26,
2131                                                const SMDS_MeshNode * n37,
2132                                                const SMDS_MeshNode * n48,
2133                                                const SMDS_MeshNode * n1234,
2134                                                const SMDS_MeshNode * n1256,
2135                                                const SMDS_MeshNode * n2367,
2136                                                const SMDS_MeshNode * n3478,
2137                                                const SMDS_MeshNode * n1458,
2138                                                const SMDS_MeshNode * n5678,
2139                                                const SMDS_MeshNode * nCenter,
2140                                                int ID)
2141 {
2142   return AddVolumeWithID(n1->GetID(), n2->GetID(), n3->GetID(), n4->GetID(),
2143                          n5->GetID(), n6->GetID(), n7->GetID(), n8->GetID(),
2144                          n12->GetID(), n23->GetID(), n34->GetID(), n41->GetID(),
2145                          n56->GetID(), n67->GetID(), n78->GetID(), n85->GetID(),
2146                          n15->GetID(), n26->GetID(), n37->GetID(), n48->GetID(),
2147                          n1234->GetID(),n1256->GetID(),n2367->GetID(),n3478->GetID(),
2148                          n1458->GetID(),n5678->GetID(),nCenter->GetID(), ID);
2149 }
2150
2151 void SMESHDS_Mesh::compactMesh()
2152 {
2153   int newNodeSize = 0;
2154   int nbNodes = myNodes.size();
2155   int nbVtkNodes = myGrid->GetNumberOfPoints();
2156   MESSAGE("nbNodes=" << nbNodes << " nbVtkNodes=" << nbVtkNodes);
2157   int nbNodeTemp = nbVtkNodes;
2158   if (nbNodes > nbVtkNodes)
2159     nbNodeTemp = nbNodes;
2160   vector<int> idNodesOldToNew;
2161   idNodesOldToNew.clear();
2162   idNodesOldToNew.resize(nbNodeTemp, -1); // all unused id will be -1
2163
2164   for (int i = 0; i < nbNodes; i++)
2165     {
2166       if (myNodes[i])
2167         {
2168           int vtkid = myNodes[i]->getVtkId();
2169           idNodesOldToNew[vtkid] = i; // old vtkId --> old smdsId (valid smdsId are >= 0)
2170           newNodeSize++;
2171         }
2172     }
2173   bool areNodesModified = (newNodeSize < nbVtkNodes);
2174   MESSAGE("------------------------- compactMesh Nodes Modified: " << areNodesModified);
2175   areNodesModified = true;
2176
2177   int newCellSize = 0;
2178   int nbCells = myCells.size();
2179   int nbVtkCells = myGrid->GetNumberOfCells();
2180   MESSAGE("nbCells=" << nbCells << " nbVtkCells=" << nbVtkCells);
2181   int nbCellTemp = nbVtkCells;
2182   if (nbCells > nbVtkCells)
2183     nbCellTemp = nbCells;
2184   vector<int> idCellsOldToNew;
2185   idCellsOldToNew.clear();
2186   idCellsOldToNew.resize(nbCellTemp, -1); // all unused id will be -1
2187
2188   for (int i = 0; i < nbCells; i++)
2189     {
2190       if (myCells[i])
2191         {
2192 //          //idCellsOldToNew[i] = myCellIdVtkToSmds[i]; // valid vtk indexes are > = 0
2193 //          int vtkid = myCells[i]->getVtkId();
2194 //          idCellsOldToNew[vtkid] = i; // old vtkId --> old smdsId (not used in input)
2195           newCellSize++;
2196         }
2197     }
2198   if (areNodesModified)
2199     myGrid->compactGrid(idNodesOldToNew, newNodeSize, idCellsOldToNew, newCellSize);
2200   else
2201     myGrid->compactGrid(idNodesOldToNew, 0, idCellsOldToNew, newCellSize);
2202
2203   int nbVtkPts = myGrid->GetNumberOfPoints();
2204   nbVtkCells = myGrid->GetNumberOfCells();
2205   if (nbVtkPts != newNodeSize)
2206     {
2207       MESSAGE("===> nbVtkPts != newNodeSize " << nbVtkPts << " " << newNodeSize);
2208       if (nbVtkPts > newNodeSize) newNodeSize = nbVtkPts; // several points with same SMDS Id
2209     }
2210   if (nbVtkCells != newCellSize)
2211     {
2212       MESSAGE("===> nbVtkCells != newCellSize " << nbVtkCells << " " << newCellSize);
2213       if (nbVtkCells > newCellSize) newCellSize = nbVtkCells; // several cells with same SMDS Id
2214     }
2215
2216   // --- SMDS_MeshNode and myNodes (id in SMDS and in VTK are the same), myNodeIdFactory
2217
2218   if (areNodesModified)
2219     {
2220       MESSAGE("-------------- modify myNodes");
2221       SetOfNodes newNodes;
2222       newNodes.resize(newNodeSize+1,0); // 0 not used, SMDS numbers 1..n
2223       int newSmdsId = 0;
2224       for (int i = 0; i < nbNodes; i++)
2225         {
2226           if (myNodes[i])
2227             {
2228               newSmdsId++; // SMDS id start to 1
2229               int oldVtkId = myNodes[i]->getVtkId();
2230               int newVtkId = idNodesOldToNew[oldVtkId];
2231               //MESSAGE("myNodes["<< i << "] vtkId " << oldVtkId << " --> " << newVtkId);
2232               myNodes[i]->setVtkId(newVtkId);
2233               myNodes[i]->setId(newSmdsId);
2234               newNodes[newSmdsId] = myNodes[i];
2235               //MESSAGE("myNodes["<< i << "] --> newNodes[" << newSmdsId << "]");
2236             }
2237         }
2238       myNodes.swap(newNodes);
2239       this->myNodeIDFactory->emptyPool(newSmdsId); // newSmdsId = number of nodes
2240       MESSAGE("myNodes.size " << myNodes.size());
2241     }
2242
2243   // --- SMDS_MeshCell, myCellIdVtkToSmds, myCellIdSmdsToVtk, myCells
2244
2245   int vtkIndexSize = myCellIdVtkToSmds.size();
2246   int maxVtkId = -1;
2247   for (int oldVtkId = 0; oldVtkId < vtkIndexSize; oldVtkId++)
2248     {
2249       int oldSmdsId = this->myCellIdVtkToSmds[oldVtkId];
2250       if (oldSmdsId > 0)
2251         {
2252           int newVtkId = idCellsOldToNew[oldVtkId];
2253           if (newVtkId > maxVtkId)
2254             maxVtkId = newVtkId;
2255           //MESSAGE("myCells["<< oldSmdsId << "] vtkId " << oldVtkId << " --> " << newVtkId);
2256           myCells[oldSmdsId]->setVtkId(newVtkId);
2257         }
2258     }
2259 //  MESSAGE("myCells.size()=" << myCells.size()
2260 //          << " myCellIdSmdsToVtk.size()=" << myCellIdSmdsToVtk.size()
2261 //          << " myCellIdVtkToSmds.size()=" << myCellIdVtkToSmds.size() );
2262
2263   SetOfCells newCells;
2264   //vector<int> newSmdsToVtk;
2265   vector<int> newVtkToSmds;
2266
2267   assert(maxVtkId < newCellSize);
2268   newCells.resize(newCellSize+1, 0); // 0 not used, SMDS numbers 1..n
2269   //newSmdsToVtk.resize(newCellSize+1, -1);
2270   newVtkToSmds.resize(newCellSize+1, -1);
2271
2272   int myCellsSize = myCells.size();
2273   int newSmdsId = 0;
2274   for (int i = 0; i < myCellsSize; i++)
2275     {
2276       if (myCells[i])
2277         {
2278           newSmdsId++; // SMDS id start to 1
2279           assert(newSmdsId <= newCellSize);
2280           newCells[newSmdsId] = myCells[i];
2281           newCells[newSmdsId]->setId(newSmdsId);
2282           //MESSAGE("myCells["<< i << "] --> newCells[" << newSmdsId << "]");
2283           int idvtk = myCells[i]->getVtkId();
2284           //newSmdsToVtk[newSmdsId] = idvtk;
2285           assert(idvtk < newCellSize);
2286           newVtkToSmds[idvtk] = newSmdsId;
2287         }
2288     }
2289
2290   myCells.swap(newCells);
2291   //myCellIdSmdsToVtk.swap(newSmdsToVtk);
2292   myCellIdVtkToSmds.swap(newVtkToSmds);
2293   MESSAGE("myCells.size()=" << myCells.size()
2294           << " myCellIdVtkToSmds.size()=" << myCellIdVtkToSmds.size() );
2295   this->myElementIDFactory->emptyPool(newSmdsId);
2296
2297   this->myScript->SetModified(true); // notify GUI client for buildPrs when update
2298
2299   // --- compact list myNodes and myElements in submeshes
2300
2301   map<int,SMESHDS_SubMesh*>::iterator it = myShapeIndexToSubMesh.begin();
2302   for(; it != myShapeIndexToSubMesh.end(); ++it)
2303     {
2304       (*it).second->compactList();
2305     }
2306
2307 }
2308
2309 void SMESHDS_Mesh::CleanDownWardConnectivity()
2310 {
2311   myGrid->CleanDownwardConnectivity();
2312 }
2313
2314 void SMESHDS_Mesh::BuildDownWardConnectivity(bool withEdges)
2315 {
2316   myGrid->BuildDownwardConnectivity(withEdges);
2317 }
2318
2319 /*! change some nodes in cell without modifying type or internal connectivity.
2320  * Nodes inverse connectivity is maintained up to date.
2321  * @param vtkVolId vtk id of the cell.
2322  * @param localClonedNodeIds map old node id to new node id.
2323  * @return ok if success.
2324  */
2325 bool SMESHDS_Mesh::ModifyCellNodes(int vtkVolId, std::map<int,int> localClonedNodeIds)
2326 {
2327   myGrid->ModifyCellNodes(vtkVolId, localClonedNodeIds);
2328   return true;
2329 }