]> SALOME platform Git repositories - modules/smesh.git/commitdiff
Salome HOME
untabify
authoreap <eap@opencascade.com>
Wed, 9 Sep 2009 06:17:26 +0000 (06:17 +0000)
committereap <eap@opencascade.com>
Wed, 9 Sep 2009 06:17:26 +0000 (06:17 +0000)
src/SMESH/SMESH_MeshEditor.cxx

index 752bab7fe3dd1146a17432fb9c161413712d9f06..d347a715772ede510fd4b89723c90ab1c3e3ab7b 100644 (file)
@@ -269,17 +269,17 @@ bool SMESH_MeshEditor::Remove (const list< int >& theIDs,
             smmap.insert( sm );
     }
     // Find sub-meshes to notify about modification
-//     SMDS_ElemIteratorPtr nodeIt = elem->nodesIterator();
-//     while ( nodeIt->more() ) {
-//       const SMDS_MeshNode* node = static_cast<const SMDS_MeshNode*>( nodeIt->next() );
-//       const SMDS_PositionPtr& aPosition = node->GetPosition();
-//       if ( aPosition.get() ) {
-//         if ( int aShapeID = aPosition->GetShapeId() ) {
-//           if ( SMESH_subMesh * sm = GetMesh()->GetSubMeshContaining( aShapeID ) )
-//             smmap.insert( sm );
-//         }
-//       }
-//     }
+    //     SMDS_ElemIteratorPtr nodeIt = elem->nodesIterator();
+    //     while ( nodeIt->more() ) {
+    //       const SMDS_MeshNode* node = static_cast<const SMDS_MeshNode*>( nodeIt->next() );
+    //       const SMDS_PositionPtr& aPosition = node->GetPosition();
+    //       if ( aPosition.get() ) {
+    //         if ( int aShapeID = aPosition->GetShapeId() ) {
+    //           if ( SMESH_subMesh * sm = GetMesh()->GetSubMeshContaining( aShapeID ) )
+    //             smmap.insert( sm );
+    //         }
+    //       }
+    //     }
 
     // Do remove
     if ( isNodes )
@@ -295,9 +295,9 @@ bool SMESH_MeshEditor::Remove (const list< int >& theIDs,
       (*smIt)->ComputeStateEngine( SMESH_subMesh::MESH_ENTITY_REMOVED );
   }
 
-//   // Check if the whole mesh becomes empty
-//   if ( SMESH_subMesh * sm = GetMesh()->GetSubMeshContaining( 1 ) )
-//     sm->ComputeStateEngine( SMESH_subMesh::CHECK_COMPUTE_STATE );
+  //   // Check if the whole mesh becomes empty
+  //   if ( SMESH_subMesh * sm = GetMesh()->GetSubMeshContaining( 1 ) )
+  //     sm->ComputeStateEngine( SMESH_subMesh::CHECK_COMPUTE_STATE );
 
   return true;
 }
@@ -1411,7 +1411,7 @@ double getAngle(const SMDS_MeshElement * tr1,
 // and able to return nodes by that ID
 // =================================================
 class LinkID_Gen {
- public:
+public:
 
   LinkID_Gen( const SMESHDS_Mesh* theMesh )
     :myMesh( theMesh ), myMaxID( theMesh->MaxNodeID() + 1)
@@ -1434,7 +1434,7 @@ class LinkID_Gen {
     return true;
   }
 
- private:
+private:
   LinkID_Gen();
   const SMESHDS_Mesh* myMesh;
   long                myMaxID;
@@ -1743,15 +1743,15 @@ bool SMESH_MeshEditor::TriToQuad (TIDSortedElemSet &                   theElems,
 //=============================================================================
 static void swap( int i1, int i2, int idNodes[], gp_Pnt P[] )
 {
-  if ( i1 == i2 )
-    return;
-  int tmp = idNodes[ i1 ];
-  idNodes[ i1 ] = idNodes[ i2 ];
-  idNodes[ i2 ] = tmp;
-  gp_Pnt Ptmp = P[ i1 ];
-  P[ i1 ] = P[ i2 ];
-  P[ i2 ] = Ptmp;
-  DUMPSO( i1 << "(" << idNodes[ i2 ] << ") <-> " << i2 << "(" << idNodes[ i1 ] << ")");
+if ( i1 == i2 )
+return;
+int tmp = idNodes[ i1 ];
+idNodes[ i1 ] = idNodes[ i2 ];
+idNodes[ i2 ] = tmp;
+gp_Pnt Ptmp = P[ i1 ];
+P[ i1 ] = P[ i2 ];
+P[ i2 ] = Ptmp;
+DUMPSO( i1 << "(" << idNodes[ i2 ] << ") <-> " << i2 << "(" << idNodes[ i1 ] << ")");
 }
 
 //=======================================================================
@@ -1762,7 +1762,7 @@ static void swap( int i1, int i2, int idNodes[], gp_Pnt P[] )
 //=======================================================================
 
 int SMESH_MeshEditor::SortQuadNodes (const SMDS_Mesh * theMesh,
-                                     int               idNodes[] )
+int               idNodes[] )
 {
   gp_Pnt P[4];
   int i;
@@ -1791,10 +1791,10 @@ int SMESH_MeshEditor::SortQuadNodes (const SMDS_Mesh * theMesh,
       i = 1;
     swap ( i, i + 1, idNodes, P );
 
-//     for ( int ii = 0; ii < 4; ii++ ) {
-//       const SMDS_MeshNode *n = theMesh->FindNode( idNodes[ii] );
-//       DUMPSO( ii << "(" << idNodes[ii] <<") : "<<n->X()<<" "<<n->Y()<<" "<<n->Z());
-//     }
+    //     for ( int ii = 0; ii < 4; ii++ ) {
+    //       const SMDS_MeshNode *n = theMesh->FindNode( idNodes[ii] );
+    //       DUMPSO( ii << "(" << idNodes[ii] <<") : "<<n->X()<<" "<<n->Y()<<" "<<n->Z());
+    //     }
   }
   return i;
 }
@@ -1910,7 +1910,7 @@ bool SMESH_MeshEditor::SortHexaNodes (const SMDS_Mesh * theMesh,
           faceNodes.insert( idNodes[ 2 ] );
           faceNodes.insert( idNodes[ iMin ] );
           DUMPSO( "loop " << iLoop2 << " id2 " << idNodes[ 1 ] << " id3 " << idNodes[ 2 ]
-            << " leastDist = " << leastDist);
+                  << " leastDist = " << leastDist);
           if ( leastDist <= DBL_MIN )
             break;
         }
@@ -1948,11 +1948,11 @@ bool SMESH_MeshEditor::SortHexaNodes (const SMDS_Mesh * theMesh,
     P[ i ] = P[ i+1 ];
     P[ i+1 ] = Ptmp;
   }
-//   else
-//     for ( int ii = 0; ii < 4; ii++ ) {
-//       const SMDS_MeshNode *n = theMesh->FindNode( idNodes[ii] );
-//       DUMPSO( ii << "(" << idNodes[ii] <<") : "<<n->X()<<" "<<n->Y()<<" "<<n->Z());
-//    }
+  //   else
+  //     for ( int ii = 0; ii < 4; ii++ ) {
+  //       const SMDS_MeshNode *n = theMesh->FindNode( idNodes[ii] );
+  //       DUMPSO( ii << "(" << idNodes[ii] <<") : "<<n->X()<<" "<<n->Y()<<" "<<n->Z());
+  //    }
 
   // Gravity center of the top and bottom faces
   gp_Pnt aGCb = ( P[0].XYZ() + P[1].XYZ() + P[2].XYZ() + P[3].XYZ() ) / 4.;
@@ -2004,11 +2004,11 @@ bool SMESH_MeshEditor::SortHexaNodes (const SMDS_Mesh * theMesh,
     swap( 5, 7, idNodes, P );
   }
 
-//   DUMPSO( "OUTPUT: ========================================");
-//   for ( i = 0; i < 8; i++ ) {
-//     float *p = ugrid->GetPoint(idNodes[i]);
-//     DUMPSO( i << "(" << idNodes[i] << ") : " << p[0] << " " << p[1] << " " << p[2]);
-//   }
+  //   DUMPSO( "OUTPUT: ========================================");
+  //   for ( i = 0; i < 8; i++ ) {
+  //     float *p = ugrid->GetPoint(idNodes[i]);
+  //     DUMPSO( i << "(" << idNodes[i] << ") : " << p[0] << " " << p[1] << " " << p[2]);
+  //   }
 
   return true;
 }*/
