src/SMESHDS/SMESHDS_Mesh.cxx

   1 // Copyright (C) 2007-2022  CEA/DEN, EDF R&D, OPEN CASCADE
   2 //
   3 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 // This library is free software; you can redistribute it and/or
   7 // modify it under the terms of the GNU Lesser General Public
   8 // License as published by the Free Software Foundation; either
   9 // version 2.1 of the License, 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 : SetMeshElementOnShape
1166 //purpose  :
1167 //=======================================================================
1168 void SMESHDS_Mesh::SetMeshElementOnShape(const SMDS_MeshElement * anElement,
1169                                          const TopoDS_Shape &     S)
1170 {
1171   add( anElement, getSubmesh(S) );
1172 }
1173
1174 //=======================================================================
1175 //function : UnSetMeshElementOnShape
1176 //purpose  :
1177 //=======================================================================
1178 void SMESHDS_Mesh::UnSetMeshElementOnShape(const SMDS_MeshElement * elem,
1179                                            const TopoDS_Shape &     S)
1180 {
1181   if ( SMESHDS_SubMesh* sm = MeshElements( S ))
1182     sm->RemoveElement(elem);
1183 }
1184
1185 //=======================================================================
1186 //function : ShapeToMesh
1187 //purpose  :
1188 //=======================================================================
1189 TopoDS_Shape SMESHDS_Mesh::ShapeToMesh() const
1190 {
1191   return myShape;
1192 }
1193
1194 //=======================================================================
1195 //function : IsGroupOfSubShapes
1196 //purpose  : return true if at least one sub-shape of theShape is a sub-shape
1197 //           of myShape or theShape == myShape
1198 //=======================================================================
1199
1200 bool SMESHDS_Mesh::IsGroupOfSubShapes (const TopoDS_Shape& theShape) const
1201 {
1202   if ( myIndexToShape.Contains(theShape) )
1203     return true;
1204
1205   for ( TopoDS_Iterator it( theShape ); it.More(); it.Next() )
1206     if ( IsGroupOfSubShapes( it.Value() ))
1207       return true;
1208
1209   return false;
1210 }
1211
1212 ///////////////////////////////////////////////////////////////////////////////
1213 /// Return the sub mesh linked to the a given TopoDS_Shape or NULL if the given
1214 /// TopoDS_Shape is unknown
1215 ///////////////////////////////////////////////////////////////////////////////
1216 SMESHDS_SubMesh * SMESHDS_Mesh::MeshElements(const TopoDS_Shape & S) const
1217 {
1218   int Index = ShapeToIndex(S);
1219   return (SMESHDS_SubMesh *) ( Index ? mySubMeshHolder->Get( Index ) : 0 );
1220 }
1221
1222 ///////////////////////////////////////////////////////////////////////////////
1223 /// Return the sub mesh by Id of shape it is linked to
1224 ///////////////////////////////////////////////////////////////////////////////
1225 SMESHDS_SubMesh * SMESHDS_Mesh::MeshElements(const int Index) const
1226 {
1227   return const_cast< SMESHDS_SubMesh* >( mySubMeshHolder->Get( Index ));
1228 }
1229
1230 //=======================================================================
1231 //function : SubMeshIndices
1232 //purpose  :
1233 //=======================================================================
1234 std::list<int> SMESHDS_Mesh::SubMeshIndices() const
1235 {
1236   std::list<int> anIndices;
1237   SMESHDS_SubMeshIteratorPtr smIt = SubMeshes();
1238   while ( const SMESHDS_SubMesh* sm = smIt->next() )
1239     anIndices.push_back( sm->GetID() );
1240
1241   return anIndices;
1242 }
1243
1244 //=======================================================================
1245 //function : SubMeshes
1246 //purpose  :
1247 //=======================================================================
1248
1249 SMESHDS_SubMeshIteratorPtr SMESHDS_Mesh::SubMeshes() const
1250 {
1251   return SMESHDS_SubMeshIteratorPtr( mySubMeshHolder->GetIterator() );
1252 }
1253
1254 //=======================================================================
1255 //function : GetHypothesis
1256 //purpose  :
1257 //=======================================================================
1258
1259 const std::list<const SMESHDS_Hypothesis*>&
1260 SMESHDS_Mesh::GetHypothesis(const TopoDS_Shape & S) const
1261 {
1262   if ( myShapeToHypothesis.IsBound( S/*.Oriented(TopAbs_FORWARD)*/ ) ) // ignore orientation of S
1263     return myShapeToHypothesis.Find( S/*.Oriented(TopAbs_FORWARD)*/ );
1264
1265   static std::list<const SMESHDS_Hypothesis*> empty;
1266   return empty;
1267 }
1268
1269 //================================================================================
1270 /*!
1271  * \brief returns true if the hypothesis is assigned to any sub-shape
1272  */
1273 //================================================================================
1274
1275 bool SMESHDS_Mesh::IsUsedHypothesis(const SMESHDS_Hypothesis * H) const
1276 {
1277   ShapeToHypothesis::Iterator s2h( myShapeToHypothesis );
1278   for ( ; s2h.More(); s2h.Next() )
1279     if ( std::find( s2h.Value().begin(), s2h.Value().end(), H ) != s2h.Value().end() )
1280       return true;
1281   return false;
1282 }
1283
1284 //=======================================================================
1285 //function : GetScript
1286 //purpose  :
1287 //=======================================================================
1288 SMESHDS_Script* SMESHDS_Mesh::GetScript()
1289 {
1290   return myScript;
1291 }
1292
1293 //=======================================================================
1294 //function : ClearScript
1295 //purpose  :
1296 //=======================================================================
1297 void SMESHDS_Mesh::ClearScript()
1298 {
1299   myScript->Clear();
1300 }
1301
1302 //=======================================================================
1303 //function : HasMeshElements
1304 //purpose  :
1305 //=======================================================================
1306 bool SMESHDS_Mesh::HasMeshElements(const TopoDS_Shape & S) const
1307 {
1308   int Index = myIndexToShape.FindIndex(S);
1309   return mySubMeshHolder->Get( Index );
1310 }
1311
1312 //=======================================================================
1313 //function : HasHypothesis
1314 //purpose  :
1315 //=======================================================================
1316 bool SMESHDS_Mesh::HasHypothesis(const TopoDS_Shape & S)
1317 {
1318   return myShapeToHypothesis.IsBound(S/*.Oriented(TopAbs_FORWARD)*/);
1319 }
1320
1321 //=======================================================================
1322 //function : NewSubMesh
1323 //purpose  :
1324 //=======================================================================
1325 SMESHDS_SubMesh * SMESHDS_Mesh::NewSubMesh(int Index)
1326 {
1327   SMESHDS_SubMesh* SM = MeshElements( Index );
1328   if ( !SM )
1329   {
1330     SM = new SMESHDS_SubMesh(this, Index);
1331     mySubMeshHolder->Add( Index, SM );
1332   }
1333   return SM;
1334 }
1335
1336 //=======================================================================
1337 //function : AddCompoundSubmesh
1338 //purpose  :
1339 //=======================================================================
1340
1341 int SMESHDS_Mesh::AddCompoundSubmesh(const TopoDS_Shape& S,
1342                                      TopAbs_ShapeEnum    type)
1343 {
1344   int aMainIndex = 0;
1345   if ( IsGroupOfSubShapes( S ))
1346   {
1347     aMainIndex = myIndexToShape.Add( S );
1348     bool all = ( type == TopAbs_SHAPE );
1349     if ( all ) // corresponding simple submesh may exist
1350       aMainIndex = -aMainIndex;
1351     SMESHDS_SubMesh * aNewSub = NewSubMesh( aMainIndex );
1352     if ( !aNewSub->IsComplexSubmesh() ) // is empty
1353     {
1354       int shapeType = Max( TopAbs_SOLID, all ? myShape.ShapeType() : type );
1355       int typeLimit = all ? TopAbs_VERTEX : type;
1356       for ( ; shapeType <= typeLimit; shapeType++ )
1357       {
1358         TopExp_Explorer exp( S, TopAbs_ShapeEnum( shapeType ));
1359         for ( ; exp.More(); exp.Next() )
1360         {
1361           int index = myIndexToShape.FindIndex( exp.Current() );
1362           if ( index )
1363             aNewSub->AddSubMesh( NewSubMesh( index ));
1364         }
1365       }
1366     }
1367   }
1368   return aMainIndex;
1369 }
1370
1371 //=======================================================================
1372 //function : IndexToShape
1373 //purpose  :
1374 //=======================================================================
1375 const TopoDS_Shape& SMESHDS_Mesh::IndexToShape(int ShapeIndex) const
1376 {
1377   try
1378   {
1379     if ( ShapeIndex > 0 )
1380       return myIndexToShape.FindKey(ShapeIndex);
1381   }
1382   catch ( ... )
1383   {
1384   }
1385   static TopoDS_Shape nullShape;
1386   return nullShape;
1387 }
1388
1389 //================================================================================
1390 /*!
1391  * \brief Return max index of sub-mesh
1392  */
1393 //================================================================================
1394
1395 int SMESHDS_Mesh::MaxSubMeshIndex() const
1396 {
1397   return mySubMeshHolder->GetMaxID();
1398 }
1399
1400 //=======================================================================
1401 //function : ShapeToIndex
1402 //purpose  :
1403 //=======================================================================
1404 int SMESHDS_Mesh::ShapeToIndex(const TopoDS_Shape & S) const
1405 {
1406   int index = myIndexToShape.FindIndex(S);
1407   return index;
1408 }
1409
1410 //=======================================================================
1411 //function : SetNodeOnVolume
1412 //purpose  :
1413 //=======================================================================
1414 void SMESHDS_Mesh::SetNodeInVolume(const SMDS_MeshNode* aNode, int Index)
1415 {
1416   if ( int shapeID = add( aNode, NewSubMesh( Index )))
1417     ((SMDS_MeshNode*) aNode)->SetPosition( SMDS_SpacePosition::originSpacePosition(), shapeID );
1418 }
1419
1420 //=======================================================================
1421 //function : SetNodeOnFace
1422 //purpose  :
1423 //=======================================================================
1424 void SMESHDS_Mesh::SetNodeOnFace(const SMDS_MeshNode* aNode, int Index, double u, double v)
1425 {
1426   //Set Position on Node
1427   if ( int shapeID = add( aNode, NewSubMesh( Index )))
1428     const_cast< SMDS_MeshNode* >
1429       ( aNode )->SetPosition(SMDS_PositionPtr(new SMDS_FacePosition( u, v )), shapeID );
1430 }
1431
1432 //=======================================================================
1433 //function : SetNodeOnEdge
1434 //purpose  :
1435 //=======================================================================
1436 void SMESHDS_Mesh::SetNodeOnEdge(const SMDS_MeshNode* aNode,
1437                                  int                  Index,
1438                                  double               u)
1439 {
1440   //Set Position on Node
1441   if (  int shapeID = add( aNode, NewSubMesh( Index )))
1442     const_cast< SMDS_MeshNode* >
1443       ( aNode )->SetPosition(SMDS_PositionPtr(new SMDS_EdgePosition( u )), shapeID );
1444 }
1445
1446 //=======================================================================
1447 //function : SetNodeOnVertex
1448 //purpose  :
1449 //=======================================================================
1450 void SMESHDS_Mesh::SetNodeOnVertex(const SMDS_MeshNode* aNode, int Index)
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_VertexPosition()), shapeID );
1456 }
1457
1458 //=======================================================================
1459 //function : SetMeshElementOnShape
1460 //purpose  :
1461 //=======================================================================
1462 void SMESHDS_Mesh::SetMeshElementOnShape(const SMDS_MeshElement* anElement,
1463                                          int                     Index)
1464 {
1465   add( anElement, NewSubMesh( Index ));
1466 }
1467
1468 //=======================================================================
1469 //function : ~SMESHDS_Mesh
1470 //purpose  :
1471 //=======================================================================
1472 SMESHDS_Mesh::~SMESHDS_Mesh()
1473 {
1474   // myScript
1475   delete myScript;
1476   // submeshes
1477   delete mySubMeshHolder;
1478 }
1479
1480
1481 //********************************************************************
1482 //********************************************************************
1483 //********                                                   *********
1484 //*****       Methods for addition of quadratic elements        ******
1485 //********                                                   *********
1486 //********************************************************************
1487 //********************************************************************
1488
1489 //=======================================================================
1490 //function : AddEdgeWithID
1491 //purpose  :
1492 //=======================================================================
1493 SMDS_MeshEdge* SMESHDS_Mesh::AddEdgeWithID(smIdType n1, smIdType n2, smIdType n12, smIdType ID)
1494 {
1495   SMDS_MeshEdge* anElem = SMDS_Mesh::AddEdgeWithID(n1,n2,n12,ID);
1496   if(anElem) myScript->AddEdge(ID,n1,n2,n12);
1497   return anElem;
1498 }
1499
1500 //=======================================================================
1501 //function : AddEdge
1502 //purpose  :
1503 //=======================================================================
1504 SMDS_MeshEdge* SMESHDS_Mesh::AddEdge(const SMDS_MeshNode* n1,
1505                                      const SMDS_MeshNode* n2,
1506                                      const SMDS_MeshNode* n12)
1507 {
1508   SMDS_MeshEdge* anElem = SMDS_Mesh::AddEdge(n1,n2,n12);
1509   if(anElem) myScript->AddEdge(anElem->GetID(),
1510                                n1->GetID(),
1511                                n2->GetID(),
1512                                n12->GetID());
1513   return anElem;
1514 }
1515
1516 //=======================================================================
1517 //function : AddEdgeWithID
1518 //purpose  :
1519 //=======================================================================
1520 SMDS_MeshEdge* SMESHDS_Mesh::AddEdgeWithID(const SMDS_MeshNode * n1,
1521                                            const SMDS_MeshNode * n2,
1522                                            const SMDS_MeshNode * n12,
1523                                            smIdType ID)
1524 {
1525   return AddEdgeWithID(n1->GetID(),
1526                        n2->GetID(),
1527                        n12->GetID(),
1528                        ID);
1529 }
1530
1531
1532 //=======================================================================
1533 //function : AddFace
1534 //purpose  :
1535 //=======================================================================
1536 SMDS_MeshFace* SMESHDS_Mesh::AddFace(const SMDS_MeshNode * n1,
1537                                      const SMDS_MeshNode * n2,
1538                                      const SMDS_MeshNode * n3,
1539                                      const SMDS_MeshNode * n12,
1540                                      const SMDS_MeshNode * n23,
1541                                      const SMDS_MeshNode * n31)
1542 {
1543   SMDS_MeshFace *anElem = SMDS_Mesh::AddFace(n1,n2,n3,n12,n23,n31);
1544   if(anElem) myScript->AddFace(anElem->GetID(),
1545                                n1->GetID(), n2->GetID(), n3->GetID(),
1546                                n12->GetID(), n23->GetID(), n31->GetID());
1547   return anElem;
1548 }
1549
1550 //=======================================================================
1551 //function : AddFaceWithID
1552 //purpose  :
1553 //=======================================================================
1554 SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(smIdType n1, smIdType n2, smIdType n3,
1555                                            smIdType n12,smIdType n23,smIdType n31, smIdType ID)
1556 {
1557   SMDS_MeshFace *anElem = SMDS_Mesh::AddFaceWithID(n1,n2,n3,n12,n23,n31,ID);
1558   if(anElem) myScript->AddFace(ID,n1,n2,n3,n12,n23,n31);
1559   return anElem;
1560 }
1561
1562 //=======================================================================
1563 //function : AddFaceWithID
1564 //purpose  :
1565 //=======================================================================
1566 SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
1567                                            const SMDS_MeshNode * n2,
1568                                            const SMDS_MeshNode * n3,
1569                                            const SMDS_MeshNode * n12,
1570                                            const SMDS_MeshNode * n23,
1571                                            const SMDS_MeshNode * n31,
1572                                            smIdType ID)
1573 {
1574   return AddFaceWithID(n1->GetID(), n2->GetID(), n3->GetID(),
1575                        n12->GetID(), n23->GetID(), n31->GetID(),
1576                        ID);
1577 }
1578
1579 //=======================================================================
1580 //function : AddFace
1581 //purpose  :
1582 //=======================================================================
1583 SMDS_MeshFace* SMESHDS_Mesh::AddFace(const SMDS_MeshNode * n1,
1584                                      const SMDS_MeshNode * n2,
1585                                      const SMDS_MeshNode * n3,
1586                                      const SMDS_MeshNode * n12,
1587                                      const SMDS_MeshNode * n23,
1588                                      const SMDS_MeshNode * n31,
1589                                      const SMDS_MeshNode * nCenter)
1590 {
1591   SMDS_MeshFace *anElem = SMDS_Mesh::AddFace(n1,n2,n3,n12,n23,n31,nCenter);
1592   if(anElem) myScript->AddFace(anElem->GetID(),
1593                                n1->GetID(), n2->GetID(), n3->GetID(),
1594                                n12->GetID(), n23->GetID(), n31->GetID(),
1595                                nCenter->GetID());
1596   return anElem;
1597 }
1598
1599 //=======================================================================
1600 //function : AddFaceWithID
1601 //purpose  :
1602 //=======================================================================
1603 SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(smIdType n1, smIdType n2, smIdType n3,
1604                                            smIdType n12,smIdType n23,smIdType n31, smIdType nCenter, smIdType ID)
1605 {
1606   SMDS_MeshFace *anElem = SMDS_Mesh::AddFaceWithID(n1,n2,n3,n12,n23,n31,nCenter,ID);
1607   if(anElem) myScript->AddFace(ID,n1,n2,n3,n12,n23,n31,nCenter);
1608   return anElem;
1609 }
1610
1611 //=======================================================================
1612 //function : AddFaceWithID
1613 //purpose  :
1614 //=======================================================================
1615 SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
1616                                            const SMDS_MeshNode * n2,
1617                                            const SMDS_MeshNode * n3,
1618                                            const SMDS_MeshNode * n12,
1619                                            const SMDS_MeshNode * n23,
1620                                            const SMDS_MeshNode * n31,
1621                                            const SMDS_MeshNode * nCenter,
1622                                            smIdType ID)
1623 {
1624   return AddFaceWithID(n1->GetID(), n2->GetID(), n3->GetID(),
1625                        n12->GetID(), n23->GetID(), n31->GetID(),
1626                        nCenter->GetID(), ID);
1627 }
1628
1629
1630 //=======================================================================
1631 //function : AddFace
1632 //purpose  :
1633 //=======================================================================
1634 SMDS_MeshFace* SMESHDS_Mesh::AddFace(const SMDS_MeshNode * n1,
1635                                      const SMDS_MeshNode * n2,
1636                                      const SMDS_MeshNode * n3,
1637                                      const SMDS_MeshNode * n4,
1638                                      const SMDS_MeshNode * n12,
1639                                      const SMDS_MeshNode * n23,
1640                                      const SMDS_MeshNode * n34,
1641                                      const SMDS_MeshNode * n41)
1642 {
1643   SMDS_MeshFace *anElem = SMDS_Mesh::AddFace(n1,n2,n3,n4,n12,n23,n34,n41);
1644   if(anElem) myScript->AddFace(anElem->GetID(),
1645                                n1->GetID(), n2->GetID(), n3->GetID(), n4->GetID(),
1646                                n12->GetID(), n23->GetID(), n34->GetID(), n41->GetID());
1647   return anElem;
1648 }
1649
1650 //=======================================================================
1651 //function : AddFaceWithID
1652 //purpose  :
1653 //=======================================================================
1654 SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
1655                                            smIdType n12,smIdType n23,smIdType n34,smIdType n41, smIdType ID)
1656 {
1657   SMDS_MeshFace *anElem = SMDS_Mesh::AddFaceWithID(n1,n2,n3,n4,n12,n23,n34,n41,ID);
1658   if(anElem) myScript->AddFace(ID,n1,n2,n3,n4,n12,n23,n34,n41);
1659   return anElem;
1660 }
1661
1662 //=======================================================================
1663 //function : AddFaceWithID
1664 //purpose  :
1665 //=======================================================================
1666 SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
1667                                            const SMDS_MeshNode * n2,
1668                                            const SMDS_MeshNode * n3,
1669                                            const SMDS_MeshNode * n4,
1670                                            const SMDS_MeshNode * n12,
1671                                            const SMDS_MeshNode * n23,
1672                                            const SMDS_MeshNode * n34,
1673                                            const SMDS_MeshNode * n41,
1674                                            smIdType ID)
1675 {
1676   return AddFaceWithID(n1->GetID(), n2->GetID(), n3->GetID(), n4->GetID(),
1677                        n12->GetID(), n23->GetID(), n34->GetID(), n41->GetID(),
1678                        ID);
1679 }
1680
1681
1682 //=======================================================================
1683 //function : AddFace
1684 //purpose  :
1685 //=======================================================================
1686 SMDS_MeshFace* SMESHDS_Mesh::AddFace(const SMDS_MeshNode * n1,
1687                                      const SMDS_MeshNode * n2,
1688                                      const SMDS_MeshNode * n3,
1689                                      const SMDS_MeshNode * n4,
1690                                      const SMDS_MeshNode * n12,
1691                                      const SMDS_MeshNode * n23,
1692                                      const SMDS_MeshNode * n34,
1693                                      const SMDS_MeshNode * n41,
1694                                      const SMDS_MeshNode * nCenter)
1695 {
1696   SMDS_MeshFace *anElem = SMDS_Mesh::AddFace(n1,n2,n3,n4,n12,n23,n34,n41,nCenter);
1697   if(anElem) myScript->AddFace(anElem->GetID(),
1698                                n1->GetID(), n2->GetID(), n3->GetID(), n4->GetID(),
1699                                n12->GetID(), n23->GetID(), n34->GetID(), n41->GetID(),
1700                                nCenter->GetID());
1701   return anElem;
1702 }
1703
1704 //=======================================================================
1705 //function : AddFaceWithID
1706 //purpose  :
1707 //=======================================================================
1708 SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
1709                                            smIdType n12,smIdType n23,smIdType n34,smIdType n41,
1710                                            smIdType nCenter, smIdType ID)
1711 {
1712   SMDS_MeshFace *anElem = SMDS_Mesh::AddFaceWithID(n1,n2,n3,n4,n12,n23,n34,n41,nCenter,ID);
1713   if(anElem) myScript->AddFace(ID,n1,n2,n3,n4,n12,n23,n34,n41,nCenter);
1714   return anElem;
1715 }
1716
1717 //=======================================================================
1718 //function : AddFaceWithID
1719 //purpose  :
1720 //=======================================================================
1721 SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
1722                                            const SMDS_MeshNode * n2,
1723                                            const SMDS_MeshNode * n3,
1724                                            const SMDS_MeshNode * n4,
1725                                            const SMDS_MeshNode * n12,
1726                                            const SMDS_MeshNode * n23,
1727                                            const SMDS_MeshNode * n34,
1728                                            const SMDS_MeshNode * n41,
1729                                            const SMDS_MeshNode * nCenter,
1730                                            smIdType ID)
1731 {
1732   return AddFaceWithID(n1->GetID(), n2->GetID(), n3->GetID(), n4->GetID(),
1733                        n12->GetID(), n23->GetID(), n34->GetID(), n41->GetID(),
1734                        nCenter->GetID(), ID);
1735 }
1736
1737
1738 //=======================================================================
1739 //function : AddVolume
1740 //purpose  :
1741 //=======================================================================
1742 SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
1743                                          const SMDS_MeshNode * n2,
1744                                          const SMDS_MeshNode * n3,
1745                                          const SMDS_MeshNode * n4,
1746                                          const SMDS_MeshNode * n12,
1747                                          const SMDS_MeshNode * n23,
1748                                          const SMDS_MeshNode * n31,
1749                                          const SMDS_MeshNode * n14,
1750                                          const SMDS_MeshNode * n24,
1751                                          const SMDS_MeshNode * n34)
1752 {
1753   SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolume(n1,n2,n3,n4,n12,n23,n31,n14,n24,n34);
1754   if(anElem) myScript->AddVolume(anElem->GetID(),
1755                                  n1->GetID(), n2->GetID(), n3->GetID(), n4->GetID(),
1756                                  n12->GetID(), n23->GetID(), n31->GetID(),
1757                                  n14->GetID(), n24->GetID(), n34->GetID());
1758   return anElem;
1759 }
1760
1761 //=======================================================================
1762 //function : AddVolumeWithID
1763 //purpose  :
1764 //=======================================================================
1765 SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
1766                                                smIdType n12,smIdType n23,smIdType n31,
1767                                                smIdType n14,smIdType n24,smIdType n34, smIdType ID)
1768 {
1769   SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolumeWithID(n1,n2,n3,n4,n12,n23,
1770                                                        n31,n14,n24,n34,ID);
1771   if(anElem) myScript->AddVolume(ID,n1,n2,n3,n4,n12,n23,n31,n14,n24,n34);
1772   return anElem;
1773 }
1774
1775 //=======================================================================
1776 //function : AddVolumeWithID
1777 //purpose  : 2d order tetrahedron of 10 nodes
1778 //=======================================================================
1779 SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
1780                                                const SMDS_MeshNode * n2,
1781                                                const SMDS_MeshNode * n3,
1782                                                const SMDS_MeshNode * n4,
1783                                                const SMDS_MeshNode * n12,
1784                                                const SMDS_MeshNode * n23,
1785                                                const SMDS_MeshNode * n31,
1786                                                const SMDS_MeshNode * n14,
1787                                                const SMDS_MeshNode * n24,
1788                                                const SMDS_MeshNode * n34,
1789                                                smIdType ID)
1790 {
1791   return AddVolumeWithID(n1->GetID(), n2->GetID(), n3->GetID(), n4->GetID(),
1792                          n12->GetID(), n23->GetID(), n31->GetID(),
1793                          n14->GetID(), n24->GetID(), n34->GetID(), ID);
1794 }
1795
1796
1797 //=======================================================================
1798 //function : AddVolume
1799 //purpose  :
1800 //=======================================================================
1801 SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
1802                                          const SMDS_MeshNode * n2,
1803                                          const SMDS_MeshNode * n3,
1804                                          const SMDS_MeshNode * n4,
1805                                          const SMDS_MeshNode * n5,
1806                                          const SMDS_MeshNode * n12,
1807                                          const SMDS_MeshNode * n23,
1808                                          const SMDS_MeshNode * n34,
1809                                          const SMDS_MeshNode * n41,
1810                                          const SMDS_MeshNode * n15,
1811                                          const SMDS_MeshNode * n25,
1812                                          const SMDS_MeshNode * n35,
1813                                          const SMDS_MeshNode * n45)
1814 {
1815   SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolume(n1,n2,n3,n4,n5,n12,n23,n34,n41,
1816                                                  n15,n25,n35,n45);
1817   if(anElem)
1818     myScript->AddVolume(anElem->GetID(), n1->GetID(), n2->GetID(),
1819                         n3->GetID(), n4->GetID(), n5->GetID(),
1820                         n12->GetID(), n23->GetID(), n34->GetID(), n41->GetID(),
1821                         n15->GetID(), n25->GetID(), n35->GetID(), n45->GetID());
1822   return anElem;
1823 }
1824
1825 //=======================================================================
1826 //function : AddVolumeWithID
1827 //purpose  :
1828 //=======================================================================
1829 SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType n5,
1830                                                smIdType n12,smIdType n23,smIdType n34,smIdType n41,
1831                                                smIdType n15,smIdType n25,smIdType n35,smIdType n45, smIdType ID)
1832 {
1833   SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolumeWithID(n1,n2,n3,n4,n5,
1834                                                        n12,n23,n34,n41,
1835                                                        n15,n25,n35,n45,ID);
1836   if(anElem) myScript->AddVolume(ID,n1,n2,n3,n4,n5,n12,n23,n34,n41,
1837                                  n15,n25,n35,n45);
1838   return anElem;
1839 }
1840
1841 //=======================================================================
1842 //function : AddVolumeWithID
1843 //purpose  : 2d order pyramid of 13 nodes
1844 //=======================================================================
1845 SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
1846                                                const SMDS_MeshNode * n2,
1847                                                const SMDS_MeshNode * n3,
1848                                                const SMDS_MeshNode * n4,
1849                                                const SMDS_MeshNode * n5,
1850                                                const SMDS_MeshNode * n12,
1851                                                const SMDS_MeshNode * n23,
1852                                                const SMDS_MeshNode * n34,
1853                                                const SMDS_MeshNode * n41,
1854                                                const SMDS_MeshNode * n15,
1855                                                const SMDS_MeshNode * n25,
1856                                                const SMDS_MeshNode * n35,
1857                                                const SMDS_MeshNode * n45,
1858                                                smIdType ID)
1859 {
1860   return AddVolumeWithID(n1->GetID(), n2->GetID(), n3->GetID(),
1861                          n4->GetID(), n5->GetID(),
1862                          n12->GetID(), n23->GetID(), n34->GetID(), n41->GetID(),
1863                          n15->GetID(), n25->GetID(), n35->GetID(), n45->GetID(),
1864                          ID);
1865 }
1866
1867
1868 //=======================================================================
1869 //function : AddVolume
1870 //purpose  : 2nd order pentahedron (prism) with 15 nodes
1871 //=======================================================================
1872 SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
1873                                          const SMDS_MeshNode * n2,
1874                                          const SMDS_MeshNode * n3,
1875                                          const SMDS_MeshNode * n4,
1876                                          const SMDS_MeshNode * n5,
1877                                          const SMDS_MeshNode * n6,
1878                                          const SMDS_MeshNode * n12,
1879                                          const SMDS_MeshNode * n23,
1880                                          const SMDS_MeshNode * n31,
1881                                          const SMDS_MeshNode * n45,
1882                                          const SMDS_MeshNode * n56,
1883                                          const SMDS_MeshNode * n64,
1884                                          const SMDS_MeshNode * n14,
1885                                          const SMDS_MeshNode * n25,
1886                                          const SMDS_MeshNode * n36)
1887 {
1888   SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolume(n1,n2,n3,n4,n5,n6,n12,n23,n31,
1889                                                  n45,n56,n64,n14,n25,n36);
1890   if(anElem)
1891     myScript->AddVolume(anElem->GetID(), n1->GetID(), n2->GetID(),
1892                         n3->GetID(), n4->GetID(), n5->GetID(), n6->GetID(),
1893                         n12->GetID(), n23->GetID(), n31->GetID(),
1894                         n45->GetID(), n56->GetID(), n64->GetID(),
1895                         n14->GetID(), n25->GetID(), n36->GetID());
1896   return anElem;
1897 }
1898
1899 //=======================================================================
1900 //function : AddVolumeWithID
1901 //purpose  : 2nd order pentahedron (prism) with 15 nodes
1902 //=======================================================================
1903 SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3,
1904                                                smIdType n4, smIdType n5, smIdType n6,
1905                                                smIdType n12,smIdType n23,smIdType n31,
1906                                                smIdType n45,smIdType n56,smIdType n64,
1907                                                smIdType n14,smIdType n25,smIdType n36, smIdType ID)
1908 {
1909   SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolumeWithID(n1,n2,n3,n4,n5,n6,
1910                                                        n12,n23,n31,
1911                                                        n45,n56,n64,
1912                                                        n14,n25,n36,ID);
1913   if(anElem) myScript->AddVolume(ID,n1,n2,n3,n4,n5,n6,n12,n23,n31,
1914                                  n45,n56,n64,n14,n25,n36);
1915   return anElem;
1916 }
1917
1918 //=======================================================================
1919 //function : AddVolumeWithID
1920 //purpose  : 2d order Pentahedron (prism) with 15 nodes
1921 //=======================================================================
1922 SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
1923                                                const SMDS_MeshNode * n2,
1924                                                const SMDS_MeshNode * n3,
1925                                                const SMDS_MeshNode * n4,
1926                                                const SMDS_MeshNode * n5,
1927                                                const SMDS_MeshNode * n6,
1928                                                const SMDS_MeshNode * n12,
1929                                                const SMDS_MeshNode * n23,
1930                                                const SMDS_MeshNode * n31,
1931                                                const SMDS_MeshNode * n45,
1932                                                const SMDS_MeshNode * n56,
1933                                                const SMDS_MeshNode * n64,
1934                                                const SMDS_MeshNode * n14,
1935                                                const SMDS_MeshNode * n25,
1936                                                const SMDS_MeshNode * n36,
1937                                                smIdType ID)
1938 {
1939   return AddVolumeWithID(n1->GetID(), n2->GetID(), n3->GetID(),
1940                          n4->GetID(), n5->GetID(), n6->GetID(),
1941                          n12->GetID(), n23->GetID(), n31->GetID(),
1942                          n45->GetID(), n56->GetID(), n64->GetID(),
1943                          n14->GetID(), n25->GetID(), n36->GetID(),
1944                          ID);
1945 }
1946 //=======================================================================
1947 //function : AddVolume
1948 //purpose  : 2nd order pentahedron (prism) with 18 nodes
1949 //=======================================================================
1950 SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
1951                                          const SMDS_MeshNode * n2,
1952                                          const SMDS_MeshNode * n3,
1953                                          const SMDS_MeshNode * n4,
1954                                          const SMDS_MeshNode * n5,
1955                                          const SMDS_MeshNode * n6,
1956                                          const SMDS_MeshNode * n12,
1957                                          const SMDS_MeshNode * n23,
1958                                          const SMDS_MeshNode * n31,
1959                                          const SMDS_MeshNode * n45,
1960                                          const SMDS_MeshNode * n56,
1961                                          const SMDS_MeshNode * n64,
1962                                          const SMDS_MeshNode * n14,
1963                                          const SMDS_MeshNode * n25,
1964                                          const SMDS_MeshNode * n36,
1965                                          const SMDS_MeshNode * n1245,
1966                                          const SMDS_MeshNode * n2356,
1967                                          const SMDS_MeshNode * n1346)
1968 {
1969   SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolume(n1,n2,n3,n4,n5,n6,n12,n23,n31,
1970                                                  n45,n56,n64,n14,n25,n36,
1971                                                  n1245, n2356, n1346);
1972   if(anElem)
1973     myScript->AddVolume(anElem->GetID(), n1->GetID(), n2->GetID(),
1974                         n3->GetID(), n4->GetID(), n5->GetID(), n6->GetID(),
1975                         n12->GetID(), n23->GetID(), n31->GetID(),
1976                         n45->GetID(), n56->GetID(), n64->GetID(),
1977                         n14->GetID(), n25->GetID(), n36->GetID(),
1978                         n1245->GetID(), n2356->GetID(), n1346->GetID());
1979   return anElem;
1980 }
1981
1982 //=======================================================================
1983 //function : AddVolumeWithID
1984 //purpose  : 2nd order pentahedron (prism) with 18 nodes
1985 //=======================================================================
1986 SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3,
1987                                                smIdType n4, smIdType n5, smIdType n6,
1988                                                smIdType n12,smIdType n23,smIdType n31,
1989                                                smIdType n45,smIdType n56,smIdType n64,
1990                                                smIdType n14,smIdType n25,smIdType n36,
1991                                                smIdType n1245, smIdType n2356, smIdType n1346,
1992                                                smIdType ID)
1993 {
1994   SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolumeWithID(n1,n2,n3,n4,n5,n6,
1995                                                        n12,n23,n31,
1996                                                        n45,n56,n64,
1997                                                        n14,n25,n36,
1998                                                        n1245, n2356, n1346, ID);
1999   if(anElem) myScript->AddVolume(ID,n1,n2,n3,n4,n5,n6,n12,n23,n31,
2000                                  n45,n56,n64,n14,n25,n36, n1245, n2356, n1346);
2001   return anElem;
2002 }
2003
2004 //=======================================================================
2005 //function : AddVolumeWithID
2006 //purpose  : 2d order Pentahedron with 18 nodes
2007 //=======================================================================
2008 SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
2009                                                const SMDS_MeshNode * n2,
2010                                                const SMDS_MeshNode * n3,
2011                                                const SMDS_MeshNode * n4,
2012                                                const SMDS_MeshNode * n5,
2013                                                const SMDS_MeshNode * n6,
2014                                                const SMDS_MeshNode * n12,
2015                                                const SMDS_MeshNode * n23,
2016                                                const SMDS_MeshNode * n31,
2017                                                const SMDS_MeshNode * n45,
2018                                                const SMDS_MeshNode * n56,
2019                                                const SMDS_MeshNode * n64,
2020                                                const SMDS_MeshNode * n14,
2021                                                const SMDS_MeshNode * n25,
2022                                                const SMDS_MeshNode * n36,
2023                                                const SMDS_MeshNode * n1245,
2024                                                const SMDS_MeshNode * n2356,
2025                                                const SMDS_MeshNode * n1346,
2026                                                smIdType ID)
2027 {
2028   return AddVolumeWithID(n1->GetID(), n2->GetID(), n3->GetID(),
2029                          n4->GetID(), n5->GetID(), n6->GetID(),
2030                          n12->GetID(), n23->GetID(), n31->GetID(),
2031                          n45->GetID(), n56->GetID(), n64->GetID(),
2032                          n14->GetID(), n25->GetID(), n36->GetID(),
2033                          n1245->GetID(), n2356->GetID(), n1346->GetID(), ID);
2034 }
2035
2036
2037 //=======================================================================
2038 //function : AddVolume
2039 //purpose  : add quadratic hexahedron
2040 //=======================================================================
2041 SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
2042                                          const SMDS_MeshNode * n2,
2043                                          const SMDS_MeshNode * n3,
2044                                          const SMDS_MeshNode * n4,
2045                                          const SMDS_MeshNode * n5,
2046                                          const SMDS_MeshNode * n6,
2047                                          const SMDS_MeshNode * n7,
2048                                          const SMDS_MeshNode * n8,
2049                                          const SMDS_MeshNode * n12,
2050                                          const SMDS_MeshNode * n23,
2051                                          const SMDS_MeshNode * n34,
2052                                          const SMDS_MeshNode * n41,
2053                                          const SMDS_MeshNode * n56,
2054                                          const SMDS_MeshNode * n67,
2055                                          const SMDS_MeshNode * n78,
2056                                          const SMDS_MeshNode * n85,
2057                                          const SMDS_MeshNode * n15,
2058                                          const SMDS_MeshNode * n26,
2059                                          const SMDS_MeshNode * n37,
2060                                          const SMDS_MeshNode * n48)
2061 {
2062   SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolume(n1,n2,n3,n4,n5,n6,n7,n8,
2063                                                  n12,n23,n34,n41,
2064                                                  n56,n67,n78,n85,
2065                                                  n15,n26,n37,n48);
2066   if(anElem)
2067     myScript->AddVolume(anElem->GetID(), n1->GetID(), n2->GetID(),
2068                         n3->GetID(), n4->GetID(), n5->GetID(),
2069                         n6->GetID(), n7->GetID(), n8->GetID(),
2070                         n12->GetID(), n23->GetID(), n34->GetID(), n41->GetID(),
2071                         n56->GetID(), n67->GetID(), n78->GetID(), n85->GetID(),
2072                         n15->GetID(), n26->GetID(), n37->GetID(), n48->GetID());
2073   return anElem;
2074 }
2075
2076 //=======================================================================
2077 //function : AddVolumeWithID
2078 //purpose  :
2079 //=======================================================================
2080 SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
2081                                                smIdType n5, smIdType n6, smIdType n7, smIdType n8,
2082                                                smIdType n12,smIdType n23,smIdType n34,smIdType n41,
2083                                                smIdType n56,smIdType n67,smIdType n78,smIdType n85,
2084                                                smIdType n15,smIdType n26,smIdType n37,smIdType n48, smIdType ID)
2085 {
2086   SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolumeWithID(n1,n2,n3,n4,n5,n6,n7,n8,
2087                                                        n12,n23,n34,n41,
2088                                                        n56,n67,n78,n85,
2089                                                        n15,n26,n37,n48,ID);
2090   if(anElem) myScript->AddVolume(ID,n1,n2,n3,n4,n5,n6,n7,n8,n12,n23,n34,n41,
2091                                  n56,n67,n78,n85,n15,n26,n37,n48);
2092   return anElem;
2093 }
2094
2095 //=======================================================================
2096 //function : AddVolumeWithID
2097 //purpose  : 2d order Hexahedrons with 20 nodes
2098 //=======================================================================
2099 SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
2100                                                const SMDS_MeshNode * n2,
2101                                                const SMDS_MeshNode * n3,
2102                                                const SMDS_MeshNode * n4,
2103                                                const SMDS_MeshNode * n5,
2104                                                const SMDS_MeshNode * n6,
2105                                                const SMDS_MeshNode * n7,
2106                                                const SMDS_MeshNode * n8,
2107                                                const SMDS_MeshNode * n12,
2108                                                const SMDS_MeshNode * n23,
2109                                                const SMDS_MeshNode * n34,
2110                                                const SMDS_MeshNode * n41,
2111                                                const SMDS_MeshNode * n56,
2112                                                const SMDS_MeshNode * n67,
2113                                                const SMDS_MeshNode * n78,
2114                                                const SMDS_MeshNode * n85,
2115                                                const SMDS_MeshNode * n15,
2116                                                const SMDS_MeshNode * n26,
2117                                                const SMDS_MeshNode * n37,
2118                                                const SMDS_MeshNode * n48,
2119                                                smIdType ID)
2120 {
2121   return AddVolumeWithID(n1->GetID(), n2->GetID(), n3->GetID(), n4->GetID(),
2122                          n5->GetID(), n6->GetID(), n7->GetID(), n8->GetID(),
2123                          n12->GetID(), n23->GetID(), n34->GetID(), n41->GetID(),
2124                          n56->GetID(), n67->GetID(), n78->GetID(), n85->GetID(),
2125                          n15->GetID(), n26->GetID(), n37->GetID(), n48->GetID(),
2126                          ID);
2127 }
2128
2129 //=======================================================================
2130 //function : AddVolume
2131 //purpose  : add tri-quadratic hexahedron of 27 nodes
2132 //=======================================================================
2133
2134 SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
2135                                          const SMDS_MeshNode * n2,
2136                                          const SMDS_MeshNode * n3,
2137                                          const SMDS_MeshNode * n4,
2138                                          const SMDS_MeshNode * n5,
2139                                          const SMDS_MeshNode * n6,
2140                                          const SMDS_MeshNode * n7,
2141                                          const SMDS_MeshNode * n8,
2142                                          const SMDS_MeshNode * n12,
2143                                          const SMDS_MeshNode * n23,
2144                                          const SMDS_MeshNode * n34,
2145                                          const SMDS_MeshNode * n41,
2146                                          const SMDS_MeshNode * n56,
2147                                          const SMDS_MeshNode * n67,
2148                                          const SMDS_MeshNode * n78,
2149                                          const SMDS_MeshNode * n85,
2150                                          const SMDS_MeshNode * n15,
2151                                          const SMDS_MeshNode * n26,
2152                                          const SMDS_MeshNode * n37,
2153                                          const SMDS_MeshNode * n48,
2154                                          const SMDS_MeshNode * n1234,
2155                                          const SMDS_MeshNode * n1256,
2156                                          const SMDS_MeshNode * n2367,
2157                                          const SMDS_MeshNode * n3478,
2158                                          const SMDS_MeshNode * n1458,
2159                                          const SMDS_MeshNode * n5678,
2160                                          const SMDS_MeshNode * nCenter)
2161 {
2162   SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolume(n1,n2,n3,n4,n5,n6,n7,n8,
2163                                                  n12,n23,n34,n41,
2164                                                  n56,n67,n78,n85,
2165                                                  n15,n26,n37,n48,
2166                                                  n1234,n1256,n2367,n3478,n1458,n5678,nCenter);
2167   if(anElem)
2168     myScript->AddVolume(anElem->GetID(), n1->GetID(), n2->GetID(),
2169                         n3->GetID(), n4->GetID(), n5->GetID(),
2170                         n6->GetID(), n7->GetID(), n8->GetID(),
2171                         n12->GetID(), n23->GetID(), n34->GetID(), n41->GetID(),
2172                         n56->GetID(), n67->GetID(), n78->GetID(), n85->GetID(),
2173                         n15->GetID(), n26->GetID(), n37->GetID(), n48->GetID(),
2174                         n1234->GetID(),n1256->GetID(),n2367->GetID(),n3478->GetID(),
2175                         n1458->GetID(),n5678->GetID(),nCenter->GetID());
2176   return anElem;
2177 }
2178
2179 SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
2180                                                smIdType n5, smIdType n6, smIdType n7, smIdType n8,
2181                                                smIdType n12,smIdType n23,smIdType n34,smIdType n41,
2182                                                smIdType n56,smIdType n67,smIdType n78,smIdType n85,
2183                                                smIdType n15,smIdType n26,smIdType n37,smIdType n48,
2184                                                smIdType n1234,smIdType n1256,smIdType n2367,smIdType n3478,
2185                                                smIdType n1458,smIdType n5678,smIdType nCenter,
2186                                                smIdType ID)
2187 {
2188   SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolumeWithID(n1,n2,n3,n4,n5,n6,n7,n8,
2189                                                        n12,n23,n34,n41,
2190                                                        n56,n67,n78,n85,
2191                                                        n15,n26,n37,n48,
2192                                                        n1234, n1256, n2367, n3478,
2193                                                        n1458, n5678, nCenter,
2194                                                        ID);
2195   if(anElem) myScript->AddVolume(ID,n1,n2,n3,n4,n5,n6,n7,n8,n12,n23,n34,n41,
2196                                  n56,n67,n78,n85,n15,n26,n37,n48,
2197                                  n1234, n1256, n2367, n3478,
2198                                  n1458, n5678, nCenter);
2199   return anElem;
2200 }
2201
2202 SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
2203                                                const SMDS_MeshNode * n2,
2204                                                const SMDS_MeshNode * n3,
2205                                                const SMDS_MeshNode * n4,
2206                                                const SMDS_MeshNode * n5,
2207                                                const SMDS_MeshNode * n6,
2208                                                const SMDS_MeshNode * n7,
2209                                                const SMDS_MeshNode * n8,
2210                                                const SMDS_MeshNode * n12,
2211                                                const SMDS_MeshNode * n23,
2212                                                const SMDS_MeshNode * n34,
2213                                                const SMDS_MeshNode * n41,
2214                                                const SMDS_MeshNode * n56,
2215                                                const SMDS_MeshNode * n67,
2216                                                const SMDS_MeshNode * n78,
2217                                                const SMDS_MeshNode * n85,
2218                                                const SMDS_MeshNode * n15,
2219                                                const SMDS_MeshNode * n26,
2220                                                const SMDS_MeshNode * n37,
2221                                                const SMDS_MeshNode * n48,
2222                                                const SMDS_MeshNode * n1234,
2223                                                const SMDS_MeshNode * n1256,
2224                                                const SMDS_MeshNode * n2367,
2225                                                const SMDS_MeshNode * n3478,
2226                                                const SMDS_MeshNode * n1458,
2227                                                const SMDS_MeshNode * n5678,
2228                                                const SMDS_MeshNode * nCenter,
2229                                                smIdType ID)
2230 {
2231   return AddVolumeWithID(n1->GetID(), n2->GetID(), n3->GetID(), n4->GetID(),
2232                          n5->GetID(), n6->GetID(), n7->GetID(), n8->GetID(),
2233                          n12->GetID(), n23->GetID(), n34->GetID(), n41->GetID(),
2234                          n56->GetID(), n67->GetID(), n78->GetID(), n85->GetID(),
2235                          n15->GetID(), n26->GetID(), n37->GetID(), n48->GetID(),
2236                          n1234->GetID(),n1256->GetID(),n2367->GetID(),n3478->GetID(),
2237                          n1458->GetID(),n5678->GetID(),nCenter->GetID(), ID);
2238 }
2239
2240 void SMESHDS_Mesh::CompactMesh()
2241 {
2242   if ( IsCompacted() )
2243     return;
2244
2245   SMDS_Mesh::CompactMesh();
2246
2247   this->myScript->SetModified(true); // notify GUI client for buildPrs when update
2248 }
2249
2250 void SMESHDS_Mesh::CleanDownWardConnectivity()
2251 {
2252   myGrid->CleanDownwardConnectivity();
2253 }
2254
2255 void SMESHDS_Mesh::BuildDownWardConnectivity(bool withEdges)
2256 {
2257   myGrid->BuildDownwardConnectivity(withEdges);
2258 }
2259
2260 /*! change some nodes in cell without modifying type or internal connectivity.
2261  * Nodes inverse connectivity is maintained up to date.
2262  * @param vtkVolId vtk id of the cell.
2263  * @param localClonedNodeIds map old node id to new node id.
2264  * @return ok if success.
2265  */
2266 bool SMESHDS_Mesh::ModifyCellNodes(vtkIdType vtkVolId, std::map<int,int> localClonedNodeIds)
2267 {
2268   myGrid->ModifyCellNodes(vtkVolId, localClonedNodeIds);
2269   return true;
2270 }