+ 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 );
+ }
+
+ TPythonDump pyDump; // suppress dump by the next line
+
+ bool done = DoubleNodes( aNodes, aModifiedElems );
+
+ pyDump << this << ".DoubleNodeGroup( " << theNodes << ", " << theModifiedElems << " )";
+
+ return done;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
+}
+
+//================================================================================
+/*!
+ * \brief Creates a hole in a mesh by doubling the nodes of some particular elements.
+ * Works as DoubleNodeGroup(), but returns a new group with newly created nodes.
+ * \param theNodes - group of nodes to be doubled.
+ * \param theModifiedElems - group of elements to be updated.
+ * \return a new group with newly created nodes
+ * \sa DoubleNodeGroup()
+ */
+//================================================================================
+
+SMESH::SMESH_Group_ptr
+SMESH_MeshEditor_i::DoubleNodeGroupNew( SMESH::SMESH_GroupBase_ptr theNodes,
+ SMESH::SMESH_GroupBase_ptr theModifiedElems )
+ throw (SALOME::SALOME_Exception)
+{
+ SMESH_TRY;
+ SMESH::SMESH_Group_var aNewGroup;
+
+ if ( CORBA::is_nil( theNodes ) && theNodes->GetType() != SMESH::NODE )
+ return aNewGroup._retn();
+
+ // Duplicate nodes
+ 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 );
+ }
+
+ TPythonDump pyDump; // suppress dump by the next line
+
+ bool aResult = DoubleNodes( aNodes, aModifiedElems );
+ if ( aResult )
+ {
+ // Create group with newly created nodes
+ SMESH::long_array_var anIds = GetLastCreatedNodes();
+ if (anIds->length() > 0) {
+ string anUnindexedName (theNodes->GetName());
+ string aNewName = generateGroupName(anUnindexedName + "_double");
+ aNewGroup = myMesh_i->CreateGroup(SMESH::NODE, aNewName.c_str());
+ aNewGroup->Add(anIds);
+ pyDump << aNewGroup << " = ";
+ }
+ }
+
+ pyDump << this << ".DoubleNodeGroupNew( " << theNodes << ", "
+ << theModifiedElems << " )";
+
+ return aNewGroup._retn();
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
+}
+
+//================================================================================
+/*!
+ \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 )
+ throw (SALOME::SALOME_Exception)
+{
+ SMESH_TRY;
+ initData();
+
+ 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 = getEditor().DoubleNodes( aNodes, anElems );
+
+ declareMeshModified( /*isReComputeSafe=*/false );
+
+ TPythonDump() << this << ".DoubleNodeGroups( " << theNodes << ", " << theModifiedElems << " )";
+
+ return aResult;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
+}
+
+//================================================================================
+/*!
+ * \brief Creates a hole in a mesh by doubling the nodes of some particular elements.
+ * Works as DoubleNodeGroups(), but returns a new group with newly created nodes.
+ * \param theNodes - group of nodes to be doubled.
+ * \param theModifiedElems - group of elements to be updated.
+ * \return a new group with newly created nodes
+ * \sa DoubleNodeGroups()
+ */
+//================================================================================
+
+SMESH::SMESH_Group_ptr
+SMESH_MeshEditor_i::DoubleNodeGroupsNew( const SMESH::ListOfGroups& theNodes,
+ const SMESH::ListOfGroups& theModifiedElems )
+ throw (SALOME::SALOME_Exception)
+{
+ SMESH::SMESH_Group_var aNewGroup;
+
+ TPythonDump pyDump; // suppress dump by the next line
+
+ bool aResult = DoubleNodeGroups( theNodes, theModifiedElems );
+
+ if ( aResult )
+ {
+ // Create group with newly created nodes
+ SMESH::long_array_var anIds = GetLastCreatedNodes();
+ if (anIds->length() > 0) {
+ string anUnindexedName (theNodes[0]->GetName());
+ string aNewName = generateGroupName(anUnindexedName + "_double");
+ aNewGroup = myMesh_i->CreateGroup(SMESH::NODE, aNewName.c_str());
+ aNewGroup->Add(anIds);
+ pyDump << aNewGroup << " = ";
+ }
+ }
+
+ pyDump << this << ".DoubleNodeGroupsNew( " << theNodes << ", "
+ << theModifiedElems << " )";
+
+ return aNewGroup._retn();
+}
+
+
+//================================================================================
+/*!
+ \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
+ \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.
+ \return TRUE if operation has been completed successfully, FALSE otherwise
+ \sa DoubleNodeGroup(), DoubleNodeGroups()
+*/
+//================================================================================
+
+CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeElem( const SMESH::long_array& theElems,
+ const SMESH::long_array& theNodesNot,
+ const SMESH::long_array& theAffectedElems )
+ throw (SALOME::SALOME_Exception)
+{
+ SMESH_TRY;
+ initData();
+
+ SMESHDS_Mesh* aMeshDS = getMeshDS();
+ TIDSortedElemSet anElems, aNodes, anAffected;
+ arrayToSet(theElems, aMeshDS, anElems, SMDSAbs_All);
+ arrayToSet(theNodesNot, aMeshDS, aNodes, SMDSAbs_Node);
+ arrayToSet(theAffectedElems, aMeshDS, anAffected, SMDSAbs_All);
+
+ bool aResult = getEditor().DoubleNodes( anElems, aNodes, anAffected );
+
+ // Update Python script
+ TPythonDump() << this << ".DoubleNodeElem( " << theElems << ", "
+ << theNodesNot << ", " << theAffectedElems << " )";
+
+ declareMeshModified( /*isReComputeSafe=*/false );
+ return aResult;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
+}
+
+//================================================================================
+/*!
+ \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
+ \param theNodesNot - list of nodes to NOT replicate
+ \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.
+ \return TRUE if operation has been completed successfully, FALSE otherwise
+ \sa DoubleNodeGroupInRegion(), DoubleNodeGroupsInRegion()
+*/
+//================================================================================
+
+CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeElemInRegion ( const SMESH::long_array& theElems,
+ const SMESH::long_array& theNodesNot,
+ GEOM::GEOM_Object_ptr theShape )
+ throw (SALOME::SALOME_Exception)
+{
+ SMESH_TRY;
+ initData();
+
+
+ SMESHDS_Mesh* aMeshDS = getMeshDS();
+ TIDSortedElemSet anElems, aNodes;
+ arrayToSet(theElems, aMeshDS, anElems, SMDSAbs_All);
+ arrayToSet(theNodesNot, aMeshDS, aNodes, SMDSAbs_Node);
+
+ TopoDS_Shape aShape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( theShape );
+ bool aResult = getEditor().DoubleNodesInRegion( anElems, aNodes, aShape );
+
+ // Update Python script
+ TPythonDump() << "isDone = " << this << ".DoubleNodeElemInRegion( " << theElems << ", "
+ << theNodesNot << ", " << theShape << " )";
+
+ declareMeshModified( /*isReComputeSafe=*/false );
+ return aResult;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
+}
+
+//================================================================================
+/*!
+ \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
+ \param theNodesNot - group of nodes not to replicated
+ \param theAffectedElems - group of elements to which the replicated nodes
+ should be associated to.
+ \return TRUE if operation has been completed successfully, FALSE otherwise
+ \sa DoubleNodes(), DoubleNodeGroups()
+*/
+//================================================================================
+
+CORBA::Boolean
+SMESH_MeshEditor_i::DoubleNodeElemGroup(SMESH::SMESH_GroupBase_ptr theElems,
+ SMESH::SMESH_GroupBase_ptr theNodesNot,
+ SMESH::SMESH_GroupBase_ptr theAffectedElems)
+ throw (SALOME::SALOME_Exception)
+{
+ SMESH_TRY;
+ if ( CORBA::is_nil( theElems ) && theElems->GetType() == SMESH::NODE )
+ return false;
+
+ initData();
+
+
+ SMESHDS_Mesh* aMeshDS = getMeshDS();
+ TIDSortedElemSet anElems, aNodes, anAffected;
+ idSourceToSet( theElems, aMeshDS, anElems, SMDSAbs_All );
+ idSourceToSet( theNodesNot, aMeshDS, aNodes, SMDSAbs_Node );
+ idSourceToSet( theAffectedElems, aMeshDS, anAffected, SMDSAbs_All );
+
+ bool aResult = getEditor().DoubleNodes( anElems, aNodes, anAffected );
+
+ // Update Python script
+ TPythonDump() << "isDone = " << this << ".DoubleNodeElemGroup( " << theElems << ", "
+ << theNodesNot << ", " << theAffectedElems << " )";
+
+ declareMeshModified( /*isReComputeSafe=*/false );
+ return aResult;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
+}
+
+//================================================================================
+/*!
+ * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
+ * Works as DoubleNodeElemGroup(), but returns a new group with newly created elements.
+ * \param theElems - group of of elements (edges or faces) to be replicated
+ * \param theNodesNot - group of nodes not to replicated
+ * \param theAffectedElems - group of elements to which the replicated nodes
+ * should be associated to.
+ * \return a new group with newly created elements
+ * \sa DoubleNodeElemGroup()
+ */
+//================================================================================
+
+SMESH::SMESH_Group_ptr
+SMESH_MeshEditor_i::DoubleNodeElemGroupNew(SMESH::SMESH_GroupBase_ptr theElems,
+ SMESH::SMESH_GroupBase_ptr theNodesNot,
+ SMESH::SMESH_GroupBase_ptr theAffectedElems)
+ throw (SALOME::SALOME_Exception)
+{
+ TPythonDump pyDump;
+ SMESH::ListOfGroups_var twoGroups = DoubleNodeElemGroup2New( theElems,
+ theNodesNot,
+ theAffectedElems,
+ true, false );
+ SMESH::SMESH_GroupBase_var baseGroup = twoGroups[0].in();
+ SMESH::SMESH_Group_var elemGroup = SMESH::SMESH_Group::_narrow( baseGroup );
+
+ pyDump << elemGroup << " = " << this << ".DoubleNodeElemGroupNew( "
+ << theElems << ", "
+ << theNodesNot << ", "
+ << theAffectedElems << " )";
+
+ return elemGroup._retn();
+}
+
+//================================================================================
+/*!
+ * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
+ * Works as DoubleNodeElemGroup(), but returns a new group with newly created elements.
+ * \param theElems - group of of elements (edges or faces) to be replicated
+ * \param theNodesNot - group of nodes not to replicated
+ * \param theAffectedElems - group of elements to which the replicated nodes
+ * should be associated to.
+ * \return a new group with newly created elements
+ * \sa DoubleNodeElemGroup()
+ */
+//================================================================================
+
+SMESH::ListOfGroups*
+SMESH_MeshEditor_i::DoubleNodeElemGroup2New(SMESH::SMESH_GroupBase_ptr theElems,
+ SMESH::SMESH_GroupBase_ptr theNodesNot,
+ SMESH::SMESH_GroupBase_ptr theAffectedElems,
+ CORBA::Boolean theElemGroupNeeded,
+ CORBA::Boolean theNodeGroupNeeded)
+ throw (SALOME::SALOME_Exception)
+{
+ SMESH_TRY;
+ SMESH::SMESH_Group_var aNewElemGroup, aNewNodeGroup;
+ SMESH::ListOfGroups_var aTwoGroups = new SMESH::ListOfGroups();
+ aTwoGroups->length( 2 );
+
+ if ( CORBA::is_nil( theElems ) && theElems->GetType() == SMESH::NODE )
+ return aTwoGroups._retn();
+
+ initData();
+
+
+ SMESHDS_Mesh* aMeshDS = getMeshDS();
+ TIDSortedElemSet anElems, aNodes, anAffected;
+ idSourceToSet( theElems, aMeshDS, anElems, SMDSAbs_All );
+ idSourceToSet( theNodesNot, aMeshDS, aNodes, SMDSAbs_Node );
+ idSourceToSet( theAffectedElems, aMeshDS, anAffected, SMDSAbs_All );
+
+
+ bool aResult = getEditor().DoubleNodes( anElems, aNodes, anAffected );
+
+ declareMeshModified( /*isReComputeSafe=*/ !aResult );
+
+ TPythonDump pyDump;
+
+ if ( aResult )
+ {
+ // Create group with newly created elements
+ CORBA::String_var elemGroupName = theElems->GetName();
+ string aNewName = generateGroupName( string(elemGroupName.in()) + "_double");
+ if ( !getEditor().GetLastCreatedElems().IsEmpty() && theElemGroupNeeded )
+ {
+ SMESH::long_array_var anIds = GetLastCreatedElems();
+ SMESH::ElementType aGroupType = myMesh_i->GetElementType(anIds[0], true);
+ aNewElemGroup = myMesh_i->CreateGroup(aGroupType, aNewName.c_str());
+ aNewElemGroup->Add(anIds);
+ }
+ if ( !getEditor().GetLastCreatedNodes().IsEmpty() && theNodeGroupNeeded )
+ {
+ SMESH::long_array_var anIds = GetLastCreatedNodes();
+ aNewNodeGroup = myMesh_i->CreateGroup(SMESH::NODE, aNewName.c_str());
+ aNewNodeGroup->Add(anIds);
+ }
+ }
+
+ // Update Python script
+
+ pyDump << "[ ";
+ if ( aNewElemGroup->_is_nil() ) pyDump << "nothing, ";
+ else pyDump << aNewElemGroup << ", ";
+ if ( aNewNodeGroup->_is_nil() ) pyDump << "nothing ] = ";
+ else pyDump << aNewNodeGroup << " ] = ";
+
+ pyDump << this << ".DoubleNodeElemGroup2New( " << theElems << ", "
+ << theNodesNot << ", "
+ << theAffectedElems << ", "
+ << theElemGroupNeeded << ", "
+ << theNodeGroupNeeded <<" )";
+
+ aTwoGroups[0] = aNewElemGroup._retn();
+ aTwoGroups[1] = aNewNodeGroup._retn();
+ return aTwoGroups._retn();
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
+}
+
+//================================================================================
+/*!
+ \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
+ \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.
+ \return TRUE if operation has been completed successfully, FALSE otherwise
+ \sa DoubleNodesInRegion(), DoubleNodeGroupsInRegion()
+*/
+//================================================================================
+
+CORBA::Boolean
+SMESH_MeshEditor_i::DoubleNodeElemGroupInRegion(SMESH::SMESH_GroupBase_ptr theElems,
+ SMESH::SMESH_GroupBase_ptr theNodesNot,
+ GEOM::GEOM_Object_ptr theShape )
+ throw (SALOME::SALOME_Exception)
+{
+ SMESH_TRY;
+ if ( CORBA::is_nil( theElems ) && theElems->GetType() == SMESH::NODE )
+ return false;
+
+ initData();
+
+
+ SMESHDS_Mesh* aMeshDS = getMeshDS();
+ TIDSortedElemSet anElems, aNodes, anAffected;
+ idSourceToSet( theElems, aMeshDS, anElems, SMDSAbs_All );
+ idSourceToSet( theNodesNot, aMeshDS, aNodes, SMDSAbs_Node );
+
+ TopoDS_Shape aShape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( theShape );
+ bool aResult = getEditor().DoubleNodesInRegion( anElems, aNodes, aShape );
+
+
+ declareMeshModified( /*isReComputeSafe=*/ !aResult );
+
+ // Update Python script
+ TPythonDump() << "isDone = " << this << ".DoubleNodeElemGroupInRegion( " << theElems << ", "
+ << theNodesNot << ", " << theShape << " )";
+ return aResult;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
+}
+
+//================================================================================
+/*!
+ * \brief Re-load elements from a list of groups into a TIDSortedElemSet
+ * \param [in] theGrpList - groups
+ * \param [in] theMeshDS - mesh
+ * \param [out] theElemSet - set of elements
+ * \param [in] theIsNodeGrp - is \a theGrpList includes goups of nodes
+ */
+//================================================================================
+
+static void listOfGroupToSet(const SMESH::ListOfGroups& theGrpList,
+ SMESHDS_Mesh* theMeshDS,
+ TIDSortedElemSet& theElemSet,
+ const bool theIsNodeGrp)
+{
+ for ( int i = 0, n = theGrpList.length(); i < n; i++ )
+ {
+ SMESH::SMESH_GroupBase_var aGrp = theGrpList[ i ];
+ if ( !CORBA::is_nil( aGrp ) && (theIsNodeGrp ? aGrp->GetType() == SMESH::NODE
+ : aGrp->GetType() != SMESH::NODE ) )
+ {
+ SMESH::long_array_var anIDs = aGrp->GetIDs();
+ arrayToSet( anIDs, theMeshDS, theElemSet, theIsNodeGrp ? SMDSAbs_Node : SMDSAbs_All );
+ }
+ }
+}
+
+//================================================================================
+/*!
+ \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 theElems - list of groups of elements (edges or faces) to be replicated
+ \param theNodesNot - list of groups of nodes not to replicated
+ \param theAffectedElems - group of elements to which the replicated nodes
+ should be associated to.
+ \return TRUE if operation has been completed successfully, FALSE otherwise
+ \sa DoubleNodeGroup(), DoubleNodes(), DoubleNodeElemGroupsNew()
+*/
+//================================================================================
+
+CORBA::Boolean
+SMESH_MeshEditor_i::DoubleNodeElemGroups(const SMESH::ListOfGroups& theElems,
+ const SMESH::ListOfGroups& theNodesNot,
+ const SMESH::ListOfGroups& theAffectedElems)
+ throw (SALOME::SALOME_Exception)
+{
+ SMESH_TRY;
+ initData();
+