@@ -2016,11 +2016,11 @@ bool SMESH_MeshEditor::SortHexaNodes (const SMDS_Mesh * theMesh,
 //================================================================================
 /*!
  * \brief Return nodes linked to the given one
 * \param theNode - the node
 * \param linkedNodes - the found nodes
 * \param type - the type of elements to check
 *
 * Medium nodes are ignored
+ * \param theNode - the node
+ * \param linkedNodes - the found nodes
+ * \param type - the type of elements to check
+ *
+ * Medium nodes are ignored
  */
 //================================================================================
 
@@ -2300,14 +2300,14 @@ void SMESH_MeshEditor::Smooth (TIDSortedElemSet &          theElems,
     }
     int nbElemOnFace = 0;
     itElem = theElems.begin();
-     // loop on not yet smoothed elements: look for elems on a face
+    // loop on not yet smoothed elements: look for elems on a face
     while ( itElem != theElems.end() ) {
       if ( faceSubMesh && nbElemOnFace == faceSubMesh->NbElements() )
         break; // all elements found
 
       const SMDS_MeshElement* elem = *itElem;
       if ( !elem || elem->GetType() != SMDSAbs_Face || elem->NbNodes() < 3 ||
-          ( faceSubMesh && !faceSubMesh->Contains( elem ))) {
+           ( faceSubMesh && !faceSubMesh->Contains( elem ))) {
         ++itElem;
         continue;
       }
@@ -2366,19 +2366,19 @@ void SMESH_MeshEditor::Smooth (TIDSortedElemSet &          theElems,
         if ( uvMap.find( node ) == uvMap.end() )
           uvCheckNodes.push_back( node );
         // add nodes of elems sharing node
-//         SMDS_ElemIteratorPtr eIt = node->GetInverseElementIterator(SMDSAbs_Face);
-//         while ( eIt->more() ) {
-//           const SMDS_MeshElement* e = eIt->next();
-//           if ( e != elem ) {
-//             SMDS_ElemIteratorPtr nIt = e->nodesIterator();
-//             while ( nIt->more() ) {
-//               const SMDS_MeshNode* n =
-//                 static_cast<const SMDS_MeshNode*>( nIt->next() );
-//               if ( uvMap.find( n ) == uvMap.end() )
-//                 uvCheckNodes.push_back( n );
-//             }
-//           }
-//         }
+        //         SMDS_ElemIteratorPtr eIt = node->GetInverseElementIterator(SMDSAbs_Face);
+        //         while ( eIt->more() ) {
+        //           const SMDS_MeshElement* e = eIt->next();
+        //           if ( e != elem ) {
+        //             SMDS_ElemIteratorPtr nIt = e->nodesIterator();
+        //             while ( nIt->more() ) {
+        //               const SMDS_MeshNode* n =
+        //                 static_cast<const SMDS_MeshNode*>( nIt->next() );
+        //               if ( uvMap.find( n ) == uvMap.end() )
+        //                 uvCheckNodes.push_back( n );
+        //             }
+        //           }
+        //         }
       }
       // check UV on face
       list< const SMDS_MeshNode* >::iterator n = uvCheckNodes.begin();
@@ -2795,11 +2795,11 @@ void SMESH_MeshEditor::sweepElement(const SMDS_MeshElement*               elem,
     nextNod[ iNode ] = listNewNodes.front();
     if( !issimple[iNode] ) {
       if ( prevNod[ iNode ] != nextNod [ iNode ])
-       iNotSameNode = iNode;
+        iNotSameNode = iNode;
       else {
-       iSameNode = iNode;
-       //nbSame++;
-       sames[nbSame++] = iNode;
+        iSameNode = iNode;
+        //nbSame++;
+        sames[nbSame++] = iNode;
       }
     }
   }
@@ -2811,10 +2811,10 @@ void SMESH_MeshEditor::sweepElement(const SMDS_MeshElement*               elem,
     return;
   }
 
-//  if( elem->IsQuadratic() && nbSame>0 ) {
-//    MESSAGE( "Can not rotate quadratic element " << elem->GetID() );
-//    return;
-//  }
+  //  if( elem->IsQuadratic() && nbSame>0 ) {
+  //    MESSAGE( "Can not rotate quadratic element " << elem->GetID() );
+  //    return;
+  //  }
 
   int iBeforeSame = 0, iAfterSame = 0, iOpposSame = 0;
   int nbBaseNodes = ( elem->IsQuadratic() ? nbNodes/2 : nbNodes );
@@ -2824,11 +2824,11 @@ void SMESH_MeshEditor::sweepElement(const SMDS_MeshElement*               elem,
     iOpposSame  = ( iSameNode - 2 < 0  ? iSameNode + 2 : iSameNode - 2 );
   }
 
-//if(nbNodes==8)
-//cout<<" prevNod[0]="<< prevNod[0]<<" prevNod[1]="<< prevNod[1]
-//    <<" prevNod[2]="<< prevNod[2]<<" prevNod[3]="<< prevNod[4]
-//    <<" prevNod[4]="<< prevNod[4]<<" prevNod[5]="<< prevNod[5]
-//    <<" prevNod[6]="<< prevNod[6]<<" prevNod[7]="<< prevNod[7]<<endl;
+  //if(nbNodes==8)
+  //cout<<" prevNod[0]="<< prevNod[0]<<" prevNod[1]="<< prevNod[1]
+  //    <<" prevNod[2]="<< prevNod[2]<<" prevNod[3]="<< prevNod[4]
+  //    <<" prevNod[4]="<< prevNod[4]<<" prevNod[5]="<< prevNod[5]
+  //    <<" prevNod[6]="<< prevNod[6]<<" prevNod[7]="<< prevNod[7]<<endl;
 
   // check element orientation
   int i0 = 0, i2 = 2;
@@ -2919,7 +2919,7 @@ void SMESH_MeshEditor::sweepElement(const SMDS_MeshElement*               elem,
           else if(nbSame==1) { // quadratic triangle
             if(sames[0]==2) {
               return; // medium node on axis
-           }
+            }
             else if(sames[0]==0) {
               aNewElem = aMesh->AddFace(prevNod[0], nextNod[1], prevNod[1],
                                         nextNod[2], midlNod[1], prevNod[2]);
@@ -2931,7 +2931,7 @@ void SMESH_MeshEditor::sweepElement(const SMDS_MeshElement*               elem,
           }
           else {
             return;
-         }
+          }
         }
         break;
       }
@@ -2966,140 +2966,140 @@ void SMESH_MeshEditor::sweepElement(const SMDS_MeshElement*               elem,
       }
       case 6: { // quadratic triangle
         // create pentahedron with 15 nodes
-       if(nbSame==0) {
-         if(i0>0) { // reversed case
-           aNewElem = aMesh->AddVolume (prevNod[0], prevNod[2], prevNod[1],
-                                        nextNod[0], nextNod[2], nextNod[1],
-                                        prevNod[5], prevNod[4], prevNod[3],
-                                        nextNod[5], nextNod[4], nextNod[3],
-                                        midlNod[0], midlNod[2], midlNod[1]);
-         }
-         else { // not reversed case
-           aNewElem = aMesh->AddVolume (prevNod[0], prevNod[1], prevNod[2],
-                                        nextNod[0], nextNod[1], nextNod[2],
-                                        prevNod[3], prevNod[4], prevNod[5],
-                                        nextNod[3], nextNod[4], nextNod[5],
-                                        midlNod[0], midlNod[1], midlNod[2]);
-         }
-       }
-       else if(nbSame==1) {
-         // 2d order pyramid of 13 nodes
-         //SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int n5,
+        if(nbSame==0) {
+          if(i0>0) { // reversed case
+            aNewElem = aMesh->AddVolume (prevNod[0], prevNod[2], prevNod[1],
+                                         nextNod[0], nextNod[2], nextNod[1],
+                                         prevNod[5], prevNod[4], prevNod[3],
+                                         nextNod[5], nextNod[4], nextNod[3],
+                                         midlNod[0], midlNod[2], midlNod[1]);
+          }
+          else { // not reversed case
+            aNewElem = aMesh->AddVolume (prevNod[0], prevNod[1], prevNod[2],
+                                         nextNod[0], nextNod[1], nextNod[2],
+                                         prevNod[3], prevNod[4], prevNod[5],
+                                         nextNod[3], nextNod[4], nextNod[5],
+                                         midlNod[0], midlNod[1], midlNod[2]);
+          }
+        }
+        else if(nbSame==1) {
+          // 2d order pyramid of 13 nodes
+          //SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int n5,
           //                                 int n12,int n23,int n34,int n41,
           //                                 int n15,int n25,int n35,int n45, int ID);
-         int n5 = iSameNode;
-         int n1,n4,n41,n15,n45;
-         if(i0>0) { // reversed case
-           n1 = ( n5 + 1 == nbBaseNodes ? 0 : n5 + 1 );
-           n4 = ( n5 == 0 ? nbBaseNodes - 1 : n5 - 1 );
-           n41 = n1 + 3;
-           n15 = n5 + 3;
-           n45 = n4 + 3;
-         }
-         else {
-           n1 = ( n5 == 0 ? nbBaseNodes - 1 : n5 - 1 );
-           n4 = ( n5 + 1 == nbBaseNodes ? 0 : n5 + 1 );
-           n41 = n4 + 3;
-           n15 = n1 + 3;
-           n45 = n5 + 3;
-         }
-         aNewElem = aMesh->AddVolume(prevNod[n1], nextNod[n1],
-                             nextNod[n4], prevNod[n4], prevNod[n5],
-                             midlNod[n1], nextNod[n41],
-                             midlNod[n4], prevNod[n41],
-                             prevNod[n15], nextNod[n15],
-                             nextNod[n45], prevNod[n45]);
-       }
-       else if(nbSame==2) {
-         // 2d order tetrahedron of 10 nodes
-         //SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4,
-         //                                 int n12,int n23,int n31,
-         //                                 int n14,int n24,int n34, int ID);
-         int n1 = iNotSameNode;
-         int n2,n3,n12,n23,n31;
-         if(i0>0) { // reversed case
-           n2 = ( n1 == 0 ? nbBaseNodes - 1 : n1 - 1 );
-           n3 = ( n1 + 1 == nbBaseNodes ? 0 : n1 + 1 );
-           n12 = n2 + 3;
-           n23 = n3 + 3;
-           n31 = n1 + 3;
-         }
-         else {
-           n2 = ( n1 + 1 == nbBaseNodes ? 0 : n1 + 1 );
-           n3 = ( n1 == 0 ? nbBaseNodes - 1 : n1 - 1 );
-           n12 = n1 + 3;
-           n23 = n2 + 3;
-           n31 = n3 + 3;
-         }
-         aNewElem = aMesh->AddVolume (prevNod[n1], prevNod[n2], prevNod[n3], nextNod[n1],
-                                      prevNod[n12], prevNod[n23], prevNod[n31],
-                                      midlNod[n1], nextNod[n12], nextNod[n31]);
-       }
+          int n5 = iSameNode;
+          int n1,n4,n41,n15,n45;
+          if(i0>0) { // reversed case
+            n1 = ( n5 + 1 == nbBaseNodes ? 0 : n5 + 1 );
+            n4 = ( n5 == 0 ? nbBaseNodes - 1 : n5 - 1 );
+            n41 = n1 + 3;
+            n15 = n5 + 3;
+            n45 = n4 + 3;
+          }
+          else {
+            n1 = ( n5 == 0 ? nbBaseNodes - 1 : n5 - 1 );
+            n4 = ( n5 + 1 == nbBaseNodes ? 0 : n5 + 1 );
+            n41 = n4 + 3;
+            n15 = n1 + 3;
+            n45 = n5 + 3;
+          }
+          aNewElem = aMesh->AddVolume(prevNod[n1], nextNod[n1],
+                                      nextNod[n4], prevNod[n4], prevNod[n5],
+                                      midlNod[n1], nextNod[n41],
+                                      midlNod[n4], prevNod[n41],
+                                      prevNod[n15], nextNod[n15],
+                                      nextNod[n45], prevNod[n45]);
+        }
+        else if(nbSame==2) {
+          // 2d order tetrahedron of 10 nodes
+          //SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4,
+          //                                 int n12,int n23,int n31,
+          //                                 int n14,int n24,int n34, int ID);
+          int n1 = iNotSameNode;
+          int n2,n3,n12,n23,n31;
+          if(i0>0) { // reversed case
+            n2 = ( n1 == 0 ? nbBaseNodes - 1 : n1 - 1 );
+            n3 = ( n1 + 1 == nbBaseNodes ? 0 : n1 + 1 );
+            n12 = n2 + 3;
+            n23 = n3 + 3;
+            n31 = n1 + 3;
+          }
+          else {
+            n2 = ( n1 + 1 == nbBaseNodes ? 0 : n1 + 1 );
+            n3 = ( n1 == 0 ? nbBaseNodes - 1 : n1 - 1 );
+            n12 = n1 + 3;
+            n23 = n2 + 3;
+            n31 = n3 + 3;
+          }
+          aNewElem = aMesh->AddVolume (prevNod[n1], prevNod[n2], prevNod[n3], nextNod[n1],
+                                       prevNod[n12], prevNod[n23], prevNod[n31],
+                                       midlNod[n1], nextNod[n12], nextNod[n31]);
+        }
         break;
       }
       case 8: { // quadratic quadrangle
-       if(nbSame==0) {
-         // create hexahedron with 20 nodes
-         if(i0>0) { // reversed case
-           aNewElem = aMesh->AddVolume (prevNod[0], prevNod[3], prevNod[2], prevNod[1],
-                                        nextNod[0], nextNod[3], nextNod[2], nextNod[1],
-                                        prevNod[7], prevNod[6], prevNod[5], prevNod[4],
-                                        nextNod[7], nextNod[6], nextNod[5], nextNod[4],
-                                        midlNod[0], midlNod[3], midlNod[2], midlNod[1]);
-         }
-         else { // not reversed case
-           aNewElem = aMesh->AddVolume (prevNod[0], prevNod[1], prevNod[2], prevNod[3],
-                                        nextNod[0], nextNod[1], nextNod[2], nextNod[3],
-                                        prevNod[4], prevNod[5], prevNod[6], prevNod[7],
-                                        nextNod[4], nextNod[5], nextNod[6], nextNod[7],
-                                        midlNod[0], midlNod[1], midlNod[2], midlNod[3]);
-         }
-       }
-       else if(nbSame==1) { 
-         // --- pyramid + pentahedron - can not be created since it is needed 
-         // additional middle node ot the center of face
-         INFOS( " Sweep for face " << elem->GetID() << " can not be created" );
-         return;
-       }
-       else if(nbSame==2) {
-         // 2d order Pentahedron with 15 nodes
-         //SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int n5, int n6,
+        if(nbSame==0) {
+          // create hexahedron with 20 nodes
+          if(i0>0) { // reversed case
+            aNewElem = aMesh->AddVolume (prevNod[0], prevNod[3], prevNod[2], prevNod[1],
+                                         nextNod[0], nextNod[3], nextNod[2], nextNod[1],
+                                         prevNod[7], prevNod[6], prevNod[5], prevNod[4],
+                                         nextNod[7], nextNod[6], nextNod[5], nextNod[4],
+                                         midlNod[0], midlNod[3], midlNod[2], midlNod[1]);
+          }
+          else { // not reversed case
+            aNewElem = aMesh->AddVolume (prevNod[0], prevNod[1], prevNod[2], prevNod[3],
+                                         nextNod[0], nextNod[1], nextNod[2], nextNod[3],
+                                         prevNod[4], prevNod[5], prevNod[6], prevNod[7],
+                                         nextNod[4], nextNod[5], nextNod[6], nextNod[7],
+                                         midlNod[0], midlNod[1], midlNod[2], midlNod[3]);
+          }
+        }
+        else if(nbSame==1) { 
+          // --- pyramid + pentahedron - can not be created since it is needed 
+          // additional middle node ot the center of face
+          INFOS( " Sweep for face " << elem->GetID() << " can not be created" );
+          return;
+        }
+        else if(nbSame==2) {
+          // 2d order Pentahedron with 15 nodes
+          //SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int n5, int n6,
           //                                 int n12,int n23,int n31,int n45,int n56,int n64,
           //                                 int n14,int n25,int n36, int ID);
-         int n1,n2,n4,n5;
+          int n1,n2,n4,n5;
           if ( prevNod[ iBeforeSame ] == nextNod[ iBeforeSame ] ) {
             // iBeforeSame is same too
-           n1 = iBeforeSame;
-           n2 = iOpposSame;
-           n4 = iSameNode;
-           n5 = iAfterSame;
-         }
-         else {
+            n1 = iBeforeSame;
+            n2 = iOpposSame;
+            n4 = iSameNode;
+            n5 = iAfterSame;
+          }
+          else {
             // iAfterSame is same too
-           n1 = iSameNode;
-           n2 = iBeforeSame;
-           n4 = iAfterSame;
-           n5 = iOpposSame;
-         }
-         int n12,n45,n14,n25;
-         if(i0>0) { //reversed case
-           n12 = n1 + 4;
-           n45 = n5 + 4;
-           n14 = n4 + 4;
-           n25 = n2 + 4;
-         }
-         else {
-           n12 = n2 + 4;
-           n45 = n4 + 4;
-           n14 = n1 + 4;
-           n25 = n5 + 4;
-         }
-         aNewElem = aMesh->AddVolume (prevNod[n1], prevNod[n2], nextNod[n2],
-                                      prevNod[n4], prevNod[n5], nextNod[n5],
-                                      prevNod[n12], midlNod[n2], nextNod[n12],
-                                      prevNod[n45], midlNod[n5], nextNod[n45],
-                                      prevNod[n14], prevNod[n25], nextNod[n25]);
-       }
+            n1 = iSameNode;
+            n2 = iBeforeSame;
+            n4 = iAfterSame;
+            n5 = iOpposSame;
+          }
+          int n12,n45,n14,n25;
+          if(i0>0) { //reversed case
+            n12 = n1 + 4;
+            n45 = n5 + 4;
+            n14 = n4 + 4;
+            n25 = n2 + 4;
+          }
+          else {
+            n12 = n2 + 4;
+            n45 = n4 + 4;
+            n14 = n1 + 4;
+            n25 = n5 + 4;
+          }
+          aNewElem = aMesh->AddVolume (prevNod[n1], prevNod[n2], nextNod[n2],
+                                       prevNod[n4], prevNod[n5], nextNod[n5],
+                                       prevNod[n12], midlNod[n2], nextNod[n12],
+                                       prevNod[n45], midlNod[n5], nextNod[n45],
+                                       prevNod[n14], prevNod[n25], nextNod[n25]);
+        }
         break;
       }
       default: {
@@ -3408,17 +3408,17 @@ void SMESH_MeshEditor::makeWalls (TNodeOfNodeListMap &     mapNewNodes,
                   if ( !f ) {
                     myLastCreatedElems.Append(aMesh->AddFace(nodes[0], nodes[2], nodes[4],
                                                              nodes[1], nodes[3], nodes[5]));
-                 }
+                  }
                   else if ( nodes[ 2 ] != f->GetNodeWrap( f->GetNodeIndex( nodes[ 0 ] ) + 1 )) {
-                   const SMDS_MeshNode** tmpnodes = new const SMDS_MeshNode*[6];
-                   tmpnodes[0] = nodes[0];
-                   tmpnodes[1] = nodes[2];
-                   tmpnodes[2] = nodes[4];
-                   tmpnodes[3] = nodes[1];
-                   tmpnodes[4] = nodes[3];
-                   tmpnodes[5] = nodes[5];
+                    const SMDS_MeshNode** tmpnodes = new const SMDS_MeshNode*[6];
+                    tmpnodes[0] = nodes[0];
+                    tmpnodes[1] = nodes[2];
+                    tmpnodes[2] = nodes[4];
+                    tmpnodes[3] = nodes[1];
+                    tmpnodes[4] = nodes[3];
+                    tmpnodes[5] = nodes[5];
                     aMesh->ChangeElementNodes( f, tmpnodes, nbn );
-                 }
+                  }
                 }
                 else {       /////// quadratic quadrangle
                   const SMDS_MeshFace * f = aMesh->FindFace( nodes[0], nodes[2], nodes[4], nodes[6],
@@ -3426,19 +3426,19 @@ 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]));
-                 }
+                  }
                   else if ( nodes[ 2 ] != f->GetNodeWrap( f->GetNodeIndex( nodes[ 0 ] ) + 1 )) {
-                   const SMDS_MeshNode** tmpnodes = new const SMDS_MeshNode*[8];
-                   tmpnodes[0] = nodes[0];
-                   tmpnodes[1] = nodes[2];
-                   tmpnodes[2] = nodes[4];
-                   tmpnodes[3] = nodes[6];
-                   tmpnodes[4] = nodes[1];
-                   tmpnodes[5] = nodes[3];
-                   tmpnodes[6] = nodes[5];
-                   tmpnodes[7] = nodes[7];
+                    const SMDS_MeshNode** tmpnodes = new const SMDS_MeshNode*[8];
+                    tmpnodes[0] = nodes[0];
+                    tmpnodes[1] = nodes[2];
+                    tmpnodes[2] = nodes[4];
+                    tmpnodes[3] = nodes[6];
+                    tmpnodes[4] = nodes[1];
+                    tmpnodes[5] = nodes[3];
+                    tmpnodes[6] = nodes[5];
+                    tmpnodes[7] = nodes[7];
                     aMesh->ChangeElementNodes( f, tmpnodes, nbn );
-                 }
+                  }
                 }
               }
               else { //////// polygon
@@ -3598,51 +3598,51 @@ SMESH_MeshEditor::RotationSweep(TIDSortedElemSet & theElems,
             newNode = aMesh->AddNode( coord[0], coord[1], coord[2] );
             myLastCreatedNodes.Append(newNode);
             srcNodes.Append( node );
-           listNewNodes.push_back( newNode );
+            listNewNodes.push_back( newNode );
+          }
+          else {
+            listNewNodes.push_back( newNode );
+            if( elem->IsQuadratic() && !elem->IsMediumNode(node) ) {
+              listNewNodes.push_back( newNode );
+            }
           }
-         else {
-           listNewNodes.push_back( newNode );
-           if( elem->IsQuadratic() && !elem->IsMediumNode(node) ) {
-             listNewNodes.push_back( newNode );
-           }
-         }
         }
       }
       /*
-      else {
+        else {
         // if current elem is quadratic and current node is not medium
         // we have to check - may be it is needed to insert additional nodes
         if( elem->IsQuadratic() && !elem->IsMediumNode(node) ) {
-          list< const SMDS_MeshNode* > & listNewNodes = nIt->second;
-          if(listNewNodes.size()==theNbSteps) {
-            listNewNodes.clear();
-            // make new nodes
-            //gp_XYZ aXYZ( node->X(), node->Y(), node->Z() );
-            //double coord[3];
-            //aXYZ.Coord( coord[0], coord[1], coord[2] );
-            const SMDS_MeshNode * newNode = node;
-           if ( !isOnAxis ) {
-             for(int i = 0; i<theNbSteps; i++) {
-               aTrsf2.Transforms( coord[0], coord[1], coord[2] );
-               newNode = aMesh->AddNode( coord[0], coord[1], coord[2] );
-               cout<<"    3 AddNode:  "<<newNode;
-               myLastCreatedNodes.Append(newNode);
-               listNewNodes.push_back( newNode );
-               srcNodes.Append( node );
-               aTrsf2.Transforms( coord[0], coord[1], coord[2] );
-               newNode = aMesh->AddNode( coord[0], coord[1], coord[2] );
-               cout<<"    4 AddNode:  "<<newNode;
-               myLastCreatedNodes.Append(newNode);
-               srcNodes.Append( node );
-               listNewNodes.push_back( newNode );
-             }
-            }
-           else {
-             listNewNodes.push_back( newNode );
-           }
-          }
+        list< const SMDS_MeshNode* > & listNewNodes = nIt->second;
+        if(listNewNodes.size()==theNbSteps) {
+        listNewNodes.clear();
+        // make new nodes
+        //gp_XYZ aXYZ( node->X(), node->Y(), node->Z() );
+        //double coord[3];
+        //aXYZ.Coord( coord[0], coord[1], coord[2] );
+        const SMDS_MeshNode * newNode = node;
+        if ( !isOnAxis ) {
+        for(int i = 0; i<theNbSteps; i++) {
+        aTrsf2.Transforms( coord[0], coord[1], coord[2] );
+        newNode = aMesh->AddNode( coord[0], coord[1], coord[2] );
+        cout<<"    3 AddNode:  "<<newNode;
+        myLastCreatedNodes.Append(newNode);
+        listNewNodes.push_back( newNode );
+        srcNodes.Append( node );
+        aTrsf2.Transforms( coord[0], coord[1], coord[2] );
+        newNode = aMesh->AddNode( coord[0], coord[1], coord[2] );
+        cout<<"    4 AddNode:  "<<newNode;
+        myLastCreatedNodes.Append(newNode);
+        srcNodes.Append( node );
+        listNewNodes.push_back( newNode );
+        }
+        }
+        else {
+        listNewNodes.push_back( newNode );
+        }
+        }
+        }
         }
-      }
       */
       newNodesItVec.push_back( nIt );
     }
