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