src/SMESHDS/SMESHDS_Mesh.cxx

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