@@ -3652,7 +3652,7 @@ SMESH_MeshEditor::RotationSweep(TIDSortedElemSet & theElems,
 
   if ( theMakeWalls )
     makeWalls( mapNewNodes, newElemsMap, mapElemNewNodes, theElems, theNbSteps, srcElems );
-  
+
   PGroupIDs newGroupIDs;
   if ( theMakeGroups )
     newGroupIDs = generateGroups( srcNodes, srcElems, "rotated");
@@ -3891,42 +3891,42 @@ SMESH_MeshEditor::ExtrusionSweep (TIDSortedElemSet &  theElems,
 //=======================================================================
 class SMESH_MeshEditor_PathPoint {
 public:
-  SMESH_MeshEditor_PathPoint() {
-    myPnt.SetCoord(99., 99., 99.);
-    myTgt.SetCoord(1.,0.,0.);
-    myAngle=0.;
-    myPrm=0.;
-  }
-  void SetPnt(const gp_Pnt& aP3D){
-    myPnt=aP3D;
-  }
-  void SetTangent(const gp_Dir& aTgt){
-    myTgt=aTgt;
-  }
-  void SetAngle(const double& aBeta){
-    myAngle=aBeta;
-  }
-  void SetParameter(const double& aPrm){
-    myPrm=aPrm;
-  }
-  const gp_Pnt& Pnt()const{
-    return myPnt;
-  }
-  const gp_Dir& Tangent()const{
-    return myTgt;
-  }
-  double Angle()const{
-    return myAngle;
-  }
-  double Parameter()const{
-    return myPrm;
-  }
+SMESH_MeshEditor_PathPoint() {
+myPnt.SetCoord(99., 99., 99.);
+myTgt.SetCoord(1.,0.,0.);
+myAngle=0.;
+myPrm=0.;
+}
+void SetPnt(const gp_Pnt& aP3D){
+myPnt=aP3D;
+}
+void SetTangent(const gp_Dir& aTgt){
+myTgt=aTgt;
+}
+void SetAngle(const double& aBeta){
+myAngle=aBeta;
+}
+void SetParameter(const double& aPrm){
+myPrm=aPrm;
+}
+const gp_Pnt& Pnt()const{
+return myPnt;
+}
+const gp_Dir& Tangent()const{
+return myTgt;
+}
+double Angle()const{
+return myAngle;
+}
+double Parameter()const{
+return myPrm;
+}
 
 protected:
-  gp_Pnt myPnt;
-  gp_Dir myTgt;
-  double myAngle;
-  double myPrm;
+gp_Pnt myPnt;
+gp_Dir myTgt;
+double myAngle;
+double myPrm;
 };
 */
 
@@ -3935,15 +3935,15 @@ protected:
 //purpose  :
 //=======================================================================
 SMESH_MeshEditor::Extrusion_Error
-  SMESH_MeshEditor::ExtrusionAlongTrack (TIDSortedElemSet &   theElements,
-                                        SMESH_subMesh*       theTrack,
-                                        const SMDS_MeshNode* theN1,
-                                        const bool           theHasAngles,
-                                        list<double>&        theAngles,
-                                        const bool           theLinearVariation,
-                                        const bool           theHasRefPoint,
-                                        const gp_Pnt&        theRefPoint,
-                                         const bool           theMakeGroups)
+SMESH_MeshEditor::ExtrusionAlongTrack (TIDSortedElemSet &   theElements,
+                                       SMESH_subMesh*       theTrack,
+                                       const SMDS_MeshNode* theN1,
+                                       const bool           theHasAngles,
+                                       list<double>&        theAngles,
+                                       const bool           theLinearVariation,
+                                       const bool           theHasRefPoint,
+                                       const gp_Pnt&        theRefPoint,
+                                       const bool           theMakeGroups)
 {
   myLastCreatedElems.Clear();
   myLastCreatedNodes.Clear();
@@ -4003,12 +4003,12 @@ SMESH_MeshEditor::Extrusion_Error
     while ( aItN->more() ) {
       const SMDS_MeshNode* pNode = aItN->next();
       const SMDS_EdgePosition* pEPos =
-       static_cast<const SMDS_EdgePosition*>( pNode->GetPosition().get() );
+        static_cast<const SMDS_EdgePosition*>( pNode->GetPosition().get() );
       double aT = pEPos->GetUParameter();
       aPrms.push_back( aT );
     }
     //Extrusion_Error err =
-      MakeEdgePathPoints(aPrms, aTrackEdge, (aN1==theN1), fullList);
+    MakeEdgePathPoints(aPrms, aTrackEdge, (aN1==theN1), fullList);
   }
   else if( aS.ShapeType() == TopAbs_WIRE ) {
     list< SMESH_subMesh* > LSM;
@@ -4029,37 +4029,37 @@ SMESH_MeshEditor::Extrusion_Error
       int k = 0;
       list< SMESH_subMesh* >::iterator itLSM = LSM.begin();
       for(; itLSM!=LSM.end(); itLSM++) {
-       k++;
-       if(UsedNums.Contains(k)) continue;
-       aTrackEdge = TopoDS::Edge( Edges.Value(k) );
-       SMESH_subMesh* locTrack = *itLSM;
-       SMESHDS_SubMesh* locMeshDS = locTrack->GetSubMeshDS();
-       TopExp::Vertices( aTrackEdge, aV1, aV2 );
-       aItN = locTrack->GetFather()->GetSubMesh(aV1)->GetSubMeshDS()->GetNodes();
-       const SMDS_MeshNode* aN1 = aItN->next();
-       aItN = locTrack->GetFather()->GetSubMesh(aV2)->GetSubMeshDS()->GetNodes();
-       const SMDS_MeshNode* aN2 = aItN->next();
-       // starting node must be aN1 or aN2
-       if ( !( aN1->GetID() == startNid || aN2->GetID() == startNid ) ) continue;
-       // 2. Collect parameters on the track edge
-       aPrms.clear();
-       aItN = locMeshDS->GetNodes();
-       while ( aItN->more() ) {
-         const SMDS_MeshNode* pNode = aItN->next();
-         const SMDS_EdgePosition* pEPos =
-           static_cast<const SMDS_EdgePosition*>( pNode->GetPosition().get() );
-         double aT = pEPos->GetUParameter();
-         aPrms.push_back( aT );
-       }
-       list<SMESH_MeshEditor_PathPoint> LPP;
-       //Extrusion_Error err =
-          MakeEdgePathPoints(aPrms, aTrackEdge,(aN1->GetID()==startNid), LPP);
-       LLPPs.push_back(LPP);
-       UsedNums.Add(k);
-       // update startN for search following egde
-       if( aN1->GetID() == startNid ) startNid = aN2->GetID();
-       else startNid = aN1->GetID();
-       break;
+        k++;
+        if(UsedNums.Contains(k)) continue;
+        aTrackEdge = TopoDS::Edge( Edges.Value(k) );
+        SMESH_subMesh* locTrack = *itLSM;
+        SMESHDS_SubMesh* locMeshDS = locTrack->GetSubMeshDS();
+        TopExp::Vertices( aTrackEdge, aV1, aV2 );
+        aItN = locTrack->GetFather()->GetSubMesh(aV1)->GetSubMeshDS()->GetNodes();
+        const SMDS_MeshNode* aN1 = aItN->next();
+        aItN = locTrack->GetFather()->GetSubMesh(aV2)->GetSubMeshDS()->GetNodes();
+        const SMDS_MeshNode* aN2 = aItN->next();
+        // starting node must be aN1 or aN2
+        if ( !( aN1->GetID() == startNid || aN2->GetID() == startNid ) ) continue;
+        // 2. Collect parameters on the track edge
+        aPrms.clear();
+        aItN = locMeshDS->GetNodes();
+        while ( aItN->more() ) {
+          const SMDS_MeshNode* pNode = aItN->next();
+          const SMDS_EdgePosition* pEPos =
+            static_cast<const SMDS_EdgePosition*>( pNode->GetPosition().get() );
+          double aT = pEPos->GetUParameter();
+          aPrms.push_back( aT );
+        }
+        list<SMESH_MeshEditor_PathPoint> LPP;
+        //Extrusion_Error err =
+        MakeEdgePathPoints(aPrms, aTrackEdge,(aN1->GetID()==startNid), LPP);
+        LLPPs.push_back(LPP);
+        UsedNums.Add(k);
+        // update startN for search following egde
+        if( aN1->GetID() == startNid ) startNid = aN2->GetID();
+        else startNid = aN1->GetID();
+        break;
       }
     }
     list< list<SMESH_MeshEditor_PathPoint> >::iterator itLLPP = LLPPs.begin();
@@ -4078,12 +4078,12 @@ SMESH_MeshEditor::Extrusion_Error
       gp_Dir D1 = PP1.Tangent();
       gp_Dir D2 = PP2.Tangent();
       gp_Dir Dnew( gp_Vec( (D1.X()+D2.X())/2, (D1.Y()+D2.Y())/2,
-                          (D1.Z()+D2.Z())/2 ) );
+                           (D1.Z()+D2.Z())/2 ) );
       PP1.SetTangent(Dnew);
       fullList.push_back(PP1);
       itPP++;
       for(; itPP!=firstList.end(); itPP++) {
-       fullList.push_back( *itPP );
+        fullList.push_back( *itPP );
       }
       PP1 = fullList.back();
       fullList.pop_back();
