Salome HOME
GetNode(int index) no longer wraps index, rather GetNodeWrap(int index) does
authoreap <eap@opencascade.com>
Wed, 20 May 2009 15:36:19 +0000 (15:36 +0000)
committereap <eap@opencascade.com>
Wed, 20 May 2009 15:36:19 +0000 (15:36 +0000)
18 files changed:
src/SMDS/SMDS_FaceOfEdges.cxx
src/SMDS/SMDS_FaceOfEdges.hxx
src/SMDS/SMDS_FaceOfNodes.cxx
src/SMDS/SMDS_FaceOfNodes.hxx
src/SMDS/SMDS_MeshEdge.cxx
src/SMDS/SMDS_MeshEdge.hxx
src/SMDS/SMDS_MeshElement.cxx
src/SMDS/SMDS_MeshNode.hxx
src/SMDS/SMDS_PolygonalFaceOfNodes.cxx
src/SMDS/SMDS_PolygonalFaceOfNodes.hxx
src/SMDS/SMDS_PolyhedralVolumeOfNodes.cxx
src/SMDS/SMDS_QuadraticFaceOfNodes.cxx
src/SMDS/SMDS_QuadraticFaceOfNodes.hxx
src/SMDS/SMDS_QuadraticVolumeOfNodes.cxx
src/SMDS/SMDS_QuadraticVolumeOfNodes.hxx
src/SMDS/SMDS_VolumeOfNodes.cxx
src/SMDS/SMDS_VolumeOfNodes.hxx
src/SMESH/SMESH_MeshEditor.cxx

index 5b5483022691d541dfaae7d2376a10021f62ca87..926b6a4465837043e5b1c808594c3528b475e2a0 100644 (file)
@@ -168,12 +168,10 @@ int SMDS_FaceOfEdges::NbNodes() const
  * \brief Return node by its index
  * \param ind - node index
  * \retval const SMDS_MeshNode* - the node
  * \brief Return node by its index
  * \param ind - node index
  * \retval const SMDS_MeshNode* - the node
