0020439: EDF 695 SMESH : Improvement of DoubleNodes TUI feature

idl/SMESH_MeshEditor.idl

@@ -697,6 +697,49 @@ module SMESH
     */
     long_array GetLastCreatedElems();
 
+    /*!
+     * \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
+     * \sa DoubleNode(), DoubleNodeGroup(), DoubleNodeGroups()
+    */
+    boolean DoubleNodes( in long_array theNodes, in long_array theModifiedElems ); 
+
+    /*!
+    * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
+    * This method provided for convenience works as DoubleNodes() described above.
+    * \param theNodeId - identifier of node to be doubled.
+    * \param theModifiedElems - identifiers of elements to be updated.
+    * \return TRUE if operation has been completed successfully, FALSE otherwise
+    * \sa DoubleNodes(), DoubleNodeGroup(), DoubleNodeGroups()
+    */
+    boolean DoubleNode( in long theNodeId, in long_array theModifiedElems ); 
+
+    /*!
+    * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
+    * This method provided for convenience works as DoubleNodes() described above.
+    * \param theNodes - group of nodes to be doubled.
+    * \param theModifiedElems - group of elements to be updated.
+    * \return TRUE if operation has been completed successfully, FALSE otherwise
+    * \sa DoubleNode(), DoubleNodes(), DoubleNodeGroups()
+    */
+    boolean DoubleNodeGroup( in SMESH_GroupBase theNodes, 
+                             in SMESH_GroupBase theModifiedElems );
+
+    /*!
+    \brief Creates a hole in a mesh by doubling the nodes of some particular elements
+    This method provided for convenience works as DoubleNodes() described above.
+    \param theNodes - list of groups of nodes to be doubled
+    \param theModifiedElems - list of groups of elements to be updated.
+    \return TRUE if operation has been completed successfully, FALSE otherwise
+    \sa DoubleNode(), DoubleNodeGroup(), DoubleNodes()
+    */
+    boolean DoubleNodeGroups( in ListOfGroups theNodes, 
+                              in ListOfGroups theModifiedElems );
+    
     /*!
      * \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
@@ -707,7 +750,7 @@ module SMESH
      * \return TRUE if operation has been completed successfully, FALSE otherwise
      * \sa DoubleNodeGroup(), DoubleNodeGroups()
     */