@@ -4097,7 +4097,7 @@ SMESH_MeshEditor::Extrusion_Error
   }
 
   return MakeExtrElements(theElements, fullList, theHasAngles, theAngles, theLinearVariation,
-                         theHasRefPoint, theRefPoint, theMakeGroups);
+                          theHasRefPoint, theRefPoint, theMakeGroups);
 }
 
 
@@ -4106,15 +4106,15 @@ SMESH_MeshEditor::Extrusion_Error
 //purpose  :
 //=======================================================================
 SMESH_MeshEditor::Extrusion_Error
-  SMESH_MeshEditor::ExtrusionAlongTrack (TIDSortedElemSet &   theElements,
-                                        SMESH_Mesh*          theTrack,
-                                        const SMDS_MeshNode* theN1,
-                                        const bool           theHasAngles,
-                                        list<double>&        theAngles,
-                                        const bool           theLinearVariation,
-                                        const bool           theHasRefPoint,
-                                        const gp_Pnt&        theRefPoint,
-                                         const bool           theMakeGroups)
+SMESH_MeshEditor::ExtrusionAlongTrack (TIDSortedElemSet &   theElements,
+                                       SMESH_Mesh*          theTrack,
+                                       const SMDS_MeshNode* theN1,
+                                       const bool           theHasAngles,
+                                       list<double>&        theAngles,
+                                       const bool           theLinearVariation,
+                                       const bool           theHasRefPoint,
+                                       const gp_Pnt&        theRefPoint,
+                                       const bool           theMakeGroups)
 {
   myLastCreatedElems.Clear();
   myLastCreatedNodes.Clear();
@@ -4175,12 +4175,12 @@ SMESH_MeshEditor::Extrusion_Error
       const SMDS_MeshNode* pNode = aItN->next();
       if( pNode==aN1 || pNode==aN2 ) continue;
       const SMDS_EdgePosition* pEPos =
-       static_cast<const SMDS_EdgePosition*>( pNode->GetPosition().get() );
+        static_cast<const SMDS_EdgePosition*>( pNode->GetPosition().get() );
       double aT = pEPos->GetUParameter();
       aPrms.push_back( aT );
     }
     //Extrusion_Error err =
-      MakeEdgePathPoints(aPrms, aTrackEdge, (aN1==theN1), fullList);
+    MakeEdgePathPoints(aPrms, aTrackEdge, (aN1==theN1), fullList);
   }
   else if( aS.ShapeType() == TopAbs_WIRE ) {
     list< SMESH_subMesh* > LSM;
@@ -4191,8 +4191,8 @@ SMESH_MeshEditor::Extrusion_Error
       if( BRep_Tool::Degenerated(E) ) continue;
       SMESH_subMesh* SM = theTrack->GetSubMesh(E);
       if(SM) {
-       LSM.push_back(SM);
-       Edges.Append(E);
+        LSM.push_back(SM);
+        Edges.Append(E);
       }
     }
     list< list<SMESH_MeshEditor_PathPoint> > LLPPs;