- * 
- * Index is wrapped if it is out of a valid range
  */
 const SMDS_MeshNode* SMDS_FaceOfEdges::GetNode(const int ind) const
 {
  */
 const SMDS_MeshNode* SMDS_FaceOfEdges::GetNode(const int ind) const
 {
-  int index = WrappedIndex( ind );
+  int index = ind;
   for ( int i = 0; i < myNbEdges; ++i ) {
     if ( index >= myEdges[ i ]->NbNodes() )
       index -= myEdges[ i ]->NbNodes();
   for ( int i = 0; i < myNbEdges; ++i ) {
     if ( index >= myEdges[ i ]->NbNodes() )
       index -= myEdges[ i ]->NbNodes();
index 23659b85cd6326c5bb86e6db29e17fb24ef227af..27cfe59e4ceaea7c145d70a3dcb7fbdd94819320 100644 (file)
@@ -56,8 +56,6 @@ class SMDS_EXPORT SMDS_FaceOfEdges:public SMDS_MeshFace
    * \brief Return node by its index
     * \param ind - node index
     * \retval const SMDS_MeshNode* - the node
    * \brief Return node by its index
     * \param ind - node index
     * \retval const SMDS_MeshNode* - the node
-   * 
-   * Index is wrapped if it is out of a valid range
    */
   virtual const SMDS_MeshNode* GetNode(const int ind) const;
 
    */
   virtual const SMDS_MeshNode* GetNode(const int ind) const;
 
index 645e934ddf777bc3539ab332b57b2203f97aa04c..f6ef320cd6e11c884bf23e69d068dbaceefaad30 100644 (file)
@@ -95,7 +95,7 @@ public:
     myElems.reserve( face->NbNodes() );
     for ( int i = 0; i < face->NbNodes(); ++i ) {
       const SMDS_MeshElement* edge =
     myElems.reserve( face->NbNodes() );
     for ( int i = 0; i < face->NbNodes(); ++i ) {
       const SMDS_MeshElement* edge =
-        SMDS_Mesh::FindEdge( face->GetNode( i ), face->GetNode( i + 1 ));
+        SMDS_Mesh::FindEdge( face->GetNode( i ), face->GetNodeWrap( i + 1 ));
       if ( edge )
         myElems.push_back( edge );
     }
       if ( edge )
         myElems.push_back( edge );
     }
@@ -169,39 +169,8 @@ bool SMDS_FaceOfNodes::ChangeNodes(const SMDS_MeshNode* nodes[],
  * \brief Return node by its index
  * \param ind - node index
  * \retval const SMDS_MeshNode* - the node
  * \brief Return node by its index
  * \param ind - node index
  * \retval const SMDS_MeshNode* - the node
- * 
- * Index is wrapped if it is out of a valid range
  */
 const SMDS_MeshNode* SMDS_FaceOfNodes::GetNode(const int ind) const
 {
  */
 const SMDS_MeshNode* SMDS_FaceOfNodes::GetNode(const int ind) const
 {
-  return myNodes[ WrappedIndex( ind )];
+  return myNodes[ ind ];
 }
 }
-
-/*bool operator<(const SMDS_FaceOfNodes& f1, const SMDS_FaceOfNodes& f2)
-{
-       set<SMDS_MeshNode> set1,set2;
-       SMDS_ElemIteratorPtr it;
-       const SMDS_MeshNode * n;
-
-       it=f1.nodesIterator();
-
-       while(it->more())
-       {
-               n=static_cast<const SMDS_MeshNode *>(it->next());
-               set1.insert(*n);
-       }
-
-       delete it;
-       it=f2.nodesIterator();
-       
-       while(it->more())
-       {       
-               n=static_cast<const SMDS_MeshNode *>(it->next());
-               set2.insert(*n);
-       }
-
-       delete it;
-       return set1<set2;       
-
-}*/
-
index bf1fac24cc4c6f7c73f8b99a267775fde59609c5..018d5778aca687f58b33c0c590b504642ba5c6f8 100644 (file)
@@ -53,8 +53,6 @@ class SMDS_EXPORT SMDS_FaceOfNodes:public SMDS_MeshFace
    * \brief Return node by its index
     * \param ind - node index
     * \retval const SMDS_MeshNode* - the node
    * \brief Return node by its index
     * \param ind - node index
     * \retval const SMDS_MeshNode* - the node
-   * 
-   * Index is wrapped if it is out of a valid range
    */
   virtual const SMDS_MeshNode* GetNode(const int ind) const;
 
    */
   virtual const SMDS_MeshNode* GetNode(const int ind) const;
 
index 9d17cd439bd043c60d9dd89a88fdfcc21f419d72..924a6c2e714c0278321b6ecfd211105ea35887bb 100644 (file)
@@ -138,12 +138,10 @@ bool operator<(const SMDS_MeshEdge & e1, const SMDS_MeshEdge & e2)
  * \brief Return node by its index
  * \param ind - node index
  * \retval const SMDS_MeshNode* - the node
  * \brief Return node by its index
  * \param ind - node index
  * \retval const SMDS_MeshNode* - the node
- * 
- * Index is wrapped if it is out of a valid range
  */
 const SMDS_MeshNode* SMDS_MeshEdge::GetNode(const int ind) const
 {
  */
 const SMDS_MeshNode* SMDS_MeshEdge::GetNode(const int ind) const
 {
-  return myNodes[ WrappedIndex( ind )];
+  return myNodes[ ind ];
 }
 
 //=======================================================================
 }
 
 //=======================================================================
index b8a6c28ac67ef34511c5cb2b0a3aedb165f7bb19..84998e1294905e7a564603bf17e52f64092c272a 100644 (file)
@@ -50,8 +50,6 @@ class SMDS_EXPORT SMDS_MeshEdge:public SMDS_MeshElement
    * \brief Return node by its index
     * \param ind - node index
     * \retval const SMDS_MeshNode* - the node
    * \brief Return node by its index
     * \param ind - node index
     * \retval const SMDS_MeshNode* - the node
-   * 
-   * Index is wrapped if it is out of a valid range
    */
   virtual const SMDS_MeshNode* GetNode(const int ind) const;
 
    */
   virtual const SMDS_MeshNode* GetNode(const int ind) const;
 
index 646f92d10cf6de7901a1d3c1dabb7f067c8d6e9a..a24cbff94b6512aeed6dc066cbb171e3f0c5707d 100644 (file)
@@ -202,12 +202,13 @@ bool SMDS_MeshElement::IsValidIndex(const int ind) const
 
 const SMDS_MeshNode* SMDS_MeshElement::GetNode(const int ind) const
 {
 
 const SMDS_MeshNode* SMDS_MeshElement::GetNode(const int ind) const
 {
-  SMDS_ElemIteratorPtr it = nodesIterator();
-  int i = 0, index = WrappedIndex( ind );
-  while ( index != i++ )
-    it->next();
-  if ( it->more() )
-    return static_cast<const SMDS_MeshNode*> (it->next());
+  if ( ind >= 0 ) {
+    SMDS_ElemIteratorPtr it = nodesIterator();
+    for ( int i = 0; i < ind; ++i )
+      it->next();
+    if ( it->more() )
+      return static_cast<const SMDS_MeshNode*> (it->next());
+  }
   return 0;
 }
 
   return 0;
 }
 
index 69b937034aa76ac1ae905996e78bb8fe1238c38f..2ee85d5db6fae724d92764664b238b2f99b1773c 100644 (file)
@@ -58,8 +58,6 @@ class SMDS_EXPORT SMDS_MeshNode:public SMDS_MeshElement
    * \brief Return node by its index
     * \param ind - node index
     * \retval const SMDS_MeshNode* - the node
    * \brief Return node by its index
     * \param ind - node index
     * \retval const SMDS_MeshNode* - the node
-   * 
-   * Index is wrapped if it is out of a valid range
    */
   virtual const SMDS_MeshNode* GetNode(const int) const { return this; }
 
    */
   virtual const SMDS_MeshNode* GetNode(const int) const { return this; }
 
index 282256c7fb4d064508e0260dfd25cd245a9c56d1..96b7e261c47fae8372210ad944735bb6877a2ad1 100644 (file)
@@ -154,7 +154,7 @@ public:
     myElems.reserve( face->NbNodes() );
     for ( int i = 0; i < face->NbNodes(); ++i ) {
       const SMDS_MeshElement* edge =
     myElems.reserve( face->NbNodes() );
     for ( int i = 0; i < face->NbNodes(); ++i ) {
       const SMDS_MeshElement* edge =
-        SMDS_Mesh::FindEdge( face->GetNode( i ), face->GetNode( i + 1 ));
+        SMDS_Mesh::FindEdge( face->GetNode( i ), face->GetNodeWrap( i + 1 ));
       if ( edge )
         myElems.push_back( edge );
     }
       if ( edge )
         myElems.push_back( edge );
     }
@@ -191,8 +191,6 @@ SMDS_ElemIteratorPtr SMDS_PolygonalFaceOfNodes::elementsIterator
  * \brief Return node by its index
  * \param ind - node index
  * \retval const SMDS_MeshNode* - the node
  * \brief Return node by its index
  * \param ind - node index
  * \retval const SMDS_MeshNode* - the node
- * 
- * Index is wrapped if it is out of a valid range
  */
 const SMDS_MeshNode* SMDS_PolygonalFaceOfNodes::GetNode(const int ind) const
 {
  */
 const SMDS_MeshNode* SMDS_PolygonalFaceOfNodes::GetNode(const int ind) const
 {
index 3c9f9a50832d3f77f011c24641e9a20f6a209320..71b083a3fdd8a2a8a2717e6e9937ebd2211402cd 100644 (file)
@@ -58,8 +58,6 @@ class SMDS_EXPORT SMDS_PolygonalFaceOfNodes:public SMDS_MeshFace
    * \brief Return node by its index
     * \param ind - node index
     * \retval const SMDS_MeshNode* - the node
    * \brief Return node by its index
     * \param ind - node index
     * \retval const SMDS_MeshNode* - the node
-   * 
-   * Index is wrapped if it is out of a valid range
    */
   virtual const SMDS_MeshNode* GetNode(const int ind) const;
 
    */
   virtual const SMDS_MeshNode* GetNode(const int ind) const;
 
index 4b20720f6be27552ca927a27b6f579962d2f794b..ce8ace8300e9efde4316b00c9d1aab9c067b264f 100644 (file)
@@ -259,5 +259,5 @@ SMDS_ElemIteratorPtr SMDS_PolyhedralVolumeOfNodes::uniqueNodesIterator() const
 
 const SMDS_MeshNode* SMDS_PolyhedralVolumeOfNodes::GetNode(const int ind) const
 {
 
 const SMDS_MeshNode* SMDS_PolyhedralVolumeOfNodes::GetNode(const int ind) const
 {
-  return myNodesByFaces[ WrappedIndex( ind )];
+  return myNodesByFaces[ ind ];
 }
 }
index b981bd92f68be7168097e340fda17f730aaf9a21..472759fb9579b31beebb211486ca51b71fc824ab 100644 (file)
@@ -255,7 +255,7 @@ public:
   _MyEdgeIterator(const SMDS_QuadraticFaceOfNodes* face):myIndex(0) {
     myElems.reserve( face->NbNodes() );
     SMDS_ElemIteratorPtr nIt = face->interlacedNodesElemIterator();
   _MyEdgeIterator(const SMDS_QuadraticFaceOfNodes* face):myIndex(0) {
     myElems.reserve( face->NbNodes() );
     SMDS_ElemIteratorPtr nIt = face->interlacedNodesElemIterator();
-    const SMDS_MeshNode* n0 = face->GetNode( -1 );
+    const SMDS_MeshNode* n0 = face->GetNodeWrap( -1 );
     while ( nIt->more() ) {
       const SMDS_MeshNode* n1 = static_cast<const SMDS_MeshNode*>( nIt->next() );
       const SMDS_MeshElement* edge = SMDS_Mesh::FindEdge( n0, n1 );
     while ( nIt->more() ) {
       const SMDS_MeshNode* n1 = static_cast<const SMDS_MeshNode*>( nIt->next() );
       const SMDS_MeshElement* edge = SMDS_Mesh::FindEdge( n0, n1 );
@@ -300,11 +300,9 @@ SMDS_ElemIteratorPtr SMDS_QuadraticFaceOfNodes::elementsIterator
  * \brief Return node by its index
  * \param ind - node index
  * \retval const SMDS_MeshNode* - the node
  * \brief Return node by its index
  * \param ind - node index
  * \retval const SMDS_MeshNode* - the node
- * 
- * Index is wrapped if it is out of a valid range
  */
 const SMDS_MeshNode* SMDS_QuadraticFaceOfNodes::GetNode(const int ind) const
 {
  */
 const SMDS_MeshNode* SMDS_QuadraticFaceOfNodes::GetNode(const int ind) const
 {
-  return myNodes[ WrappedIndex( ind )];
+  return myNodes[ ind ];
 }
 
 }
 
index f4284918adbb68efb6deae5ad2921bb0983c6119..58c709f2255a3fb83844b6dfd5eb76e47ec635b3 100644 (file)
@@ -70,8 +70,6 @@ public:
    * \brief Return node by its index
     * \param ind - node index
     * \retval const SMDS_MeshNode* - the node
    * \brief Return node by its index
     * \param ind - node index
     * \retval const SMDS_MeshNode* - the node
-   * 
-   * Index is wrapped if it is out of a valid range
    */
   virtual const SMDS_MeshNode* GetNode(const int ind) const;
 
    */
   virtual const SMDS_MeshNode* GetNode(const int ind) const;
 
index 4a0ae2e7e4cbb8cbfe5570a328d87eaefac5464c..2225bdcda846bfa049183040295420fbab98c600 100644 (file)
@@ -362,11 +362,9 @@ SMDS_ElemIteratorPtr SMDS_QuadraticVolumeOfNodes::elementsIterator
  * \brief Return node by its index
  * \param ind - node index
  * \retval const SMDS_MeshNode* - the node
  * \brief Return node by its index
  * \param ind - node index
  * \retval const SMDS_MeshNode* - the node
- * 
- * Index is wrapped if it is out of a valid range
  */
 const SMDS_MeshNode* SMDS_QuadraticVolumeOfNodes::GetNode(const int ind) const
 {
  */
 const SMDS_MeshNode* SMDS_QuadraticVolumeOfNodes::GetNode(const int ind) const
 {
-  return myNodes[ WrappedIndex( ind )];
+  return myNodes[ ind ];
 }
 
 }
 
index 34ce542a6d967154d407b7457a6d0247af8fc458..3a004f4481f057edaa3c29083eeeab92511530cc 100644 (file)
@@ -116,8 +116,6 @@ public:
    * \brief Return node by its index
     * \param ind - node index
     * \retval const SMDS_MeshNode* - the node
    * \brief Return node by its index
     * \param ind - node index
     * \retval const SMDS_MeshNode* - the node
-   * 
-   * Index is wrapped if it is out of a valid range
    */
   virtual const SMDS_MeshNode* GetNode(const int ind) const;
 
    */
   virtual const SMDS_MeshNode* GetNode(const int ind) const;
 
index ff46fc318ab25cfd98512f9f25436a9052a9455b..eb5101e7a96ca1322b38cbaa2e4fb80c35462a37 100644 (file)
@@ -141,7 +141,7 @@ void SMDS_VolumeOfNodes::Print(ostream & OS) const
 {
        OS << "volume <" << GetID() << "> : ";
        int i;
 {
        OS << "volume <" << GetID() << "> : ";
        int i;
-       for (i = 0; i < NbNodes(); ++i) OS << myNodes[i] << ",";
+       for (i = 0; i < NbNodes()-1; ++i) OS << myNodes[i] << ",";
        OS << myNodes[NbNodes()-1]<< ") " << endl;
 }
 
        OS << myNodes[NbNodes()-1]<< ") " << endl;
 }
 
@@ -241,10 +241,8 @@ SMDSAbs_ElementType SMDS_VolumeOfNodes::GetType() const
  * \brief Return node by its index
  * \param ind - node index
  * \retval const SMDS_MeshNode* - the node
  * \brief Return node by its index
  * \param ind - node index
  * \retval const SMDS_MeshNode* - the node
- * 
- * Index is wrapped if it is out of a valid range
  */
 const SMDS_MeshNode* SMDS_VolumeOfNodes::GetNode(const int ind) const
 {
  */
 const SMDS_MeshNode* SMDS_VolumeOfNodes::GetNode(const int ind) const
 {
-  return myNodes[ WrappedIndex( ind )];
+  return myNodes[ ind ];
 }
 }
index ee773285b39f4d4a6e6943ed43f4b54d739d8e68..7f35af2a4defd6e65baec57f75aa3f9f0f5b0683 100644 (file)
@@ -75,8 +75,6 @@ class SMDS_EXPORT SMDS_VolumeOfNodes:public SMDS_MeshVolume
    * \brief Return node by its index
     * \param ind - node index
     * \retval const SMDS_MeshNode* - the node
    * \brief Return node by its index
     * \param ind - node index
     * \retval const SMDS_MeshNode* - the node
-   * 
-   * Index is wrapped if it is out of a valid range
    */
   virtual const SMDS_MeshNode* GetNode(const int ind) const;
 
    */
   virtual const SMDS_MeshNode* GetNode(const int ind) const;
 
index c8c0f069326ebc18b76c4078250fe37ecacf75b3..18ae0388b20c898913514875fcc332dce835a042 100644 (file)
@@ -90,22 +90,6 @@ struct TNodeXYZ : public gp_XYZ {
   TNodeXYZ( const SMDS_MeshNode* n ):gp_XYZ( n->X(), n->Y(), n->Z() ) {}
 };
 
   TNodeXYZ( const SMDS_MeshNode* n ):gp_XYZ( n->X(), n->Y(), n->Z() ) {}
 };
 
-typedef pair< const SMDS_MeshNode*, const SMDS_MeshNode* > NLink;
-
-//=======================================================================
-/*!
- * \brief A sorted pair of nodes
- */
-//=======================================================================
-
-struct TLink: public NLink
-{
-  TLink(const SMDS_MeshNode* n1, const SMDS_MeshNode* n2 ):NLink( n1, n2 )
-  { if ( n1->GetID() < n2->GetID() ) std::swap( first, second ); }
-  TLink(const NLink& link ):NLink( link )
-  { if ( first->GetID() < second->GetID() ) std::swap( first, second ); }
-};
-
 //=======================================================================
 //function : SMESH_MeshEditor
 //purpose  :
 //=======================================================================
 //function : SMESH_MeshEditor
 //purpose  :
@@ -1479,10 +1463,10 @@ bool SMESH_MeshEditor::TriToQuad (TIDSortedElemSet &                   theElems,
   // 1. map of elements with their linkIDs
   // 2. map of linkIDs with their elements
 
   // 1. map of elements with their linkIDs
   // 2. map of linkIDs with their elements
 
-  map< TLink, list< const SMDS_MeshElement* > > mapLi_listEl;
-  map< TLink, list< const SMDS_MeshElement* > >::iterator itLE;
-  map< const SMDS_MeshElement*, set< TLink > >  mapEl_setLi;
-  map< const SMDS_MeshElement*, set< TLink > >::iterator itEL;
+  map< SMESH_TLink, list< const SMDS_MeshElement* > > mapLi_listEl;
+  map< SMESH_TLink, list< const SMDS_MeshElement* > >::iterator itLE;
+  map< const SMDS_MeshElement*, set< SMESH_TLink > >  mapEl_setLi;
+  map< const SMDS_MeshElement*, set< SMESH_TLink > >::iterator itEL;
 
   TIDSortedElemSet::iterator itElem;
   for ( itElem = theElems.begin(); itElem != theElems.end(); itElem++ ) {
 
   TIDSortedElemSet::iterator itElem;
   for ( itElem = theElems.begin(); itElem != theElems.end(); itElem++ ) {
@@ -1501,7 +1485,7 @@ bool SMESH_MeshEditor::TriToQuad (TIDSortedElemSet &                   theElems,
 
     // fill maps
     for ( i = 0; i < 3; i++ ) {
 
     // fill maps
     for ( i = 0; i < 3; i++ ) {
-      TLink link( aNodes[i], aNodes[i+1] );
+      SMESH_TLink link( aNodes[i], aNodes[i+1] );
       // check if elements sharing a link can be fused
       itLE = mapLi_listEl.find( link );
       if ( itLE != mapLi_listEl.end() ) {
       // check if elements sharing a link can be fused
       itLE = mapLi_listEl.find( link );
       if ( itLE != mapLi_listEl.end() ) {
@@ -1527,7 +1511,7 @@ bool SMESH_MeshEditor::TriToQuad (TIDSortedElemSet &                   theElems,
     int nbElems = (*itLE).second.size();
     if ( nbElems < 2  ) {
       const SMDS_MeshElement* elem = (*itLE).second.front();
     int nbElems = (*itLE).second.size();
     if ( nbElems < 2  ) {
       const SMDS_MeshElement* elem = (*itLE).second.front();
-      TLink link = (*itLE).first;
+      SMESH_TLink link = (*itLE).first;
       mapEl_setLi[ elem ].erase( link );
       if ( mapEl_setLi[ elem ].empty() )
         mapEl_setLi.erase( elem );
       mapEl_setLi[ elem ].erase( link );
       if ( mapEl_setLi[ elem ].empty() )
         mapEl_setLi.erase( elem );
@@ -1553,11 +1537,11 @@ bool SMESH_MeshEditor::TriToQuad (TIDSortedElemSet &                   theElems,
 
     // search elements to fuse starting from startElem or links of elements
     // fused earlyer - startLinks
 
     // search elements to fuse starting from startElem or links of elements
     // fused earlyer - startLinks
-    list< TLink > startLinks;
+    list< SMESH_TLink > startLinks;
     while ( startElem || !startLinks.empty() ) {
       while ( !startElem && !startLinks.empty() ) {
         // Get an element to start, by a link
     while ( startElem || !startLinks.empty() ) {
       while ( !startElem && !startLinks.empty() ) {
         // Get an element to start, by a link
-        TLink linkId = startLinks.front();
+        SMESH_TLink linkId = startLinks.front();
         startLinks.pop_front();
         itLE = mapLi_listEl.find( linkId );
         if ( itLE != mapLi_listEl.end() ) {
         startLinks.pop_front();
         itLE = mapLi_listEl.find( linkId );
         if ( itLE != mapLi_listEl.end() ) {
@@ -1573,15 +1557,15 @@ bool SMESH_MeshEditor::TriToQuad (TIDSortedElemSet &                   theElems,
       if ( startElem ) {
         // Get candidates to be fused
         const SMDS_MeshElement *tr1 = startElem, *tr2 = 0, *tr3 = 0;
       if ( startElem ) {
         // Get candidates to be fused
         const SMDS_MeshElement *tr1 = startElem, *tr2 = 0, *tr3 = 0;
-        const TLink *link12, *link13;
+        const SMESH_TLink *link12, *link13;
         startElem = 0;
         ASSERT( mapEl_setLi.find( tr1 ) != mapEl_setLi.end() );
         startElem = 0;
         ASSERT( mapEl_setLi.find( tr1 ) != mapEl_setLi.end() );
-        set< TLink >& setLi = mapEl_setLi[ tr1 ];
+        set< SMESH_TLink >& setLi = mapEl_setLi[ tr1 ];
         ASSERT( !setLi.empty() );
         ASSERT( !setLi.empty() );
-        set< TLink >::iterator itLi;
+        set< SMESH_TLink >::iterator itLi;
         for ( itLi = setLi.begin(); itLi != setLi.end(); itLi++ )
         {
         for ( itLi = setLi.begin(); itLi != setLi.end(); itLi++ )
         {
-          const TLink & link = (*itLi);
+          const SMESH_TLink & link = (*itLi);
           itLE = mapLi_listEl.find( link );
           if ( itLE == mapLi_listEl.end() )
             continue;
           itLE = mapLi_listEl.find( link );
           if ( itLE == mapLi_listEl.end() )
             continue;
@@ -1602,10 +1586,10 @@ bool SMESH_MeshEditor::TriToQuad (TIDSortedElemSet &                   theElems,
           }
 
           // add other links of elem to list of links to re-start from
           }
 
           // add other links of elem to list of links to re-start from
-          set< TLink >& links = mapEl_setLi[ elem ];
-          set< TLink >::iterator it;
+          set< SMESH_TLink >& links = mapEl_setLi[ elem ];
+          set< SMESH_TLink >::iterator it;
           for ( it = links.begin(); it != links.end(); it++ ) {
           for ( it = links.begin(); it != links.end(); it++ ) {
-            const TLink& link2 = (*it);
+            const SMESH_TLink& link2 = (*it);
             if ( link2 != link )
               startLinks.push_back( link2 );
           }
             if ( link2 != link )
               startLinks.push_back( link2 );
           }
@@ -2066,8 +2050,8 @@ void SMESH_MeshEditor::GetLinkedNodes( const SMDS_MeshNode* theNode,
             iAfter  = SMESH_MesherHelper::WrapIndex( iAfter, nb );
             iBefore = SMESH_MesherHelper::WrapIndex( iBefore, nb );
           }
             iAfter  = SMESH_MesherHelper::WrapIndex( iAfter, nb );
             iBefore = SMESH_MesherHelper::WrapIndex( iBefore, nb );
           }
-          linkedNodes.insert( elem->GetNode( iAfter ));
-          linkedNodes.insert( elem->GetNode( iBefore ));
+          linkedNodes.insert( elem->GetNodeWrap( iAfter ));
+          linkedNodes.insert( elem->GetNodeWrap( iBefore ));
         }
       }
     }
         }
       }
     }
@@ -2462,9 +2446,8 @@ void SMESH_MeshEditor::Smooth (TIDSortedElemSet &          theElems,
     // fix nodes on mesh boundary
 
     if ( checkBoundaryNodes ) {
     // fix nodes on mesh boundary
 
     if ( checkBoundaryNodes ) {
-      typedef pair<const SMDS_MeshNode*, const SMDS_MeshNode*> TLink;
-      map< TLink, int > linkNbMap; // how many times a link encounters in elemsOnFace
-      map< TLink, int >::iterator link_nb;
+      map< NLink, int > linkNbMap; // how many times a link encounters in elemsOnFace
+      map< NLink, int >::iterator link_nb;
       // put all elements links to linkNbMap
       list< const SMDS_MeshElement* >::iterator elemIt = elemsOnFace.begin();
       for ( ; elemIt != elemsOnFace.end(); ++elemIt ) {
       // put all elements links to linkNbMap
       list< const SMDS_MeshElement* >::iterator elemIt = elemsOnFace.begin();
       for ( ; elemIt != elemsOnFace.end(); ++elemIt ) {
@@ -2473,10 +2456,10 @@ void SMESH_MeshEditor::Smooth (TIDSortedElemSet &          theElems,
         if(elem->IsQuadratic())
           nbn = nbn/2;
         // loop on elem links: insert them in linkNbMap
         if(elem->IsQuadratic())
           nbn = nbn/2;
         // loop on elem links: insert them in linkNbMap
-        const SMDS_MeshNode* curNode, *prevNode = elem->GetNode( nbn );
+        const SMDS_MeshNode* curNode, *prevNode = elem->GetNodeWrap( nbn );
         for ( int iN = 0; iN < nbn; ++iN ) {
           curNode = elem->GetNode( iN );
         for ( int iN = 0; iN < nbn; ++iN ) {
           curNode = elem->GetNode( iN );
-          TLink link;
+          NLink link;
           if ( curNode < prevNode ) link = make_pair( curNode , prevNode );
           else                      link = make_pair( prevNode , curNode );
           prevNode = curNode;
           if ( curNode < prevNode ) link = make_pair( curNode , prevNode );
           else                      link = make_pair( prevNode , curNode );
           prevNode = curNode;
@@ -2791,8 +2774,6 @@ void SMESH_MeshEditor::sweepElement(const SMDS_MeshElement*               elem,
 
   int iNode, nbSame = 0, iNotSameNode = 0, iSameNode = 0;
   vector<int> sames(nbNodes);
 
   int iNode, nbSame = 0, iNotSameNode = 0, iSameNode = 0;
   vector<int> sames(nbNodes);
-
-  //bool issimple[nbNodes];
   vector<bool> issimple(nbNodes);
 
   for ( iNode = 0; iNode < nbNodes; iNode++ ) {
   vector<bool> issimple(nbNodes);
 
   for ( iNode = 0; iNode < nbNodes; iNode++ ) {
@@ -2802,12 +2783,7 @@ void SMESH_MeshEditor::sweepElement(const SMDS_MeshElement*               elem,
     if ( listNewNodes.empty() )
       return;
 
     if ( listNewNodes.empty() )
       return;
 
-    if(listNewNodes.size()==nbSteps) {
-      issimple[iNode] = true;
-    }
-    else {
-      issimple[iNode] = false;
-    }
+    issimple[iNode] = (listNewNodes.size()==nbSteps);
 
     itNN[ iNode ] = listNewNodes.begin();
     prevNod[ iNode ] = node;
 
     itNN[ iNode ] = listNewNodes.begin();
     prevNod[ iNode ] = node;
@@ -2852,11 +2828,8 @@ void SMESH_MeshEditor::sweepElement(const SMDS_MeshElement*               elem,
     //MESSAGE("Reversed elem " << elem );
     i0 = 2;
     i2 = 0;
     //MESSAGE("Reversed elem " << elem );
     i0 = 2;
     i2 = 0;
-    if ( nbSame > 0 ) {
-      int iAB = iAfterSame + iBeforeSame;
-      iBeforeSame = iAB - iBeforeSame;
-      iAfterSame  = iAB - iAfterSame;
-    }
+    if ( nbSame > 0 )
+      std::swap( iBeforeSame, iAfterSame );
   }
 
   // make new elements
   }
 
   // make new elements
@@ -2875,8 +2848,7 @@ void SMESH_MeshEditor::sweepElement(const SMDS_MeshElement*               elem,
           nextNod[ iNode ] = *itNN[ iNode ];
           itNN[ iNode ]++;
         }
           nextNod[ iNode ] = *itNN[ iNode ];
           itNN[ iNode ]++;
         }
-        else if(!elem->IsQuadratic() ||
-           elem->IsQuadratic() && elem->IsMediumNode(prevNod[iNode]) ) {
+        else if(!elem->IsQuadratic() || elem->IsMediumNode(prevNod[iNode]) ) {
           // we have to use each second node
           itNN[ iNode ]++;
           nextNod[ iNode ] = *itNN[ iNode ];
           // we have to use each second node
           itNN[ iNode ]++;
           nextNod[ iNode ] = *itNN[ iNode ];
@@ -3304,7 +3276,7 @@ void SMESH_MeshEditor::makeWalls (TNodeOfNodeListMap &     mapNewNodes,
               const SMDS_MeshFace * f = aMesh->FindFace( nodes[ 0 ], nodes[ 1 ], nodes[ 2 ]);
               if ( !f )
                 myLastCreatedElems.Append(aMesh->AddFace( nodes[ 0 ], nodes[ 1 ], nodes[ 2 ] ));
               const SMDS_MeshFace * f = aMesh->FindFace( nodes[ 0 ], nodes[ 1 ], nodes[ 2 ]);
               if ( !f )
                 myLastCreatedElems.Append(aMesh->AddFace( nodes[ 0 ], nodes[ 1 ], nodes[ 2 ] ));
-              else if ( nodes[ 1 ] != f->GetNode( f->GetNodeIndex( nodes[ 0 ] ) + 1 ))
+              else if ( nodes[ 1 ] != f->GetNodeWrap( f->GetNodeIndex( nodes[ 0 ] ) + 1 ))
                 aMesh->ChangeElementNodes( f, nodes, nbn );
               break;
             }
                 aMesh->ChangeElementNodes( f, nodes, nbn );
               break;
             }
@@ -3312,7 +3284,7 @@ void SMESH_MeshEditor::makeWalls (TNodeOfNodeListMap &     mapNewNodes,
               const SMDS_MeshFace * f = aMesh->FindFace( nodes[ 0 ], nodes[ 1 ], nodes[ 2 ], nodes[ 3 ]);
               if ( !f )
                 myLastCreatedElems.Append(aMesh->AddFace( nodes[ 0 ], nodes[ 1 ], nodes[ 2 ], nodes[ 3 ] ));
               const SMDS_MeshFace * f = aMesh->FindFace( nodes[ 0 ], nodes[ 1 ], nodes[ 2 ], nodes[ 3 ]);
               if ( !f )
                 myLastCreatedElems.Append(aMesh->AddFace( nodes[ 0 ], nodes[ 1 ], nodes[ 2 ], nodes[ 3 ] ));
-              else if ( nodes[ 1 ] != f->GetNode( f->GetNodeIndex( nodes[ 0 ] ) + 1 ))
+              else if ( nodes[ 1 ] != f->GetNodeWrap( f->GetNodeIndex( nodes[ 0 ] ) + 1 ))
                 aMesh->ChangeElementNodes( f, nodes, nbn );
               break;
             }
                 aMesh->ChangeElementNodes( f, nodes, nbn );
               break;
             }
@@ -3324,7 +3296,7 @@ void SMESH_MeshEditor::makeWalls (TNodeOfNodeListMap &     mapNewNodes,
                   if ( !f )
                     myLastCreatedElems.Append(aMesh->AddFace(nodes[0], nodes[2], nodes[4],
                                                              nodes[1], nodes[3], nodes[5]));
                   if ( !f )
                     myLastCreatedElems.Append(aMesh->AddFace(nodes[0], nodes[2], nodes[4],
                                                              nodes[1], nodes[3], nodes[5]));
-                  else if ( nodes[ 2 ] != f->GetNode( f->GetNodeIndex( nodes[ 0 ] ) + 1 ))
+                  else if ( nodes[ 2 ] != f->GetNodeWrap( f->GetNodeIndex( nodes[ 0 ] ) + 1 ))
                     aMesh->ChangeElementNodes( f, nodes, nbn );
                 }
                 else {       /////// quadratic quadrangle
                     aMesh->ChangeElementNodes( f, nodes, nbn );
                 }
                 else {       /////// quadratic quadrangle
@@ -3333,7 +3305,7 @@ void SMESH_MeshEditor::makeWalls (TNodeOfNodeListMap &     mapNewNodes,
                   if ( !f )
                     myLastCreatedElems.Append(aMesh->AddFace(nodes[0], nodes[2], nodes[4], nodes[6],
                                                              nodes[1], nodes[3], nodes[5], nodes[7]));
                   if ( !f )
                     myLastCreatedElems.Append(aMesh->AddFace(nodes[0], nodes[2], nodes[4], nodes[6],
                                                              nodes[1], nodes[3], nodes[5], nodes[7]));
-                  else if ( nodes[ 2 ] != f->GetNode( f->GetNodeIndex( nodes[ 0 ] ) + 1 ))
+                  else if ( nodes[ 2 ] != f->GetNodeWrap( f->GetNodeIndex( nodes[ 0 ] ) + 1 ))
                     aMesh->ChangeElementNodes( f, nodes, nbn );
                 }
               }
                     aMesh->ChangeElementNodes( f, nodes, nbn );
                 }
               }
@@ -3342,7 +3314,7 @@ void SMESH_MeshEditor::makeWalls (TNodeOfNodeListMap &     mapNewNodes,
                 const SMDS_MeshFace * f = aMesh->FindFace( polygon_nodes );
                 if ( !f )
                   myLastCreatedElems.Append(aMesh->AddPolygonalFace(polygon_nodes));
                 const SMDS_MeshFace * f = aMesh->FindFace( polygon_nodes );
                 if ( !f )
                   myLastCreatedElems.Append(aMesh->AddPolygonalFace(polygon_nodes));
-                else if ( nodes[ 1 ] != f->GetNode( f->GetNodeIndex( nodes[ 0 ] ) + 1 ))
+                else if ( nodes[ 1 ] != f->GetNodeWrap( f->GetNodeIndex( nodes[ 0 ] ) + 1 ))
                   aMesh->ChangeElementNodes( f, nodes, nbn );
               }
             }
                   aMesh->ChangeElementNodes( f, nodes, nbn );
               }
             }
@@ -7547,7 +7519,6 @@ SMESH_MeshEditor::Sew_Error
 
 #ifdef _DEBUG_
 //#define DEBUG_MATCHING_NODES
 
 #ifdef _DEBUG_
 //#define DEBUG_MATCHING_NODES
-//#define MESSAGE(m) {cout<<m<<endl;}
 #endif
 
 SMESH_MeshEditor::Sew_Error
 #endif
 
 SMESH_MeshEditor::Sew_Error
@@ -7567,8 +7538,8 @@ SMESH_MeshEditor::FindMatchingNodes(set<const SMDS_MeshElement*>& theSide1,
   if ( theSecondNode1 != theSecondNode2 )
     nReplaceMap.insert( make_pair( theSecondNode1, theSecondNode2 ));
 
   if ( theSecondNode1 != theSecondNode2 )
     nReplaceMap.insert( make_pair( theSecondNode1, theSecondNode2 ));
 
-  set< TLink > linkSet; // set of nodes where order of nodes is ignored
-  linkSet.insert( TLink( theFirstNode1, theSecondNode1 ));
+  set< SMESH_TLink > linkSet; // set of nodes where order of nodes is ignored
+  linkSet.insert( SMESH_TLink( theFirstNode1, theSecondNode1 ));
 
   list< NLink > linkList[2];
   linkList[0].push_back( NLink( theFirstNode1, theSecondNode1 ));
 
   list< NLink > linkList[2];
   linkList[0].push_back( NLink( theFirstNode1, theSecondNode1 ));
@@ -7683,8 +7654,8 @@ SMESH_MeshEditor::FindMatchingNodes(set<const SMDS_MeshElement*>& theSide1,
       for ( int i = 0; i < nbN; i++ )
       {
         const SMDS_MeshNode* n2 = f0->GetNode( i );
       for ( int i = 0; i < nbN; i++ )
       {
         const SMDS_MeshNode* n2 = f0->GetNode( i );
-        pair< set< TLink >::iterator, bool > iter_isnew =
-          linkSet.insert( TLink( n1, n2 ));
+        pair< set< SMESH_TLink >::iterator, bool > iter_isnew =
+          linkSet.insert( SMESH_TLink( n1, n2 ));
         if ( !iter_isnew.second ) { // already in a set: no need to process
           linkSet.erase( iter_isnew.first );
         }
         if ( !iter_isnew.second ) { // already in a set: no need to process
           linkSet.erase( iter_isnew.first );
         }
@@ -7704,3 +7675,92 @@ SMESH_MeshEditor::FindMatchingNodes(set<const SMDS_MeshElement*>& theSide1,
 
   return SEW_OK;
 }
 
   return SEW_OK;
 }
+
+/*!
+  \brief Creates a hole in a mesh by doubling the nodes of some particular elements
+  \param theNodes - identifiers of nodes to be doubled
+  \param theModifiedElems - identifiers of elements to be updated by the new (doubled) 
+         nodes. If list of element identifiers is empty then nodes are doubled but 
+         they not assigned to elements
+  \return TRUE if operation has been completed successfully, FALSE otherwise
+*/
+bool SMESH_MeshEditor::DoubleNodes( const std::list< int >& theListOfNodes, 
+                                    const std::list< int >& theListOfModifiedElems )
+{
+  myLastCreatedElems.Clear();
+  myLastCreatedNodes.Clear();
+
+  if ( theListOfNodes.size() == 0 )
+    return false;
+
+  SMESHDS_Mesh* aMeshDS = GetMeshDS();
+  if ( !aMeshDS )
+    return false;
+
+  // iterate through nodes and duplicate them
+
+  std::map< const SMDS_MeshNode*, const SMDS_MeshNode* > anOldNodeToNewNode;
+
+  std::list< int >::const_iterator aNodeIter;
+  for ( aNodeIter = theListOfNodes.begin(); aNodeIter != theListOfNodes.end(); ++aNodeIter )
+  {
+    int aCurr = *aNodeIter;
+    SMDS_MeshNode* aNode = (SMDS_MeshNode*)aMeshDS->FindNode( aCurr );
+    if ( !aNode )
+      continue;
+
+    // duplicate node
+
+    const SMDS_MeshNode* aNewNode = aMeshDS->AddNode( aNode->X(), aNode->Y(), aNode->Z() );
+    if ( aNewNode )
+    {
+      anOldNodeToNewNode[ aNode ] = aNewNode;
+      myLastCreatedNodes.Append( aNewNode );
+    }
+  }
+
+  // Create map of new nodes for modified elements
+
+  std::map< SMDS_MeshElement*, vector<const SMDS_MeshNode*> > anElemToNodes;
+
+  std::list< int >::const_iterator anElemIter;
+  for ( anElemIter = theListOfModifiedElems.begin(); 
+        anElemIter != theListOfModifiedElems.end(); ++anElemIter )
+  {
+    int aCurr = *anElemIter;
+    SMDS_MeshElement* anElem = (SMDS_MeshElement*)aMeshDS->FindElement( aCurr );
+    if ( !anElem )
+      continue;
+
+    vector<const SMDS_MeshNode*> aNodeArr( anElem->NbNodes() );
+
+    SMDS_ElemIteratorPtr anIter = anElem->nodesIterator();
+    int ind = 0;
+    while ( anIter->more() ) 
+    { 
+      SMDS_MeshNode* aCurrNode = (SMDS_MeshNode*)anIter->next();
+      if ( aCurr && anOldNodeToNewNode.find( aCurrNode ) != anOldNodeToNewNode.end() )
+      {
+        const SMDS_MeshNode* aNewNode = anOldNodeToNewNode[ aCurrNode ];
+        aNodeArr[ ind++ ] = aNewNode;
+      }
+      else
+        aNodeArr[ ind++ ] = aCurrNode;
+    }
+    anElemToNodes[ anElem ] = aNodeArr;
+  }
+
+  // Change nodes of elements  
+
+  std::map< SMDS_MeshElement*, vector<const SMDS_MeshNode*> >::iterator
+    anElemToNodesIter = anElemToNodes.begin();
+  for ( ; anElemToNodesIter != anElemToNodes.end(); ++anElemToNodesIter )
+  {
+    const SMDS_MeshElement* anElem = anElemToNodesIter->first;
+    vector<const SMDS_MeshNode*> aNodeArr = anElemToNodesIter->second;
+    if ( anElem )
+      aMeshDS->ChangeElementNodes( anElem, &aNodeArr[ 0 ], anElem->NbNodes() );
+  }
+
+  return true;
+}