-    boolean DoubleNodes( in long_array theElems,
+    boolean DoubleNodeElem( in long_array theElems,
                             in long_array theNodesNot,
                             in long_array theAffectedElems ); 
 
@@ -722,7 +765,7 @@ module SMESH
      * \return TRUE if operation has been completed successfully, FALSE otherwise
      * \sa DoubleNodeGroupInRegion(), DoubleNodeGroupsInRegion()
     */
-    boolean DoubleNodesInRegion( in long_array theElems,
+    boolean DoubleNodeElemInRegion( in long_array theElems,
                                     in long_array theNodesNot,
                                     in GEOM::GEOM_Object theShape );
 
@@ -736,7 +779,7 @@ module SMESH
      * \return TRUE if operation has been completed successfully, FALSE otherwise
      * \sa DoubleNodes(), DoubleNodeGroups()
     */
-    boolean DoubleNodeGroup( in SMESH_GroupBase theElems, 
+    boolean DoubleNodeElemGroup( in SMESH_GroupBase theElems, 
                                  in SMESH_GroupBase theNodesNot,
                                  in SMESH_GroupBase theAffectedElems );
 
@@ -751,7 +794,7 @@ module SMESH
      * \return TRUE if operation has been completed successfully, FALSE otherwise
      * \sa DoubleNodesInRegion(), DoubleNodeGroupsInRegion()
     */
-    boolean DoubleNodeGroupInRegion( in SMESH_GroupBase theElems, 
+    boolean DoubleNodeElemGroupInRegion( in SMESH_GroupBase theElems, 
                                      in SMESH_GroupBase theNodesNot,
                                      in GEOM::GEOM_Object theShape );
 
@@ -765,7 +808,7 @@ module SMESH
      * \return TRUE if operation has been completed successfully, FALSE otherwise
      * \sa DoubleNodeGroup(), DoubleNodes()
     */
-    boolean DoubleNodeGroups( in ListOfGroups theElems,
+    boolean DoubleNodeElemGroups( in ListOfGroups theElems,
                                   in ListOfGroups theNodesNot,
                                   in ListOfGroups theAffectedElems );
 
@@ -780,7 +823,7 @@ module SMESH
      * \return TRUE if operation has been completed successfully, FALSE otherwise
      * \sa DoubleNodeGroupInRegion(), DoubleNodesInRegion()
     */
-    boolean DoubleNodeGroupsInRegion( in ListOfGroups theElems,
+    boolean DoubleNodeElemGroupsInRegion( in ListOfGroups theElems,
                                           in ListOfGroups theNodesNot,
                                           in GEOM::GEOM_Object theShape );
 

src/SMESH/SMESH_MeshEditor.cxx

@@ -8769,6 +8769,95 @@ static bool isInside(const SMDS_MeshElement* theElem,
   return (aState == TopAbs_IN || aState == TopAbs_ON );
 }
 
+/*!
+  \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;
+}
+
 /*!
   \brief Creates a hole in a mesh by doubling the nodes of some particular elements
   \param theElems - group of of elements (edges or faces) to be replicated

src/SMESH/SMESH_MeshEditor.hxx

@@ -602,6 +602,9 @@ public:
 
   const SMESH_SequenceOfElemPtr& GetLastCreatedElems() const { return myLastCreatedElems; }
 
+  bool DoubleNodes( const std::list< int >& theListOfNodes, 
+                    const std::list< int >& theListOfModifiedElems );
+  
   bool DoubleNodes( const TIDSortedElemSet& theElems, 
                     const TIDSortedElemSet& theNodesNot,
                     const TIDSortedElemSet& theAffectedElems );

src/SMESH_I/SMESH_MeshEditor_i.cxx

@@ -4214,6 +4214,142 @@ void SMESH_MeshEditor_i::DumpGroupsList(TPythonDump &               theDumpPytho
   }
 }
 
+//================================================================================
+/*!
+  \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
+  \sa DoubleNode(), DoubleNodeGroup(), DoubleNodeGroups()
+*/
+//================================================================================
+
+CORBA::Boolean SMESH_MeshEditor_i::DoubleNodes( const SMESH::long_array& theNodes, 
+                                                const SMESH::long_array& theModifiedElems )
+{
+  initData();
+
+  ::SMESH_MeshEditor aMeshEditor( myMesh );
+  list< int > aListOfNodes;
+  int i, n;
+  for ( i = 0, n = theNodes.length(); i < n; i++ )
+    aListOfNodes.push_back( theNodes[ i ] );
+
+  list< int > aListOfElems;
+  for ( i = 0, n = theModifiedElems.length(); i < n; i++ )
+    aListOfElems.push_back( theModifiedElems[ i ] );
+
+  bool aResult = aMeshEditor.DoubleNodes( aListOfNodes, aListOfElems );
+
+  storeResult( aMeshEditor) ;
+
+  return aResult;
+}
+
+//================================================================================
+/*!
+  \brief Creates a hole in a mesh by doubling the nodes of some particular elements
+  This method provided for convenience works as DoubleNodes() described above.
+  \param theNodeId - identifier of node to be doubled.
+  \param theModifiedElems - identifiers of elements to be updated.
+  \return TRUE if operation has been completed successfully, FALSE otherwise
+  \sa DoubleNodes(), DoubleNodeGroup(), DoubleNodeGroups()
+*/
+//================================================================================
+
+CORBA::Boolean SMESH_MeshEditor_i::DoubleNode( CORBA::Long              theNodeId, 
+                                               const SMESH::long_array& theModifiedElems )
+{
+  SMESH::long_array_var aNodes = new SMESH::long_array;
+  aNodes->length( 1 );
+  aNodes[ 0 ] = theNodeId;
+  return DoubleNodes( aNodes, theModifiedElems );
+}
+
+//================================================================================
+/*!
+  \brief Creates a hole in a mesh by doubling the nodes of some particular elements
+  This method provided for convenience works as DoubleNodes() described above.
+  \param theNodes - group of nodes to be doubled.
+  \param theModifiedElems - group of elements to be updated.
+  \return TRUE if operation has been completed successfully, FALSE otherwise
+  \sa DoubleNode(), DoubleNodes(), DoubleNodeGroups()
+*/
+//================================================================================
+
+CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeGroup( 
+  SMESH::SMESH_GroupBase_ptr theNodes,
+  SMESH::SMESH_GroupBase_ptr theModifiedElems )
+{
+  if ( CORBA::is_nil( theNodes ) && theNodes->GetType() != SMESH::NODE )
+    return false;
+
+  SMESH::long_array_var aNodes = theNodes->GetListOfID();
+  SMESH::long_array_var aModifiedElems;
+  if ( !CORBA::is_nil( theModifiedElems ) )
+    aModifiedElems = theModifiedElems->GetListOfID();
+  else 
+  {
+    aModifiedElems = new SMESH::long_array;
+    aModifiedElems->length( 0 );
+  }
+
+  return DoubleNodes( aNodes, aModifiedElems );
+}
+
+//================================================================================
+/*!
+  \brief Creates a hole in a mesh by doubling the nodes of some particular elements
+  This method provided for convenience works as DoubleNodes() described above.
+  \param theNodes - list of groups of nodes to be doubled
+  \param theModifiedElems - list of groups of elements to be updated.
+  \return TRUE if operation has been completed successfully, FALSE otherwise
+  \sa DoubleNode(), DoubleNodeGroup(), DoubleNodes()
+*/
+//================================================================================
+
+CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeGroups( 
+  const SMESH::ListOfGroups& theNodes,
+  const SMESH::ListOfGroups& theModifiedElems )
+{
+  initData();
+
+  ::SMESH_MeshEditor aMeshEditor( myMesh );
+
+  std::list< int > aNodes;
+  int i, n, j, m;
+  for ( i = 0, n = theNodes.length(); i < n; i++ )
+  {
+    SMESH::SMESH_GroupBase_var aGrp = theNodes[ i ];
+    if ( !CORBA::is_nil( aGrp ) && aGrp->GetType() == SMESH::NODE )
+    {
+      SMESH::long_array_var aCurr = aGrp->GetListOfID();
+      for ( j = 0, m = aCurr->length(); j < m; j++ )
+        aNodes.push_back( aCurr[ j ] );
+    }
+  }
+
+  std::list< int > anElems;
+  for ( i = 0, n = theModifiedElems.length(); i < n; i++ )
+  {
+    SMESH::SMESH_GroupBase_var aGrp = theModifiedElems[ i ];
+    if ( !CORBA::is_nil( aGrp ) && aGrp->GetType() != SMESH::NODE )
+    {
+      SMESH::long_array_var aCurr = aGrp->GetListOfID();
+      for ( j = 0, m = aCurr->length(); j < m; j++ )
+        anElems.push_back( aCurr[ j ] );
+    }
+  }
+
+  bool aResult = aMeshEditor.DoubleNodes( aNodes, anElems );
+
+  storeResult( aMeshEditor) ;
+
+  return aResult;
+}
+
 //================================================================================
 /*!
   \brief Creates a hole in a mesh by doubling the nodes of some particular elements
@@ -4227,7 +4363,7 @@ void SMESH_MeshEditor_i::DumpGroupsList(TPythonDump &               theDumpPytho
 */
 //================================================================================
 
-CORBA::Boolean SMESH_MeshEditor_i::DoubleNodes( const SMESH::long_array& theElems, 
+CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeElem( const SMESH::long_array& theElems, 
                                                    const SMESH::long_array& theNodesNot,
                                                    const SMESH::long_array& theAffectedElems )
 
@@ -4266,7 +4402,7 @@ CORBA::Boolean SMESH_MeshEditor_i::DoubleNodes( const SMESH::long_array& theElem
 */
 //================================================================================
 
-CORBA::Boolean SMESH_MeshEditor_i::DoubleNodesInRegion
+CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeElemInRegion
 ( const SMESH::long_array& theElems, 
   const SMESH::long_array& theNodesNot,
   GEOM::GEOM_Object_ptr    theShape )
@@ -4316,7 +4452,7 @@ static void groupToSet(SMESH::SMESH_GroupBase_ptr theGrp,
   arrayToSet( anIDs, theMeshDS, theElemSet, theType);
 }
 
-CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeGroup( 
+CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeElemGroup( 
                                                        SMESH::SMESH_GroupBase_ptr theElems,
                                                        SMESH::SMESH_GroupBase_ptr theNodesNot,
                                                        SMESH::SMESH_GroupBase_ptr theAffectedElems )
@@ -4358,7 +4494,7 @@ CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeGroup(
 */
 //================================================================================
 
-CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeGroupInRegion( 
+CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeElemGroupInRegion( 
                                                                SMESH::SMESH_GroupBase_ptr theElems,
                                                                SMESH::SMESH_GroupBase_ptr theNodesNot,
                                                                GEOM::GEOM_Object_ptr      theShape )
@@ -4417,7 +4553,7 @@ static void listOfGroupToSet(const SMESH::ListOfGroups& theGrpList,
   }
 }
 
-CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeGroups( 
+CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeElemGroups( 
                                                         const SMESH::ListOfGroups& theElems,
                                                         const SMESH::ListOfGroups& theNodesNot,
                                                         const SMESH::ListOfGroups& theAffectedElems )
@@ -4456,7 +4592,7 @@ CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeGroups(
 */
 //================================================================================
 
-CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeGroupsInRegion( 
+CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeElemGroupsInRegion( 
                                                                 const SMESH::ListOfGroups& theElems,
                                                                 const SMESH::ListOfGroups& theNodesNot,
                                                                 GEOM::GEOM_Object_ptr      theShape )

src/SMESH_I/SMESH_MeshEditor_i.hxx

@@ -514,6 +514,17 @@ class SMESH_MeshEditor_i: public POA_SMESH::SMESH_MeshEditor
    */
   int GetMeshId() const { return myMesh->GetId(); }
 
+ CORBA::Boolean DoubleNodes( const SMESH::long_array& theNodes,
+                              const SMESH::long_array& theModifiedElems );
+
+  CORBA::Boolean DoubleNode( CORBA::Long theNodeId,
+                             const SMESH::long_array& theModifiedElems );
+
+  CORBA::Boolean DoubleNodeGroup( SMESH::SMESH_GroupBase_ptr theNodes,
+                                  SMESH::SMESH_GroupBase_ptr theModifiedElems );
+
+  CORBA::Boolean DoubleNodeGroups( const SMESH::ListOfGroups& theNodes,
+                                   const SMESH::ListOfGroups& theModifiedElems);
 
   /*!
    * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
@@ -525,7 +536,7 @@ class SMESH_MeshEditor_i: public POA_SMESH::SMESH_MeshEditor
    * \return TRUE if operation has been completed successfully, FALSE otherwise
    * \sa DoubleNodeGroup(), DoubleNodeGroups()
    */
-  CORBA::Boolean DoubleNodes( const SMESH::long_array& theElems, 
+  CORBA::Boolean DoubleNodeElem( const SMESH::long_array& theElems, 
                                  const SMESH::long_array& theNodesNot,
                                  const SMESH::long_array& theAffectedElems );
 
@@ -540,7 +551,7 @@ class SMESH_MeshEditor_i: public POA_SMESH::SMESH_MeshEditor
    * \return TRUE if operation has been completed successfully, FALSE otherwise
    * \sa DoubleNodeGroupInRegion(), DoubleNodeGroupsInRegion()
    */
-  CORBA::Boolean DoubleNodesInRegion( const SMESH::long_array& theElems, 
+  CORBA::Boolean DoubleNodeElemInRegion( const SMESH::long_array& theElems, 
                                          const SMESH::long_array& theNodesNot,
                                          GEOM::GEOM_Object_ptr    theShape );
 
@@ -553,7 +564,7 @@ class SMESH_MeshEditor_i: public POA_SMESH::SMESH_MeshEditor
    * \return TRUE if operation has been completed successfully, FALSE otherwise
    * \sa DoubleNodes(), DoubleNodeGroups()
    */
-  CORBA::Boolean DoubleNodeGroup( SMESH::SMESH_GroupBase_ptr theElems,
+  CORBA::Boolean DoubleNodeElemGroup( SMESH::SMESH_GroupBase_ptr theElems,
                                       SMESH::SMESH_GroupBase_ptr theNodesNot,
                                       SMESH::SMESH_GroupBase_ptr theAffectedElems );
   
@@ -567,7 +578,7 @@ class SMESH_MeshEditor_i: public POA_SMESH::SMESH_MeshEditor
    * \return TRUE if operation has been completed successfully, FALSE otherwise
    * \sa DoubleNodesInRegion(), DoubleNodeGroupsInRegion()
    */
-  CORBA::Boolean DoubleNodeGroupInRegion( SMESH::SMESH_GroupBase_ptr theElems,
+  CORBA::Boolean DoubleNodeElemGroupInRegion( SMESH::SMESH_GroupBase_ptr theElems,
                                               SMESH::SMESH_GroupBase_ptr theNodesNot,
                                               GEOM::GEOM_Object_ptr      theShape );
 
@@ -581,7 +592,7 @@ class SMESH_MeshEditor_i: public POA_SMESH::SMESH_MeshEditor
    * \return TRUE if operation has been completed successfully, FALSE otherwise
    * \sa DoubleNodeGroup(), DoubleNodes()
    */
-  CORBA::Boolean DoubleNodeGroups( const SMESH::ListOfGroups& theElems,
+  CORBA::Boolean DoubleNodeElemGroups( const SMESH::ListOfGroups& theElems,
                                        const SMESH::ListOfGroups& theNodesNot,
                                        const SMESH::ListOfGroups& theAffectedElems );
 
@@ -597,7 +608,7 @@ class SMESH_MeshEditor_i: public POA_SMESH::SMESH_MeshEditor
    * \return TRUE if operation has been completed successfully, FALSE otherwise
    * \sa DoubleNodeGroupInRegion(), DoubleNodesInRegion()
    */
-  CORBA::Boolean DoubleNodeGroupsInRegion( const SMESH::ListOfGroups& theElems,
+  CORBA::Boolean DoubleNodeElemGroupsInRegion( const SMESH::ListOfGroups& theElems,
                                                const SMESH::ListOfGroups& theNodesNot,
                                                GEOM::GEOM_Object_ptr      theShape );
 

src/SMESH_SWIG/smeshDC.py

@@ -3422,6 +3422,43 @@ class Mesh:
         return self.editor.GetLastCreatedElems()
 
      ## 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
+    #  @ingroup l2_modif_edit
+    def DoubleNodes(self, theNodes, theModifiedElems):
+        return self.editor.DoubleNodes(theNodes, theModifiedElems)
+        
+    ## Creates a hole in a mesh by doubling the nodes of some particular elements
+    #  This method provided for convenience works as DoubleNodes() described above.
+    #  @param theNodes identifiers of node to be doubled
+    #  @param theModifiedElems identifiers of elements to be updated
+    #  @return TRUE if operation has been completed successfully, FALSE otherwise
+    #  @ingroup l2_modif_edit
+    def DoubleNode(self, theNodeId, theModifiedElems):
+        return self.editor.DoubleNode(theNodeId, theModifiedElems)
+        
+    ## Creates a hole in a mesh by doubling the nodes of some particular elements
+    #  This method provided for convenience works as DoubleNodes() described above.
+    #  @param theNodes group of nodes to be doubled
+    #  @param theModifiedElems group of elements to be updated.
+    #  @return TRUE if operation has been completed successfully, FALSE otherwise
+    #  @ingroup l2_modif_edit
+    def DoubleNodeGroup(self, theNodes, theModifiedElems):
+        return self.editor.DoubleNodeGroup(theNodes, theModifiedElems)
+        
+    ## Creates a hole in a mesh by doubling the nodes of some particular elements
+    #  This method provided for convenience works as DoubleNodes() described above.
+    #  @param theNodes list of groups of nodes to be doubled
+    #  @param theModifiedElems list of groups of elements to be updated.
+    #  @return TRUE if operation has been completed successfully, FALSE otherwise
+    #  @ingroup l2_modif_edit
+    def DoubleNodeGroups(self, theNodes, theModifiedElems):
+        return self.editor.DoubleNodeGroups(theNodes, theModifiedElems)
+    
+    ## 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
     #  @param theNodesNot - list of nodes to NOT replicate
@@ -3429,8 +3466,8 @@ class Mesh:
     #         replicated nodes should be associated to.
     #  @return TRUE if operation has been completed successfully, FALSE otherwise
     #  @ingroup l2_modif_edit
-    def DoubleNodes(self, theElems, theNodesNot, theAffectedElems):
+    def DoubleNodeElem(self, theElems, theNodesNot, theAffectedElems):
-        return self.editor.DoubleNodes(theElems, theNodesNot, theAffectedElems)
+        return self.editor.DoubleNodeElem(theElems, theNodesNot, theAffectedElems)
         
     ## 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
@@ -3441,8 +3478,8 @@ class Mesh:
     #         The replicated nodes should be associated to affected elements.
     #  @return TRUE if operation has been completed successfully, FALSE otherwise
     #  @ingroup l2_modif_edit
-    def DoubleNodesInRegion(self, theElems, theNodesNot, theShape):
+    def DoubleNodeElemInRegion(self, theElems, theNodesNot, theShape):
-        return self.editor.DoubleNodesInRegion(theElems, theNodesNot, theShape)
+        return self.editor.DoubleNodeElemInRegion(theElems, theNodesNot, theShape)
     
     ## Creates a hole in a mesh by doubling the nodes of some particular elements
     #  This method provided for convenience works as DoubleNodes() described above.
@@ -3451,8 +3488,8 @@ class Mesh:
     #  @param theAffectedElems - group of elements to which the replicated nodes
     #         should be associated to.
     #  @ingroup l2_modif_edit
-    def DoubleNodeGroup(self, theElems, theNodesNot, theAffectedElems):
+    def DoubleNodeElemGroup(self, theElems, theNodesNot, theAffectedElems):
-        return self.editor.DoubleNodeGroup(theElems, theNodesNot, theAffectedElems)
+        return self.editor.DoubleNodeElemGroup(theElems, theNodesNot, theAffectedElems)
         
     ## Creates a hole in a mesh by doubling the nodes of some particular elements
     #  This method provided for convenience works as DoubleNodes() described above.
@@ -3462,8 +3499,8 @@ class Mesh:
     #         located on or inside shape).
     #         The replicated nodes should be associated to affected elements.
     #  @ingroup l2_modif_edit
-    def DoubleNodeGroupInRegion(self, theElems, theNodesNot, theShape):
+    def DoubleNodeElemGroupInRegion(self, theElems, theNodesNot, theShape):
-        return self.editor.DoubleNodeGroup(theElems, theNodesNot, theShape)
+        return self.editor.DoubleNodeElemGroup(theElems, theNodesNot, theShape)
         
     ## Creates a hole in a mesh by doubling the nodes of some particular elements
     #  This method provided for convenience works as DoubleNodes() described above.
@@ -3473,8 +3510,8 @@ class Mesh:
     #         should be associated to.
     #  @return TRUE if operation has been completed successfully, FALSE otherwise
     #  @ingroup l2_modif_edit
-    def DoubleNodeGroups(self, theElems, theNodesNot, theAffectedElems):
+    def DoubleNodeElemGroups(self, theElems, theNodesNot, theAffectedElems):
-        return self.editor.DoubleNodeGroups(theElems, theNodesNot, theAffectedElems)
+        return self.editor.DoubleNodeElemGroups(theElems, theNodesNot, theAffectedElems)
 
     ## Creates a hole in a mesh by doubling the nodes of some particular elements
     #  This method provided for convenience works as DoubleNodes() described above.
@@ -3485,8 +3522,8 @@ class Mesh:
     #         The replicated nodes should be associated to affected elements.
     #  @return TRUE if operation has been completed successfully, FALSE otherwise
     #  @ingroup l2_modif_edit
-    def DoubleNodeGroupsInRegion(self, theElems, theNodesNot, theShape):
+    def DoubleNodeElemGroupsInRegion(self, theElems, theNodesNot, theShape):
-        return self.editor.DoubleNodeGroupsInRegion(theElems, theNodesNot, theShape)
+        return self.editor.DoubleNodeElemGroupsInRegion(theElems, theNodesNot, theShape)
 
 ## The mother class to define algorithm, it is not recommended to use it directly.
 #