@@ -4204,37 +4204,37 @@ SMESH_MeshEditor::Extrusion_Error
       int k = 0;
       list< SMESH_subMesh* >::iterator itLSM = LSM.begin();
       for(; itLSM!=LSM.end(); itLSM++) {
-       k++;
-       if(UsedNums.Contains(k)) continue;
-       aTrackEdge = TopoDS::Edge( Edges.Value(k) );
-       SMESH_subMesh* locTrack = *itLSM;
-       SMESHDS_SubMesh* locMeshDS = locTrack->GetSubMeshDS();
-       TopExp::Vertices( aTrackEdge, aV1, aV2 );
-       aItN = locTrack->GetFather()->GetSubMesh(aV1)->GetSubMeshDS()->GetNodes();
-       const SMDS_MeshNode* aN1 = aItN->next();
-       aItN = locTrack->GetFather()->GetSubMesh(aV2)->GetSubMeshDS()->GetNodes();
-       const SMDS_MeshNode* aN2 = aItN->next();
-       // starting node must be aN1 or aN2
-       if ( !( aN1->GetID() == startNid || aN2->GetID() == startNid ) ) continue;
-       // 2. Collect parameters on the track edge
-       aPrms.clear();
-       aItN = locMeshDS->GetNodes();
-       while ( aItN->more() ) {
-         const SMDS_MeshNode* pNode = aItN->next();
-         const SMDS_EdgePosition* pEPos =
-           static_cast<const SMDS_EdgePosition*>( pNode->GetPosition().get() );
-         double aT = pEPos->GetUParameter();
-         aPrms.push_back( aT );
-       }
-       list<SMESH_MeshEditor_PathPoint> LPP;
-       //Extrusion_Error err =
-          MakeEdgePathPoints(aPrms, aTrackEdge,(aN1->GetID()==startNid), LPP);
-       LLPPs.push_back(LPP);
-       UsedNums.Add(k);
-       // update startN for search following egde
-       if( aN1->GetID() == startNid ) startNid = aN2->GetID();
-       else startNid = aN1->GetID();
-       break;
+        k++;
+        if(UsedNums.Contains(k)) continue;
+        aTrackEdge = TopoDS::Edge( Edges.Value(k) );
+        SMESH_subMesh* locTrack = *itLSM;
+        SMESHDS_SubMesh* locMeshDS = locTrack->GetSubMeshDS();
+        TopExp::Vertices( aTrackEdge, aV1, aV2 );
+        aItN = locTrack->GetFather()->GetSubMesh(aV1)->GetSubMeshDS()->GetNodes();
+        const SMDS_MeshNode* aN1 = aItN->next();
+        aItN = locTrack->GetFather()->GetSubMesh(aV2)->GetSubMeshDS()->GetNodes();
+        const SMDS_MeshNode* aN2 = aItN->next();
+        // starting node must be aN1 or aN2
+        if ( !( aN1->GetID() == startNid || aN2->GetID() == startNid ) ) continue;
+        // 2. Collect parameters on the track edge
+        aPrms.clear();
+        aItN = locMeshDS->GetNodes();
+        while ( aItN->more() ) {
+          const SMDS_MeshNode* pNode = aItN->next();
+          const SMDS_EdgePosition* pEPos =
+            static_cast<const SMDS_EdgePosition*>( pNode->GetPosition().get() );
+          double aT = pEPos->GetUParameter();
+          aPrms.push_back( aT );
+        }
+        list<SMESH_MeshEditor_PathPoint> LPP;
+        //Extrusion_Error err =
+        MakeEdgePathPoints(aPrms, aTrackEdge,(aN1->GetID()==startNid), LPP);
+        LLPPs.push_back(LPP);
+        UsedNums.Add(k);
+        // update startN for search following egde
+        if( aN1->GetID() == startNid ) startNid = aN2->GetID();
+        else startNid = aN1->GetID();
+        break;
       }
     }
     list< list<SMESH_MeshEditor_PathPoint> >::iterator itLLPP = LLPPs.begin();
@@ -4256,12 +4256,12 @@ SMESH_MeshEditor::Extrusion_Error
       gp_Dir D1 = PP1.Tangent();
       gp_Dir D2 = PP2.Tangent();
       gp_Dir Dnew( gp_Vec( (D1.X()+D2.X())/2, (D1.Y()+D2.Y())/2,
-                          (D1.Z()+D2.Z())/2 ) );
+                           (D1.Z()+D2.Z())/2 ) );
       PP1.SetTangent(Dnew);
       fullList.push_back(PP1);
       itPP++;
       for(; itPP!=currList.end(); itPP++) {
-       fullList.push_back( *itPP );
+        fullList.push_back( *itPP );
       }
       PP1 = fullList.back();
       fullList.pop_back();
@@ -4275,7 +4275,7 @@ SMESH_MeshEditor::Extrusion_Error
   }
 
   return MakeExtrElements(theElements, fullList, theHasAngles, theAngles, theLinearVariation,
-                         theHasRefPoint, theRefPoint, theMakeGroups);
+                          theHasRefPoint, theRefPoint, theMakeGroups);
 }
 
 
