}
//================================================================================
/*!
- * \brief function for conversion long_array to TIDSortedElemSet
+ * \brief function for conversion of long_array to TIDSortedElemSet
* \param IDs - array of IDs
* \param aMesh - mesh
* \param aMap - collection to fill
if ( const SMDS_MeshNode * n = theMeshDS->FindNode( aElementsId[i] ))
theNodeSet.insert( theNodeSet.end(), n);
}
- else {
+ else if ( SMESH::DownCast<SMESH_Mesh_i*>( theObject ))
+ {
+ SMDS_NodeIteratorPtr nIt = theMeshDS->nodesIterator();
+ while ( nIt->more( ))
+ if( const SMDS_MeshElement * elem = nIt->next() )
+ theNodeSet.insert( elem->begin_nodes(), elem->end_nodes());
+ }
+ else
+ {
for(int i = 0; i < aElementsId->length(); i++)
if( const SMDS_MeshElement * elem = theMeshDS->FindElement( aElementsId[i] ))
theNodeSet.insert( elem->begin_nodes(), elem->end_nodes());
}
}
+
+ //================================================================================
+ /*!
+ * \brief Returns elements connected to the given elements
+ */
+ //================================================================================
+
+ void getElementsAround(const TIDSortedElemSet& theElements,
+ const SMESHDS_Mesh* theMeshDS,
+ TIDSortedElemSet& theElementsAround)
+ {
+ if ( theElements.empty() ) return;
+
+ SMDSAbs_ElementType elemType = (*theElements.begin())->GetType();
+ bool sameElemType = ( elemType == (*theElements.rbegin())->GetType() );
+ if ( sameElemType &&
+ theMeshDS->GetMeshInfo().NbElements( elemType ) == theElements.size() )
+ return; // all the elements are in theElements
+
+ if ( !sameElemType )
+ elemType = SMDSAbs_All;
+
+ TIDSortedElemSet visitedNodes;
+ TIDSortedElemSet::const_iterator elemIt = theElements.begin();
+ for ( ; elemIt != theElements.end(); ++elemIt )
+ {
+ const SMDS_MeshElement* e = *elemIt;
+ int i = e->NbCornerNodes();
+ while ( --i != -1 )
+ {
+ const SMDS_MeshNode* n = e->GetNode( i );
+ if ( visitedNodes.insert( n ).second )
+ {
+ SMDS_ElemIteratorPtr invIt = n->GetInverseElementIterator(elemType);
+ while ( invIt->more() )
+ {
+ const SMDS_MeshElement* elemAround = invIt->next();
+ if ( !theElements.count( elemAround ))
+ theElementsAround.insert( elemAround );
+ }
+ }
+ }
+ }
+ }
}
//=============================================================================
SMESH_MeshEditor_i::extrusionSweep(const SMESH::long_array & theIDsOfElements,
const SMESH::DirStruct & theStepVector,
CORBA::Long theNbOfSteps,
- const bool theMakeGroups,
+ bool theMakeGroups,
const SMDSAbs_ElementType theElementType)
{
initData();
#ifdef NO_CAS_CATCH
OCC_CATCH_SIGNALS;
#endif
- TIDSortedElemSet elements;
+ TIDSortedElemSet elements, copyElements;
arrayToSet(theIDsOfElements, GetMeshDS(), elements, theElementType);
const SMESH::PointStruct * P = &theStepVector.PS;
gp_Vec stepVec( P->x, P->y, P->z );
+ TIDSortedElemSet* workElements = & elements;
+ TPreviewMesh tmpMesh( SMDSAbs_Face );
+ SMESH_Mesh* mesh = myMesh;
+
+ if ( myPreviewMode ) {
+ SMDSAbs_ElementType select = SMDSAbs_All, avoid = SMDSAbs_Volume;
+ tmpMesh.Copy( elements, copyElements, select, avoid );
+ mesh = &tmpMesh;
+ workElements = & copyElements;
+ theMakeGroups = false;
+ }
+
TElemOfElemListMap aHystory;
- ::SMESH_MeshEditor anEditor( myMesh );
+ ::SMESH_MeshEditor anEditor( mesh );
::SMESH_MeshEditor::PGroupIDs groupIds =
- anEditor.ExtrusionSweep (elements, stepVec, theNbOfSteps, aHystory, theMakeGroups);
+ anEditor.ExtrusionSweep (*workElements, stepVec, theNbOfSteps, aHystory, theMakeGroups);
myMesh->GetMeshDS()->Modified();
storeResult(anEditor);
CORBA::Boolean LinearVariation,
CORBA::Boolean HasRefPoint,
const SMESH::PointStruct& RefPoint,
- const bool MakeGroups,
+ bool MakeGroups,
const SMDSAbs_ElementType ElementType,
SMESH::SMESH_MeshEditor::Extrusion_Error & Error)
{
return EmptyGr;
}
- TIDSortedElemSet elements;
+ TIDSortedElemSet elements, copyElements;
arrayToSet(IDsOfElements, GetMeshDS(), elements, ElementType);
- ::SMESH_MeshEditor anEditor( myMesh );
+ TIDSortedElemSet* workElements = &elements;
+ TPreviewMesh tmpMesh( SMDSAbs_Face );
+ SMESH_Mesh* mesh = myMesh;
+
+ if ( myPreviewMode )
+ {
+ SMDSAbs_ElementType select = SMDSAbs_All, avoid = SMDSAbs_Volume;
+ tmpMesh.Copy( elements, copyElements, select, avoid );
+ mesh = &tmpMesh;
+ workElements = & copyElements;
+ MakeGroups = false;
+ }
+
+ ::SMESH_MeshEditor anEditor( mesh );
::SMESH_MeshEditor::Extrusion_Error error;
- SMESH_Mesh_i* aMeshImp = SMESH::DownCast<SMESH_Mesh_i*>( Path );
- if(aMeshImp) {
+ if ( SMESH_Mesh_i* aMeshImp = SMESH::DownCast<SMESH_Mesh_i*>( Path ))
+ {
// path as mesh
SMDS_MeshNode* aNodeStart =
(SMDS_MeshNode*)aMeshImp->GetImpl().GetMeshDS()->FindNode(NodeStart);
Error = SMESH::SMESH_MeshEditor::EXTR_BAD_STARTING_NODE;
return EmptyGr;
}
- error = anEditor.ExtrusionAlongTrack( elements, &(aMeshImp->GetImpl()), aNodeStart,
+ error = anEditor.ExtrusionAlongTrack( *workElements, &(aMeshImp->GetImpl()), aNodeStart,
HasAngles, angles, LinearVariation,
HasRefPoint, refPnt, MakeGroups );
myMesh->GetMeshDS()->Modified();
}
- else {
- SMESH_subMesh_i* aSubMeshImp = SMESH::DownCast<SMESH_subMesh_i*>( Path );
- if(aSubMeshImp) {
- // path as submesh
- SMESH::SMESH_Mesh_ptr aPathMesh = aSubMeshImp->GetFather();
- aMeshImp = SMESH::DownCast<SMESH_Mesh_i*>( aPathMesh );
- SMDS_MeshNode* aNodeStart =
- (SMDS_MeshNode*)aMeshImp->GetImpl().GetMeshDS()->FindNode(NodeStart);
- if ( !aNodeStart ) {
- Error = SMESH::SMESH_MeshEditor::EXTR_BAD_STARTING_NODE;
- return EmptyGr;
- }
- SMESH_subMesh* aSubMesh =
- aMeshImp->GetImpl().GetSubMeshContaining(aSubMeshImp->GetId());
- error = anEditor.ExtrusionAlongTrack( elements, aSubMesh, aNodeStart,
- HasAngles, angles, LinearVariation,
- HasRefPoint, refPnt, MakeGroups );
- myMesh->GetMeshDS()->Modified();
- }
- else {
- SMESH_Group_i* aGroupImp = SMESH::DownCast<SMESH_Group_i*>( Path );
- if(aGroupImp) {
- // path as group of 1D elements
- }
- else {
- // invalid path
- Error = SMESH::SMESH_MeshEditor::EXTR_BAD_PATH_SHAPE;
- return EmptyGr;
- }
+ else if ( SMESH_subMesh_i* aSubMeshImp = SMESH::DownCast<SMESH_subMesh_i*>( Path ))
+ {
+ // path as submesh
+ SMESH::SMESH_Mesh_ptr aPathMesh = aSubMeshImp->GetFather();
+ aMeshImp = SMESH::DownCast<SMESH_Mesh_i*>( aPathMesh );
+ SMDS_MeshNode* aNodeStart =
+ (SMDS_MeshNode*)aMeshImp->GetImpl().GetMeshDS()->FindNode(NodeStart);
+ if ( !aNodeStart ) {
+ Error = SMESH::SMESH_MeshEditor::EXTR_BAD_STARTING_NODE;
+ return EmptyGr;
}
+ SMESH_subMesh* aSubMesh =
+ aMeshImp->GetImpl().GetSubMeshContaining(aSubMeshImp->GetId());
+ error = anEditor.ExtrusionAlongTrack( *workElements, aSubMesh, aNodeStart,
+ HasAngles, angles, LinearVariation,
+ HasRefPoint, refPnt, MakeGroups );
+ myMesh->GetMeshDS()->Modified();
+ }
+ else if ( SMESH::DownCast<SMESH_Group_i*>( Path ))
+ {
+ // path as group of 1D elements
+ // ????????
+ }
+ else
+ {
+ // invalid path
+ Error = SMESH::SMESH_MeshEditor::EXTR_BAD_PATH_SHAPE;
+ return EmptyGr;
}
storeResult(anEditor);
const SMESH::AxisStruct & theAxis,
SMESH::SMESH_MeshEditor::MirrorType theMirrorType,
CORBA::Boolean theCopy,
- const bool theMakeGroups,
+ bool theMakeGroups,
::SMESH_Mesh* theTargetMesh)
{
initData();
gp_Pnt P ( theAxis.x, theAxis.y, theAxis.z );
gp_Vec V ( theAxis.vx, theAxis.vy, theAxis.vz );
+ if ( theTargetMesh )
+ theCopy = false;
+
gp_Trsf aTrsf;
switch ( theMirrorType ) {
case SMESH::SMESH_MeshEditor::POINT:
aTrsf.SetMirror( gp_Ax2( P, V ));
}
- ::SMESH_MeshEditor anEditor( myMesh );
- ::SMESH_MeshEditor::PGroupIDs groupIds =
- anEditor.Transform (theElements, aTrsf, theCopy, theMakeGroups, theTargetMesh);
+ TIDSortedElemSet copyElements;
+ TPreviewMesh tmpMesh;
+ TIDSortedElemSet* workElements = & theElements;
+ SMESH_Mesh* mesh = myMesh;
- if(theCopy)
- storeResult(anEditor);
- else
+ if ( myPreviewMode )
+ {
+ tmpMesh.Copy( theElements, copyElements);
+ if ( !theCopy && !theTargetMesh )
{
- myMesh->GetMeshDS()->Modified();
- myMesh->SetIsModified( true );
+ TIDSortedElemSet elemsAround, elemsAroundCopy;
+ getElementsAround( theElements, GetMeshDS(), elemsAround );
+ tmpMesh.Copy( elemsAround, elemsAroundCopy);
}
+ mesh = &tmpMesh;
+ workElements = & copyElements;
+ theMakeGroups = false;
+ }
+ ::SMESH_MeshEditor anEditor( mesh );
+ ::SMESH_MeshEditor::PGroupIDs groupIds =
+ anEditor.Transform (*workElements, aTrsf, theCopy, theMakeGroups, theTargetMesh);
+
+ if(theCopy || myPreviewMode)
+ storeResult(anEditor);
+ else
+ {
+ myMesh->SetIsModified( true );
+ myMesh->GetMeshDS()->Modified();
+ }
return theMakeGroups ? getGroups(groupIds.get()) : 0;
}
<< theCopy << " )";
}
TIDSortedElemSet elements;
- if (idSourceToSet(theObject, GetMeshDS(), elements, SMDSAbs_All, /*emptyIfIsMesh=*/1))
+
+ bool emptyIfIsMesh = myPreviewMode ? false : true;
+
+ if (idSourceToSet(theObject, GetMeshDS(), elements, SMDSAbs_All, emptyIfIsMesh))
mirror(elements, theAxis, theMirrorType, theCopy, false);
}
SMESH_MeshEditor_i::translate(TIDSortedElemSet & theElements,
const SMESH::DirStruct & theVector,
CORBA::Boolean theCopy,
- const bool theMakeGroups,
+ bool theMakeGroups,
::SMESH_Mesh* theTargetMesh)
{
initData();
+ if ( theTargetMesh )
+ theCopy = false;
+
gp_Trsf aTrsf;
const SMESH::PointStruct * P = &theVector.PS;
aTrsf.SetTranslation( gp_Vec( P->x, P->y, P->z ));
- ::SMESH_MeshEditor anEditor( myMesh );
+ TIDSortedElemSet copyElements;
+ TIDSortedElemSet* workElements = &theElements;
+ TPreviewMesh tmpMesh;
+ SMESH_Mesh* mesh = myMesh;
+
+ if ( myPreviewMode )
+ {
+ tmpMesh.Copy( theElements, copyElements);
+ if ( !theCopy && !theTargetMesh )
+ {
+ TIDSortedElemSet elemsAround, elemsAroundCopy;
+ getElementsAround( theElements, GetMeshDS(), elemsAround );
+ tmpMesh.Copy( elemsAround, elemsAroundCopy);
+ }
+ mesh = &tmpMesh;
+ workElements = & copyElements;
+ theMakeGroups = false;
+ }
+
+ ::SMESH_MeshEditor anEditor( mesh );
::SMESH_MeshEditor::PGroupIDs groupIds =
- anEditor.Transform (theElements, aTrsf, theCopy, theMakeGroups, theTargetMesh);
+ anEditor.Transform (*workElements, aTrsf, theCopy, theMakeGroups, theTargetMesh);
- if(theCopy)
+ if(theCopy || myPreviewMode)
storeResult(anEditor);
else
- {
- myMesh->GetMeshDS()->Modified();
- myMesh->SetIsModified( true );
- }
+ {
+ myMesh->GetMeshDS()->Modified();
+ myMesh->SetIsModified( true );
+ }
return theMakeGroups ? getGroups(groupIds.get()) : 0;
}
<< theCopy << " )";
}
TIDSortedElemSet elements;
- if (idSourceToSet(theObject, GetMeshDS(), elements, SMDSAbs_All, /*emptyIfIsMesh=*/1))
+
+ bool emptyIfIsMesh = myPreviewMode ? false : true;
+
+ if (idSourceToSet(theObject, GetMeshDS(), elements, SMDSAbs_All, emptyIfIsMesh))
translate(elements, theVector, theCopy, false);
}
const SMESH::AxisStruct & theAxis,
CORBA::Double theAngle,
CORBA::Boolean theCopy,
- const bool theMakeGroups,
+ bool theMakeGroups,
::SMESH_Mesh* theTargetMesh)
{
initData();
+ if ( theTargetMesh )
+ theCopy = false;
+
gp_Pnt P ( theAxis.x, theAxis.y, theAxis.z );
gp_Vec V ( theAxis.vx, theAxis.vy, theAxis.vz );
gp_Trsf aTrsf;
aTrsf.SetRotation( gp_Ax1( P, V ), theAngle);
- ::SMESH_MeshEditor anEditor( myMesh );
+ TIDSortedElemSet copyElements;
+ TIDSortedElemSet* workElements = &theElements;
+ TPreviewMesh tmpMesh;
+ SMESH_Mesh* mesh = myMesh;
+
+ if ( myPreviewMode ) {
+ tmpMesh.Copy( theElements, copyElements );
+ if ( !theCopy && !theTargetMesh )
+ {
+ TIDSortedElemSet elemsAround, elemsAroundCopy;
+ getElementsAround( theElements, GetMeshDS(), elemsAround );
+ tmpMesh.Copy( elemsAround, elemsAroundCopy);
+ }
+ mesh = &tmpMesh;
+ workElements = ©Elements;
+ theMakeGroups = false;
+ }
+
+ ::SMESH_MeshEditor anEditor( mesh );
::SMESH_MeshEditor::PGroupIDs groupIds =
- anEditor.Transform (theElements, aTrsf, theCopy, theMakeGroups, theTargetMesh);
+ anEditor.Transform (*workElements, aTrsf, theCopy, theMakeGroups, theTargetMesh);
- if(theCopy)
+ if(theCopy || myPreviewMode)
storeResult(anEditor);
else
- {
- myMesh->GetMeshDS()->Modified();
- myMesh->SetIsModified( true );
- }
+ {
+ myMesh->GetMeshDS()->Modified();
+ myMesh->SetIsModified( true );
+ }
return theMakeGroups ? getGroups(groupIds.get()) : 0;
}
<< theCopy << " )";
}
TIDSortedElemSet elements;
- if (idSourceToSet(theObject, GetMeshDS(), elements, SMDSAbs_All, /*emptyIfIsMesh=*/1))
+ bool emptyIfIsMesh = myPreviewMode ? false : true;
+ if (idSourceToSet(theObject, GetMeshDS(), elements, SMDSAbs_All, emptyIfIsMesh))
rotate(elements,theAxis,theAngle,theCopy,false);
}
const SMESH::PointStruct& thePoint,
const SMESH::double_array& theScaleFact,
CORBA::Boolean theCopy,
- const bool theMakeGroups,
+ bool theMakeGroups,
::SMESH_Mesh* theTargetMesh)
{
initData();
if ( theScaleFact.length() == 2 )
THROW_SALOME_CORBA_EXCEPTION("Invalid nb of scale factors : 2", SALOME::BAD_PARAM);
+ if ( theTargetMesh )
+ theCopy = false;
+
TIDSortedElemSet elements;
- if ( !idSourceToSet(theObject, GetMeshDS(), elements, SMDSAbs_All, /*emptyIfIsMesh=*/true))
+ bool emptyIfIsMesh = myPreviewMode ? false : true;
+ if ( !idSourceToSet(theObject, GetMeshDS(), elements, SMDSAbs_All, emptyIfIsMesh))
return 0;
- vector<double> S(3);
- S[0] = theScaleFact[0];
- S[1] = (theScaleFact.length() == 1) ? theScaleFact[0] : theScaleFact[1];
- S[2] = (theScaleFact.length() == 1) ? theScaleFact[0] : theScaleFact[2];
+ double S[3] = {
+ theScaleFact[0],
+ (theScaleFact.length() == 1) ? theScaleFact[0] : theScaleFact[1],
+ (theScaleFact.length() == 1) ? theScaleFact[0] : theScaleFact[2],
+ };
double tol = std::numeric_limits<double>::max();
gp_Trsf aTrsf;
aTrsf.SetValues( S[0], 0, 0, thePoint.x * (1-S[0]),
0, S[1], 0, thePoint.y * (1-S[1]),
0, 0, S[2], thePoint.z * (1-S[2]), tol, tol);
- ::SMESH_MeshEditor anEditor( myMesh );
+ TIDSortedElemSet copyElements;
+ TPreviewMesh tmpMesh;
+ TIDSortedElemSet* workElements = &elements;
+ SMESH_Mesh* mesh = myMesh;
+
+ if ( myPreviewMode )
+ {
+ tmpMesh.Copy( elements, copyElements);
+ if ( !theCopy && !theTargetMesh )
+ {
+ TIDSortedElemSet elemsAround, elemsAroundCopy;
+ getElementsAround( elements, GetMeshDS(), elemsAround );
+ tmpMesh.Copy( elemsAround, elemsAroundCopy);
+ }
+ mesh = &tmpMesh;
+ workElements = & copyElements;
+ theMakeGroups = false;
+ }
+
+ ::SMESH_MeshEditor anEditor( mesh );
::SMESH_MeshEditor::PGroupIDs groupIds =
- anEditor.Transform (elements, aTrsf, theCopy, theMakeGroups, theTargetMesh);
+ anEditor.Transform (*workElements, aTrsf, theCopy, theMakeGroups, theTargetMesh);
- if(theCopy)
+ if(theCopy || myPreviewMode )
storeResult(anEditor);
else
- {
- myMesh->GetMeshDS()->Modified();
- myMesh->SetIsModified( true );
- }
+ {
+ myMesh->GetMeshDS()->Modified();
+ myMesh->SetIsModified( true );
+ }
return theMakeGroups ? getGroups(groupIds.get()) : 0;
}
}
{
- // add new nodes into myLastCreatedNodes
+ // append new nodes into myLastCreatedNodes
const SMESH_SequenceOfElemPtr& aSeq = anEditor.GetLastCreatedNodes();
- myLastCreatedNodes->length(aSeq.Length());
- for(int i=0; i<aSeq.Length(); i++)
- myLastCreatedNodes[i] = aSeq.Value(i+1)->GetID();
+ int j = myLastCreatedNodes->length();
+ int newLen = j + aSeq.Length();
+ myLastCreatedNodes->length( newLen );
+ for(int i=0; j<newLen; i++,j++)
+ myLastCreatedNodes[j] = aSeq.Value(i+1)->GetID();
}
{
- // add new elements into myLastCreatedElems
+ // append new elements into myLastCreatedElems
const SMESH_SequenceOfElemPtr& aSeq = anEditor.GetLastCreatedElems();
- myLastCreatedElems->length(aSeq.Length());
- for(int i=0; i<aSeq.Length(); i++)
- myLastCreatedElems[i] = aSeq.Value(i+1)->GetID();
+ int j = myLastCreatedElems->length();
+ int newLen = j + aSeq.Length();
+ myLastCreatedElems->length( newLen );
+ for(int i=0; j<newLen; i++,j++)
+ myLastCreatedElems[j] = aSeq.Value(i+1)->GetID();
}
}
myMesh->SetIsModified( true );
return isDone;
}
+//================================================================================
+/*!
+ * \brief Makes a part of the mesh quadratic
+ */
+//================================================================================
+
+void SMESH_MeshEditor_i::ConvertToQuadraticObject(CORBA::Boolean theForce3d,
+ SMESH::SMESH_IDSource_ptr theObject)
+ throw (SALOME::SALOME_Exception)
+{
+ Unexpect aCatch(SALOME_SalomeException);
+ TPythonDump pyDump;
+ TIDSortedElemSet elems;
+ if ( idSourceToSet( theObject, GetMeshDS(), elems, SMDSAbs_All, /*emptyIfIsMesh=*/true ))
+ {
+ if ( elems.empty() )
+ {
+ ConvertToQuadratic( theForce3d );
+ }
+ else if ( (*elems.begin())->GetType() == SMDSAbs_Node )
+ {
+ THROW_SALOME_CORBA_EXCEPTION("Group of nodes is not allowed", SALOME::BAD_PARAM);
+ }
+ else
+ {
+ ::SMESH_MeshEditor anEditor( myMesh );
+ anEditor.ConvertToQuadratic(theForce3d, elems);
+ }
+ }
+ myMesh->GetMeshDS()->Modified();
+ myMesh->SetIsModified( true );
+
+ pyDump << this << ".ConvertToQuadraticObject( "<<theForce3d<<", "<<theObject<<" )";
+}
+
+//================================================================================
+/*!
+ * \brief Makes a part of the mesh linear
+ */
+//================================================================================
+
+void SMESH_MeshEditor_i::ConvertFromQuadraticObject(SMESH::SMESH_IDSource_ptr theObject)
+ throw (SALOME::SALOME_Exception)
+{
+ Unexpect aCatch(SALOME_SalomeException);
+ TPythonDump pyDump;
+ TIDSortedElemSet elems;
+ if ( idSourceToSet( theObject, GetMeshDS(), elems, SMDSAbs_All, /*emptyIfIsMesh=*/true ))
+ {
+ if ( elems.empty() )
+ {
+ ConvertFromQuadratic();
+ }
+ else if ( (*elems.begin())->GetType() == SMDSAbs_Node )
+ {
+ THROW_SALOME_CORBA_EXCEPTION("Group of nodes is not allowed", SALOME::BAD_PARAM);
+ }
+ else
+ {
+ ::SMESH_MeshEditor anEditor( myMesh );
+ anEditor.ConvertFromQuadratic(elems);
+ }
+ }
+ myMesh->GetMeshDS()->Modified();
+ myMesh->SetIsModified( true );
+
+ pyDump << this << ".ConvertFromQuadraticObject( "<<theObject<<" )";
+}
//=======================================================================
//function : makeMesh
return aResult;
}
+//================================================================================
+/*!
+ * \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 )
+{
+ 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 << "createdNodes = " << this << ".DoubleNodeGroupsNew( " << theNodes << ", "
+ << theModifiedElems << " )";
+
+ return aNewGroup._retn();
+}
+
+
//================================================================================
/*!
\brief Creates a hole in a mesh by doubling the nodes of some particular elements
\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()
+ \sa DoubleNodeGroup(), DoubleNodes(), DoubleNodeElemGroupsNew()
*/
//================================================================================
return aResult;
}
+//================================================================================
+/*!
+ * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
+ * Works as DoubleNodeElemGroups(), but returns a new group with newly created elements.
+ \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 a new group with newly created elements
+ * \sa DoubleNodeElemGroups()
+ */
+//================================================================================
+
+SMESH::SMESH_Group_ptr SMESH_MeshEditor_i::DoubleNodeElemGroupsNew(const SMESH::ListOfGroups& theElems,
+ const SMESH::ListOfGroups& theNodesNot,
+ const SMESH::ListOfGroups& theAffectedElems)
+{
+ SMESH::SMESH_Group_var aNewGroup;
+
+ initData();
+
+ ::SMESH_MeshEditor aMeshEditor( myMesh );
+
+ SMESHDS_Mesh* aMeshDS = GetMeshDS();
+ TIDSortedElemSet anElems, aNodes, anAffected;
+ listOfGroupToSet(theElems, aMeshDS, anElems, false );
+ listOfGroupToSet(theNodesNot, aMeshDS, aNodes, true );
+ listOfGroupToSet(theAffectedElems, aMeshDS, anAffected, false );
+
+ bool aResult = aMeshEditor.DoubleNodes( anElems, aNodes, anAffected );
+
+ storeResult( aMeshEditor) ;
+
+ myMesh->GetMeshDS()->Modified();
+ if ( aResult ) {
+ myMesh->SetIsModified( true );
+
+ // Create group with newly created elements
+ SMESH::long_array_var anIds = GetLastCreatedElems();
+ if (anIds->length() > 0) {
+ SMESH::ElementType aGroupType = myMesh_i->GetElementType(anIds[0], true);
+ string anUnindexedName (theElems[0]->GetName());
+ string aNewName = generateGroupName(anUnindexedName + "_double");
+ aNewGroup = myMesh_i->CreateGroup(aGroupType, aNewName.c_str());
+ aNewGroup->Add(anIds);
+ }
+ }
+
+ // Update Python script
+ TPythonDump() << "createdElems = " << this << ".DoubleNodeElemGroupsNew( " << &theElems << ", "
+ << &theNodesNot << ", " << &theAffectedElems << " )";
+ return aNewGroup._retn();
+}
+
//================================================================================
/*!
\brief Creates a hole in a mesh by doubling the nodes of some particular elements
* The nodes of the internal faces at the boundaries of the groups are doubled.
* In option, the internal faces are replaced by flat elements.
* Triangles are transformed in prisms, and quadrangles in hexahedrons.
+ * The flat elements are stored in groups of volumes.
* @param theDomains - list of groups of volumes
* @param createJointElems - if TRUE, create the elements
* @return TRUE if operation has been completed successfully, FALSE otherwise
}
bool aResult = aMeshEditor.DoubleNodesOnGroupBoundaries( domains, createJointElems );
+ // TODO publish the groups of flat elements in study
storeResult( aMeshEditor) ;
myMesh->GetMeshDS()->Modified();
if ( dim > SMESH::BND_1DFROM2D )
THROW_SALOME_CORBA_EXCEPTION("Invalid boundary dimension", SALOME::BAD_PARAM);
-
SMESHDS_Mesh* aMeshDS = GetMeshDS();
SMESH::SMESH_Mesh_var mesh_var;
toCopyElements,
toCopyExistingBondary);
storeResult( aMeshEditor );
+
+ if ( smesh_mesh )
+ smesh_mesh->GetMeshDS()->Modified();
}
const char* dimName[] = { "BND_2DFROM3D", "BND_1DFROM3D", "BND_1DFROM2D" };
group = group_var._retn();
return mesh_var._retn();
}
+
+//================================================================================
+/*!
+ * \brief Creates missing boundary elements
+ * \param dimension - defines type of boundary elements to create
+ * \param groupName - a name of group to store all boundary elements in,
+ * "" means not to create the group
+ * \param meshName - a name of a new mesh, which is a copy of the initial
+ * mesh + created boundary elements; "" means not to create the new mesh
+ * \param toCopyAll - if true, the whole initial mesh will be copied into
+ * the new mesh else only boundary elements will be copied into the new mesh
+ * \param groups - optional groups of elements to make boundary around
+ * \param mesh - returns the mesh where elements were added to
+ * \param group - returns the created group, if any
+ * \retval long - number of added boundary elements
+ */
+//================================================================================
+
+CORBA::Long SMESH_MeshEditor_i::MakeBoundaryElements(SMESH::Bnd_Dimension dim,
+ const char* groupName,
+ const char* meshName,
+ CORBA::Boolean toCopyAll,
+ const SMESH::ListOfIDSources& groups,
+ SMESH::SMESH_Mesh_out mesh,
+ SMESH::SMESH_Group_out group)
+ throw (SALOME::SALOME_Exception)
+{
+ Unexpect aCatch(SALOME_SalomeException);
+
+ initData();
+
+ if ( dim > SMESH::BND_1DFROM2D )
+ THROW_SALOME_CORBA_EXCEPTION("Invalid boundary dimension", SALOME::BAD_PARAM);
+
+ // check that groups belongs to to this mesh and is not this mesh
+ const int nbGroups = groups.length();
+ for ( int i = 0; i < nbGroups; ++i )
+ {
+ SMESH::SMESH_Mesh_var m = groups[i]->GetMesh();
+ if ( myMesh_i != SMESH::DownCast<SMESH_Mesh_i*>( m ))
+ THROW_SALOME_CORBA_EXCEPTION("group does not belong to this mesh", SALOME::BAD_PARAM);
+ if ( SMESH::DownCast<SMESH_Mesh_i*>( groups[i] ))
+ THROW_SALOME_CORBA_EXCEPTION("expect a group but recieve a mesh", SALOME::BAD_PARAM);
+ }
+
+ TPythonDump pyDump;
+
+ int nbAdded = 0;
+ SMESH::SMESH_Mesh_var mesh_var;
+ SMESH::SMESH_Group_var group_var;
+
+ // get mesh to fill
+ mesh_var = SMESH::SMESH_Mesh::_duplicate( myMesh_i->_this() );
+ const bool toCopyMesh = ( strlen( meshName ) > 0 );
+ if ( toCopyMesh )
+ {
+ if ( toCopyAll )
+ mesh_var = SMESH_Gen_i::GetSMESHGen()->CopyMesh(mesh_var,
+ meshName,
+ /*toCopyGroups=*/false,
+ /*toKeepIDs=*/true);
+ else
+ mesh_var = makeMesh(meshName);
+ }
+ SMESH_Mesh_i* mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( mesh_var );
+ SMESH_Mesh* tgtMesh = &mesh_i->GetImpl();
+
+ // source mesh
+ SMESH_Mesh* srcMesh = ( toCopyMesh && !toCopyAll ) ? myMesh : tgtMesh;
+ SMESHDS_Mesh* srcMeshDS = srcMesh->GetMeshDS();
+
+ // group of boundary elements
+ SMESH_Group* smesh_group = 0;
+ SMDSAbs_ElementType elemType = (dim == SMESH::BND_2DFROM3D) ? SMDSAbs_Volume : SMDSAbs_Face;
+ if ( strlen(groupName) )
+ {
+ SMESH::ElementType groupType = SMESH::ElementType( int(elemType)-1 );
+ group_var = mesh_i->CreateGroup( groupType, groupName );
+ if ( SMESH_GroupBase_i* group_i = SMESH::DownCast<SMESH_GroupBase_i*>( group_var ))
+ smesh_group = group_i->GetSmeshGroup();
+ }
+
+ TIDSortedElemSet elements;
+
+ if ( nbGroups > 0 )
+ {
+ for ( int i = 0; i < nbGroups; ++i )
+ {
+ elements.clear();
+ if ( idSourceToSet( groups[i], srcMeshDS, elements, elemType,/*emptyIfIsMesh=*/false ))
+ {
+ SMESH::Bnd_Dimension bdim =
+ ( elemType == SMDSAbs_Volume ) ? SMESH::BND_2DFROM3D : SMESH::BND_1DFROM2D;
+ ::SMESH_MeshEditor aMeshEditor( srcMesh );
+ nbAdded += aMeshEditor.MakeBoundaryMesh( elements,
+ ::SMESH_MeshEditor::Bnd_Dimension(bdim),
+ smesh_group,
+ tgtMesh,
+ /*toCopyElements=*/false,
+ /*toCopyExistingBondary=*/srcMesh != tgtMesh,
+ /*toAddExistingBondary=*/true,
+ /*aroundElements=*/true);
+ storeResult( aMeshEditor );
+ }
+ }
+ }
+ else
+ {
+ ::SMESH_MeshEditor aMeshEditor( srcMesh );
+ nbAdded += aMeshEditor.MakeBoundaryMesh( elements,
+ ::SMESH_MeshEditor::Bnd_Dimension(dim),
+ smesh_group,
+ tgtMesh,
+ /*toCopyElements=*/false,
+ /*toCopyExistingBondary=*/srcMesh != tgtMesh,
+ /*toAddExistingBondary=*/true);
+ storeResult( aMeshEditor );
+ }
+ tgtMesh->GetMeshDS()->Modified();
+
+ const char* dimName[] = { "BND_2DFROM3D", "BND_1DFROM3D", "BND_1DFROM2D" };
+
+ // result of MakeBoundaryElements() is a tuple (nb, mesh, group)
+ pyDump << "nbAdded, ";
+ if ( mesh_var->_is_nil() )
+ pyDump << myMesh_i->_this() << ", ";
+ else
+ pyDump << mesh_var << ", ";
+ if ( group_var->_is_nil() )
+ pyDump << "_NoneGroup = "; // assignment to None is forbiden
+ else
+ pyDump << group_var << " = ";
+ pyDump << this << ".MakeBoundaryElements( "
+ << "SMESH." << dimName[int(dim)] << ", "
+ << "'" << groupName << "', "
+ << "'" << meshName<< "', "
+ << toCopyAll << ", "
+ << groups << ")";
+
+ mesh = mesh_var._retn();
+ group = group_var._retn();
+ return nbAdded;
+}