getEditor().GetError().reset();
getEditor().CrearLastCreated();
}
+
+//================================================================================
+/*!
+ * \brief Increment mesh modif time and optionally record that the performed
+ * modification may influence futher mesh re-compute.
+ * \param [in] isReComputeSafe - true if the modification does not infulence
+ * futher mesh re-compute
+ */
+//================================================================================
+
+void SMESH_MeshEditor_i::declareMeshModified( bool isReComputeSafe )
+{
+ myMesh->GetMeshDS()->Modified();
+ if ( !isReComputeSafe )
+ myMesh->SetIsModified( true );
+}
+
//================================================================================
/*!
* \brief Return either myEditor or myPreviewEditor depending on myIsPreviewMode.
return myPreviewMesh;
}
-//================================================================================
-/*!
- * \brief Now does nothing
- */
-//================================================================================
-
-// void SMESH_MeshEditor_i::storeResult(::SMESH_MeshEditor& )
-// {
-// }
-
//================================================================================
/*!
* Return data of mesh edition preview
//================================================================================
SMESH::MeshPreviewStruct* SMESH_MeshEditor_i::GetPreviewData()
-{
+ throw (SALOME::SALOME_Exception)
+{
+ SMESH_TRY;
const bool hasBadElems = ( getEditor().GetError() && getEditor().GetError()->HasBadElems() );
if ( myIsPreviewMode || hasBadElems ) { // --- MeshPreviewStruct filling ---
}
return myPreviewData._retn();
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
//================================================================================
//================================================================================
SMESH::long_array* SMESH_MeshEditor_i::GetLastCreatedNodes()
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
SMESH::long_array_var myLastCreatedNodes = new SMESH::long_array();
+
const SMESH_SequenceOfElemPtr& aSeq = getEditor().GetLastCreatedNodes();
myLastCreatedNodes->length( aSeq.Length() );
for (int i = 1; i <= aSeq.Length(); i++)
myLastCreatedNodes[i-1] = aSeq.Value(i)->GetID();
+
return myLastCreatedNodes._retn();
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
//================================================================================
//================================================================================
SMESH::long_array* SMESH_MeshEditor_i::GetLastCreatedElems()
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
SMESH::long_array_var myLastCreatedElems = new SMESH::long_array();
+
const SMESH_SequenceOfElemPtr& aSeq = getEditor().GetLastCreatedElems();
myLastCreatedElems->length( aSeq.Length() );
for ( int i = 1; i <= aSeq.Length(); i++ )
myLastCreatedElems[i-1] = aSeq.Value(i)->GetID();
+
return myLastCreatedElems._retn();
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
//=======================================================================
//=======================================================================
SMESH::ComputeError* SMESH_MeshEditor_i::GetLastError()
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
SMESH::ComputeError_var errOut = new SMESH::ComputeError;
SMESH_ComputeErrorPtr& errIn = getEditor().GetError();
if ( errIn && !errIn->IsOK() )
errOut->subShapeID = -1;
errOut->hasBadMesh = false;
}
+
return errOut._retn();
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
//=======================================================================
CORBA::Boolean
SMESH_MeshEditor_i::RemoveElements(const SMESH::long_array & IDsOfElements)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
list< int > IdList;
// Remove Elements
bool ret = getEditor().Remove( IdList, false );
- myMesh->GetMeshDS()->Modified();
- if ( IDsOfElements.length() )
- myMesh->SetIsModified( true ); // issue 0020693
+
+ declareMeshModified( /*isReComputeSafe=*/ IDsOfElements.length() == 0 ); // issue 0020693
return ret;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
//=============================================================================
//=============================================================================
CORBA::Boolean SMESH_MeshEditor_i::RemoveNodes(const SMESH::long_array & IDsOfNodes)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
list< int > IdList;
TPythonDump() << "isDone = " << this << ".RemoveNodes( " << IDsOfNodes << " )";
bool ret = getEditor().Remove( IdList, true );
- myMesh->GetMeshDS()->Modified();
- if ( IDsOfNodes.length() )
- myMesh->SetIsModified( true ); // issue 0020693
+
+ declareMeshModified( /*isReComputeSafe=*/ !ret ); // issue 0020693
return ret;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
//=============================================================================
//=============================================================================
CORBA::Long SMESH_MeshEditor_i::RemoveOrphanNodes()
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
-
// Update Python script
TPythonDump() << "nbRemoved = " << this << ".RemoveOrphanNodes()";
int nbNodesBefore = myMesh->NbNodes();
getEditor().Remove( IdList, true );
- myMesh->GetMeshDS()->Modified();
- if ( IdList.size() )
- myMesh->SetIsModified( true );
int nbNodesAfter = myMesh->NbNodes();
+ declareMeshModified( /*isReComputeSafe=*/ IdList.size() == 0 ); // issue 0020693
return nbNodesBefore - nbNodesAfter;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
//=============================================================================
*/
//=============================================================================
-CORBA::Long SMESH_MeshEditor_i::AddNode(CORBA::Double x,
- CORBA::Double y, CORBA::Double z)
+CORBA::Long SMESH_MeshEditor_i::AddNode(CORBA::Double x,CORBA::Double y, CORBA::Double z)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
const SMDS_MeshNode* N = getMeshDS()->AddNode(x, y, z);
TPythonDump() << "nodeID = " << this << ".AddNode( "
<< TVar( x ) << ", " << TVar( y ) << ", " << TVar( z )<< " )";
- myMesh->GetMeshDS()->Modified();
- myMesh->SetIsModified( true ); // issue 0020693
+ declareMeshModified( /*isReComputeSafe=*/false );
return N->GetID();
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
//=============================================================================
//=============================================================================
CORBA::Long SMESH_MeshEditor_i::Add0DElement(CORBA::Long IDOfNode)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
const SMDS_MeshNode* aNode = getMeshDS()->FindNode(IDOfNode);
// Update Python script
TPythonDump() << "elem0d = " << this << ".Add0DElement( " << IDOfNode <<" )";
- myMesh->GetMeshDS()->Modified();
- myMesh->SetIsModified( true ); // issue 0020693
+ declareMeshModified( /*isReComputeSafe=*/false );
- if (elem)
- return elem->GetID();
+ return elem ? elem->GetID() : 0;
+ SMESH_CATCH( SMESH::throwCorbaException );
return 0;
}
CORBA::Long SMESH_MeshEditor_i::AddBall(CORBA::Long IDOfNode, CORBA::Double diameter)
throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
if ( diameter < std::numeric_limits<double>::min() )
THROW_SALOME_CORBA_EXCEPTION("Invalid diameter", SALOME::BAD_PARAM);
- SMESH_TRY;
-
const SMDS_MeshNode* aNode = getMeshDS()->FindNode(IDOfNode);
SMDS_MeshElement* elem = getMeshDS()->AddBall(aNode, diameter);
TPythonDump() << "ballElem = "
<< this << ".AddBall( " << IDOfNode << ", " << diameter <<" )";
- myMesh->GetMeshDS()->Modified();
- myMesh->SetIsModified( true ); // issue 0020693
-
- if (elem)
- return elem->GetID();
+ declareMeshModified( /*isReComputeSafe=*/false );
+ return elem ? elem->GetID() : 0;
SMESH_CATCH( SMESH::throwCorbaException );
-
return 0;
}
//=============================================================================
CORBA::Long SMESH_MeshEditor_i::AddEdge(const SMESH::long_array & IDsOfNodes)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
int NbNodes = IDsOfNodes.length();
<<n1<<", "<<n2<<", "<<n12<<" ])";
}
- myMesh->GetMeshDS()->Modified();
- if(elem)
- return myMesh->SetIsModified( true ), elem->GetID();
+ declareMeshModified( /*isReComputeSafe=*/false );
+ return elem ? elem->GetID() : 0;
+ SMESH_CATCH( SMESH::throwCorbaException );
return 0;
}
//=============================================================================
CORBA::Long SMESH_MeshEditor_i::AddFace(const SMESH::long_array & IDsOfNodes)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
int NbNodes = IDsOfNodes.length();
// Update Python script
TPythonDump() << "faceID = " << this << ".AddFace( " << IDsOfNodes << " )";
- myMesh->GetMeshDS()->Modified();
- if(elem)
- return myMesh->SetIsModified( true ), elem->GetID();
+ declareMeshModified( /*isReComputeSafe=*/false );
+ return elem ? elem->GetID() : 0;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
return 0;
}
*/
//=============================================================================
CORBA::Long SMESH_MeshEditor_i::AddPolygonalFace (const SMESH::long_array & IDsOfNodes)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
int NbNodes = IDsOfNodes.length();
// Update Python script
TPythonDump() <<"faceID = "<<this<<".AddPolygonalFace( "<<IDsOfNodes<<" )";
- myMesh->GetMeshDS()->Modified();
- return elem ? ( myMesh->SetIsModified( true ), elem->GetID()) : 0;
+ declareMeshModified( /*isReComputeSafe=*/false );
+ return elem ? elem->GetID() : 0;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
//=============================================================================
//=============================================================================
CORBA::Long SMESH_MeshEditor_i::AddVolume(const SMESH::long_array & IDsOfNodes)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
int NbNodes = IDsOfNodes.length();
// Update Python script
TPythonDump() << "volID = " << this << ".AddVolume( " << IDsOfNodes << " )";
- myMesh->GetMeshDS()->Modified();
- if(elem)
- return myMesh->SetIsModified( true ), elem->GetID();
+ declareMeshModified( /*isReComputeSafe=*/false );
+ return elem ? elem->GetID() : 0;
+ SMESH_CATCH( SMESH::throwCorbaException );
return 0;
}
//=============================================================================
CORBA::Long SMESH_MeshEditor_i::AddPolyhedralVolume (const SMESH::long_array & IDsOfNodes,
const SMESH::long_array & Quantities)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
int NbNodes = IDsOfNodes.length();
// Update Python script
TPythonDump() << "volID = " << this << ".AddPolyhedralVolume( "
<< IDsOfNodes << ", " << Quantities << " )";
- myMesh->GetMeshDS()->Modified();
- return elem ? ( myMesh->SetIsModified( true ), elem->GetID()) : 0;
+ declareMeshModified( /*isReComputeSafe=*/false );
+ return elem ? elem->GetID() : 0;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
//=============================================================================
//=============================================================================
CORBA::Long SMESH_MeshEditor_i::AddPolyhedralVolumeByFaces (const SMESH::long_array & IdsOfFaces)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
int NbFaces = IdsOfFaces.length();
// Update Python script
TPythonDump() << "volID = " << this << ".AddPolyhedralVolumeByFaces( "
<< IdsOfFaces << " )";
- myMesh->GetMeshDS()->Modified();
- return elem ? ( myMesh->SetIsModified( true ), elem->GetID()) : 0;
+ declareMeshModified( /*isReComputeSafe=*/false );
+ return elem ? elem->GetID() : 0;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
//=============================================================================
const char* theGroupName)
throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
SMESH::SMESH_IDSource_var result;
TPythonDump pyDump;
- SMESH_TRY;
-
TIDSortedElemSet elements, elems0D;
if ( idSourceToSet( theObject, getMeshDS(), elements, SMDSAbs_All, /*emptyIfIsMesh=*/1))
getEditor().Create0DElementsOnAllNodes( elements, elems0D );
pyDump << " = " << this << ".Create0DElementsOnAllNodes( "
<< theObject << ", '" << theGroupName << "' )";
- SMESH_CATCH( SMESH::throwCorbaException );
-
return result._retn();
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
//=============================================================================
void SMESH_MeshEditor_i::SetNodeOnVertex(CORBA::Long NodeID, CORBA::Long VertexID)
throw (SALOME::SALOME_Exception)
{
- Unexpect aCatch(SALOME_SalomeException);
+ SMESH_TRY;
SMESHDS_Mesh * mesh = getMeshDS();
SMDS_MeshNode* node = const_cast<SMDS_MeshNode*>( mesh->FindNode(NodeID) );
mesh->SetNodeOnVertex( node, VertexID );
myMesh->SetIsModified( true );
+
+ SMESH_CATCH( SMESH::throwCorbaException );
}
//=============================================================================
CORBA::Double paramOnEdge)
throw (SALOME::SALOME_Exception)
{
- Unexpect aCatch(SALOME_SalomeException);
+ SMESH_TRY;
SMESHDS_Mesh * mesh = getMeshDS();
SMDS_MeshNode* node = const_cast<SMDS_MeshNode*>( mesh->FindNode(NodeID) );
mesh->SetNodeOnEdge( node, EdgeID, paramOnEdge );
myMesh->SetIsModified( true );
+
+ SMESH_CATCH( SMESH::throwCorbaException );
}
//=============================================================================
CORBA::Double u, CORBA::Double v)
throw (SALOME::SALOME_Exception)
{
- Unexpect aCatch(SALOME_SalomeException);
-
+ SMESH_TRY;
SMESHDS_Mesh * mesh = getMeshDS();
SMDS_MeshNode* node = const_cast<SMDS_MeshNode*>( mesh->FindNode(NodeID) );
if ( !node )
mesh->SetNodeOnFace( node, FaceID, u, v );
myMesh->SetIsModified( true );
+
+ SMESH_CATCH( SMESH::throwCorbaException );
}
//=============================================================================
void SMESH_MeshEditor_i::SetNodeInVolume(CORBA::Long NodeID, CORBA::Long SolidID)
throw (SALOME::SALOME_Exception)
{
- Unexpect aCatch(SALOME_SalomeException);
-
+ SMESH_TRY;
SMESHDS_Mesh * mesh = getMeshDS();
SMDS_MeshNode* node = const_cast<SMDS_MeshNode*>( mesh->FindNode(NodeID) );
if ( !node )
mesh->SetNodeInVolume( node, SolidID );
- // myMesh->SetIsModified( true ); - SetNodeInVolume() can't prevent re-compute, I believe
+ SMESH_CATCH( SMESH::throwCorbaException );
}
//=============================================================================
CORBA::Long ShapeID)
throw (SALOME::SALOME_Exception)
{
- Unexpect aCatch(SALOME_SalomeException);
-
+ SMESH_TRY;
SMESHDS_Mesh * mesh = getMeshDS();
SMDS_MeshElement* elem = const_cast<SMDS_MeshElement*>(mesh->FindElement(ElementID));
if ( !elem )
mesh->SetMeshElementOnShape( elem, ShapeID );
myMesh->SetIsModified( true );
+
+ SMESH_CATCH( SMESH::throwCorbaException );
}
//=============================================================================
CORBA::Boolean SMESH_MeshEditor_i::InverseDiag(CORBA::Long NodeID1,
CORBA::Long NodeID2)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
const SMDS_MeshNode * n1 = getMeshDS()->FindNode( NodeID1 );
TPythonDump() << "isDone = " << this << ".InverseDiag( "
<< NodeID1 << ", " << NodeID2 << " )";
-
int ret = getEditor().InverseDiag ( n1, n2 );
- myMesh->GetMeshDS()->Modified();
- myMesh->SetIsModified( true );
+
+ declareMeshModified( /*isReComputeSafe=*/false );
return ret;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
//=============================================================================
CORBA::Boolean SMESH_MeshEditor_i::DeleteDiag(CORBA::Long NodeID1,
CORBA::Long NodeID2)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
const SMDS_MeshNode * n1 = getMeshDS()->FindNode( NodeID1 );
bool stat = getEditor().DeleteDiag ( n1, n2 );
- myMesh->GetMeshDS()->Modified();
- if ( stat )
- myMesh->SetIsModified( true ); // issue 0020693
-
+ declareMeshModified( /*isReComputeSafe=*/!stat );
return stat;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
//=============================================================================
//=============================================================================
CORBA::Boolean SMESH_MeshEditor_i::Reorient(const SMESH::long_array & IDsOfElements)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
for (int i = 0; i < IDsOfElements.length(); i++)
// Update Python script
TPythonDump() << "isDone = " << this << ".Reorient( " << IDsOfElements << " )";
- myMesh->GetMeshDS()->Modified();
- if ( IDsOfElements.length() )
- myMesh->SetIsModified( true ); // issue 0020693
-
+ declareMeshModified( /*isReComputeSafe=*/ IDsOfElements.length() == 0 );
return true;
-}
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
+}
//=============================================================================
/*!
//=============================================================================
CORBA::Boolean SMESH_MeshEditor_i::ReorientObject(SMESH::SMESH_IDSource_ptr theObject)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
TPythonDump aTPythonDump; // suppress dump in Reorient()
// Update Python script
aTPythonDump << "isDone = " << this << ".ReorientObject( " << theObject << " )";
+ declareMeshModified( /*isReComputeSafe=*/ anElementsId->length() == 0 );
return isDone;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
//=======================================================================
const SMESH::PointStruct& thePoint)
throw (SALOME::SALOME_Exception)
{
- Unexpect aCatch(SALOME_SalomeException);
-
+ SMESH_TRY;
initData(/*deleteSearchers=*/false);
TIDSortedElemSet elements;
int nbReori = getEditor().Reorient2D( elements, dirVec, face );
if ( nbReori ) {
- myMesh->SetIsModified( true );
- myMesh->GetMeshDS()->Modified();
+ declareMeshModified( /*isReComputeSafe=*/false );
}
TPythonDump() << this << ".Reorient2D( "
<< the2Dgroup << ", "
<< thePoint << " )";
return nbReori;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
//=============================================================================
*
*/
//=============================================================================
+
CORBA::Boolean SMESH_MeshEditor_i::TriToQuad (const SMESH::long_array & IDsOfElements,
SMESH::NumericalFunctor_ptr Criterion,
CORBA::Double MaxAngle)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
SMESHDS_Mesh* aMesh = getMeshDS();
bool stat = getEditor().TriToQuad( faces, aCrit, MaxAngle );
- myMesh->GetMeshDS()->Modified();
- if ( stat )
- myMesh->SetIsModified( true ); // issue 0020693
-
+ declareMeshModified( /*isReComputeSafe=*/!stat );
return stat;
-}
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
+}
//=============================================================================
/*!
*
*/
//=============================================================================
+
CORBA::Boolean SMESH_MeshEditor_i::TriToQuadObject (SMESH::SMESH_IDSource_ptr theObject,
SMESH::NumericalFunctor_ptr Criterion,
CORBA::Double MaxAngle)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
TPythonDump aTPythonDump; // suppress dump in TriToQuad()
<< theObject << ", " << aNumericalFunctor << ", " << TVar( MaxAngle ) << " )";
return isDone;
-}
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
+}
//=============================================================================
/*!
*
*/
//=============================================================================
+
CORBA::Boolean SMESH_MeshEditor_i::QuadToTri (const SMESH::long_array & IDsOfElements,
SMESH::NumericalFunctor_ptr Criterion)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
SMESHDS_Mesh* aMesh = getMeshDS();
TPythonDump() << "isDone = " << this << ".QuadToTri( " << IDsOfElements << ", " << aNumericalFunctor << " )";
CORBA::Boolean stat = getEditor().QuadToTri( faces, aCrit );
- myMesh->GetMeshDS()->Modified();
- if ( stat )
- myMesh->SetIsModified( true ); // issue 0020693
-
+ declareMeshModified( /*isReComputeSafe=*/false );
return stat;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
//=============================================================================
CORBA::Boolean SMESH_MeshEditor_i::QuadToTriObject (SMESH::SMESH_IDSource_ptr theObject,
SMESH::NumericalFunctor_ptr Criterion)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
TPythonDump aTPythonDump; // suppress dump in QuadToTri()
// Update Python script
aTPythonDump << "isDone = " << this << ".QuadToTriObject( " << theObject << ", " << aNumericalFunctor << " )";
+ declareMeshModified( /*isReComputeSafe=*/false );
return isDone;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
//=============================================================================
CORBA::Boolean SMESH_MeshEditor_i::SplitQuad (const SMESH::long_array & IDsOfElements,
CORBA::Boolean Diag13)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
SMESHDS_Mesh* aMesh = getMeshDS();
<< IDsOfElements << ", " << Diag13 << " )";
CORBA::Boolean stat = getEditor().QuadToTri( faces, Diag13 );
- myMesh->GetMeshDS()->Modified();
- if ( stat )
- myMesh->SetIsModified( true ); // issue 0020693
-
-
+ declareMeshModified( /*isReComputeSafe=*/ !stat );
return stat;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
//=============================================================================
CORBA::Boolean SMESH_MeshEditor_i::SplitQuadObject (SMESH::SMESH_IDSource_ptr theObject,
CORBA::Boolean Diag13)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
TPythonDump aTPythonDump; // suppress dump in SplitQuad()
aTPythonDump << "isDone = " << this << ".SplitQuadObject( "
<< theObject << ", " << Diag13 << " )";
+ declareMeshModified( /*isReComputeSafe=*/!isDone );
return isDone;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
* BestSplit
*/
//=============================================================================
+
CORBA::Long SMESH_MeshEditor_i::BestSplit (CORBA::Long IDOfQuad,
SMESH::NumericalFunctor_ptr Criterion)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
const SMDS_MeshElement* quad = getMeshDS()->FindElement(IDOfQuad);
else
aCrit.reset(new SMESH::Controls::AspectRatio());
- return getEditor().BestSplit(quad, aCrit);
+ int id = getEditor().BestSplit(quad, aCrit);
+ declareMeshModified( /*isReComputeSafe=*/ id < 1 );
}
- return -1;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
//================================================================================
CORBA::Short methodFlags)
throw (SALOME::SALOME_Exception)
{
- Unexpect aCatch(SALOME_SalomeException);
-
+ SMESH_TRY;
initData();
SMESH::long_array_var anElementsId = elems->GetIDs();
arrayToSet( anElementsId, getMeshDS(), elemSet, SMDSAbs_Volume );
getEditor().SplitVolumesIntoTetra( elemSet, int( methodFlags ));
- myMesh->GetMeshDS()->Modified();
-
-
-// if ( myLastCreatedElems.length() ) - it does not influence Compute()
-// myMesh->SetIsModified( true ); // issue 0020693
+ declareMeshModified( /*isReComputeSafe=*/true ); // it does not influence Compute()
TPythonDump() << this << ".SplitVolumesIntoTetra( "
<< elems << ", " << methodFlags << " )";
+
+ SMESH_CATCH( SMESH::throwCorbaException );
}
//=======================================================================
CORBA::Long MaxNbOfIterations,
CORBA::Double MaxAspectRatio,
SMESH::SMESH_MeshEditor::Smooth_Method Method)
+ throw (SALOME::SALOME_Exception)
{
return smooth( IDsOfElements, IDsOfFixedNodes, MaxNbOfIterations,
MaxAspectRatio, Method, false );
CORBA::Long MaxNbOfIterations,
CORBA::Double MaxAspectRatio,
SMESH::SMESH_MeshEditor::Smooth_Method Method)
+ throw (SALOME::SALOME_Exception)
{
return smooth( IDsOfElements, IDsOfFixedNodes, MaxNbOfIterations,
MaxAspectRatio, Method, true );
CORBA::Long MaxNbOfIterations,
CORBA::Double MaxAspectRatio,
SMESH::SMESH_MeshEditor::Smooth_Method Method)
+ throw (SALOME::SALOME_Exception)
{
return smoothObject (theObject, IDsOfFixedNodes, MaxNbOfIterations,
MaxAspectRatio, Method, false);
CORBA::Long MaxNbOfIterations,
CORBA::Double MaxAspectRatio,
SMESH::SMESH_MeshEditor::Smooth_Method Method)
+ throw (SALOME::SALOME_Exception)
{
return smoothObject (theObject, IDsOfFixedNodes, MaxNbOfIterations,
MaxAspectRatio, Method, true);
CORBA::Double MaxAspectRatio,
SMESH::SMESH_MeshEditor::Smooth_Method Method,
bool IsParametric)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
SMESHDS_Mesh* aMesh = getMeshDS();
getEditor().Smooth(elements, fixedNodes, method,
MaxNbOfIterations, MaxAspectRatio, IsParametric );
- myMesh->GetMeshDS()->Modified();
- myMesh->SetIsModified( true ); // issue 0020693
-
+ declareMeshModified( /*isReComputeSafe=*/true ); // does not prevent re-compute
// Update Python script
TPythonDump() << "isDone = " << this << "."
"CENTROIDAL_SMOOTH )" : "LAPLACIAN_SMOOTH )");
return true;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
CORBA::Double MaxAspectRatio,
SMESH::SMESH_MeshEditor::Smooth_Method Method,
bool IsParametric)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
TPythonDump aTPythonDump; // suppress dump in smooth()
"CENTROIDAL_SMOOTH )" : "LAPLACIAN_SMOOTH )");
return isDone;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
//=============================================================================
void SMESH_MeshEditor_i::RenumberNodes()
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
// Update Python script
TPythonDump() << this << ".RenumberNodes()";
getMeshDS()->Renumber( true );
-}
+ SMESH_CATCH( SMESH::throwCorbaException );
+}
//=============================================================================
/*!
//=============================================================================
void SMESH_MeshEditor_i::RenumberElements()
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
// Update Python script
TPythonDump() << this << ".RenumberElements()";
getMeshDS()->Renumber( false );
+
+ SMESH_CATCH( SMESH::throwCorbaException );
}
//=======================================================================
//=======================================================================
SMESH::ListOfGroups* SMESH_MeshEditor_i::getGroups(const std::list<int>* groupIDs)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
if ( !groupIDs )
return 0;
myMesh_i->CreateGroupServants();
return myMesh_i->GetGroups( *groupIDs );
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
//=======================================================================
CORBA::Double theTolerance,
const bool theMakeGroups,
const SMDSAbs_ElementType theElementType)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
TIDSortedElemSet inElements, copyElements;
::SMESH_MeshEditor::PGroupIDs groupIds =
getEditor().RotationSweep (*workElements, Ax1, theAngleInRadians,
theNbOfSteps, theTolerance, theMakeGroups, makeWalls);
- myMesh->GetMeshDS()->Modified();
- // myMesh->SetIsModified( true ); -- it does not influence Compute()
+ declareMeshModified( /*isReComputeSafe=*/true ); // does not influence Compute()
return theMakeGroups ? getGroups(groupIds.get()) : 0;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
//=======================================================================
CORBA::Double theAngleInRadians,
CORBA::Long theNbOfSteps,
CORBA::Double theTolerance)
+ throw (SALOME::SALOME_Exception)
{
if ( !myIsPreviewMode ) {
TPythonDump() << this << ".RotationSweep( "
CORBA::Double theAngleInRadians,
CORBA::Long theNbOfSteps,
CORBA::Double theTolerance)
+ throw (SALOME::SALOME_Exception)
{
TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
theTolerance,
true);
if (!myIsPreviewMode) {
- DumpGroupsList(aPythonDump, aGroups);
+ dumpGroupsList(aPythonDump, aGroups);
aPythonDump << this << ".RotationSweepMakeGroups( "
<< theIDsOfElements << ", "
<< theAxis << ", "
CORBA::Double theAngleInRadians,
CORBA::Long theNbOfSteps,
CORBA::Double theTolerance)
+ throw (SALOME::SALOME_Exception)
{
if ( !myIsPreviewMode ) {
TPythonDump() << this << ".RotationSweepObject( "
CORBA::Double theAngleInRadians,
CORBA::Long theNbOfSteps,
CORBA::Double theTolerance)
+ throw (SALOME::SALOME_Exception)
{
if ( !myIsPreviewMode ) {
TPythonDump() << this << ".RotationSweepObject1D( "
CORBA::Double theAngleInRadians,
CORBA::Long theNbOfSteps,
CORBA::Double theTolerance)
+ throw (SALOME::SALOME_Exception)
{
if ( !myIsPreviewMode ) {
TPythonDump() << this << ".RotationSweepObject2D( "
CORBA::Double theAngleInRadians,
CORBA::Long theNbOfSteps,
CORBA::Double theTolerance)
+ throw (SALOME::SALOME_Exception)
{
TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
theTolerance,
true);
if (!myIsPreviewMode) {
- DumpGroupsList(aPythonDump, aGroups);
+ dumpGroupsList(aPythonDump, aGroups);
aPythonDump << this << ".RotationSweepObjectMakeGroups( "
<< theObject << ", "
<< theAxis << ", "
CORBA::Double theAngleInRadians,
CORBA::Long theNbOfSteps,
CORBA::Double theTolerance)
+ throw (SALOME::SALOME_Exception)
{
TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
true,
SMDSAbs_Edge);
if (!myIsPreviewMode) {
- DumpGroupsList(aPythonDump, aGroups);
+ dumpGroupsList(aPythonDump, aGroups);
aPythonDump << this << ".RotationSweepObject1DMakeGroups( "
<< theObject << ", "
<< theAxis << ", "
CORBA::Double theAngleInRadians,
CORBA::Long theNbOfSteps,
CORBA::Double theTolerance)
+ throw (SALOME::SALOME_Exception)
{
TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
true,
SMDSAbs_Face);
if (!myIsPreviewMode) {
- DumpGroupsList(aPythonDump, aGroups);
+ dumpGroupsList(aPythonDump, aGroups);
aPythonDump << this << ".RotationSweepObject2DMakeGroups( "
<< theObject << ", "
<< theAxis << ", "
CORBA::Long theNbOfSteps,
bool theMakeGroups,
const SMDSAbs_ElementType theElementType)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
- try {
-#ifdef NO_CAS_CATCH
- OCC_CATCH_SIGNALS;
-#endif
- TIDSortedElemSet elements, copyElements;
- arrayToSet(theIDsOfElements, getMeshDS(), elements, theElementType);
+ TIDSortedElemSet elements, copyElements;
+ arrayToSet(theIDsOfElements, getMeshDS(), elements, theElementType);
- const SMESH::PointStruct * P = &theStepVector.PS;
- gp_Vec stepVec( P->x, P->y, P->z );
+ const SMESH::PointStruct * P = &theStepVector.PS;
+ gp_Vec stepVec( P->x, P->y, P->z );
- TIDSortedElemSet* workElements = & elements;
+ TIDSortedElemSet* workElements = & elements;
- SMDSAbs_ElementType aType = SMDSAbs_Face;
- if (theElementType == SMDSAbs_Node)
- {
- aType = SMDSAbs_Edge;
- }
- if ( myIsPreviewMode ) {
- SMDSAbs_ElementType select = SMDSAbs_All, avoid = SMDSAbs_Volume;
- getPreviewMesh( aType )->Copy( elements, copyElements, select, avoid );
- workElements = & copyElements;
- theMakeGroups = false;
- }
+ SMDSAbs_ElementType aType = SMDSAbs_Face;
+ if (theElementType == SMDSAbs_Node)
+ {
+ aType = SMDSAbs_Edge;
+ }
+ if ( myIsPreviewMode ) {
+ SMDSAbs_ElementType select = SMDSAbs_All, avoid = SMDSAbs_Volume;
+ getPreviewMesh( aType )->Copy( elements, copyElements, select, avoid );
+ workElements = & copyElements;
+ theMakeGroups = false;
+ }
- TElemOfElemListMap aHystory;
- ::SMESH_MeshEditor::PGroupIDs groupIds =
- getEditor().ExtrusionSweep (*workElements, stepVec, theNbOfSteps, aHystory, theMakeGroups);
+ TElemOfElemListMap aHystory;
+ ::SMESH_MeshEditor::PGroupIDs groupIds =
+ getEditor().ExtrusionSweep (*workElements, stepVec, theNbOfSteps, aHystory, theMakeGroups);
- myMesh->GetMeshDS()->Modified();
+ declareMeshModified( /*isReComputeSafe=*/true ); // does not influence Compute()
- return theMakeGroups ? getGroups(groupIds.get()) : 0;
+ return theMakeGroups ? getGroups(groupIds.get()) : 0;
- } catch(Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
- INFOS( "SMESH_MeshEditor_i::ExtrusionSweep fails - "<< aFail->GetMessageString() );
- }
+ SMESH_CATCH( SMESH::throwCorbaException );
return 0;
}
void SMESH_MeshEditor_i::ExtrusionSweep(const SMESH::long_array & theIDsOfElements,
const SMESH::DirStruct & theStepVector,
CORBA::Long theNbOfSteps)
+ throw (SALOME::SALOME_Exception)
{
extrusionSweep (theIDsOfElements, theStepVector, theNbOfSteps, false );
if (!myIsPreviewMode) {
void SMESH_MeshEditor_i::ExtrusionSweep0D(const SMESH::long_array & theIDsOfElements,
const SMESH::DirStruct & theStepVector,
CORBA::Long theNbOfSteps)
+ throw (SALOME::SALOME_Exception)
{
extrusionSweep (theIDsOfElements, theStepVector, theNbOfSteps, false, SMDSAbs_Node );
if (!myIsPreviewMode) {
void SMESH_MeshEditor_i::ExtrusionSweepObject(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::DirStruct & theStepVector,
CORBA::Long theNbOfSteps)
+ throw (SALOME::SALOME_Exception)
{
SMESH::long_array_var anElementsId = theObject->GetIDs();
extrusionSweep (anElementsId, theStepVector, theNbOfSteps, false );
void SMESH_MeshEditor_i::ExtrusionSweepObject0D(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::DirStruct & theStepVector,
CORBA::Long theNbOfSteps)
+ throw (SALOME::SALOME_Exception)
{
SMESH::long_array_var anElementsId = theObject->GetIDs();
extrusionSweep (anElementsId, theStepVector, theNbOfSteps, false, SMDSAbs_Node );
void SMESH_MeshEditor_i::ExtrusionSweepObject1D(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::DirStruct & theStepVector,
CORBA::Long theNbOfSteps)
+ throw (SALOME::SALOME_Exception)
{
SMESH::long_array_var anElementsId = theObject->GetIDs();
extrusionSweep (anElementsId, theStepVector, theNbOfSteps, false, SMDSAbs_Edge );
void SMESH_MeshEditor_i::ExtrusionSweepObject2D(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::DirStruct & theStepVector,
CORBA::Long theNbOfSteps)
+ throw (SALOME::SALOME_Exception)
{
SMESH::long_array_var anElementsId = theObject->GetIDs();
extrusionSweep (anElementsId, theStepVector, theNbOfSteps, false, SMDSAbs_Face );
SMESH_MeshEditor_i::ExtrusionSweepMakeGroups(const SMESH::long_array& theIDsOfElements,
const SMESH::DirStruct& theStepVector,
CORBA::Long theNbOfSteps)
+ throw (SALOME::SALOME_Exception)
{
TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
SMESH::ListOfGroups* aGroups = extrusionSweep(theIDsOfElements, theStepVector, theNbOfSteps, true);
if (!myIsPreviewMode) {
- DumpGroupsList(aPythonDump, aGroups);
+ dumpGroupsList(aPythonDump, aGroups);
aPythonDump << this << ".ExtrusionSweepMakeGroups( " << theIDsOfElements
<< ", " << theStepVector <<", " << TVar( theNbOfSteps ) << " )";
}
SMESH_MeshEditor_i::ExtrusionSweepMakeGroups0D(const SMESH::long_array& theIDsOfElements,
const SMESH::DirStruct& theStepVector,
CORBA::Long theNbOfSteps)
+ throw (SALOME::SALOME_Exception)
{
TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
SMESH::ListOfGroups* aGroups = extrusionSweep(theIDsOfElements, theStepVector, theNbOfSteps, true,SMDSAbs_Node);
if (!myIsPreviewMode) {
- DumpGroupsList(aPythonDump, aGroups);
+ dumpGroupsList(aPythonDump, aGroups);
aPythonDump << this << ".ExtrusionSweepMakeGroups0D( " << theIDsOfElements
<< ", " << theStepVector <<", " << TVar( theNbOfSteps ) << " )";
}
SMESH_MeshEditor_i::ExtrusionSweepObjectMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::DirStruct& theStepVector,
CORBA::Long theNbOfSteps)
+ throw (SALOME::SALOME_Exception)
{
TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
SMESH::ListOfGroups * aGroups = extrusionSweep(anElementsId, theStepVector, theNbOfSteps, true);
if (!myIsPreviewMode) {
- DumpGroupsList(aPythonDump, aGroups);
+ dumpGroupsList(aPythonDump, aGroups);
aPythonDump << this << ".ExtrusionSweepObjectMakeGroups( " << theObject
<< ", " << theStepVector << ", " << theNbOfSteps << " )";
}
SMESH_MeshEditor_i::ExtrusionSweepObject0DMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::DirStruct& theStepVector,
CORBA::Long theNbOfSteps)
+ throw (SALOME::SALOME_Exception)
{
TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
SMESH::ListOfGroups * aGroups = extrusionSweep(anElementsId, theStepVector,
theNbOfSteps, true, SMDSAbs_Node);
if (!myIsPreviewMode) {
- DumpGroupsList(aPythonDump, aGroups);
+ dumpGroupsList(aPythonDump, aGroups);
aPythonDump << this << ".ExtrusionSweepObject0DMakeGroups( " << theObject
<< ", " << theStepVector << ", " << TVar( theNbOfSteps ) << " )";
}
SMESH_MeshEditor_i::ExtrusionSweepObject1DMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::DirStruct& theStepVector,
CORBA::Long theNbOfSteps)
+ throw (SALOME::SALOME_Exception)
{
TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
SMESH::ListOfGroups * aGroups = extrusionSweep(anElementsId, theStepVector,
theNbOfSteps, true, SMDSAbs_Edge);
if (!myIsPreviewMode) {
- DumpGroupsList(aPythonDump, aGroups);
+ dumpGroupsList(aPythonDump, aGroups);
aPythonDump << this << ".ExtrusionSweepObject1DMakeGroups( " << theObject
<< ", " << theStepVector << ", " << TVar( theNbOfSteps ) << " )";
}
SMESH_MeshEditor_i::ExtrusionSweepObject2DMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::DirStruct& theStepVector,
CORBA::Long theNbOfSteps)
+ throw (SALOME::SALOME_Exception)
{
TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
SMESH::ListOfGroups * aGroups = extrusionSweep(anElementsId, theStepVector,
theNbOfSteps, true, SMDSAbs_Face);
if (!myIsPreviewMode) {
- DumpGroupsList(aPythonDump, aGroups);
+ dumpGroupsList(aPythonDump, aGroups);
aPythonDump << this << ".ExtrusionSweepObject2DMakeGroups( " << theObject
<< ", " << theStepVector << ", " << TVar( theNbOfSteps ) << " )";
}
CORBA::Long theExtrFlags,
CORBA::Double theSewTolerance,
const bool theMakeGroups)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
TIDSortedElemSet elements;
getEditor().ExtrusionSweep (elements, stepVec, theNbOfSteps, aHystory,
theMakeGroups, theExtrFlags, theSewTolerance);
+ declareMeshModified( /*isReComputeSafe=*/true );
+
return theMakeGroups ? getGroups(groupIds.get()) : 0;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
//=======================================================================
CORBA::Long theNbOfSteps,
CORBA::Long theExtrFlags,
CORBA::Double theSewTolerance)
+ throw (SALOME::SALOME_Exception)
{
if ( !myIsPreviewMode ) {
TPythonDump() << "stepVector = " << theStepVector;
CORBA::Long theNbOfSteps,
CORBA::Long theExtrFlags,
CORBA::Double theSewTolerance)
+ throw (SALOME::SALOME_Exception)
{
if (!myIsPreviewMode) {
TPythonDump() << "stepVector = " << theStepVector;
true);
if (!myIsPreviewMode) {
- DumpGroupsList(aPythonDump, aGroups);
+ dumpGroupsList(aPythonDump, aGroups);
aPythonDump << this << ".AdvancedExtrusionMakeGroups("
<< theIDsOfElements
<< ", stepVector, "
const bool theMakeGroups,
SMESH::SMESH_MeshEditor::Extrusion_Error & theError,
const SMDSAbs_ElementType theElementType)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
MESSAGE("extrusionAlongPath");
initData();
getEditor().ExtrusionAlongTrack( elements, aSubMesh, nodeStart,
theHasAngles, angles, false,
theHasRefPoint, refPnt, theMakeGroups );
- myMesh->GetMeshDS()->Modified();
+
+ declareMeshModified( /*isReComputeSafe=*/true );
theError = convExtrError( error );
if ( theMakeGroups ) {
return getGroups( & groupIDs );
}
return 0;
-}
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
+}
//=======================================================================
//function : extrusionAlongPathX
//purpose :
//=======================================================================
+
SMESH::ListOfGroups*
SMESH_MeshEditor_i::extrusionAlongPathX(const SMESH::long_array & IDsOfElements,
SMESH::SMESH_IDSource_ptr Path,
bool MakeGroups,
const SMDSAbs_ElementType ElementType,
SMESH::SMESH_MeshEditor::Extrusion_Error & Error)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
SMESH::ListOfGroups* EmptyGr = new SMESH::ListOfGroups;
initData();
error = getEditor().ExtrusionAlongTrack( *workElements, &(aMeshImp->GetImpl()), aNodeStart,
HasAngles, angles, LinearVariation,
HasRefPoint, refPnt, MakeGroups );
- myMesh->GetMeshDS()->Modified();
+ declareMeshModified( /*isReComputeSafe=*/true );
}
else if ( SMESH_subMesh_i* aSubMeshImp = SMESH::DownCast<SMESH_subMesh_i*>( Path ))
{
error = getEditor().ExtrusionAlongTrack( *workElements, aSubMesh, aNodeStart,
HasAngles, angles, LinearVariation,
HasRefPoint, refPnt, MakeGroups );
- myMesh->GetMeshDS()->Modified();
+ declareMeshModified( /*isReComputeSafe=*/true );
}
else if ( SMESH::DownCast<SMESH_Group_i*>( Path ))
{
return getGroups( & groupIDs );
}
return EmptyGr;
-}
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
+}
//=======================================================================
//function : ExtrusionAlongPath
//purpose :
//=======================================================================
+
SMESH::SMESH_MeshEditor::Extrusion_Error
SMESH_MeshEditor_i::ExtrusionAlongPath(const SMESH::long_array & theIDsOfElements,
SMESH::SMESH_Mesh_ptr thePathMesh,
const SMESH::double_array & theAngles,
CORBA::Boolean theHasRefPoint,
const SMESH::PointStruct & theRefPoint)
+ throw (SALOME::SALOME_Exception)
{
MESSAGE("ExtrusionAlongPath");
if ( !myIsPreviewMode ) {
//function : ExtrusionAlongPathObject
//purpose :
//=======================================================================
+
SMESH::SMESH_MeshEditor::Extrusion_Error
SMESH_MeshEditor_i::ExtrusionAlongPathObject(SMESH::SMESH_IDSource_ptr theObject,
SMESH::SMESH_Mesh_ptr thePathMesh,
const SMESH::double_array & theAngles,
CORBA::Boolean theHasRefPoint,
const SMESH::PointStruct & theRefPoint)
+ throw (SALOME::SALOME_Exception)
{
if ( !myIsPreviewMode ) {
TPythonDump() << "error = " << this << ".ExtrusionAlongPathObject( "
//function : ExtrusionAlongPathObject1D
//purpose :
//=======================================================================
+
SMESH::SMESH_MeshEditor::Extrusion_Error
SMESH_MeshEditor_i::ExtrusionAlongPathObject1D(SMESH::SMESH_IDSource_ptr theObject,
SMESH::SMESH_Mesh_ptr thePathMesh,
const SMESH::double_array & theAngles,
CORBA::Boolean theHasRefPoint,
const SMESH::PointStruct & theRefPoint)
+ throw (SALOME::SALOME_Exception)
{
if ( !myIsPreviewMode ) {
TPythonDump() << "error = " << this << ".ExtrusionAlongPathObject1D( "
//function : ExtrusionAlongPathObject2D
//purpose :
//=======================================================================
+
SMESH::SMESH_MeshEditor::Extrusion_Error
SMESH_MeshEditor_i::ExtrusionAlongPathObject2D(SMESH::SMESH_IDSource_ptr theObject,
SMESH::SMESH_Mesh_ptr thePathMesh,
const SMESH::double_array & theAngles,
CORBA::Boolean theHasRefPoint,
const SMESH::PointStruct & theRefPoint)
+ throw (SALOME::SALOME_Exception)
{
if ( !myIsPreviewMode ) {
TPythonDump() << "error = " << this << ".ExtrusionAlongPathObject2D( "
//function : ExtrusionAlongPathMakeGroups
//purpose :
//=======================================================================
+
SMESH::ListOfGroups*
SMESH_MeshEditor_i::ExtrusionAlongPathMakeGroups(const SMESH::long_array& theIDsOfElements,
SMESH::SMESH_Mesh_ptr thePathMesh,
CORBA::Boolean theHasRefPoint,
const SMESH::PointStruct& theRefPoint,
SMESH::SMESH_MeshEditor::Extrusion_Error& Error)
+ throw (SALOME::SALOME_Exception)
{
TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
//function : ExtrusionAlongPathObjectMakeGroups
//purpose :
//=======================================================================
+
SMESH::ListOfGroups* SMESH_MeshEditor_i::
ExtrusionAlongPathObjectMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
SMESH::SMESH_Mesh_ptr thePathMesh,
CORBA::Boolean theHasRefPoint,
const SMESH::PointStruct& theRefPoint,
SMESH::SMESH_MeshEditor::Extrusion_Error& Error)
+ throw (SALOME::SALOME_Exception)
{
TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
//function : ExtrusionAlongPathObject1DMakeGroups
//purpose :
//=======================================================================
+
SMESH::ListOfGroups* SMESH_MeshEditor_i::
ExtrusionAlongPathObject1DMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
SMESH::SMESH_Mesh_ptr thePathMesh,
CORBA::Boolean theHasRefPoint,
const SMESH::PointStruct& theRefPoint,
SMESH::SMESH_MeshEditor::Extrusion_Error& Error)
+ throw (SALOME::SALOME_Exception)
{
TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
//function : ExtrusionAlongPathObject2DMakeGroups
//purpose :
//=======================================================================
+
SMESH::ListOfGroups* SMESH_MeshEditor_i::
ExtrusionAlongPathObject2DMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
SMESH::SMESH_Mesh_ptr thePathMesh,
CORBA::Boolean theHasRefPoint,
const SMESH::PointStruct& theRefPoint,
SMESH::SMESH_MeshEditor::Extrusion_Error& Error)
+ throw (SALOME::SALOME_Exception)
{
TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
return aGroups;
}
-
//=======================================================================
//function : ExtrusionAlongPathObjX
//purpose :
//=======================================================================
+
SMESH::ListOfGroups* SMESH_MeshEditor_i::
ExtrusionAlongPathObjX(SMESH::SMESH_IDSource_ptr Object,
SMESH::SMESH_IDSource_ptr Path,
CORBA::Boolean MakeGroups,
SMESH::ElementType ElemType,
SMESH::SMESH_MeshEditor::Extrusion_Error& Error)
+ throw (SALOME::SALOME_Exception)
{
TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
return aGroups;
}
-
//=======================================================================
//function : ExtrusionAlongPathX
//purpose :
//=======================================================================
+
SMESH::ListOfGroups* SMESH_MeshEditor_i::
ExtrusionAlongPathX(const SMESH::long_array& IDsOfElements,
SMESH::SMESH_IDSource_ptr Path,
CORBA::Boolean MakeGroups,
SMESH::ElementType ElemType,
SMESH::SMESH_MeshEditor::Extrusion_Error& Error)
+ throw (SALOME::SALOME_Exception)
{
TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
return aGroups;
}
-
//================================================================================
/*!
* \brief Compute rotation angles for ExtrusionAlongPath as linear variation
return aResult._retn();
}
-
//=======================================================================
//function : mirror
//purpose :
CORBA::Boolean theCopy,
bool theMakeGroups,
::SMESH_Mesh* theTargetMesh)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
gp_Pnt P ( theAxis.x, theAxis.y, theAxis.z );
}
else
{
- myMesh->GetMeshDS()->Modified();
- myMesh->SetIsModified( true );
+ declareMeshModified( /*isReComputeSafe=*/false );
}
}
return theMakeGroups ? getGroups(groupIds.get()) : 0;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
//=======================================================================
const SMESH::AxisStruct & theAxis,
SMESH::SMESH_MeshEditor::MirrorType theMirrorType,
CORBA::Boolean theCopy)
+ throw (SALOME::SALOME_Exception)
{
if ( !myIsPreviewMode ) {
TPythonDump() << this << ".Mirror( "
const SMESH::AxisStruct & theAxis,
SMESH::SMESH_MeshEditor::MirrorType theMirrorType,
CORBA::Boolean theCopy)
+ throw (SALOME::SALOME_Exception)
{
if ( !myIsPreviewMode ) {
TPythonDump() << this << ".MirrorObject( "
SMESH_MeshEditor_i::MirrorMakeGroups(const SMESH::long_array& theIDsOfElements,
const SMESH::AxisStruct& theMirror,
SMESH::SMESH_MeshEditor::MirrorType theMirrorType)
+ throw (SALOME::SALOME_Exception)
{
TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
aGroups = mirror(elements, theMirror, theMirrorType, true, true);
}
if (!myIsPreviewMode) {
- DumpGroupsList(aPythonDump, aGroups);
+ dumpGroupsList(aPythonDump, aGroups);
aPythonDump << this << ".MirrorMakeGroups( "
<< theIDsOfElements << ", "
<< theMirror << ", "
SMESH_MeshEditor_i::MirrorObjectMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::AxisStruct& theMirror,
SMESH::SMESH_MeshEditor::MirrorType theMirrorType)
+ throw (SALOME::SALOME_Exception)
{
TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
if (!myIsPreviewMode)
{
- DumpGroupsList(aPythonDump,aGroups);
+ dumpGroupsList(aPythonDump,aGroups);
aPythonDump << this << ".MirrorObjectMakeGroups( "
<< theObject << ", "
<< theMirror << ", "
SMESH::SMESH_MeshEditor::MirrorType theMirrorType,
CORBA::Boolean theCopyGroups,
const char* theMeshName)
+ throw (SALOME::SALOME_Exception)
{
SMESH_Mesh_i* mesh_i;
SMESH::SMESH_Mesh_var mesh;
SMESH::SMESH_MeshEditor::MirrorType theMirrorType,
CORBA::Boolean theCopyGroups,
const char* theMeshName)
+ throw (SALOME::SALOME_Exception)
{
SMESH_Mesh_i* mesh_i;
SMESH::SMESH_Mesh_var mesh;
CORBA::Boolean theCopy,
bool theMakeGroups,
::SMESH_Mesh* theTargetMesh)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
if ( theTargetMesh )
}
else
{
- myMesh->GetMeshDS()->Modified();
- myMesh->SetIsModified( true );
+ declareMeshModified( /*isReComputeSafe=*/false );
}
}
return theMakeGroups ? getGroups(groupIds.get()) : 0;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
//=======================================================================
void SMESH_MeshEditor_i::Translate(const SMESH::long_array & theIDsOfElements,
const SMESH::DirStruct & theVector,
CORBA::Boolean theCopy)
+ throw (SALOME::SALOME_Exception)
{
if (!myIsPreviewMode) {
TPythonDump() << this << ".Translate( "
void SMESH_MeshEditor_i::TranslateObject(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::DirStruct & theVector,
CORBA::Boolean theCopy)
+ throw (SALOME::SALOME_Exception)
{
if (!myIsPreviewMode) {
TPythonDump() << this << ".TranslateObject( "
SMESH::ListOfGroups*
SMESH_MeshEditor_i::TranslateMakeGroups(const SMESH::long_array& theIDsOfElements,
const SMESH::DirStruct& theVector)
+ throw (SALOME::SALOME_Exception)
{
TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
aGroups = translate(elements,theVector,true,true);
}
if (!myIsPreviewMode) {
- DumpGroupsList(aPythonDump, aGroups);
+ dumpGroupsList(aPythonDump, aGroups);
aPythonDump << this << ".TranslateMakeGroups( "
<< theIDsOfElements << ", "
<< theVector << " )";
SMESH::ListOfGroups*
SMESH_MeshEditor_i::TranslateObjectMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::DirStruct& theVector)
+ throw (SALOME::SALOME_Exception)
{
TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
aGroups = translate(elements, theVector, true, true);
if (!myIsPreviewMode) {
- DumpGroupsList(aPythonDump, aGroups);
+ dumpGroupsList(aPythonDump, aGroups);
aPythonDump << this << ".TranslateObjectMakeGroups( "
<< theObject << ", "
<< theVector << " )";
const SMESH::DirStruct& theVector,
CORBA::Boolean theCopyGroups,
const char* theMeshName)
+ throw (SALOME::SALOME_Exception)
{
SMESH_Mesh_i* mesh_i;
SMESH::SMESH_Mesh_var mesh;
const SMESH::DirStruct& theVector,
CORBA::Boolean theCopyGroups,
const char* theMeshName)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
SMESH_Mesh_i* mesh_i;
SMESH::SMESH_Mesh_var mesh;
{ // open new scope to dump "MakeMesh" command
mesh_i->GetGroups();
return mesh._retn();
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
//=======================================================================
CORBA::Boolean theCopy,
bool theMakeGroups,
::SMESH_Mesh* theTargetMesh)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
if ( theTargetMesh )
if ( theCopy && !myIsPreviewMode)
{
- if ( theTargetMesh )
- {
- theTargetMesh->GetMeshDS()->Modified();
- }
- else
- {
- myMesh->GetMeshDS()->Modified();
- myMesh->SetIsModified( true );
- }
+ if ( theTargetMesh ) theTargetMesh->GetMeshDS()->Modified();
+ else declareMeshModified( /*isReComputeSafe=*/false );
}
return theMakeGroups ? getGroups(groupIds.get()) : 0;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
//=======================================================================
const SMESH::AxisStruct & theAxis,
CORBA::Double theAngle,
CORBA::Boolean theCopy)
+ throw (SALOME::SALOME_Exception)
{
if (!myIsPreviewMode) {
TPythonDump() << this << ".Rotate( "
const SMESH::AxisStruct & theAxis,
CORBA::Double theAngle,
CORBA::Boolean theCopy)
+ throw (SALOME::SALOME_Exception)
{
if ( !myIsPreviewMode ) {
TPythonDump() << this << ".RotateObject( "
SMESH_MeshEditor_i::RotateMakeGroups(const SMESH::long_array& theIDsOfElements,
const SMESH::AxisStruct& theAxis,
CORBA::Double theAngle)
+ throw (SALOME::SALOME_Exception)
{
TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
aGroups = rotate(elements,theAxis,theAngle,true,true);
}
if (!myIsPreviewMode) {
- DumpGroupsList(aPythonDump, aGroups);
+ dumpGroupsList(aPythonDump, aGroups);
aPythonDump << this << ".RotateMakeGroups( "
<< theIDsOfElements << ", "
<< theAxis << ", "
SMESH_MeshEditor_i::RotateObjectMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::AxisStruct& theAxis,
CORBA::Double theAngle)
+ throw (SALOME::SALOME_Exception)
{
TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
aGroups = rotate(elements, theAxis, theAngle, true, true);
if (!myIsPreviewMode) {
- DumpGroupsList(aPythonDump, aGroups);
+ dumpGroupsList(aPythonDump, aGroups);
aPythonDump << this << ".RotateObjectMakeGroups( "
<< theObject << ", "
<< theAxis << ", "
CORBA::Double theAngleInRadians,
CORBA::Boolean theCopyGroups,
const char* theMeshName)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
SMESH::SMESH_Mesh_var mesh;
SMESH_Mesh_i* mesh_i;
mesh_i->GetGroups();
return mesh._retn();
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
//=======================================================================
CORBA::Double theAngleInRadians,
CORBA::Boolean theCopyGroups,
const char* theMeshName)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
SMESH::SMESH_Mesh_var mesh;
SMESH_Mesh_i* mesh_i;
mesh_i->GetGroups();
return mesh._retn();
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
//=======================================================================
CORBA::Boolean theCopy,
bool theMakeGroups,
::SMESH_Mesh* theTargetMesh)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
if ( theScaleFact.length() < 1 )
THROW_SALOME_CORBA_EXCEPTION("Scale factor not given", SALOME::BAD_PARAM);
if ( theCopy && !myIsPreviewMode )
{
- if ( theTargetMesh )
- {
- theTargetMesh->GetMeshDS()->Modified();
- }
- else
- {
- myMesh->GetMeshDS()->Modified();
- myMesh->SetIsModified( true );
- }
+ if ( theTargetMesh ) theTargetMesh->GetMeshDS()->Modified();
+ else declareMeshModified( /*isReComputeSafe=*/false );
}
-
return theMakeGroups ? getGroups(groupIds.get()) : 0;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
//=======================================================================
const SMESH::PointStruct& thePoint,
const SMESH::double_array& theScaleFact,
CORBA::Boolean theCopy)
+ throw (SALOME::SALOME_Exception)
{
if ( !myIsPreviewMode ) {
TPythonDump() << this << ".Scale( "
SMESH_MeshEditor_i::ScaleMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::PointStruct& thePoint,
const SMESH::double_array& theScaleFact)
+ throw (SALOME::SALOME_Exception)
{
TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
SMESH::ListOfGroups * aGroups = scale(theObject, thePoint, theScaleFact, true, true);
if (!myIsPreviewMode) {
- DumpGroupsList(aPythonDump, aGroups);
+ dumpGroupsList(aPythonDump, aGroups);
aPythonDump << this << ".Scale("
<< theObject << ","
<< thePoint << ","
const SMESH::double_array& theScaleFact,
CORBA::Boolean theCopyGroups,
const char* theMeshName)
+ throw (SALOME::SALOME_Exception)
{
SMESH_Mesh_i* mesh_i;
SMESH::SMESH_Mesh_var mesh;
void SMESH_MeshEditor_i::FindCoincidentNodes (CORBA::Double Tolerance,
SMESH::array_of_long_array_out GroupsOfNodes)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
::SMESH_MeshEditor::TListOfListOfNodes aListOfListOfNodes;
}
TPythonDump() << "coincident_nodes = " << this << ".FindCoincidentNodes( "
<< Tolerance << " )";
+
+ SMESH_CATCH( SMESH::throwCorbaException );
}
//=======================================================================
//function : FindCoincidentNodesOnPart
//purpose :
//=======================================================================
+
void SMESH_MeshEditor_i::FindCoincidentNodesOnPart(SMESH::SMESH_IDSource_ptr theObject,
CORBA::Double Tolerance,
SMESH::array_of_long_array_out GroupsOfNodes)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
TIDSortedNodeSet nodes;
TPythonDump() << "coincident_nodes_on_part = " << this << ".FindCoincidentNodesOnPart( "
<<theObject<<", "
<< Tolerance << " )";
+
+ SMESH_CATCH( SMESH::throwCorbaException );
}
//================================================================================
CORBA::Double theTolerance,
SMESH::array_of_long_array_out theGroupsOfNodes,
const SMESH::ListOfIDSources& theExceptSubMeshOrGroups)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
TIDSortedNodeSet nodes;
<< theObject<<", "
<< theTolerance << ", "
<< theExceptSubMeshOrGroups << " )";
+
+ SMESH_CATCH( SMESH::throwCorbaException );
}
//=======================================================================
//=======================================================================
void SMESH_MeshEditor_i::MergeNodes (const SMESH::array_of_long_array& GroupsOfNodes)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
SMESHDS_Mesh* aMesh = getMeshDS();
getEditor().MergeNodes( aListOfListOfNodes );
aTPythonDump << "])";
- myMesh->GetMeshDS()->Modified();
- myMesh->SetIsModified( true );
+
+ declareMeshModified( /*isReComputeSafe=*/false );
+
+ SMESH_CATCH( SMESH::throwCorbaException );
}
//=======================================================================
//function : FindEqualElements
//purpose :
//=======================================================================
+
void SMESH_MeshEditor_i::FindEqualElements(SMESH::SMESH_IDSource_ptr theObject,
SMESH::array_of_long_array_out GroupsOfElementsID)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
SMESH::SMESH_GroupBase_var group = SMESH::SMESH_GroupBase::_narrow(theObject);
TPythonDump() << "equal_elements = " << this << ".FindEqualElements( "
<<theObject<<" )";
}
+
+ SMESH_CATCH( SMESH::throwCorbaException );
}
//=======================================================================
//=======================================================================
void SMESH_MeshEditor_i::MergeElements(const SMESH::array_of_long_array& GroupsOfElementsID)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
TPythonDump aTPythonDump;
}
getEditor().MergeElements(aListOfListOfElementsID);
- myMesh->GetMeshDS()->Modified();
- myMesh->SetIsModified( true );
+
+ declareMeshModified( /*isReComputeSafe=*/true );
aTPythonDump << "] )";
+
+ SMESH_CATCH( SMESH::throwCorbaException );
}
//=======================================================================
//=======================================================================
void SMESH_MeshEditor_i::MergeEqualElements()
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
getEditor().MergeEqualElements();
- myMesh->GetMeshDS()->Modified();
+ declareMeshModified( /*isReComputeSafe=*/true );
TPythonDump() << this << ".MergeEqualElements()";
+
+ SMESH_CATCH( SMESH::throwCorbaException );
}
//=============================================================================
CORBA::Double x,
CORBA::Double y,
CORBA::Double z)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData(/*deleteSearchers=*/false);
const SMDS_MeshNode * node = getMeshDS()->FindNode( NodeID );
// Update Python script
TPythonDump() << "isDone = " << this << ".MoveNode( "
<< NodeID << ", " << TVar(x) << ", " << TVar(y) << ", " << TVar(z) << " )";
- myMesh->GetMeshDS()->Modified();
- myMesh->SetIsModified( true );
+ declareMeshModified( /*isReComputeSafe=*/false );
}
+ SMESH_CATCH( SMESH::throwCorbaException );
+
return true;
}
CORBA::Long SMESH_MeshEditor_i::FindNodeClosestTo(CORBA::Double x,
CORBA::Double y,
CORBA::Double z)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
theSearchersDeleter.Set( myMesh ); // remove theNodeSearcher if mesh is other
if ( !theNodeSearcher ) {
if ( const SMDS_MeshNode* node = theNodeSearcher->FindClosestTo( p ))
return node->GetID();
+ SMESH_CATCH( SMESH::throwCorbaException );
return 0;
}
CORBA::Double y,
CORBA::Double z,
CORBA::Long theNodeID)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
// We keep theNodeSearcher until any mesh modification:
// 1) initData() deletes theNodeSearcher at any edition,
// 2) TSearchersDeleter - at any mesh compute event and mesh change
<< ".MoveClosestNodeToPoint( "<< x << ", " << y << ", " << z
<< ", " << nodeID << " )";
- myMesh->GetMeshDS()->Modified();
- myMesh->SetIsModified( true );
+ declareMeshModified( /*isReComputeSafe=*/false );
}
return nodeID;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
//=======================================================================
CORBA::Double y,
CORBA::Double z,
SMESH::ElementType type)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
SMESH::long_array_var res = new SMESH::long_array;
vector< const SMDS_MeshElement* > foundElems;
<< type << " )";
return res._retn();
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
//=======================================================================
CORBA::Double y,
CORBA::Double z,
SMESH::ElementType type)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
SMESH::long_array_var res = new SMESH::long_array;
SMESH::array_of_ElementType_var types = elementIDs->GetTypes();
<< type << " )";
return res._retn();
-
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
+
//=======================================================================
//function : GetPointState
//purpose : Return point state in a closed 2D mesh in terms of TopAbs_State enumeration.
CORBA::Short SMESH_MeshEditor_i::GetPointState(CORBA::Double x,
CORBA::Double y,
CORBA::Double z)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
theSearchersDeleter.Set( myMesh );
if ( !theElementSearcher ) {
theElementSearcher = myEditor.GetElementSearcher();
}
return CORBA::Short( theElementSearcher->GetPointState( gp_Pnt( x,y,z )));
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
//=======================================================================
CORBA::Long LastNodeID2,
CORBA::Boolean CreatePolygons,
CORBA::Boolean CreatePolyedrs)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
SMESHDS_Mesh* aMesh = getMeshDS();
CreatePolyedrs) );
- myMesh->GetMeshDS()->Modified();
- myMesh->SetIsModified( true );
-
+ declareMeshModified( /*isReComputeSafe=*/false );
return error;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return SMESH::SMESH_MeshEditor::Sew_Error(0);
}
CORBA::Long LastNodeID1,
CORBA::Long FirstNodeID2,
CORBA::Long SecondNodeID2)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
SMESHDS_Mesh* aMesh = getMeshDS();
true,
false, false) );
-
- myMesh->GetMeshDS()->Modified();
- myMesh->SetIsModified( true );
-
+ declareMeshModified( /*isReComputeSafe=*/false );
return error;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return SMESH::SMESH_MeshEditor::Sew_Error(0);
}
CORBA::Long LastNodeIDOnSide,
CORBA::Boolean CreatePolygons,
CORBA::Boolean CreatePolyedrs)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
SMESHDS_Mesh* aMesh = getMeshDS();
CreatePolygons,
CreatePolyedrs) );
-
- myMesh->GetMeshDS()->Modified();
- myMesh->SetIsModified( true );
-
+ declareMeshModified( /*isReComputeSafe=*/false );
return error;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return SMESH::SMESH_MeshEditor::Sew_Error(0);
}
CORBA::Long NodeID1OfSide2ToMerge,
CORBA::Long NodeID2OfSide1ToMerge,
CORBA::Long NodeID2OfSide2ToMerge)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
SMESHDS_Mesh* aMesh = getMeshDS();
aSecondNode1ToMerge,
aSecondNode2ToMerge));
+ declareMeshModified( /*isReComputeSafe=*/false );
+ return error;
- myMesh->GetMeshDS()->Modified();
- myMesh->SetIsModified( true );
-
- return error;
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return SMESH::SMESH_MeshEditor::Sew_Error(0);
}
//================================================================================
CORBA::Boolean SMESH_MeshEditor_i::ChangeElemNodes(CORBA::Long ide,
const SMESH::long_array& newIDs)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
const SMDS_MeshElement* elem = getMeshDS()->FindElement(ide);
MESSAGE("ChangeElementNodes");
bool res = getMeshDS()->ChangeElementNodes( elem, & aNodes[0], nbn1+1 );
- myMesh->GetMeshDS()->Modified();
- if ( res )
- myMesh->SetIsModified( true );
+ declareMeshModified( /*isReComputeSafe=*/ !res );
return res;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
//=======================================================================
-//function : ConvertToQuadratic
-//purpose :
+/*!
+ * \brief Makes a part of the mesh quadratic or bi-quadratic
+ */
//=======================================================================
-void SMESH_MeshEditor_i::ConvertToQuadratic(CORBA::Boolean theForce3d)
+void SMESH_MeshEditor_i::convertToQuadratic(CORBA::Boolean theForce3d,
+ CORBA::Boolean theToBiQuad,
+ SMESH::SMESH_IDSource_ptr theObject)
+ throw (SALOME::SALOME_Exception)
{
- getEditor().ConvertToQuadratic(theForce3d);
- TPythonDump() << this << ".ConvertToQuadratic( " << theForce3d << " )";
- myMesh->GetMeshDS()->Modified();
- myMesh->SetIsModified( true );
+ SMESH_TRY;
+ TIDSortedElemSet elems;
+ bool elemsOK;
+ if ( !( elemsOK = CORBA::is_nil( theObject )))
+ elemsOK = idSourceToSet( theObject, getMeshDS(), elems,
+ SMDSAbs_All, /*emptyIfIsMesh=*/true );
+ if ( elemsOK )
+ {
+ if ( !elems.empty() && (*elems.begin())->GetType() == SMDSAbs_Node )
+ THROW_SALOME_CORBA_EXCEPTION("Group of nodes is not allowed", SALOME::BAD_PARAM);
+
+ if ( elems.empty() ) getEditor().ConvertToQuadratic(theForce3d, theToBiQuad);
+ else getEditor().ConvertToQuadratic(theForce3d, elems, theToBiQuad);
+
+ declareMeshModified( /*isReComputeSafe=*/false );
+ }
+
+ SMESH_CATCH( SMESH::throwCorbaException );
}
//=======================================================================
//=======================================================================
CORBA::Boolean SMESH_MeshEditor_i::ConvertFromQuadratic()
+ throw (SALOME::SALOME_Exception)
{
CORBA::Boolean isDone = getEditor().ConvertFromQuadratic();
TPythonDump() << this << ".ConvertFromQuadratic()";
- myMesh->GetMeshDS()->Modified();
- if ( isDone )
- myMesh->SetIsModified( true );
+ declareMeshModified( /*isReComputeSafe=*/!isDone );
return isDone;
}
+
+//=======================================================================
+//function : ConvertToQuadratic
+//purpose :
+//=======================================================================
+
+void SMESH_MeshEditor_i::ConvertToQuadratic(CORBA::Boolean theForce3d)
+ throw (SALOME::SALOME_Exception)
+{
+ convertToQuadratic( theForce3d, false );
+ TPythonDump() << this << ".ConvertToQuadratic("<<theForce3d<<")";
+}
+
//================================================================================
/*!
* \brief Makes a part of the mesh quadratic
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
- {
- getEditor().ConvertToQuadratic(theForce3d, elems);
- }
- }
- myMesh->GetMeshDS()->Modified();
- myMesh->SetIsModified( true );
+ convertToQuadratic( theForce3d, false, theObject );
+ TPythonDump() << this << ".ConvertToQuadraticObject("<<theForce3d<<", "<<theObject<<")";
+}
- pyDump << this << ".ConvertToQuadraticObject( "<<theForce3d<<", "<<theObject<<" )";
+//================================================================================
+/*!
+ * \brief Makes a part of the mesh bi-quadratic
+ */
+//================================================================================
+
+void SMESH_MeshEditor_i::ConvertToBiQuadratic(CORBA::Boolean theForce3d,
+ SMESH::SMESH_IDSource_ptr theObject)
+ throw (SALOME::SALOME_Exception)
+{
+ convertToQuadratic( theForce3d, true, theObject );
+ TPythonDump() << this << ".ConvertToBiQuadratic("<<theForce3d<<", "<<theObject<<")";
}
//================================================================================
void SMESH_MeshEditor_i::ConvertFromQuadraticObject(SMESH::SMESH_IDSource_ptr theObject)
throw (SALOME::SALOME_Exception)
{
- Unexpect aCatch(SALOME_SalomeException);
- TPythonDump pyDump;
+ SMESH_TRY;
+ TPythonDump pyDump;
TIDSortedElemSet elems;
if ( idSourceToSet( theObject, getMeshDS(), elems, SMDSAbs_All, /*emptyIfIsMesh=*/true ))
{
getEditor().ConvertFromQuadratic(elems);
}
}
- myMesh->GetMeshDS()->Modified();
- myMesh->SetIsModified( true );
+ declareMeshModified( /*isReComputeSafe=*/false );
pyDump << this << ".ConvertFromQuadraticObject( "<<theObject<<" )";
+
+ SMESH_CATCH( SMESH::throwCorbaException );
}
//=======================================================================
}
//=======================================================================
-//function : DumpGroupsList
+//function : dumpGroupsList
//purpose :
//=======================================================================
-void SMESH_MeshEditor_i::DumpGroupsList(TPythonDump & theDumpPython,
+
+void SMESH_MeshEditor_i::dumpGroupsList(TPythonDump & theDumpPython,
const SMESH::ListOfGroups * theGroupList)
{
- bool isDumpGroupList = theGroupList && theGroupList->length() > 0;
- if(isDumpGroupList) {
+ bool isDumpGroupList = ( theGroupList && theGroupList->length() > 0 );
+ if ( isDumpGroupList )
theDumpPython << theGroupList << " = ";
- }
}
//================================================================================
\return unique name
*/
//================================================================================
+
string SMESH_MeshEditor_i::generateGroupName(const string& thePrefix)
{
SMESH::ListOfGroups_var groups = myMesh_i->GetGroups();
CORBA::Boolean SMESH_MeshEditor_i::DoubleNodes( const SMESH::long_array& theNodes,
const SMESH::long_array& theModifiedElems )
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
list< int > aListOfNodes;
bool aResult = getEditor().DoubleNodes( aListOfNodes, aListOfElems );
- myMesh->GetMeshDS()->Modified();
- if ( aResult )
- myMesh->SetIsModified( true );
+ declareMeshModified( /*isReComputeSafe=*/ !aResult );
// Update Python script
TPythonDump() << this << ".DoubleNodes( " << theNodes << ", "<< theModifiedElems << " )";
return aResult;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
//================================================================================
CORBA::Boolean SMESH_MeshEditor_i::DoubleNode( CORBA::Long theNodeId,
const SMESH::long_array& theModifiedElems )
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
SMESH::long_array_var aNodes = new SMESH::long_array;
aNodes->length( 1 );
aNodes[ 0 ] = theNodeId;
pyDump << this << ".DoubleNode( " << theNodeId << ", " << theModifiedElems << " )";
return done;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
//================================================================================
CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeGroup(SMESH::SMESH_GroupBase_ptr theNodes,
SMESH::SMESH_GroupBase_ptr theModifiedElems )
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
if ( CORBA::is_nil( theNodes ) && theNodes->GetType() != SMESH::NODE )
return false;
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.
* \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 )
<< theModifiedElems << " )";
return aNewGroup._retn();
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
//================================================================================
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++ )
bool aResult = getEditor().DoubleNodes( aNodes, anElems );
-
- myMesh->GetMeshDS()->Modified();
- if ( aResult )
- myMesh->SetIsModified( true );
-
+ declareMeshModified( /*isReComputeSafe=*/false );
TPythonDump() << this << ".DoubleNodeGroups( " << theNodes << ", " << theModifiedElems << " )";
return aResult;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
//================================================================================
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;
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);
bool aResult = getEditor().DoubleNodes( anElems, aNodes, anAffected );
-
- myMesh->GetMeshDS()->Modified();
- if ( aResult )
- myMesh->SetIsModified( true );
-
// Update Python script
TPythonDump() << this << ".DoubleNodeElem( " << theElems << ", "
<< theNodesNot << ", " << theAffectedElems << " )";
+
+ declareMeshModified( /*isReComputeSafe=*/false );
return aResult;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
//================================================================================
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();
TopoDS_Shape aShape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( theShape );
bool aResult = getEditor().DoubleNodesInRegion( anElems, aNodes, aShape );
-
- myMesh->GetMeshDS()->Modified();
- if ( aResult )
- myMesh->SetIsModified( true );
-
// Update Python script
TPythonDump() << "isDone = " << this << ".DoubleNodeElemInRegion( " << theElems << ", "
<< theNodesNot << ", " << theShape << " )";
+
+ declareMeshModified( /*isReComputeSafe=*/false );
return aResult;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
//================================================================================
*/
//================================================================================
-CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeElemGroup(SMESH::SMESH_GroupBase_ptr theElems,
- SMESH::SMESH_GroupBase_ptr theNodesNot,
- SMESH::SMESH_GroupBase_ptr theAffectedElems)
+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;
bool aResult = getEditor().DoubleNodes( anElems, aNodes, anAffected );
-
- myMesh->GetMeshDS()->Modified();
- if ( aResult )
- myMesh->SetIsModified( true );
-
// 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.
* \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,
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 );
bool aResult = getEditor().DoubleNodes( anElems, aNodes, anAffected );
- myMesh->GetMeshDS()->Modified();
+ declareMeshModified( /*isReComputeSafe=*/ !aResult );
TPythonDump pyDump;
if ( aResult )
{
- myMesh->SetIsModified( true );
-
// Create group with newly created elements
CORBA::String_var elemGroupName = theElems->GetName();
string aNewName = generateGroupName( string(elemGroupName.in()) + "_double");
aTwoGroups[0] = aNewElemGroup._retn();
aTwoGroups[1] = aNewNodeGroup._retn();
return aTwoGroups._retn();
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
//================================================================================
*/
//================================================================================
-CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeElemGroupInRegion(SMESH::SMESH_GroupBase_ptr theElems,
- SMESH::SMESH_GroupBase_ptr theNodesNot,
- GEOM::GEOM_Object_ptr theShape )
-
+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;
bool aResult = getEditor().DoubleNodesInRegion( anElems, aNodes, aShape );
- myMesh->GetMeshDS()->Modified();
- if ( aResult )
- myMesh->SetIsModified( true );
+ declareMeshModified( /*isReComputeSafe=*/ !aResult );
// Update Python script
TPythonDump() << "isDone = " << this << ".DoubleNodeElemGroupInRegion( " << theElems << ", "
<< theNodesNot << ", " << theShape << " )";
return aResult;
+
+ 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 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()
-*/
+ * \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,
}
}
-CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeElemGroups(const SMESH::ListOfGroups& theElems,
- const SMESH::ListOfGroups& theNodesNot,
- const SMESH::ListOfGroups& theAffectedElems)
+//================================================================================
+/*!
+ \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();
bool aResult = getEditor().DoubleNodes( anElems, aNodes, anAffected );
-
- myMesh->GetMeshDS()->Modified();
- if ( aResult )
- myMesh->SetIsModified( true );
-
// Update Python script
TPythonDump() << "isDone = " << this << ".DoubleNodeElemGroups( " << &theElems << ", "
<< &theNodesNot << ", " << &theAffectedElems << " )";
+
+ declareMeshModified( /*isReComputeSafe=*/false );
return aResult;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
//================================================================================
SMESH_MeshEditor_i::DoubleNodeElemGroupsNew(const SMESH::ListOfGroups& theElems,
const SMESH::ListOfGroups& theNodesNot,
const SMESH::ListOfGroups& theAffectedElems)
+ throw (SALOME::SALOME_Exception)
{
TPythonDump pyDump;
SMESH::ListOfGroups_var twoGroups = DoubleNodeElemGroups2New( theElems,
return elemGroup._retn();
}
+//================================================================================
+/*!
+ * \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::ListOfGroups*
SMESH_MeshEditor_i::DoubleNodeElemGroups2New(const SMESH::ListOfGroups& theElems,
const SMESH::ListOfGroups& theNodesNot,
const SMESH::ListOfGroups& 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 );
bool aResult = getEditor().DoubleNodes( anElems, aNodes, anAffected );
+ declareMeshModified( /*isReComputeSafe=*/ !aResult );
- myMesh->GetMeshDS()->Modified();
TPythonDump pyDump;
if ( aResult )
{
- myMesh->SetIsModified( true );
-
// Create group with newly created elements
CORBA::String_var elemGroupName = theElems[0]->GetName();
string aNewName = generateGroupName( string(elemGroupName.in()) + "_double");
aTwoGroups[0] = aNewElemGroup._retn();
aTwoGroups[1] = aNewNodeGroup._retn();
return aTwoGroups._retn();
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
//================================================================================
SMESH_MeshEditor_i::DoubleNodeElemGroupsInRegion(const SMESH::ListOfGroups& theElems,
const SMESH::ListOfGroups& theNodesNot,
GEOM::GEOM_Object_ptr theShape )
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
TopoDS_Shape aShape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( theShape );
bool aResult = getEditor().DoubleNodesInRegion( anElems, aNodes, aShape );
-
- myMesh->GetMeshDS()->Modified();
- if ( aResult )
- myMesh->SetIsModified( true );
-
// Update Python script
TPythonDump() << "isDone = " << this << ".DoubleNodeElemGroupsInRegion( " << &theElems << ", "
<< &theNodesNot << ", " << theShape << " )";
+
+ declareMeshModified( /*isReComputeSafe=*/ !aResult );
return aResult;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
//================================================================================
/*!
- \brief Identify the elements that will be affected by node duplication (actual duplication is not performed.
+ \brief Identify the elements that will be affected by node duplication (actual
+ duplication is not performed.
This method is the first step of DoubleNodeElemGroupsInRegion.
\param theElems - list of groups of elements (edges or faces) to be replicated
\param theNodesNot - list of groups of nodes not to replicated
The replicated nodes should be associated to affected elements.
\return groups of affected elements
\sa DoubleNodeElemGroupsInRegion()
- */
+*/
//================================================================================
SMESH::ListOfGroups*
SMESH_MeshEditor_i::AffectedElemGroupsInRegion( const SMESH::ListOfGroups& theElems,
const SMESH::ListOfGroups& theNodesNot,
GEOM::GEOM_Object_ptr theShape )
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
MESSAGE("AffectedElemGroupsInRegion");
SMESH::ListOfGroups_var aListOfGroups = new SMESH::ListOfGroups();
bool isEdgeGroup = false;
bool aResult = aMeshEditor.AffectedElemGroupsInRegion(anElems, aNodes, aShape, anAffected);
- myMesh->GetMeshDS()->Modified();
+ declareMeshModified( /*isReComputeSafe=*/ !aResult );
+
TPythonDump pyDump;
if (aResult)
+ {
+ int lg = anAffected.size();
+ MESSAGE("lg="<< lg);
+ SMESH::long_array_var volumeIds = new SMESH::long_array;
+ volumeIds->length(lg);
+ SMESH::long_array_var faceIds = new SMESH::long_array;
+ faceIds->length(lg);
+ SMESH::long_array_var edgeIds = new SMESH::long_array;
+ edgeIds->length(lg);
+ int ivol = 0;
+ int iface = 0;
+ int iedge = 0;
+
+ TIDSortedElemSet::const_iterator eIt = anAffected.begin();
+ for (; eIt != anAffected.end(); ++eIt)
{
- myMesh->SetIsModified(true);
-
- int lg = anAffected.size();
- MESSAGE("lg="<< lg);
- SMESH::long_array_var volumeIds = new SMESH::long_array;
- volumeIds->length(lg);
- SMESH::long_array_var faceIds = new SMESH::long_array;
- faceIds->length(lg);
- SMESH::long_array_var edgeIds = new SMESH::long_array;
- edgeIds->length(lg);
- int ivol = 0;
- int iface = 0;
- int iedge = 0;
-
- TIDSortedElemSet::const_iterator eIt = anAffected.begin();
- for (; eIt != anAffected.end(); ++eIt)
- {
- const SMDS_MeshElement* anElem = *eIt;
- if (!anElem)
- continue;
- int elemId = anElem->GetID();
- if (myMesh->GetElementType(elemId, true) == SMDSAbs_Volume)
- volumeIds[ivol++] = elemId;
- else if (myMesh->GetElementType(elemId, true) == SMDSAbs_Face)
- faceIds[iface++] = elemId;
- else if (myMesh->GetElementType(elemId, true) == SMDSAbs_Edge)
- edgeIds[iedge++] = elemId;
- }
- volumeIds->length(ivol);
- faceIds->length(iface);
- edgeIds->length(iedge);
-
- aNewVolumeGroup->Add(volumeIds);
- aNewFaceGroup->Add(faceIds);
- aNewEdgeGroup->Add(edgeIds);
- isVolumeGroup = (aNewVolumeGroup->Size() > 0);
- isFaceGroup = (aNewFaceGroup->Size() > 0);
- isEdgeGroup = (aNewEdgeGroup->Size() > 0);
+ const SMDS_MeshElement* anElem = *eIt;
+ if (!anElem)
+ continue;
+ int elemId = anElem->GetID();
+ if (myMesh->GetElementType(elemId, true) == SMDSAbs_Volume)
+ volumeIds[ivol++] = elemId;
+ else if (myMesh->GetElementType(elemId, true) == SMDSAbs_Face)
+ faceIds[iface++] = elemId;
+ else if (myMesh->GetElementType(elemId, true) == SMDSAbs_Edge)
+ edgeIds[iedge++] = elemId;
}
+ volumeIds->length(ivol);
+ faceIds->length(iface);
+ edgeIds->length(iedge);
+
+ aNewVolumeGroup->Add(volumeIds);
+ aNewFaceGroup->Add(faceIds);
+ aNewEdgeGroup->Add(edgeIds);
+ isVolumeGroup = (aNewVolumeGroup->Size() > 0);
+ isFaceGroup = (aNewFaceGroup->Size() > 0);
+ isEdgeGroup = (aNewEdgeGroup->Size() > 0);
+ }
int nbGroups = 0;
- if (isEdgeGroup)
- nbGroups++;
- if (isFaceGroup)
- nbGroups++;
- if (isVolumeGroup)
- nbGroups++;
+ if (isEdgeGroup) nbGroups++;
+ if (isFaceGroup) nbGroups++;
+ if (isVolumeGroup) nbGroups++;
aListOfGroups->length(nbGroups);
int i = 0;
- if (isEdgeGroup)
- aListOfGroups[i++] = aNewEdgeGroup._retn();
- if (isFaceGroup)
- aListOfGroups[i++] = aNewFaceGroup._retn();
- if (isVolumeGroup)
- aListOfGroups[i++] = aNewVolumeGroup._retn();
+ if (isEdgeGroup) aListOfGroups[i++] = aNewEdgeGroup._retn();
+ if (isFaceGroup) aListOfGroups[i++] = aNewFaceGroup._retn();
+ if (isVolumeGroup) aListOfGroups[i++] = aNewVolumeGroup._retn();
// Update Python script
pyDump << "[ ";
- if (isEdgeGroup)
- pyDump << aNewEdgeGroup << ", ";
- if (isFaceGroup)
- pyDump << aNewFaceGroup << ", ";
- if (isVolumeGroup)
- pyDump << aNewVolumeGroup << ", ";
+ if (isEdgeGroup) pyDump << aNewEdgeGroup << ", ";
+ if (isFaceGroup) pyDump << aNewFaceGroup << ", ";
+ if (isVolumeGroup) pyDump << aNewVolumeGroup << ", ";
pyDump << "] = ";
- pyDump << this << ".AffectedElemGroupsInRegion( " << &theElems << ", " << &theNodesNot << ", " << theShape << " )";
+ pyDump << this << ".AffectedElemGroupsInRegion( "
+ << &theElems << ", " << &theNodesNot << ", " << theShape << " )";
return aListOfGroups._retn();
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
//================================================================================
//================================================================================
CORBA::Boolean SMESH_MeshEditor_i::Make2DMeshFrom3D()
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
bool aResult = getEditor().Make2DMeshFrom3D();
- myMesh->GetMeshDS()->Modified();
+
TPythonDump() << "isDone = " << this << ".Make2DMeshFrom3D()";
+
+ declareMeshModified( /*isReComputeSafe=*/ !aResult );
return aResult;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return false;
}
//================================================================================
/*!
- * \brief Double nodes on shared faces between groups of volumes and create flat elements on demand.
+ * \brief Double nodes on shared faces between groups of volumes and create flat
+ * elements on demand.
* The list of groups must describe a partition of the mesh volumes.
* The nodes of the internal faces at the boundaries of the groups are doubled.
* In option, the internal faces are replaced by flat elements.
*/
//================================================================================
-CORBA::Boolean SMESH_MeshEditor_i::DoubleNodesOnGroupBoundaries( const SMESH::ListOfGroups& theDomains,
- CORBA::Boolean createJointElems )
+CORBA::Boolean
+SMESH_MeshEditor_i::DoubleNodesOnGroupBoundaries( const SMESH::ListOfGroups& theDomains,
+ CORBA::Boolean createJointElems )
throw (SALOME::SALOME_Exception)
{
bool aResult = false;
aResult = getEditor().DoubleNodesOnGroupBoundaries( domains, createJointElems );
// TODO publish the groups of flat elements in study
- myMesh->GetMeshDS()->Modified();
+ declareMeshModified( /*isReComputeSafe=*/ !aResult );
// Update Python script
TPythonDump() << "isDone = " << this << ".DoubleNodesOnGroupBoundaries( " << &theDomains
*/
//================================================================================
-CORBA::Boolean SMESH_MeshEditor_i::CreateFlatElementsOnFacesGroups( const SMESH::ListOfGroups& theGroupsOfFaces )
+CORBA::Boolean
+SMESH_MeshEditor_i::CreateFlatElementsOnFacesGroups( const SMESH::ListOfGroups& theGroupsOfFaces )
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
-
SMESHDS_Mesh* aMeshDS = getMeshDS();
vector<TIDSortedElemSet> faceGroups;
bool aResult = getEditor().CreateFlatElementsOnFacesGroups( faceGroups );
// TODO publish the groups of flat elements in study
- myMesh->GetMeshDS()->Modified();
+ declareMeshModified( /*isReComputeSafe=*/ !aResult );
// Update Python script
- TPythonDump() << "isDone = " << this << ".CreateFlatElementsOnFacesGroups( " << &theGroupsOfFaces << " )";
+ TPythonDump() << this << ".CreateFlatElementsOnFacesGroups( " << &theGroupsOfFaces << " )";
return aResult;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return false;
}
+//================================================================================
/*!
- * \brief identify all the elements around a geom shape, get the faces delimiting the hole
- * Build groups of volume to remove, groups of faces to replace on the skin of the object,
- * groups of faces to remove inside the object, (idem edges).
- * Build ordered list of nodes at the border of each group of faces to replace (to be used to build a geom subshape)
+ * \brief Identify all the elements around a geom shape, get the faces delimiting
+ * the hole.
+ *
+ * Build groups of volume to remove, groups of faces to replace on the skin of the
+ * object, groups of faces to remove inside the object, (idem edges).
+ * Build ordered list of nodes at the border of each group of faces to replace
+ * (to be used to build a geom subshape).
*/
-void SMESH_MeshEditor_i::CreateHoleSkin(CORBA::Double radius,
- GEOM::GEOM_Object_ptr theShape,
- const char* groupName,
- const SMESH::double_array& theNodesCoords,
+//================================================================================
+
+void SMESH_MeshEditor_i::CreateHoleSkin(CORBA::Double radius,
+ GEOM::GEOM_Object_ptr theShape,
+ const char* groupName,
+ const SMESH::double_array& theNodesCoords,
SMESH::array_of_long_array_out GroupsOfNodes)
throw (SALOME::SALOME_Exception)
{
SMESH_CATCH( SMESH::throwCorbaException );
}
-
// issue 20749 ===================================================================
/*!
* \brief Creates missing boundary elements
CORBA::Boolean toCopyElements,
CORBA::Boolean toCopyExistingBondary,
SMESH::SMESH_Group_out group)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
initData();
if ( dim > SMESH::BND_1DFROM2D )
group = group_var._retn();
return mesh_var._retn();
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return SMESH::SMESH_Mesh::_nil();
}
//================================================================================
SMESH::SMESH_Group_out group)
throw (SALOME::SALOME_Exception)
{
- Unexpect aCatch(SALOME_SalomeException);
-
+ SMESH_TRY;
initData();
if ( dim > SMESH::BND_1DFROM2D )
mesh = mesh_var._retn();
group = group_var._retn();
return nbAdded;
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
}
/*!
* Return data of mesh edition preview
*/
- SMESH::MeshPreviewStruct* GetPreviewData();
+ SMESH::MeshPreviewStruct* GetPreviewData() throw (SALOME::SALOME_Exception);
/*!
* If during last operation of MeshEditor some nodes were
* created this method returns list of their IDs, if new nodes
* not created - returns an empty list
*/
- SMESH::long_array* GetLastCreatedNodes();
+ SMESH::long_array* GetLastCreatedNodes() throw (SALOME::SALOME_Exception);
/*!
* If during last operation of MeshEditor some elements were
* created this method returns list of their IDs, if new elements
* not created - returns an empty list
*/
- SMESH::long_array* GetLastCreatedElems();
+ SMESH::long_array* GetLastCreatedElems() throw (SALOME::SALOME_Exception);
/*!
* \brief Returns description of an error/warning occured during the last operation
*/
- SMESH::ComputeError* GetLastError();
+ SMESH::ComputeError* GetLastError() throw (SALOME::SALOME_Exception);
/*!
* \brief Wrap a sequence of ids in a SMESH_IDSource
SMESH::SMESH_IDSource_ptr MakeIDSource(const SMESH::long_array& IDsOfElements,
SMESH::ElementType type);
static bool IsTemporaryIDSource( SMESH::SMESH_IDSource_ptr& idSource );
- CORBA::Boolean RemoveElements(const SMESH::long_array & IDsOfElements);
- CORBA::Boolean RemoveNodes(const SMESH::long_array & IDsOfNodes);
- CORBA::Long RemoveOrphanNodes();
+
+ CORBA::Boolean RemoveElements(const SMESH::long_array & IDsOfElements)
+ throw (SALOME::SALOME_Exception);
+ CORBA::Boolean RemoveNodes (const SMESH::long_array & IDsOfNodes)
+ throw (SALOME::SALOME_Exception);
+ CORBA::Long RemoveOrphanNodes()
+ throw (SALOME::SALOME_Exception);
/*!
* Methods for creation new elements.
* Returns ID of created element or 0 if element not created
*/
- CORBA::Long AddNode(CORBA::Double x, CORBA::Double y, CORBA::Double z);
- CORBA::Long Add0DElement(CORBA::Long IDOfNode);
+ CORBA::Long AddNode(CORBA::Double x, CORBA::Double y, CORBA::Double z)
+ throw (SALOME::SALOME_Exception);
+ CORBA::Long Add0DElement(CORBA::Long IDOfNode)
+ throw (SALOME::SALOME_Exception);
CORBA::Long AddBall(CORBA::Long IDOfNodem, CORBA::Double diameter)
throw (SALOME::SALOME_Exception);
- CORBA::Long AddEdge(const SMESH::long_array & IDsOfNodes);
- CORBA::Long AddFace(const SMESH::long_array & IDsOfNodes);
- CORBA::Long AddPolygonalFace(const SMESH::long_array & IDsOfNodes);
- CORBA::Long AddVolume(const SMESH::long_array & IDsOfNodes);
+ CORBA::Long AddEdge(const SMESH::long_array & IDsOfNodes)
+ throw (SALOME::SALOME_Exception);
+ CORBA::Long AddFace(const SMESH::long_array & IDsOfNodes)
+ throw (SALOME::SALOME_Exception);
+ CORBA::Long AddPolygonalFace(const SMESH::long_array & IDsOfNodes)
+ throw (SALOME::SALOME_Exception);
+ CORBA::Long AddVolume(const SMESH::long_array & IDsOfNodes)
+ throw (SALOME::SALOME_Exception);
CORBA::Long AddPolyhedralVolume(const SMESH::long_array & IDsOfNodes,
- const SMESH::long_array & Quantities);
- CORBA::Long AddPolyhedralVolumeByFaces(const SMESH::long_array & IdsOfFaces);
+ const SMESH::long_array & Quantities)
+ throw (SALOME::SALOME_Exception);
+ CORBA::Long AddPolyhedralVolumeByFaces(const SMESH::long_array & IdsOfFaces)
+ throw (SALOME::SALOME_Exception);
/*!
* \brief Create 0D elements on all nodes of the given object except those
CORBA::Boolean MoveNode(CORBA::Long NodeID,
- CORBA::Double x, CORBA::Double y, CORBA::Double z);
+ CORBA::Double x, CORBA::Double y, CORBA::Double z)
+ throw (SALOME::SALOME_Exception);
+
+ CORBA::Boolean InverseDiag(CORBA::Long NodeID1, CORBA::Long NodeID2)
+ throw (SALOME::SALOME_Exception);
+ CORBA::Boolean DeleteDiag(CORBA::Long NodeID1, CORBA::Long NodeID2)
+ throw (SALOME::SALOME_Exception);
+ CORBA::Boolean Reorient(const SMESH::long_array & IDsOfElements)
+ throw (SALOME::SALOME_Exception);
+ CORBA::Boolean ReorientObject(SMESH::SMESH_IDSource_ptr theObject)
+ throw (SALOME::SALOME_Exception);
- CORBA::Boolean InverseDiag(CORBA::Long NodeID1, CORBA::Long NodeID2);
- CORBA::Boolean DeleteDiag(CORBA::Long NodeID1, CORBA::Long NodeID2);
- CORBA::Boolean Reorient(const SMESH::long_array & IDsOfElements);
- CORBA::Boolean ReorientObject(SMESH::SMESH_IDSource_ptr theObject);
/*!
* \brief Reorient faces contained in \a the2Dgroup.
* \param the2Dgroup - the mesh or its part to reorient
// Split/Join faces
CORBA::Boolean TriToQuad (const SMESH::long_array & IDsOfElements,
SMESH::NumericalFunctor_ptr Criterion,
- CORBA::Double MaxAngle);
+ CORBA::Double MaxAngle)
+ throw (SALOME::SALOME_Exception);
CORBA::Boolean TriToQuadObject (SMESH::SMESH_IDSource_ptr theObject,
SMESH::NumericalFunctor_ptr Criterion,
- CORBA::Double MaxAngle);
+ CORBA::Double MaxAngle)
+ throw (SALOME::SALOME_Exception);
CORBA::Boolean QuadToTri (const SMESH::long_array & IDsOfElements,
- SMESH::NumericalFunctor_ptr Criterion);
+ SMESH::NumericalFunctor_ptr Criterion)
+ throw (SALOME::SALOME_Exception);
CORBA::Boolean QuadToTriObject (SMESH::SMESH_IDSource_ptr theObject,
- SMESH::NumericalFunctor_ptr Criterion);
+ SMESH::NumericalFunctor_ptr Criterion)
+ throw (SALOME::SALOME_Exception);
CORBA::Boolean SplitQuad (const SMESH::long_array & IDsOfElements,
- CORBA::Boolean Diag13);
+ CORBA::Boolean Diag13)
+ throw (SALOME::SALOME_Exception);
CORBA::Boolean SplitQuadObject (SMESH::SMESH_IDSource_ptr theObject,
- CORBA::Boolean Diag13);
+ CORBA::Boolean Diag13)
+ throw (SALOME::SALOME_Exception);
CORBA::Long BestSplit (CORBA::Long IDOfQuad,
- SMESH::NumericalFunctor_ptr Criterion);
- void SplitVolumesIntoTetra (SMESH::SMESH_IDSource_ptr elems,
- CORBA::Short methodFlags) throw (SALOME::SALOME_Exception);
+ SMESH::NumericalFunctor_ptr Criterion)
+ throw (SALOME::SALOME_Exception);
+ void SplitVolumesIntoTetra(SMESH::SMESH_IDSource_ptr elems,
+ CORBA::Short methodFlags)
+ throw (SALOME::SALOME_Exception);
CORBA::Boolean Smooth(const SMESH::long_array & IDsOfElements,
const SMESH::long_array & IDsOfFixedNodes,
CORBA::Long MaxNbOfIterations,
CORBA::Double MaxAspectRatio,
- SMESH::SMESH_MeshEditor::Smooth_Method Method);
+ SMESH::SMESH_MeshEditor::Smooth_Method Method)
+ throw (SALOME::SALOME_Exception);
CORBA::Boolean SmoothObject(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::long_array & IDsOfFixedNodes,
CORBA::Long MaxNbOfIterations,
CORBA::Double MaxAspectRatio,
- SMESH::SMESH_MeshEditor::Smooth_Method Method);
+ SMESH::SMESH_MeshEditor::Smooth_Method Method)
+ throw (SALOME::SALOME_Exception);
CORBA::Boolean SmoothParametric(const SMESH::long_array & IDsOfElements,
const SMESH::long_array & IDsOfFixedNodes,
CORBA::Long MaxNbOfIterations,
CORBA::Double MaxAspectRatio,
- SMESH::SMESH_MeshEditor::Smooth_Method Method);
+ SMESH::SMESH_MeshEditor::Smooth_Method Method)
+ throw (SALOME::SALOME_Exception);
CORBA::Boolean SmoothParametricObject(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::long_array & IDsOfFixedNodes,
CORBA::Long MaxNbOfIterations,
CORBA::Double MaxAspectRatio,
- SMESH::SMESH_MeshEditor::Smooth_Method Method);
+ SMESH::SMESH_MeshEditor::Smooth_Method Method)
+ throw (SALOME::SALOME_Exception);
CORBA::Boolean smooth(const SMESH::long_array & IDsOfElements,
const SMESH::long_array & IDsOfFixedNodes,
CORBA::Long MaxNbOfIterations,
CORBA::Double MaxAspectRatio,
SMESH::SMESH_MeshEditor::Smooth_Method Method,
- bool IsParametric);
+ bool IsParametric)
+ throw (SALOME::SALOME_Exception);
CORBA::Boolean smoothObject(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::long_array & IDsOfFixedNodes,
CORBA::Long MaxNbOfIterations,
CORBA::Double MaxAspectRatio,
SMESH::SMESH_MeshEditor::Smooth_Method Method,
- bool IsParametric);
-
+ bool IsParametric)
+ throw (SALOME::SALOME_Exception);
- void ConvertToQuadratic(CORBA::Boolean Force3d);
- CORBA::Boolean ConvertFromQuadratic();
- void ConvertToQuadraticObject(CORBA::Boolean theForce3d,
- SMESH::SMESH_IDSource_ptr theObject)
+ CORBA::Boolean ConvertFromQuadratic()
+ throw (SALOME::SALOME_Exception);
+ void ConvertFromQuadraticObject(SMESH::SMESH_IDSource_ptr theObject)
+ throw (SALOME::SALOME_Exception);
+ void ConvertToQuadratic(CORBA::Boolean Force3d)
+ throw (SALOME::SALOME_Exception);
+ void ConvertToQuadraticObject(CORBA::Boolean theForce3d,
+ SMESH::SMESH_IDSource_ptr theObject)
throw (SALOME::SALOME_Exception);
- void ConvertFromQuadraticObject(SMESH::SMESH_IDSource_ptr theObject)
+ void ConvertToBiQuadratic(CORBA::Boolean theForce3d,
+ SMESH::SMESH_IDSource_ptr theObject)
throw (SALOME::SALOME_Exception);
- void RenumberNodes();
- void RenumberElements();
+ void RenumberNodes() throw (SALOME::SALOME_Exception);
+ void RenumberElements() throw (SALOME::SALOME_Exception);
void RotationSweep(const SMESH::long_array & IDsOfElements,
const SMESH::AxisStruct & Axis,
CORBA::Double AngleInRadians,
CORBA::Long NbOfSteps,
- CORBA::Double Tolerance);
+ CORBA::Double Tolerance)
+ throw (SALOME::SALOME_Exception);
void RotationSweepObject(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::AxisStruct & Axis,
CORBA::Double AngleInRadians,
CORBA::Long NbOfSteps,
- CORBA::Double Tolerance);
+ CORBA::Double Tolerance)
+ throw (SALOME::SALOME_Exception);
void RotationSweepObject1D(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::AxisStruct & Axis,
CORBA::Double AngleInRadians,
CORBA::Long NbOfSteps,
- CORBA::Double Tolerance);
+ CORBA::Double Tolerance)
+ throw (SALOME::SALOME_Exception);
void RotationSweepObject2D(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::AxisStruct & Axis,
CORBA::Double AngleInRadians,
CORBA::Long NbOfSteps,
- CORBA::Double Tolerance);
+ CORBA::Double Tolerance)
+ throw (SALOME::SALOME_Exception);
void ExtrusionSweep(const SMESH::long_array & IDsOfElements,
const SMESH::DirStruct & StepVector,
- CORBA::Long NbOfSteps);
+ CORBA::Long NbOfSteps)
+ throw (SALOME::SALOME_Exception);
void ExtrusionSweep0D(const SMESH::long_array & IDsOfElements,
const SMESH::DirStruct & StepVector,
- CORBA::Long NbOfSteps);
+ CORBA::Long NbOfSteps)
+ throw (SALOME::SALOME_Exception);
void ExtrusionSweepObject(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::DirStruct & StepVector,
- CORBA::Long NbOfSteps);
+ CORBA::Long NbOfSteps)
+ throw (SALOME::SALOME_Exception);
void ExtrusionSweepObject0D(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::DirStruct & StepVector,
- CORBA::Long NbOfSteps);
+ CORBA::Long NbOfSteps)
+ throw (SALOME::SALOME_Exception);
void ExtrusionSweepObject1D(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::DirStruct & StepVector,
- CORBA::Long NbOfSteps);
+ CORBA::Long NbOfSteps)
+ throw (SALOME::SALOME_Exception);
void ExtrusionSweepObject2D(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::DirStruct & StepVector,
- CORBA::Long NbOfSteps);
+ CORBA::Long NbOfSteps)
+ throw (SALOME::SALOME_Exception);
void AdvancedExtrusion(const SMESH::long_array & theIDsOfElements,
const SMESH::DirStruct & theStepVector,
CORBA::Long theNbOfSteps,
CORBA::Long theExtrFlags,
- CORBA::Double theSewTolerance);
+ CORBA::Double theSewTolerance)
+ throw (SALOME::SALOME_Exception);
SMESH::SMESH_MeshEditor::Extrusion_Error
ExtrusionAlongPath(const SMESH::long_array & IDsOfElements,
CORBA::Boolean HasAngles,
const SMESH::double_array & Angles,
CORBA::Boolean HasRefPoint,
- const SMESH::PointStruct & RefPoint);
+ const SMESH::PointStruct & RefPoint)
+ throw (SALOME::SALOME_Exception);
SMESH::SMESH_MeshEditor::Extrusion_Error
ExtrusionAlongPathObject(SMESH::SMESH_IDSource_ptr theObject,
CORBA::Boolean HasAngles,
const SMESH::double_array & Angles,
CORBA::Boolean HasRefPoint,
- const SMESH::PointStruct & RefPoint);
+ const SMESH::PointStruct & RefPoint)
+ throw (SALOME::SALOME_Exception);
SMESH::SMESH_MeshEditor::Extrusion_Error
ExtrusionAlongPathObject1D(SMESH::SMESH_IDSource_ptr theObject,
SMESH::SMESH_Mesh_ptr PathMesh,
CORBA::Boolean HasAngles,
const SMESH::double_array & Angles,
CORBA::Boolean HasRefPoint,
- const SMESH::PointStruct & RefPoint);
+ const SMESH::PointStruct & RefPoint)
+ throw (SALOME::SALOME_Exception);
SMESH::SMESH_MeshEditor::Extrusion_Error
ExtrusionAlongPathObject2D(SMESH::SMESH_IDSource_ptr theObject,
SMESH::SMESH_Mesh_ptr PathMesh,
CORBA::Boolean HasAngles,
const SMESH::double_array & Angles,
CORBA::Boolean HasRefPoint,
- const SMESH::PointStruct & RefPoint);
+ const SMESH::PointStruct & RefPoint)
+ throw (SALOME::SALOME_Exception);
SMESH::double_array* LinearAnglesVariation(SMESH::SMESH_Mesh_ptr PathMesh,
GEOM::GEOM_Object_ptr PathShape,
void Mirror(const SMESH::long_array & IDsOfElements,
const SMESH::AxisStruct & Axis,
SMESH::SMESH_MeshEditor::MirrorType MirrorType,
- CORBA::Boolean Copy);
+ CORBA::Boolean Copy)
+ throw (SALOME::SALOME_Exception);
void MirrorObject(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::AxisStruct & Axis,
SMESH::SMESH_MeshEditor::MirrorType MirrorType,
- CORBA::Boolean Copy);
+ CORBA::Boolean Copy)
+ throw (SALOME::SALOME_Exception);
void Translate(const SMESH::long_array & IDsOfElements,
const SMESH::DirStruct & Vector,
- CORBA::Boolean Copy);
+ CORBA::Boolean Copy)
+ throw (SALOME::SALOME_Exception);
void TranslateObject(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::DirStruct & Vector,
- CORBA::Boolean Copy);
+ CORBA::Boolean Copy)
+ throw (SALOME::SALOME_Exception);
void Rotate(const SMESH::long_array & IDsOfElements,
const SMESH::AxisStruct & Axis,
CORBA::Double Angle,
- CORBA::Boolean Copy);
+ CORBA::Boolean Copy)
+ throw (SALOME::SALOME_Exception);
void RotateObject(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::AxisStruct & Axis,
CORBA::Double Angle,
- CORBA::Boolean Copy);
+ CORBA::Boolean Copy)
+ throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* RotationSweepMakeGroups(const SMESH::long_array& IDsOfElements,
const SMESH::AxisStruct& Axix,
CORBA::Double AngleInRadians,
CORBA::Long NbOfSteps,
- CORBA::Double Tolerance);
+ CORBA::Double Tolerance)
+ throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* RotationSweepObjectMakeGroups(SMESH::SMESH_IDSource_ptr Object,
const SMESH::AxisStruct& Axix,
CORBA::Double AngleInRadians,
CORBA::Long NbOfSteps,
- CORBA::Double Tolerance);
+ CORBA::Double Tolerance)
+ throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* RotationSweepObject1DMakeGroups(SMESH::SMESH_IDSource_ptr Object,
const SMESH::AxisStruct& Axix,
CORBA::Double AngleInRadians,
CORBA::Long NbOfSteps,
- CORBA::Double Tolerance);
+ CORBA::Double Tolerance)
+ throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* RotationSweepObject2DMakeGroups(SMESH::SMESH_IDSource_ptr Object,
const SMESH::AxisStruct& Axix,
CORBA::Double AngleInRadians,
CORBA::Long NbOfSteps,
- CORBA::Double Tolerance);
+ CORBA::Double Tolerance)
+ throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* ExtrusionSweepMakeGroups(const SMESH::long_array& IDsOfElements,
const SMESH::DirStruct& StepVector,
- CORBA::Long NbOfSteps);
+ CORBA::Long NbOfSteps)
+ throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* ExtrusionSweepMakeGroups0D(const SMESH::long_array& IDsOfElements,
const SMESH::DirStruct& StepVector,
- CORBA::Long NbOfSteps);
+ CORBA::Long NbOfSteps)
+ throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* AdvancedExtrusionMakeGroups(const SMESH::long_array& IDsOfElements,
const SMESH::DirStruct& StepVector,
CORBA::Long NbOfSteps,
CORBA::Long ExtrFlags,
- CORBA::Double SewTolerance);
+ CORBA::Double SewTolerance)
+ throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* ExtrusionSweepObjectMakeGroups(SMESH::SMESH_IDSource_ptr Object,
const SMESH::DirStruct& StepVector,
- CORBA::Long NbOfSteps);
+ CORBA::Long NbOfSteps)
+ throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* ExtrusionSweepObject0DMakeGroups(SMESH::SMESH_IDSource_ptr Object,
const SMESH::DirStruct& StepVector,
- CORBA::Long NbOfSteps);
+ CORBA::Long NbOfSteps)
+ throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* ExtrusionSweepObject1DMakeGroups(SMESH::SMESH_IDSource_ptr Object,
const SMESH::DirStruct& StepVector,
- CORBA::Long NbOfSteps);
+ CORBA::Long NbOfSteps)
+ throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* ExtrusionSweepObject2DMakeGroups(SMESH::SMESH_IDSource_ptr Object,
const SMESH::DirStruct& StepVector,
- CORBA::Long NbOfSteps);
+ CORBA::Long NbOfSteps)
+ throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* ExtrusionAlongPathMakeGroups(const SMESH::long_array& IDsOfElements,
SMESH::SMESH_Mesh_ptr PathMesh,
GEOM::GEOM_Object_ptr PathShape,
const SMESH::double_array& Angles,
CORBA::Boolean HasRefPoint,
const SMESH::PointStruct& RefPoint,
- SMESH::SMESH_MeshEditor::Extrusion_Error& Error);
+ SMESH::SMESH_MeshEditor::Extrusion_Error& Error)
+ throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* ExtrusionAlongPathObjectMakeGroups(SMESH::SMESH_IDSource_ptr Object,
SMESH::SMESH_Mesh_ptr PathMesh,
GEOM::GEOM_Object_ptr PathShape,
const SMESH::double_array& Angles,
CORBA::Boolean HasRefPoint,
const SMESH::PointStruct& RefPoint,
- SMESH::SMESH_MeshEditor::Extrusion_Error& Error);
+ SMESH::SMESH_MeshEditor::Extrusion_Error& Error)
+ throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* ExtrusionAlongPathObject1DMakeGroups(SMESH::SMESH_IDSource_ptr Object,
SMESH::SMESH_Mesh_ptr PathMesh,
GEOM::GEOM_Object_ptr PathShape,
const SMESH::double_array& Angles,
CORBA::Boolean HasRefPoint,
const SMESH::PointStruct& RefPoint,
- SMESH::SMESH_MeshEditor::Extrusion_Error& Error);
+ SMESH::SMESH_MeshEditor::Extrusion_Error& Error)
+ throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* ExtrusionAlongPathObject2DMakeGroups(SMESH::SMESH_IDSource_ptr Object,
SMESH::SMESH_Mesh_ptr PathMesh,
GEOM::GEOM_Object_ptr PathShape,
const SMESH::double_array& Angles,
CORBA::Boolean HasRefPoint,
const SMESH::PointStruct& RefPoint,
- SMESH::SMESH_MeshEditor::Extrusion_Error& Error);
+ SMESH::SMESH_MeshEditor::Extrusion_Error& Error)
+ throw (SALOME::SALOME_Exception);
// skl 04.06.2009
SMESH::ListOfGroups* ExtrusionAlongPathObjX(SMESH::SMESH_IDSource_ptr Object,
const SMESH::PointStruct& RefPoint,
CORBA::Boolean MakeGroups,
SMESH::ElementType ElemType,
- SMESH::SMESH_MeshEditor::Extrusion_Error& Error);
+ SMESH::SMESH_MeshEditor::Extrusion_Error& Error)
+ throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* ExtrusionAlongPathX(const SMESH::long_array& IDsOfElements,
SMESH::SMESH_IDSource_ptr Path,
CORBA::Long NodeStart,
const SMESH::PointStruct& RefPoint,
CORBA::Boolean MakeGroups,
SMESH::ElementType ElemType,
- SMESH::SMESH_MeshEditor::Extrusion_Error& Error);
+ SMESH::SMESH_MeshEditor::Extrusion_Error& Error)
+ throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* MirrorMakeGroups(const SMESH::long_array& IDsOfElements,
const SMESH::AxisStruct& Mirror,
- SMESH::SMESH_MeshEditor::MirrorType MirrorType);
+ SMESH::SMESH_MeshEditor::MirrorType MirrorType)
+ throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* MirrorObjectMakeGroups(SMESH::SMESH_IDSource_ptr Object,
const SMESH::AxisStruct& Mirror,
- SMESH::SMESH_MeshEditor::MirrorType MirrorType);
+ SMESH::SMESH_MeshEditor::MirrorType MirrorType)
+ throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* TranslateMakeGroups(const SMESH::long_array& IDsOfElements,
- const SMESH::DirStruct& Vector);
+ const SMESH::DirStruct& Vector)
+ throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* TranslateObjectMakeGroups(SMESH::SMESH_IDSource_ptr Object,
- const SMESH::DirStruct& Vector);
+ const SMESH::DirStruct& Vector)
+ throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* RotateMakeGroups(const SMESH::long_array& IDsOfElements,
const SMESH::AxisStruct& Axis,
- CORBA::Double AngleInRadians);
+ CORBA::Double AngleInRadians)
+ throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* RotateObjectMakeGroups(SMESH::SMESH_IDSource_ptr Object,
const SMESH::AxisStruct& Axis,
- CORBA::Double AngleInRadians);
+ CORBA::Double AngleInRadians)
+ throw (SALOME::SALOME_Exception);
SMESH::SMESH_Mesh_ptr MirrorMakeMesh(const SMESH::long_array& IDsOfElements,
const SMESH::AxisStruct& Mirror,
SMESH::SMESH_MeshEditor::MirrorType MirrorType,
CORBA::Boolean CopyGroups,
- const char* MeshName);
+ const char* MeshName)
+ throw (SALOME::SALOME_Exception);
SMESH::SMESH_Mesh_ptr MirrorObjectMakeMesh(SMESH::SMESH_IDSource_ptr Object,
const SMESH::AxisStruct& Mirror,
SMESH::SMESH_MeshEditor::MirrorType MirrorType,
CORBA::Boolean CopyGroups,
- const char* MeshName);
+ const char* MeshName)
+ throw (SALOME::SALOME_Exception);
SMESH::SMESH_Mesh_ptr TranslateMakeMesh(const SMESH::long_array& IDsOfElements,
const SMESH::DirStruct& Vector,
CORBA::Boolean CopyGroups,
- const char* MeshName);
+ const char* MeshName)
+ throw (SALOME::SALOME_Exception);
SMESH::SMESH_Mesh_ptr TranslateObjectMakeMesh(SMESH::SMESH_IDSource_ptr Object,
const SMESH::DirStruct& Vector,
CORBA::Boolean CopyGroups,
- const char* MeshName);
+ const char* MeshName)
+ throw (SALOME::SALOME_Exception);
SMESH::SMESH_Mesh_ptr RotateMakeMesh(const SMESH::long_array& IDsOfElements,
const SMESH::AxisStruct& Axis,
CORBA::Double AngleInRadians,
CORBA::Boolean CopyGroups,
- const char* MeshName);
+ const char* MeshName)
+ throw (SALOME::SALOME_Exception);
SMESH::SMESH_Mesh_ptr RotateObjectMakeMesh(SMESH::SMESH_IDSource_ptr Object,
const SMESH::AxisStruct& Axis,
CORBA::Double AngleInRadians,
CORBA::Boolean CopyGroups,
- const char* MeshName);
+ const char* MeshName)
+ throw (SALOME::SALOME_Exception);
void Scale(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::PointStruct& thePoint,
const SMESH::double_array& theScaleFact,
- CORBA::Boolean theCopy);
+ CORBA::Boolean theCopy)
+ throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* ScaleMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::PointStruct& thePoint,
- const SMESH::double_array& theScaleFact);
+ const SMESH::double_array& theScaleFact)
+ throw (SALOME::SALOME_Exception);
SMESH::SMESH_Mesh_ptr ScaleMakeMesh(SMESH::SMESH_IDSource_ptr Object,
const SMESH::PointStruct& Point,
const SMESH::double_array& theScaleFact,
CORBA::Boolean CopyGroups,
- const char* MeshName);
+ const char* MeshName)
+ throw (SALOME::SALOME_Exception);
void FindCoincidentNodes (CORBA::Double Tolerance,
- SMESH::array_of_long_array_out GroupsOfNodes);
+ SMESH::array_of_long_array_out GroupsOfNodes)
+ throw (SALOME::SALOME_Exception);
void FindCoincidentNodesOnPart(SMESH::SMESH_IDSource_ptr Object,
CORBA::Double Tolerance,
- SMESH::array_of_long_array_out GroupsOfNodes);
+ SMESH::array_of_long_array_out GroupsOfNodes)
+ throw (SALOME::SALOME_Exception);
void FindCoincidentNodesOnPartBut(SMESH::SMESH_IDSource_ptr Object,
CORBA::Double Tolerance,
SMESH::array_of_long_array_out GroupsOfNodes,
- const SMESH::ListOfIDSources& ExceptSubMeshOrGroups);
- void MergeNodes (const SMESH::array_of_long_array& GroupsOfNodes);
+ const SMESH::ListOfIDSources& ExceptSubMeshOrGroups)
+ throw (SALOME::SALOME_Exception);
+ void MergeNodes (const SMESH::array_of_long_array& GroupsOfNodes)
+ throw (SALOME::SALOME_Exception);
void FindEqualElements(SMESH::SMESH_IDSource_ptr Object,
- SMESH::array_of_long_array_out GroupsOfElementsID);
- void MergeElements(const SMESH::array_of_long_array& GroupsOfElementsID);
- void MergeEqualElements();
+ SMESH::array_of_long_array_out GroupsOfElementsID)
+ throw (SALOME::SALOME_Exception);
+ void MergeElements(const SMESH::array_of_long_array& GroupsOfElementsID)
+ throw (SALOME::SALOME_Exception);
+ void MergeEqualElements()
+ throw (SALOME::SALOME_Exception);
CORBA::Long MoveClosestNodeToPoint(CORBA::Double x,
CORBA::Double y,
CORBA::Double z,
- CORBA::Long nodeID);
+ CORBA::Long nodeID)
+ throw (SALOME::SALOME_Exception);
/*!
* \brief Return ID of node closest to a given point
*/
CORBA::Long FindNodeClosestTo(CORBA::Double x,
CORBA::Double y,
- CORBA::Double z);
+ CORBA::Double z)
+ throw (SALOME::SALOME_Exception);
/*!
* Return elements of given type where the given point is IN or ON.
* 'ALL' type means elements of any type excluding nodes
SMESH::long_array* FindElementsByPoint(CORBA::Double x,
CORBA::Double y,
CORBA::Double z,
- SMESH::ElementType type);
+ SMESH::ElementType type)
+ throw (SALOME::SALOME_Exception);
/*!
* Searching among the given elements, return elements of given type
* where the given point is IN or ON.
CORBA::Double x,
CORBA::Double y,
CORBA::Double z,
- SMESH::ElementType type);
+ SMESH::ElementType type)
+ throw (SALOME::SALOME_Exception);
/*!
* Return point state in a closed 2D mesh in terms of TopAbs_State enumeration.
* TopAbs_UNKNOWN state means that either mesh is wrong or the analysis fails.
*/
- CORBA::Short GetPointState(CORBA::Double x, CORBA::Double y, CORBA::Double z);
+ CORBA::Short GetPointState(CORBA::Double x, CORBA::Double y, CORBA::Double z)
+ throw (SALOME::SALOME_Exception);
SMESH::SMESH_MeshEditor::Sew_Error
SewFreeBorders(CORBA::Long FirstNodeID1,
CORBA::Long SecondNodeID2,
CORBA::Long LastNodeID2,
CORBA::Boolean CreatePolygons,
- CORBA::Boolean CreatePolyedrs);
+ CORBA::Boolean CreatePolyedrs)
+ throw (SALOME::SALOME_Exception);
SMESH::SMESH_MeshEditor::Sew_Error
SewConformFreeBorders(CORBA::Long FirstNodeID1,
CORBA::Long SecondNodeID1,
CORBA::Long LastNodeID1,
CORBA::Long FirstNodeID2,
- CORBA::Long SecondNodeID2);
+ CORBA::Long SecondNodeID2)
+ throw (SALOME::SALOME_Exception);
SMESH::SMESH_MeshEditor::Sew_Error
SewBorderToSide(CORBA::Long FirstNodeIDOnFreeBorder,
CORBA::Long SecondNodeIDOnFreeBorder,
CORBA::Long FirstNodeIDOnSide,
CORBA::Long LastNodeIDOnSide,
CORBA::Boolean CreatePolygons,
- CORBA::Boolean CreatePolyedrs);
+ CORBA::Boolean CreatePolyedrs)
+ throw (SALOME::SALOME_Exception);
SMESH::SMESH_MeshEditor::Sew_Error
SewSideElements(const SMESH::long_array& IDsOfSide1Elements,
const SMESH::long_array& IDsOfSide2Elements,
CORBA::Long NodeID1OfSide1ToMerge,
CORBA::Long NodeID1OfSide2ToMerge,
CORBA::Long NodeID2OfSide1ToMerge,
- CORBA::Long NodeID2OfSide2ToMerge);
+ CORBA::Long NodeID2OfSide2ToMerge)
+ throw (SALOME::SALOME_Exception);
/*!
* Set new nodes for given element.
* If number of nodes is not corresponded to type of
* element - returns false
*/
- CORBA::Boolean ChangeElemNodes(CORBA::Long ide, const SMESH::long_array& newIDs);
+ CORBA::Boolean ChangeElemNodes(CORBA::Long ide, const SMESH::long_array& newIDs)
+ throw (SALOME::SALOME_Exception);
CORBA::Boolean DoubleNodes( const SMESH::long_array& theNodes,
- const SMESH::long_array& theModifiedElems );
+ const SMESH::long_array& theModifiedElems )
+ throw (SALOME::SALOME_Exception);
CORBA::Boolean DoubleNode( CORBA::Long theNodeId,
- const SMESH::long_array& theModifiedElems );
+ const SMESH::long_array& theModifiedElems )
+ throw (SALOME::SALOME_Exception);
CORBA::Boolean DoubleNodeGroup( SMESH::SMESH_GroupBase_ptr theNodes,
- SMESH::SMESH_GroupBase_ptr theModifiedElems );
+ SMESH::SMESH_GroupBase_ptr theModifiedElems )
+ throw (SALOME::SALOME_Exception);
/*!
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements.
* \sa DoubleNodeGroup()
*/
SMESH::SMESH_Group_ptr DoubleNodeGroupNew( SMESH::SMESH_GroupBase_ptr theNodes,
- SMESH::SMESH_GroupBase_ptr theModifiedElems );
+ SMESH::SMESH_GroupBase_ptr theModifiedElems )
+ throw (SALOME::SALOME_Exception);
CORBA::Boolean DoubleNodeGroups( const SMESH::ListOfGroups& theNodes,
- const SMESH::ListOfGroups& theModifiedElems );
+ const SMESH::ListOfGroups& theModifiedElems )
+ throw (SALOME::SALOME_Exception);
SMESH::SMESH_Group_ptr DoubleNodeGroupsNew( const SMESH::ListOfGroups& theNodes,
- const SMESH::ListOfGroups& theModifiedElems );
+ const SMESH::ListOfGroups& theModifiedElems )
+ throw (SALOME::SALOME_Exception);
/*!
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements
*/
CORBA::Boolean DoubleNodeElem( const SMESH::long_array& theElems,
const SMESH::long_array& theNodesNot,
- const SMESH::long_array& theAffectedElems );
+ const SMESH::long_array& theAffectedElems )
+ throw (SALOME::SALOME_Exception);
/*!
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements
*/
CORBA::Boolean DoubleNodeElemInRegion( const SMESH::long_array& theElems,
const SMESH::long_array& theNodesNot,
- GEOM::GEOM_Object_ptr theShape );
+ GEOM::GEOM_Object_ptr theShape )
+ throw (SALOME::SALOME_Exception);
/*!
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements
*/
CORBA::Boolean DoubleNodeElemGroup( SMESH::SMESH_GroupBase_ptr theElems,
SMESH::SMESH_GroupBase_ptr theNodesNot,
- SMESH::SMESH_GroupBase_ptr theAffectedElems );
+ SMESH::SMESH_GroupBase_ptr theAffectedElems )
+ throw (SALOME::SALOME_Exception);
/*!
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements
*/
SMESH::SMESH_Group_ptr DoubleNodeElemGroupNew( SMESH::SMESH_GroupBase_ptr theElems,
SMESH::SMESH_GroupBase_ptr theNodesNot,
- SMESH::SMESH_GroupBase_ptr theAffectedElems );
+ SMESH::SMESH_GroupBase_ptr theAffectedElems )
+ throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* DoubleNodeElemGroup2New(SMESH::SMESH_GroupBase_ptr theElems,
SMESH::SMESH_GroupBase_ptr theNodesNot,
SMESH::SMESH_GroupBase_ptr theAffectedElems,
CORBA::Boolean theElemGroupNeeded,
- CORBA::Boolean theNodeGroupNeeded);
+ CORBA::Boolean theNodeGroupNeeded)
+ throw (SALOME::SALOME_Exception);
/*!
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements
*/
CORBA::Boolean DoubleNodeElemGroupInRegion( SMESH::SMESH_GroupBase_ptr theElems,
SMESH::SMESH_GroupBase_ptr theNodesNot,
- GEOM::GEOM_Object_ptr theShape );
+ GEOM::GEOM_Object_ptr theShape )
+ throw (SALOME::SALOME_Exception);
/*!
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements
*/
CORBA::Boolean DoubleNodeElemGroups( const SMESH::ListOfGroups& theElems,
const SMESH::ListOfGroups& theNodesNot,
- const SMESH::ListOfGroups& theAffectedElems );
+ const SMESH::ListOfGroups& theAffectedElems )
+ throw (SALOME::SALOME_Exception);
/*!
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements
*/
SMESH::SMESH_Group_ptr DoubleNodeElemGroupsNew( const SMESH::ListOfGroups& theElems,
const SMESH::ListOfGroups& theNodesNot,
- const SMESH::ListOfGroups& theAffectedElems );
+ const SMESH::ListOfGroups& theAffectedElems )
+ throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* DoubleNodeElemGroups2New(const SMESH::ListOfGroups& theElems,
const SMESH::ListOfGroups& theNodesNot,
const SMESH::ListOfGroups& theAffectedElems,
CORBA::Boolean theElemGroupNeeded,
- CORBA::Boolean theNodeGroupNeeded);
+ CORBA::Boolean theNodeGroupNeeded)
+ throw (SALOME::SALOME_Exception);
/*!
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements
*/
CORBA::Boolean DoubleNodeElemGroupsInRegion( const SMESH::ListOfGroups& theElems,
const SMESH::ListOfGroups& theNodesNot,
- GEOM::GEOM_Object_ptr theShape );
+ GEOM::GEOM_Object_ptr theShape )
+ throw (SALOME::SALOME_Exception);
/*!
* \brief Identify the elements that will be affected by node duplication (actual duplication is not performed.
*/
SMESH::ListOfGroups* AffectedElemGroupsInRegion( const SMESH::ListOfGroups& theElems,
const SMESH::ListOfGroups& theNodesNot,
- GEOM::GEOM_Object_ptr theShape );
+ GEOM::GEOM_Object_ptr theShape )
+ throw (SALOME::SALOME_Exception);
/*!
* \brief Double nodes on shared faces between groups of volumes and create flat elements on demand.
* @param theGroupsOfFaces - list of groups of faces
* @return TRUE if operation has been completed successfully, FALSE otherwise
*/
- CORBA::Boolean CreateFlatElementsOnFacesGroups( const SMESH::ListOfGroups& theGroupsOfFaces );
+ CORBA::Boolean CreateFlatElementsOnFacesGroups( const SMESH::ListOfGroups& theGroupsOfFaces )
+ throw (SALOME::SALOME_Exception);
/*!
* \brief identify all the elements around a geom shape, get the faces delimiting the hole
* The created 2D mesh elements based on nodes of free faces of boundary volumes
* \return TRUE if operation has been completed successfully, FALSE otherwise
*/
- CORBA::Boolean Make2DMeshFrom3D();
+ CORBA::Boolean Make2DMeshFrom3D()
+ throw (SALOME::SALOME_Exception);
SMESH::SMESH_Mesh_ptr MakeBoundaryMesh(SMESH::SMESH_IDSource_ptr elements,
SMESH::Bnd_Dimension dimension,
const char* meshName,
CORBA::Boolean toCopyElements,
CORBA::Boolean toCopyMissingBondary,
- SMESH::SMESH_Group_out group);
+ SMESH::SMESH_Group_out group)
+ throw (SALOME::SALOME_Exception);
CORBA::Long MakeBoundaryElements(SMESH::Bnd_Dimension dimension,
const char* groupName,
MeshEditor_I::TPreviewMesh * getPreviewMesh( SMDSAbs_ElementType previewType = SMDSAbs_All );
- /*!
- * \brief Update myLastCreated* or myPreviewData
- * \param anEditor - it contains edition results
- */
- //void storeResult(::SMESH_MeshEditor& anEditor);
+ void declareMeshModified( bool isReComputeSafe );
+
/*!
* \brief Clear myLastCreated* or myPreviewData
*/
/*!
* \brief Return groups by their IDs
*/
- SMESH::ListOfGroups* getGroups(const std::list<int>* groupIDs);
+ SMESH::ListOfGroups* getGroups(const std::list<int>* groupIDs)
+ throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* rotationSweep(const SMESH::long_array & IDsOfElements,
const SMESH::AxisStruct & Axis,
CORBA::Long NbOfSteps,
CORBA::Double Tolerance,
const bool MakeGroups,
- const SMDSAbs_ElementType ElementType=SMDSAbs_All);
+ const SMDSAbs_ElementType ElementType=SMDSAbs_All)
+ throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* extrusionSweep(const SMESH::long_array & IDsOfElements,
const SMESH::DirStruct & StepVector,
CORBA::Long NbOfSteps,
bool MakeGroups,
- const SMDSAbs_ElementType ElementType=SMDSAbs_All);
+ const SMDSAbs_ElementType ElementType=SMDSAbs_All)
+ throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* advancedExtrusion(const SMESH::long_array & theIDsOfElements,
const SMESH::DirStruct & theStepVector,
CORBA::Long theNbOfSteps,
CORBA::Long theExtrFlags,
CORBA::Double theSewTolerance,
- const bool MakeGroups);
+ const bool MakeGroups)
+ throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* extrusionAlongPath(const SMESH::long_array & IDsOfElements,
SMESH::SMESH_Mesh_ptr PathMesh,
GEOM::GEOM_Object_ptr PathShape,
const SMESH::PointStruct & RefPoint,
const bool MakeGroups,
SMESH::SMESH_MeshEditor::Extrusion_Error & Error,
- const SMDSAbs_ElementType ElementType=SMDSAbs_All);
+ const SMDSAbs_ElementType ElementType=SMDSAbs_All)
+ throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* extrusionAlongPathX(const SMESH::long_array & IDsOfElements,
SMESH::SMESH_IDSource_ptr Path,
CORBA::Long NodeStart,
const SMESH::PointStruct& RefPoint,
bool MakeGroups,
const SMDSAbs_ElementType ElementType,
- SMESH::SMESH_MeshEditor::Extrusion_Error & theError);
+ SMESH::SMESH_MeshEditor::Extrusion_Error & theError)
+ throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* mirror(TIDSortedElemSet & IDsOfElements,
const SMESH::AxisStruct & Axis,
SMESH::SMESH_MeshEditor::MirrorType MirrorType,
CORBA::Boolean Copy,
bool MakeGroups,
- ::SMESH_Mesh* TargetMesh=0);
+ ::SMESH_Mesh* TargetMesh=0)
+ throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* translate(TIDSortedElemSet & IDsOfElements,
const SMESH::DirStruct & Vector,
CORBA::Boolean Copy,
bool MakeGroups,
- ::SMESH_Mesh* TargetMesh=0);
+ ::SMESH_Mesh* TargetMesh=0)
+ throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* rotate(TIDSortedElemSet & IDsOfElements,
const SMESH::AxisStruct & Axis,
CORBA::Double Angle,
CORBA::Boolean Copy,
bool MakeGroups,
- ::SMESH_Mesh* TargetMesh=0);
+ ::SMESH_Mesh* TargetMesh=0)
+ throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* scale(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::PointStruct& thePoint,
const SMESH::double_array& theScaleFact,
CORBA::Boolean theCopy,
bool theMakeGroups,
- ::SMESH_Mesh* theTargetMesh=0);
+ ::SMESH_Mesh* theTargetMesh=0)
+ throw (SALOME::SALOME_Exception);
+
+ void convertToQuadratic(CORBA::Boolean theForce3d,
+ CORBA::Boolean theToBiQuad,
+ SMESH::SMESH_IDSource_ptr theObject = SMESH::SMESH_IDSource::_nil())
+ throw (SALOME::SALOME_Exception);
SMESH::SMESH_Mesh_ptr makeMesh(const char* theMeshName);
- void DumpGroupsList(SMESH::TPythonDump & theDumpPython,
+ void dumpGroupsList(SMESH::TPythonDump & theDumpPython,
const SMESH::ListOfGroups * theGroupList);
string generateGroupName(const string& thePrefix);