@@ -4285,9 +4285,9 @@ SMESH_MeshEditor::Extrusion_Error
 //=======================================================================
 SMESH_MeshEditor::Extrusion_Error
 SMESH_MeshEditor::MakeEdgePathPoints(std::list<double>& aPrms,
-                                    const TopoDS_Edge& aTrackEdge,
-                                    bool FirstIsStart,
-                                    list<SMESH_MeshEditor_PathPoint>& LPP)
+                                     const TopoDS_Edge& aTrackEdge,
+                                     bool FirstIsStart,
+                                     list<SMESH_MeshEditor_PathPoint>& LPP)
 {
   Standard_Real aTx1, aTx2, aL2, aTolVec, aTolVec2;
   aTolVec=1.e-7;
@@ -4340,13 +4340,13 @@ SMESH_MeshEditor::MakeEdgePathPoints(std::list<double>& aPrms,
 //=======================================================================
 SMESH_MeshEditor::Extrusion_Error
 SMESH_MeshEditor::MakeExtrElements(TIDSortedElemSet&  theElements,
-                                  list<SMESH_MeshEditor_PathPoint>& fullList,
-                                  const bool theHasAngles,
-                                  list<double>& theAngles,
-                                  const bool theLinearVariation,
-                                  const bool theHasRefPoint,
-                                  const gp_Pnt& theRefPoint,
-                                  const bool theMakeGroups)
+                                   list<SMESH_MeshEditor_PathPoint>& fullList,
+                                   const bool theHasAngles,
+                                   list<double>& theAngles,
+                                   const bool theLinearVariation,
+                                   const bool theHasRefPoint,
+                                   const gp_Pnt& theRefPoint,
+                                   const bool theMakeGroups)
 {
   //cout<<"MakeExtrElements  fullList.size() = "<<fullList.size()<<endl;
   int aNbTP = fullList.size();
@@ -4395,26 +4395,26 @@ SMESH_MeshEditor::MakeExtrElements(TIDSortedElemSet&  theElements,
   if ( !theHasRefPoint ) {
     aNb = 0;
     aGC.SetCoord( 0.,0.,0. );
-    
+
     itElem = theElements.begin();
     for ( ; itElem != theElements.end(); itElem++ ) {
       const SMDS_MeshElement* elem = *itElem;
-      
+
       SMDS_ElemIteratorPtr itN = elem->nodesIterator();
       while ( itN->more() ) {
-       const SMDS_MeshNode* node = static_cast<const SMDS_MeshNode*>( itN->next() );
-       aX = node->X();
-       aY = node->Y();
-       aZ = node->Z();
-       
-       if ( mapNewNodes.find( node ) == mapNewNodes.end() ) {
-         list<const SMDS_MeshNode*> aLNx;
-         mapNewNodes[node] = aLNx;
-         //
-         gp_XYZ aXYZ( aX, aY, aZ );
-         aGC += aXYZ;
-         ++aNb;
-       }
+        const SMDS_MeshNode* node = static_cast<const SMDS_MeshNode*>( itN->next() );
+        aX = node->X();
+        aY = node->Y();
+        aZ = node->Z();
+
+        if ( mapNewNodes.find( node ) == mapNewNodes.end() ) {
+          list<const SMDS_MeshNode*> aLNx;
+          mapNewNodes[node] = aLNx;
+          //
+          gp_XYZ aXYZ( aX, aY, aZ );
+          aGC += aXYZ;
+          ++aNb;
+        }
       }
     }
     aGC /= aNb;
@@ -4443,66 +4443,66 @@ SMESH_MeshEditor::MakeExtrElements(TIDSortedElemSet&  theElements,
       ++nodeIndex;
       // check if a node has been already processed
       const SMDS_MeshNode* node =
-       static_cast<const SMDS_MeshNode*>( itN->next() );
+        static_cast<const SMDS_MeshNode*>( itN->next() );
       TNodeOfNodeListMap::iterator nIt = mapNewNodes.find( node );
       if ( nIt == mapNewNodes.end() ) {
         nIt = mapNewNodes.insert( make_pair( node, list<const SMDS_MeshNode*>() )).first;
         list<const SMDS_MeshNode*>& listNewNodes = nIt->second;
 
-       // make new nodes
-       aX = node->X();  aY = node->Y(); aZ = node->Z();
-
-       Standard_Real aAngle1x, aAngleT1T0, aTolAng;
-       gp_Pnt aP0x, aP1x, aPN0, aPN1, aV0x, aV1x;
-       gp_Ax1 anAx1, anAxT1T0;
-       gp_Dir aDT1x, aDT0x, aDT1T0;
-
-       aTolAng=1.e-4;
-
-       aV0x = aV0;
-       aPN0.SetCoord(aX, aY, aZ);
-
-       const SMESH_MeshEditor_PathPoint& aPP0 = aPPs[0];
-       aP0x = aPP0.Pnt();
-       aDT0x= aPP0.Tangent();
-       //cout<<"j = 0   PP: Pnt("<<aP0x.X()<<","<<aP0x.Y()<<","<<aP0x.Z()<<")"<<endl;
-
-       for ( j = 1; j < aNbTP; ++j ) {
-         const SMESH_MeshEditor_PathPoint& aPP1 = aPPs[j];
-         aP1x = aPP1.Pnt();
-         aDT1x = aPP1.Tangent();
-         aAngle1x = aPP1.Angle();
-
-         gp_Trsf aTrsf, aTrsfRot, aTrsfRotT1T0;
-         // Translation
-         gp_Vec aV01x( aP0x, aP1x );
-         aTrsf.SetTranslation( aV01x );
-
-         // traslated point
-         aV1x = aV0x.Transformed( aTrsf );
-         aPN1 = aPN0.Transformed( aTrsf );
-
-         // rotation 1 [ T1,T0 ]
-         aAngleT1T0=-aDT1x.Angle( aDT0x );
-         if (fabs(aAngleT1T0) > aTolAng) {
-           aDT1T0=aDT1x^aDT0x;
-           anAxT1T0.SetLocation( aV1x );
-           anAxT1T0.SetDirection( aDT1T0 );
-           aTrsfRotT1T0.SetRotation( anAxT1T0, aAngleT1T0 );
-
-           aPN1 = aPN1.Transformed( aTrsfRotT1T0 );
-         }
+        // make new nodes
+        aX = node->X();  aY = node->Y(); aZ = node->Z();
+
+        Standard_Real aAngle1x, aAngleT1T0, aTolAng;
+        gp_Pnt aP0x, aP1x, aPN0, aPN1, aV0x, aV1x;
+        gp_Ax1 anAx1, anAxT1T0;
+        gp_Dir aDT1x, aDT0x, aDT1T0;
+
+        aTolAng=1.e-4;
+
+        aV0x = aV0;
+        aPN0.SetCoord(aX, aY, aZ);
+
+        const SMESH_MeshEditor_PathPoint& aPP0 = aPPs[0];
+        aP0x = aPP0.Pnt();
+        aDT0x= aPP0.Tangent();
+        //cout<<"j = 0   PP: Pnt("<<aP0x.X()<<","<<aP0x.Y()<<","<<aP0x.Z()<<")"<<endl;
+
+        for ( j = 1; j < aNbTP; ++j ) {
+          const SMESH_MeshEditor_PathPoint& aPP1 = aPPs[j];
+          aP1x = aPP1.Pnt();
+          aDT1x = aPP1.Tangent();
+          aAngle1x = aPP1.Angle();
+
+          gp_Trsf aTrsf, aTrsfRot, aTrsfRotT1T0;
+          // Translation
+          gp_Vec aV01x( aP0x, aP1x );
+          aTrsf.SetTranslation( aV01x );
+
+          // traslated point
+          aV1x = aV0x.Transformed( aTrsf );
+          aPN1 = aPN0.Transformed( aTrsf );
+
+          // rotation 1 [ T1,T0 ]
+          aAngleT1T0=-aDT1x.Angle( aDT0x );
+          if (fabs(aAngleT1T0) > aTolAng) {
+            aDT1T0=aDT1x^aDT0x;
+            anAxT1T0.SetLocation( aV1x );
+            anAxT1T0.SetDirection( aDT1T0 );
+            aTrsfRotT1T0.SetRotation( anAxT1T0, aAngleT1T0 );
+
+            aPN1 = aPN1.Transformed( aTrsfRotT1T0 );
+          }
 
-         // rotation 2
-         if ( theHasAngles ) {
-           anAx1.SetLocation( aV1x );
-           anAx1.SetDirection( aDT1x );
-           aTrsfRot.SetRotation( anAx1, aAngle1x );
+          // rotation 2
+          if ( theHasAngles ) {
+            anAx1.SetLocation( aV1x );
+            anAx1.SetDirection( aDT1x );
+            aTrsfRot.SetRotation( anAx1, aAngle1x );
 
-           aPN1 = aPN1.Transformed( aTrsfRot );
-         }
+            aPN1 = aPN1.Transformed( aTrsfRot );
+          }
 
-         // make new node
+          // make new node
           if( elem->IsQuadratic() && !elem->IsMediumNode(node) ) {
             // create additional node
             double x = ( aPN1.X() + aPN0.X() )/2.;
@@ -4513,19 +4513,19 @@ SMESH_MeshEditor::MakeExtrElements(TIDSortedElemSet&  theElements,
             srcNodes.Append( node );
             listNewNodes.push_back( newNode );
           }
-         aX = aPN1.X();
-         aY = aPN1.Y();
-         aZ = aPN1.Z();
-         const SMDS_MeshNode* newNode = aMesh->AddNode( aX, aY, aZ );
+          aX = aPN1.X();
+          aY = aPN1.Y();
+          aZ = aPN1.Z();
+          const SMDS_MeshNode* newNode = aMesh->AddNode( aX, aY, aZ );
           myLastCreatedNodes.Append(newNode);
           srcNodes.Append( node );
-         listNewNodes.push_back( newNode );
+          listNewNodes.push_back( newNode );
 
-         aPN0 = aPN1;
-         aP0x = aP1x;
-         aV0x = aV1x;
-         aDT0x = aDT1x;
-       }
+          aPN0 = aPN1;
+          aP0x = aP1x;
+          aV0x = aV1x;
+          aDT0x = aDT1x;
+        }
       }
 
       else {
@@ -4580,7 +4580,7 @@ SMESH_MeshEditor::MakeExtrElements(TIDSortedElemSet&  theElements,
 //purpose  : auxilary for ExtrusionAlongTrack
 //=======================================================================
 void SMESH_MeshEditor::LinearAngleVariation(const int nbSteps,
-                                           list<double>& Angles)
+                                            list<double>& Angles)
 {
   int nbAngles = Angles.size();
   if( nbSteps > nbAngles ) {
@@ -4599,19 +4599,19 @@ void SMESH_MeshEditor::LinearAngleVariation(const int nbSteps,
       double angCurFloor  = floor( angCur );
       double angPrevFloor = floor( angPrev );
       if ( angPrevFloor == angCurFloor )
-       angle = rAn2St * theAngles[ int( angCurFloor ) ];
+        angle = rAn2St * theAngles[ int( angCurFloor ) ];
       else {
-       int iP = int( angPrevFloor );
-       double angPrevCeil = ceil(angPrev);
-       angle = ( angPrevCeil - angPrev ) * theAngles[ iP ];
-          
-       int iC = int( angCurFloor );
-       if ( iC < nbAngles )
-         angle += ( angCur - angCurFloor ) * theAngles[ iC ];
-       
-       iP = int( angPrevCeil );
-       while ( iC-- > iP )
-         angle += theAngles[ iC ];
+        int iP = int( angPrevFloor );
+        double angPrevCeil = ceil(angPrev);
+        angle = ( angPrevCeil - angPrev ) * theAngles[ iP ];
+
+        int iC = int( angCurFloor );
+        if ( iC < nbAngles )
+          angle += ( angCur - angCurFloor ) * theAngles[ iC ];
+
+        iP = int( angPrevCeil );
+        while ( iC-- > iP )
+          angle += theAngles[ iC ];
       }
       res.push_back(angle);
       angPrev = angCur;
@@ -4665,7 +4665,7 @@ SMESH_MeshEditor::Transform (TIDSortedElemSet & theElems,
   SMESH_MeshEditor targetMeshEditor( theTargetMesh );
   SMESHDS_Mesh* aTgtMesh = theTargetMesh ? theTargetMesh->GetMeshDS() : 0;
   SMESHDS_Mesh* aMesh    = GetMeshDS();
-  
+
 
   // map old node to new one
   TNodeNodeMap nodeMap;
@@ -4747,7 +4747,7 @@ SMESH_MeshEditor::Transform (TIDSortedElemSet & theElems,
     REV_FACE    = 3,
     REV_HEXA    = 4,  //  = nbNodes - 4
     FORWARD     = 5
-    };
+  };
   int index[][8] = {
     { 2, 1, 0, 3, 4, 0, 0, 0 },  // REV_TETRA
     { 2, 1, 0, 3, 4, 0, 0, 0 },  // REV_PYRAMID
@@ -4848,18 +4848,18 @@ SMESH_MeshEditor::Transform (TIDSortedElemSet & theElems,
           }
         }
         break;
-    default:;
+      default:;
+      }
+      continue;
     }
-    continue;
-  }
 
-  // Regular elements
-  int* i = index[ FORWARD ];
-  if ( needReverse && nbNodes > 2) // reverse mirrored faces and volumes
-    if ( elemType == SMDSAbs_Face )
-      i = index[ REV_FACE ];
-    else
-      i = index[ nbNodes - 4 ];
+    // Regular elements
+    int* i = index[ FORWARD ];
+    if ( needReverse && nbNodes > 2) // reverse mirrored faces and volumes
+      if ( elemType == SMDSAbs_Face )
+        i = index[ REV_FACE ];
+      else
+        i = index[ nbNodes - 4 ];
 
     if(elem->IsQuadratic()) {
       static int anIds[] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19};
@@ -5317,7 +5317,7 @@ void SMESH_MeshEditor::MergeNodes (TListOfListOfNodes & theGroupsOfNodes)
       SMDS_ElemIteratorPtr invElemIt = nToRemove->GetInverseElementIterator();
       while ( invElemIt->more() ) {
         const SMDS_MeshElement* elem = invElemIt->next();
-          elems.insert(elem);
+        elems.insert(elem);
       }
     }
   }
@@ -5851,24 +5851,24 @@ void SMESH_MeshEditor::MergeNodes (TListOfListOfNodes & theGroupsOfNodes)
 // ========================================================
 class SortableElement : public set <const SMDS_MeshElement*>
 {
- public:
+public:
 
   SortableElement( const SMDS_MeshElement* theElem )
-    {
-      myElem = theElem;
-      SMDS_ElemIteratorPtr nodeIt = theElem->nodesIterator();
-      while ( nodeIt->more() )
-        this->insert( nodeIt->next() );
-    }
+  {
+    myElem = theElem;
+    SMDS_ElemIteratorPtr nodeIt = theElem->nodesIterator();
+    while ( nodeIt->more() )
+      this->insert( nodeIt->next() );
+  }
 
   const SMDS_MeshElement* Get() const
-    { return myElem; }
+  { return myElem; }
 
   void Set(const SMDS_MeshElement* e) const
-    { myElem = e; }
+  { myElem = e; }
 
 
- private:
+private:
   mutable const SMDS_MeshElement* myElem;
 };
 
@@ -5878,7 +5878,7 @@ class SortableElement : public set <const SMDS_MeshElement*>
 //           Search among theElements or in the whole mesh if theElements is empty
 //=======================================================================
 void SMESH_MeshEditor::FindEqualElements(set<const SMDS_MeshElement*> & theElements,
-                                        TListOfListOfElementsID &      theGroupsOfElementsID)
+                                         TListOfListOfElementsID &      theGroupsOfElementsID)
 {
   myLastCreatedElems.Clear();
   myLastCreatedNodes.Clear();
@@ -5976,7 +5976,7 @@ void SMESH_MeshEditor::MergeElements(TListOfListOfElementsID & theGroupsOfElemen
 void SMESH_MeshEditor::MergeEqualElements()
 {
   set<const SMDS_MeshElement*> aMeshElements; /* empty input -
-                                                to merge equal elements in the whole mesh */
+                                                 to merge equal elements in the whole mesh */
   TListOfListOfElementsID aGroupsOfElementsID;
   FindEqualElements(aMeshElements, aGroupsOfElementsID);
   MergeElements(aGroupsOfElementsID);
@@ -5990,10 +5990,10 @@ void SMESH_MeshEditor::MergeEqualElements()
 //=======================================================================
 
 const SMDS_MeshElement*
-  SMESH_MeshEditor::FindFaceInSet(const SMDS_MeshNode*    n1,
-                                  const SMDS_MeshNode*    n2,
-                                  const TIDSortedElemSet& elemSet,
-                                  const TIDSortedElemSet& avoidSet)
+SMESH_MeshEditor::FindFaceInSet(const SMDS_MeshNode*    n1,
+                                const SMDS_MeshNode*    n2,
+                                const TIDSortedElemSet& elemSet,
+                                const TIDSortedElemSet& avoidSet)
 
 {
   SMDS_ElemIteratorPtr invElemIt = n1->GetInverseElementIterator(SMDSAbs_Face);
@@ -6126,7 +6126,7 @@ bool SMESH_MeshEditor::FindFreeBorder (const SMDS_MeshNode*             theFirst
         int iNode = 0, nbNodes = e->NbNodes();
         //const SMDS_MeshNode* nodes[nbNodes+1];
         vector<const SMDS_MeshNode*> nodes(nbNodes+1);
-        
+
         if(e->IsQuadratic()) {
           const SMDS_QuadraticFaceOfNodes* F =
             static_cast<const SMDS_QuadraticFaceOfNodes*>(e);
@@ -6246,15 +6246,15 @@ bool SMESH_MeshEditor::CheckFreeBorderNodes(const SMDS_MeshNode* theNode1,
 //=======================================================================
 
 SMESH_MeshEditor::Sew_Error
-  SMESH_MeshEditor::SewFreeBorder (const SMDS_MeshNode* theBordFirstNode,
-                                   const SMDS_MeshNode* theBordSecondNode,
-                                   const SMDS_MeshNode* theBordLastNode,
-                                   const SMDS_MeshNode* theSideFirstNode,
-                                   const SMDS_MeshNode* theSideSecondNode,
-                                   const SMDS_MeshNode* theSideThirdNode,
-                                   const bool           theSideIsFreeBorder,
-                                   const bool           toCreatePolygons,
-                                   const bool           toCreatePolyedrs)
+SMESH_MeshEditor::SewFreeBorder (const SMDS_MeshNode* theBordFirstNode,
+                                 const SMDS_MeshNode* theBordSecondNode,
+                                 const SMDS_MeshNode* theBordLastNode,
+                                 const SMDS_MeshNode* theSideFirstNode,
+                                 const SMDS_MeshNode* theSideSecondNode,
+                                 const SMDS_MeshNode* theSideThirdNode,
+                                 const bool           theSideIsFreeBorder,
+                                 const bool           toCreatePolygons,
+                                 const bool           toCreatePolyedrs)
 {
   myLastCreatedElems.Clear();
   myLastCreatedNodes.Clear();
@@ -6508,7 +6508,7 @@ SMESH_MeshEditor::Sew_Error
 
   TListOfListOfNodes nodeGroupsToMerge;
   if ( nbNodes[0] == nbNodes[1] ||
-      ( theSideIsFreeBorder && !theSideThirdNode)) {
+       ( theSideIsFreeBorder && !theSideThirdNode)) {
 
     // all nodes are to be merged
 
@@ -7159,44 +7159,44 @@ int SMESH_MeshEditor::convertElemToQuadratic(SMESHDS_SubMesh *   theSm,
     switch( aType )
     {
     case SMDSAbs_Edge :
-    {
-      NewElem = theHelper.AddEdge(aNds[0], aNds[1], id, theForce3d);
-      break;
-    }
+      {
+        NewElem = theHelper.AddEdge(aNds[0], aNds[1], id, theForce3d);
+        break;
+      }
     case SMDSAbs_Face :
-    {
-      switch(nbNodes)
       {
-      case 3:
-       NewElem = theHelper.AddFace(aNds[0], aNds[1], aNds[2], id, theForce3d);
-       break;
-      case 4:
-       NewElem = theHelper.AddFace(aNds[0], aNds[1], aNds[2], aNds[3], id, theForce3d);
-       break;
-      default:
-       continue;
+        switch(nbNodes)
+        {
+        case 3:
+          NewElem = theHelper.AddFace(aNds[0], aNds[1], aNds[2], id, theForce3d);
+          break;
+        case 4:
+          NewElem = theHelper.AddFace(aNds[0], aNds[1], aNds[2], aNds[3], id, theForce3d);
+          break;
+        default:
+          continue;
+        }
+        break;
       }
-      break;
-    }
     case SMDSAbs_Volume :
-    {
-      switch(nbNodes)
       {
-      case 4:
-       NewElem = theHelper.AddVolume(aNds[0], aNds[1], aNds[2], aNds[3], id, theForce3d);
-       break;
-      case 6:
-       NewElem = theHelper.AddVolume(aNds[0], aNds[1], aNds[2], aNds[3], aNds[4], aNds[5], id, theForce3d);
-       break;
-      case 8:
-       NewElem = theHelper.AddVolume(aNds[0], aNds[1], aNds[2], aNds[3],
-                                      aNds[4], aNds[5], aNds[6], aNds[7], id, theForce3d);
-       break;
-      default:
-       continue;
+        switch(nbNodes)
+        {
+        case 4:
+          NewElem = theHelper.AddVolume(aNds[0], aNds[1], aNds[2], aNds[3], id, theForce3d);
+          break;
+        case 6:
+          NewElem = theHelper.AddVolume(aNds[0], aNds[1], aNds[2], aNds[3], aNds[4], aNds[5], id, theForce3d);
+          break;
+        case 8:
+          NewElem = theHelper.AddVolume(aNds[0], aNds[1], aNds[2], aNds[3],
+                                        aNds[4], aNds[5], aNds[6], aNds[7], id, theForce3d);
+          break;
+        default:
+          continue;
+        }
+        break;
       }
-      break;
-    }
     default :
       continue;
     }
@@ -7245,11 +7245,11 @@ void SMESH_MeshEditor::ConvertToQuadratic(const bool theForce3d)
       const SMDS_MeshEdge* edge = aEdgeItr->next();
       if(edge && !edge->IsQuadratic())
       {
-       int id = edge->GetID();
-       const SMDS_MeshNode* n1 = edge->GetNode(0);
-       const SMDS_MeshNode* n2 = edge->GetNode(1);
+        int id = edge->GetID();
+        const SMDS_MeshNode* n1 = edge->GetNode(0);
+        const SMDS_MeshNode* n2 = edge->GetNode(1);
 
-       meshDS->RemoveFreeElement(edge, smDS, notFromGroups);
+        meshDS->RemoveFreeElement(edge, smDS, notFromGroups);
 
         const SMDS_MeshEdge* NewEdge = aHelper.AddEdge(n1, n2, id, theForce3d);
         ReplaceElemInGroups( edge, NewEdge, GetMeshDS());
@@ -7267,7 +7267,7 @@ void SMESH_MeshEditor::ConvertToQuadratic(const bool theForce3d)
 
       for(int i = 0; i < nbNodes; i++)
       {
-       aNds[i] = face->GetNode(i);
+        aNds[i] = face->GetNode(i);
       }
 
       meshDS->RemoveFreeElement(face, smDS, notFromGroups);
@@ -7276,13 +7276,13 @@ void SMESH_MeshEditor::ConvertToQuadratic(const bool theForce3d)
       switch(nbNodes)
       {
       case 3:
-       NewFace = aHelper.AddFace(aNds[0], aNds[1], aNds[2], id, theForce3d);
-       break;
+        NewFace = aHelper.AddFace(aNds[0], aNds[1], aNds[2], id, theForce3d);
+        break;
       case 4:
-       NewFace = aHelper.AddFace(aNds[0], aNds[1], aNds[2], aNds[3], id, theForce3d);
-       break;
+        NewFace = aHelper.AddFace(aNds[0], aNds[1], aNds[2], aNds[3], id, theForce3d);
+        break;
       default:
-       continue;
+        continue;
       }
       ReplaceElemInGroups( face, NewFace, GetMeshDS());
     }
@@ -7298,7 +7298,7 @@ void SMESH_MeshEditor::ConvertToQuadratic(const bool theForce3d)
 
       for(int i = 0; i < nbNodes; i++)
       {
-       aNds[i] = volume->GetNode(i);
+        aNds[i] = volume->GetNode(i);
       }
 
       meshDS->RemoveFreeElement(volume, smDS, notFromGroups);
@@ -7307,19 +7307,19 @@ void SMESH_MeshEditor::ConvertToQuadratic(const bool theForce3d)
       switch(nbNodes)
       {
       case 4:
-       NewVolume = aHelper.AddVolume(aNds[0], aNds[1], aNds[2],
+        NewVolume = aHelper.AddVolume(aNds[0], aNds[1], aNds[2],
                                       aNds[3], id, theForce3d );
-       break;
+        break;
       case 6:
-       NewVolume = aHelper.AddVolume(aNds[0], aNds[1], aNds[2],
+        NewVolume = aHelper.AddVolume(aNds[0], aNds[1], aNds[2],
                                       aNds[3], aNds[4], aNds[5], id, theForce3d);
-       break;
+        break;
       case 8:
-       NewVolume = aHelper.AddVolume(aNds[0], aNds[1], aNds[2], aNds[3],
+        NewVolume = aHelper.AddVolume(aNds[0], aNds[1], aNds[2], aNds[3],
                                       aNds[4], aNds[5], aNds[6], aNds[7], id, theForce3d);
-       break;
+        break;
       default:
-       continue;
+        continue;
       }
       ReplaceElemInGroups(volume, NewVolume, meshDS);
     }
@@ -7359,12 +7359,12 @@ int SMESH_MeshEditor::removeQuadElem(SMESHDS_SubMesh *    theSm,
 
       for(int i = 0; i < nbNodes; i++)
       {
-       const SMDS_MeshNode* n = elem->GetNode(i);
+        const SMDS_MeshNode* n = elem->GetNode(i);
 
-       if( elem->IsMediumNode( n ) )
+        if( elem->IsMediumNode( n ) )
           mediumNodes.push_back( n );
-       else
-         aNds.push_back( n );
+        else
+          aNds.push_back( n );
       }
       if( aNds.empty() ) continue;
       SMDSAbs_ElementType aType = elem->GetType();
@@ -7375,7 +7375,7 @@ int SMESH_MeshEditor::removeQuadElem(SMESHDS_SubMesh *    theSm,
       SMDS_MeshElement * NewElem = AddElement( aNds, aType, false, id );
       ReplaceElemInGroups(elem, NewElem, meshDS);
       if( theSm && NewElem )
-       theSm->AddElement( NewElem );
+        theSm->AddElement( NewElem );
 
       // remove medium nodes
       vector<const SMDS_MeshNode*>::iterator nIt = mediumNodes.begin();
@@ -7387,7 +7387,7 @@ int SMESH_MeshEditor::removeQuadElem(SMESHDS_SubMesh *    theSm,
                                     ( n->GetPosition()->GetShapeId() ));
           else
             meshDS->RemoveFreeNode( n, theSm );
-       }
+        }
       }
     }
   }
@@ -7413,7 +7413,7 @@ bool  SMESH_MeshEditor::ConvertFromQuadratic()
       }
     }
   }
-  
+
   int totalNbElems =
     GetMeshDS()->NbEdges() + GetMeshDS()->NbFaces() + GetMeshDS()->NbVolumes();
   if ( nbCheckedElems < totalNbElems ) // not all elements are in submeshes
@@ -7431,12 +7431,12 @@ bool  SMESH_MeshEditor::ConvertFromQuadratic()
 //=======================================================================
 
 SMESH_MeshEditor::Sew_Error
-  SMESH_MeshEditor::SewSideElements (TIDSortedElemSet&    theSide1,
-                                     TIDSortedElemSet&    theSide2,
-                                     const SMDS_MeshNode* theFirstNode1,
-                                     const SMDS_MeshNode* theFirstNode2,
-                                     const SMDS_MeshNode* theSecondNode1,
-                                     const SMDS_MeshNode* theSecondNode2)
+SMESH_MeshEditor::SewSideElements (TIDSortedElemSet&    theSide1,
+                                   TIDSortedElemSet&    theSide2,
+                                   const SMDS_MeshNode* theFirstNode1,
+                                   const SMDS_MeshNode* theFirstNode2,
+                                   const SMDS_MeshNode* theSecondNode1,
+                                   const SMDS_MeshNode* theSecondNode2)
 {
   myLastCreatedElems.Clear();
   myLastCreatedNodes.Clear();
@@ -7675,40 +7675,40 @@ SMESH_MeshEditor::Sew_Error
           const SMDS_MeshElement* aFreeFace = freeFaceList.front();
           faceSet->insert( aFreeFace );
           // complete a node set with nodes of a found free face
-//           for ( iNode = 0; iNode < ; iNode++ )
-//             nodeSet->insert( fNodes[ iNode ] );
+          //           for ( iNode = 0; iNode < ; iNode++ )
+          //             nodeSet->insert( fNodes[ iNode ] );
         }
 
       } // loop on volumes of a side
 
-//       // complete a set of faces if new nodes in a nodeSet appeared
-//       // ----------------------------------------------------------
-//       if ( nodeSetSize != nodeSet->size() ) {
-//         for ( ; nIt != nodeSet->end(); nIt++ ) { // loop on nodes of iSide
-//           SMDS_ElemIteratorPtr fIt = (*nIt)->GetInverseElementIterator(SMDSAbs_Face);
-//           while ( fIt->more() ) { // loop on faces sharing a node
-//             const SMDS_MeshElement* f = fIt->next();
-//             if ( faceSet->find( f ) == faceSet->end() ) {
-//               // check if all nodes are in nodeSet and
-//               // complete setOfFaceNodeSet if they are
-//               set <const SMDS_MeshNode*> faceNodeSet;
-//               SMDS_ElemIteratorPtr nodeIt = f->nodesIterator();
-//               bool allInSet = true;
-//               while ( nodeIt->more() && allInSet ) { // loop on nodes of a face
-//                 const SMDS_MeshNode* n = static_cast<const SMDS_MeshNode*>( nodeIt->next() );
-//                 if ( nodeSet->find( n ) == nodeSet->end() )
-//                   allInSet = false;
-//                 else
-//                   faceNodeSet.insert( n );
-//               }
-//               if ( allInSet ) {
-//                 faceSet->insert( f );
-//                 setOfFaceNodeSet.insert( faceNodeSet );
-//               }
-//             }
-//           }
-//         }
-//       }
+      //       // complete a set of faces if new nodes in a nodeSet appeared
+      //       // ----------------------------------------------------------
+      //       if ( nodeSetSize != nodeSet->size() ) {
+      //         for ( ; nIt != nodeSet->end(); nIt++ ) { // loop on nodes of iSide
+      //           SMDS_ElemIteratorPtr fIt = (*nIt)->GetInverseElementIterator(SMDSAbs_Face);
+      //           while ( fIt->more() ) { // loop on faces sharing a node
+      //             const SMDS_MeshElement* f = fIt->next();
+      //             if ( faceSet->find( f ) == faceSet->end() ) {
+      //               // check if all nodes are in nodeSet and
+      //               // complete setOfFaceNodeSet if they are
+      //               set <const SMDS_MeshNode*> faceNodeSet;
+      //               SMDS_ElemIteratorPtr nodeIt = f->nodesIterator();
+      //               bool allInSet = true;
+      //               while ( nodeIt->more() && allInSet ) { // loop on nodes of a face
+      //                 const SMDS_MeshNode* n = static_cast<const SMDS_MeshNode*>( nodeIt->next() );
+      //                 if ( nodeSet->find( n ) == nodeSet->end() )
+      //                   allInSet = false;
+      //                 else
+      //                   faceNodeSet.insert( n );
+      //               }
+      //               if ( allInSet ) {
+      //                 faceSet->insert( f );
+      //                 setOfFaceNodeSet.insert( faceNodeSet );
+      //               }
+      //             }
+      //           }
+      //         }
+      //       }
     } // Create temporary faces, if there are volumes given
   } // loop on sides
 
@@ -7814,10 +7814,10 @@ SMESH_MeshEditor::Sew_Error
                   nbl++;
                   if(iSide==0)
                     notLinkNodes1[nbl] = n;
-                    //notLinkNodes1.push_back(n);
+                  //notLinkNodes1.push_back(n);
                   else
                     notLinkNodes2[nbl] = n;
-                    //notLinkNodes2.push_back(n);
+                  //notLinkNodes2.push_back(n);
                 }
                 //faceNodes[ iSide ][ iNode++ ] = n;
                 if(iSide==0) {
@@ -7898,7 +7898,7 @@ SMESH_MeshEditor::Sew_Error
         //nReplaceMap.insert( TNodeNodeMap::value_type
         //                   ( notLinkNodes[0][0], notLinkNodes[1][0] ));
         nReplaceMap.insert( TNodeNodeMap::value_type
-                           ( notLinkNodes1[0], notLinkNodes2[0] ));
+                            ( notLinkNodes1[0], notLinkNodes2[0] ));
       }
       else {
         for ( iSide = 0; iSide < 2; iSide++ ) { // loop on 2 sides
@@ -7919,7 +7919,7 @@ SMESH_MeshEditor::Sew_Error
           //                   ( notLinkNodes[0][1], notLinkNodes[1][1] ));
           for(int nn=0; nn<nbNodes-2; nn++) {
             nReplaceMap.insert( TNodeNodeMap::value_type
-                             ( notLinkNodes1[nn], notLinkNodes2[nn] ));
+                                ( notLinkNodes1[nn], notLinkNodes2[nn] ));
           }
         }
         else {
@@ -7929,7 +7929,7 @@ SMESH_MeshEditor::Sew_Error
           //                   ( notLinkNodes[0][1], notLinkNodes[1][0] ));
           for(int nn=0; nn<nbNodes-2; nn++) {
             nReplaceMap.insert( TNodeNodeMap::value_type
-                             ( notLinkNodes1[nn], notLinkNodes2[nbNodes-3-nn] ));
+                                ( notLinkNodes1[nn], notLinkNodes2[nbNodes-3-nn] ));
           }
         }
       }
@@ -7959,10 +7959,10 @@ SMESH_MeshEditor::Sew_Error
   } // loop on link lists
 
   if ( aResult == SEW_OK &&
-      ( linkIt[0] != linkList[0].end() ||
-       !faceSetPtr[0]->empty() || !faceSetPtr[1]->empty() )) {
+       ( linkIt[0] != linkList[0].end() ||
+         !faceSetPtr[0]->empty() || !faceSetPtr[1]->empty() )) {
     MESSAGE( (linkIt[0] != linkList[0].end()) <<" "<< (faceSetPtr[0]->empty()) <<
-            " " << (faceSetPtr[1]->empty()));
+             " " << (faceSetPtr[1]->empty()));
     aResult = SEW_TOPO_DIFF_SETS_OF_ELEMENTS;
   }
 
@@ -8017,17 +8017,17 @@ SMESH_MeshEditor::Sew_Error
 }
 
 //================================================================================
-  /*!
  * \brief Find corresponding nodes in two sets of faces
   * \param theSide1 - first face set
   * \param theSide2 - second first face
   * \param theFirstNode1 - a boundary node of set 1
   * \param theFirstNode2 - a node of set 2 corresponding to theFirstNode1
   * \param theSecondNode1 - a boundary node of set 1 linked with theFirstNode1
   * \param theSecondNode2 - a node of set 2 corresponding to theSecondNode1
   * \param nReplaceMap - output map of corresponding nodes
   * \retval bool  - is a success or not
  */
+/*!
+ * \brief Find corresponding nodes in two sets of faces
+ * \param theSide1 - first face set
+ * \param theSide2 - second first face
+ * \param theFirstNode1 - a boundary node of set 1
+ * \param theFirstNode2 - a node of set 2 corresponding to theFirstNode1
+ * \param theSecondNode1 - a boundary node of set 1 linked with theFirstNode1
+ * \param theSecondNode2 - a node of set 2 corresponding to theSecondNode1
+ * \param nReplaceMap - output map of corresponding nodes
+ * \retval bool  - is a success or not
+ */
 //================================================================================
 
 #ifdef _DEBUG_
@@ -8144,8 +8144,8 @@ SMESH_MeshEditor::FindMatchingNodes(set<const SMDS_MeshElement*>& theSide1,
       }
 #ifdef DEBUG_MATCHING_NODES
       MESSAGE ( " Link 1: " << link[0].first->GetID() <<" "<< link[0].second->GetID()
-             << " F 1: " << face[0] << "| Link 2: " << link[1].first->GetID() <<" "
-            << link[1].second->GetID() << " F 2: " << face[1] << " | Bind: " ) ;
+                << " F 1: " << face[0] << "| Link 2: " << link[1].first->GetID() <<" "
+                << link[1].second->GetID() << " F 2: " << face[1] << " | Bind: " ) ;
 #endif
       int nbN = nbNodes[0];
       {
@@ -8176,7 +8176,7 @@ SMESH_MeshEditor::FindMatchingNodes(set<const SMDS_MeshElement*>& theSide1,
         {
 #ifdef DEBUG_MATCHING_NODES
           MESSAGE ( "Add link 1: " << n1->GetID() << " " << n2->GetID() << " "
-         << " | link 2: " << nReplaceMap[n1]->GetID() << " " << nReplaceMap[n2]->GetID() << " " );
+                    << " | link 2: " << nReplaceMap[n1]->GetID() << " " << nReplaceMap[n2]->GetID() << " " );
 #endif
           linkList[0].push_back ( NLink( n1, n2 ));
           linkList[1].push_back ( NLink( nReplaceMap[n1], nReplaceMap[n2] ));
@@ -8192,10 +8192,10 @@ SMESH_MeshEditor::FindMatchingNodes(set<const SMDS_MeshElement*>& theSide1,
 /*!
   \brief Creates a hole in a mesh by doubling the nodes of some particular elements
   \param theElems - the list of elements (edges or faces) to be replicated
-        The nodes for duplication could be found from these elements
+  The nodes for duplication could be found from these elements
   \param theNodesNot - list of nodes to NOT replicate
   \param theAffectedElems - the list of elements (cells and edges) to which the 
-        replicated nodes should be associated to.
+  replicated nodes should be associated to.
   \return TRUE if operation has been completed successfully, FALSE otherwise
 */
 bool SMESH_MeshEditor::DoubleNodes( const TIDSortedElemSet& theElems,
@@ -8253,7 +8253,7 @@ bool SMESH_MeshEditor::doubleNodes( SMESHDS_Mesh*     theMeshDS,
     int ind = 0;
     while ( anIter->more() ) 
     { 
-      
+
       SMDS_MeshNode* aCurrNode = (SMDS_MeshNode*)anIter->next();
       SMDS_MeshNode* aNewNode = aCurrNode;
       if ( theNodeNodeMap.find( aCurrNode ) != theNodeNodeMap.end() )
@@ -8270,12 +8270,12 @@ bool SMESH_MeshEditor::doubleNodes( SMESHDS_Mesh*     theMeshDS,
     }
     if ( !isDuplicate )
       continue;
-  
+
     if ( theIsDoubleElem )
       myLastCreatedElems.Append( AddElement(newNodes, anElem->GetType(), anElem->IsPoly()) );
     else
       theMeshDS->ChangeElementNodes( anElem, &newNodes[ 0 ], anElem->NbNodes() );
-          
+
     res = true;
   }
   return res;
@@ -8308,8 +8308,8 @@ static bool isInside(const SMDS_MeshElement* theElem,
   \param theElems - group of of elements (edges or faces) to be replicated
   \param theNodesNot - group of nodes not to replicated
   \param theShape - shape to detect affected elements (element which geometric center
-         located on or inside shape).
-         The replicated nodes should be associated to affected elements.
+  located on or inside shape).
+  The replicated nodes should be associated to affected elements.
   \return TRUE if operation has been completed successfully, FALSE otherwise
 */