public:
TSequenceOfXYZ();
- explicit TSequenceOfXYZ(size_type n);
+ explicit TSequenceOfXYZ(size_type n);
TSequenceOfXYZ(size_type n, const gp_XYZ& t);
protected:
PredicatePtr myPredicate;
};
- };
-};
+ }
+}
#endif
virtual void SetMeshName(const std::string& theMeshName);
virtual std::string GetMeshName() const;
- virtual void SetOption(const std::string& optionName,
- const std::string& optionValue) {}
+ virtual void SetOption(const std::string& /*optionName*/,
+ const std::string& /*optionValue*/) {}
virtual Status Perform() = 0;
myAllSubMeshes = true;
}
-void DriverMED_W_SMESHDS_Mesh::AddSubMesh(SMESHDS_SubMesh* theSubMesh, int theID)
+void DriverMED_W_SMESHDS_Mesh::AddSubMesh(SMESHDS_SubMesh* theSubMesh, int /*theID*/)
{
mySubMeshes.push_back( theSubMesh );
}
TInt
GetNbConn(EGeometrieElement typmai,
- EEntiteMaillage typent,
- TInt mdim)
+ EEntiteMaillage /*typent*/,
+ TInt /*mdim*/)
{
return typmai % 100;
}
template<>
TFloat
- GetCoord<eNone>(const TCCoordSlice& theCoordSlice)
+ GetCoord<eNone>(const TCCoordSlice& /*theCoordSlice*/)
{
return 0.0;
}
const TGeom2Size& theGeom2Size,
const TGeom2NbGauss& theGeom2NbGauss,
TInt theNumDt,
- TInt theNumOrd,
+ TInt /*theNumOrd*/,
TFloat theDt,
const std::string& theUnitDt,
const TGeom2Gauss& theGeom2Gauss)
void
TWrapper
::GetNames(TElemInfo& theInfo,
- TInt theNb,
+ TInt /*theNb*/,
EEntiteMaillage theEntity,
EGeometrieElement theGeom,
TErr* theErr)
void
TWrapper
::GetNumeration(TElemInfo& theInfo,
- TInt theNb,
+ TInt /*theNb*/,
EEntiteMaillage theEntity,
EGeometrieElement theGeom,
TErr* theErr)
void
TWrapper
::GetFamilies(TElemInfo& theInfo,
- TInt theNb,
+ TInt /*theNb*/,
EEntiteMaillage theEntity,
EGeometrieElement theGeom,
TErr* theErr)
//----------------------------------------------------------------------------
EGeometrieElement
TWrapper
- ::GetBallGeom(const TMeshInfo& theMeshInfo)
+ ::GetBallGeom(const TMeshInfo& /*theMeshInfo*/)
{
TErr anError;
TFileWrapper aFileWrapper(myFile, eLECTURE, &anError, myMinor);
//----------------------------------------------------------------------------
void
TWrapper
- ::GetGaussInfo(TInt theId,
+ ::GetGaussInfo(TInt /*theId*/,
TGaussInfo& theInfo,
TErr* theErr)
{
//----------------------------------------------------------------------------
void
TWrapper
- ::GetProfileInfo(TInt theId,
+ ::GetProfileInfo(TInt /*theId*/,
TProfileInfo& theInfo,
TErr* theErr)
{
//----------------------------------------------------------------------------
PGrilleInfo
TWrapper
- ::CrGrilleInfo(const PMeshInfo& theMeshInfo)
+ ::CrGrilleInfo(const PMeshInfo& /*theMeshInfo*/)
{
return PGrilleInfo(); // not implemented????
}
*
* @param cellId
*/
-void SMDS_Downward::initCell(int cellId)
+void SMDS_Downward::initCell(int /*cellId*/)
{
}
* @param cellId not used here.
* @return
*/
-int SMDS_Downward::getNumberOfDownCells(int cellId)
+int SMDS_Downward::getNumberOfDownCells(int /*cellId*/)
{
return _nbDownCells;
}
* @param cellId index of the cell in the downward structure relative to a vtk cell type.
* @return table of downward entities types.
*/
-const unsigned char* SMDS_Downward::getDownTypes(int cellId)
+const unsigned char* SMDS_Downward::getDownTypes(int /*cellId*/)
{
return &_cellTypes[0];
}
* @param lowCellId index of the children cell to add (dimension n-1)
* @param aType vtk cell type of the cell to add (needed to find the SMDS_Downward structure containing the cell to add).
*/
-void SMDS_Downward::addDownCell(int cellId, int lowCellId, unsigned char aType)
+void SMDS_Downward::addDownCell(int /*cellId*/, int /*lowCellId*/, unsigned char /*aType*/)
{
ASSERT(0); // must be re-implemented in derived class
}
* @param upCellId index of the parent cell to add (dimension n+1)
* @param aType vtk cell type of the cell to add (needed to find the SMDS_Downward structure containing the cell to add).
*/
-void SMDS_Downward::addUpCell(int cellId, int upCellId, unsigned char aType)
+void SMDS_Downward::addUpCell(int /*cellId*/, int /*upCellId*/, unsigned char /*aType*/)
{
ASSERT(0); // must be re-implemented in derived class
}
-int SMDS_Downward::getNodeSet(int cellId, int* nodeSet)
+int SMDS_Downward::getNodeSet(int /*cellId*/, int* /*nodeSet*/)
{
return 0;
}
// nothing to do, size was known before
}
-int SMDS_Down3D::getNumberOfUpCells(int cellId)
+int SMDS_Down3D::getNumberOfUpCells(int /*cellId*/)
{
return 0;
}
-const int* SMDS_Down3D::getUpCells(int cellId)
+const int* SMDS_Down3D::getUpCells(int /*cellId*/)
{
return 0;
}
-const unsigned char* SMDS_Down3D::getUpTypes(int cellId)
+const unsigned char* SMDS_Down3D::getUpTypes(int /*cellId*/)
{
return 0;
}
edgesWithNodes.elems[2].vtkType = VTK_LINE;
}
-void SMDS_DownTriangle::addDownCell(int cellId, int lowCellId, unsigned char aType)
+void SMDS_DownTriangle::addDownCell(int cellId, int lowCellId, unsigned char /*aType*/)
{
//ASSERT((cellId >=0)&& (cellId < _maxId));
//ASSERT(aType == VTK_LINE);
edgesWithNodes.elems[2].vtkType = VTK_QUADRATIC_EDGE;
}
-void SMDS_DownQuadTriangle::addDownCell(int cellId, int lowCellId, unsigned char aType)
+void SMDS_DownQuadTriangle::addDownCell(int cellId, int lowCellId, unsigned char /*aType*/)
{
//ASSERT((cellId >=0)&& (cellId < _maxId));
//ASSERT(aType == VTK_QUADRATIC_EDGE);
edgesWithNodes.elems[3].vtkType = VTK_LINE;
}
-void SMDS_DownQuadrangle::addDownCell(int cellId, int lowCellId, unsigned char aType)
+void SMDS_DownQuadrangle::addDownCell(int cellId, int lowCellId, unsigned char /*aType*/)
{
//ASSERT((cellId >=0)&& (cellId < _maxId));
//ASSERT(aType == VTK_LINE);
edgesWithNodes.elems[3].vtkType = VTK_QUADRATIC_EDGE;
}
-void SMDS_DownQuadQuadrangle::addDownCell(int cellId, int lowCellId, unsigned char aType)
+void SMDS_DownQuadQuadrangle::addDownCell(int cellId, int lowCellId, unsigned char /*aType*/)
{
//ASSERT((cellId >=0)&& (cellId < _maxId));
//ASSERT(aType == VTK_QUADRATIC_EDGE);
MESSAGE(nodes[0] << " " << nodes[1] << " " << nodes[2] << " " << nodes[3]);
}
-void SMDS_DownTetra::addDownCell(int cellId, int lowCellId, unsigned char aType)
+void SMDS_DownTetra::addDownCell(int cellId, int lowCellId, unsigned char /*aType*/)
{
//ASSERT((cellId >=0)&& (cellId < _maxId));
//ASSERT(aType == VTK_TRIANGLE);
MESSAGE(nodes[0] << " " << nodes[1] << " " << nodes[2] << " " << nodes[3]);
}
-void SMDS_DownQuadTetra::addDownCell(int cellId, int lowCellId, unsigned char aType)
+void SMDS_DownQuadTetra::addDownCell(int cellId, int lowCellId, unsigned char /*aType*/)
{
//ASSERT((cellId >=0)&& (cellId < _maxId));
//ASSERT(aType == VTK_QUADRATIC_TRIANGLE);
MESSAGE(nodes[4] << " " << nodes[5] << " " << nodes[6] << " " << nodes[7]);
}
-void SMDS_DownHexa::addDownCell(int cellId, int lowCellId, unsigned char aType)
+void SMDS_DownHexa::addDownCell(int cellId, int lowCellId, unsigned char /*aType*/)
{
//ASSERT((cellId >=0)&& (cellId < _maxId));
int *faces = &_cellIds[_nbDownCells * cellId];
MESSAGE(nodes[0] << " " << nodes[1] << " " << nodes[2] << " " << nodes[3]);
}
-void SMDS_DownQuadHexa::addDownCell(int cellId, int lowCellId, unsigned char aType)
+void SMDS_DownQuadHexa::addDownCell(int cellId, int lowCellId, unsigned char /*aType*/)
{
//ASSERT((cellId >=0)&& (cellId < _maxId));
int *faces = &_cellIds[_nbDownCells * cellId];
virtual const int* getUpCells(int cellId) = 0;
virtual const unsigned char* getUpTypes(int cellId) = 0;
virtual void getNodeIds(int cellId, std::set<int>& nodeSet) = 0;
- virtual int getNodes(int cellId, int* nodevec) {return 0; }
- virtual void getOrderedNodesOfFace(int cellId, std::vector<vtkIdType>& orderedNodes) {};
+ virtual int getNodes(int /*cellId*/, int* /*nodevec*/) {return 0; }
+ virtual void getOrderedNodesOfFace(int /*cellId*/, std::vector<vtkIdType>& /*orderedNodes*/) {};
int getVtkCellId(int cellId)
{
return _vtkCellIds[cellId];
{ min = false; max = true; return myUsedRanges; }
//! Return ranges of elements assigned to sub-shapes and min/max of sub-shape IDs
- const TSubIDRangeSet& GetSubIDRangesMinMax( int& min, int& max ) const
+ const TSubIDRangeSet& GetSubIDRangesMinMax( int& /*min*/, int& /*max*/ ) const
{ /*min = myMinSubID; max = myMaxSubID;*/ return mySubIDRanges; }
//! Minimize allocated memory
*/
//================================================================================
-int SMDS_Mesh::CheckMemory(const bool doNotRaise) throw (std::bad_alloc)
+int SMDS_Mesh::CheckMemory(const bool doNotRaise)
{
return -1;
#if !defined WIN32 && !defined __APPLE__
* \param doNotRaise - if true, suppress exception, just return free memory size
* \retval int - amount of available memory in MB or negative number in failure case
*/
- static int CheckMemory(const bool doNotRaise=false) throw (std::bad_alloc);
+ static int CheckMemory(const bool doNotRaise=false);
virtual int MaxNodeID() const;
virtual int MinNodeID() const;
virtual bool IsPoly() const { return false; }
virtual bool IsQuadratic() const { return false; }
- virtual bool IsMediumNode(const SMDS_MeshNode* node) const { return false; }
+ virtual bool IsMediumNode(const SMDS_MeshNode* /*node*/) const { return false; }
virtual int NbCornerNodes() const { return 1; }
void Print(std::ostream & OS) const;
}
return -1;
}
-bool SMDS_MeshVolume::ChangeNodes(const SMDS_MeshNode* nodes[], const int nbNodes)
+bool SMDS_MeshVolume::ChangeNodes(const SMDS_MeshNode* /*nodes[]*/, const int /*nbNodes*/)
{
return false;
}
virtual int NbFaces() const;
virtual int NbEdges() const;
virtual int GetNodeIndex( const SMDS_MeshNode* node ) const;
- virtual bool ChangeNodes(const SMDS_MeshNode* nodes[], const int nbNodes);
+ virtual bool ChangeNodes(const SMDS_MeshNode* /*nodes[]*/, const int /*nbNodes*/);
virtual bool IsMediumNode(const SMDS_MeshNode* node) const;
virtual int NbCornerNodes() const;
template <typename VALUE>
struct PassAllValueFilter
{
- bool operator()(const VALUE& t ) { return true; }
+ bool operator()(const VALUE& /*t*/ ) { return true; }
};
template <typename VALUE>
//=============================================================================
SMESH_Mesh* SMESH_Gen::CreateMesh(bool theIsEmbeddedMode)
- throw(SALOME_Exception)
{
Unexpect aCatch(SalomeException);
~SMESH_Gen();
SMESH_Mesh* CreateMesh(bool theIsEmbeddedMode)
- throw(SALOME_Exception);
+ ;
enum ComputeFlags
{
int SMESH_HypoFilter::TypePredicate::Value( const SMESH_Hypothesis* aHyp ) const
{
return aHyp->GetType();
-};
+}
//=======================================================================
//function : DimPredicate::Value
const TopoDS_Shape& /*aShape*/) const
{
return SMESH_subMesh::IsApplicableHypothesis( aHyp, (TopAbs_ShapeEnum)_shapeType );
-};
+}
//=======================================================================
//function : IsAuxiliaryPredicate::IsOk
const TopoDS_Shape& /*aShape*/) const
{
return aHyp->IsAuxiliary();
-};
+}
//=======================================================================
//function : ApplicablePredicate::ApplicablePredicate
//purpose :
//=======================================================================
-bool SMESH_HypoFilter::IsAssignedToPredicate::IsOk(const SMESH_Hypothesis* aHyp,
+bool SMESH_HypoFilter::IsAssignedToPredicate::IsOk(const SMESH_Hypothesis* /*aHyp*/,
const TopoDS_Shape& aShape) const
{
return ( !_mainShape.IsNull() && !aShape.IsNull() && _mainShape.IsSame( aShape ));
SMESH_Hypothesis::Hypothesis_Status
SMESH_Mesh::AddHypothesis(const TopoDS_Shape & aSubShape,
int anHypId,
- std::string* anError ) throw(SALOME_Exception)
+ std::string* anError )
{
Unexpect aCatch(SalomeException);
if(MYDEBUG) MESSAGE("SMESH_Mesh::AddHypothesis");
SMESH_Hypothesis::Hypothesis_Status
SMESH_Mesh::RemoveHypothesis(const TopoDS_Shape & aSubShape,
- int anHypId) throw( SALOME_Exception )
+ int anHypId)
{
Unexpect aCatch(SalomeException);
if(MYDEBUG) MESSAGE("SMESH_Mesh::RemoveHypothesis");
const std::list<const SMESHDS_Hypothesis*>&
SMESH_Mesh::GetHypothesisList(const TopoDS_Shape & aSubShape) const
- throw(SALOME_Exception)
+
{
return _myMeshDS->GetHypothesis(aSubShape);
}
*/
//=============================================================================
-const std::list<SMESHDS_Command*> & SMESH_Mesh::GetLog() throw(SALOME_Exception)
+const std::list<SMESHDS_Command*> & SMESH_Mesh::GetLog()
{
Unexpect aCatch(SalomeException);
return _myMeshDS->GetScript()->GetCommands();
*
*/
//=============================================================================
-void SMESH_Mesh::ClearLog() throw(SALOME_Exception)
+void SMESH_Mesh::ClearLog()
{
Unexpect aCatch(SalomeException);
_myMeshDS->GetScript()->Clear();
//=============================================================================
SMESH_subMesh * SMESH_Mesh::GetSubMesh(const TopoDS_Shape & aSubShape)
- throw(SALOME_Exception)
+
{
int index = _myMeshDS->ShapeToIndex(aSubShape);
if ( !index && aSubShape.IsNull() )
//=============================================================================
SMESH_subMesh *SMESH_Mesh::GetSubMeshContaining(const TopoDS_Shape & aSubShape) const
- throw(SALOME_Exception)
+
{
int index = _myMeshDS->ShapeToIndex(aSubShape);
return GetSubMeshContaining( index );
//=============================================================================
SMESH_subMesh *SMESH_Mesh::GetSubMeshContaining(const int aShapeID) const
-throw(SALOME_Exception)
+
{
SMESH_subMesh *aSubMesh = _subMeshHolder->Get( aShapeID );
std::list<SMESH_subMesh*>
SMESH_Mesh::GetGroupSubMeshesContaining(const TopoDS_Shape & aSubShape) const
- throw(SALOME_Exception)
+
{
std::list<SMESH_subMesh*> found;
* Auto color functionality
*/
//=============================================================================
-void SMESH_Mesh::SetAutoColor(bool theAutoColor) throw(SALOME_Exception)
+void SMESH_Mesh::SetAutoColor(bool theAutoColor)
{
Unexpect aCatch(SalomeException);
_isAutoColor = theAutoColor;
}
-bool SMESH_Mesh::GetAutoColor() throw(SALOME_Exception)
+bool SMESH_Mesh::GetAutoColor()
{
Unexpect aCatch(SalomeException);
return _isAutoColor;
bool theAddODOnVertices,
double theZTolerance,
bool theAllElemsToGroup)
-throw(SALOME_Exception)
+
{
MESSAGE("MED_VERSION:"<< theVersion);
SMESH_TRY;
void SMESH_Mesh::ExportSAUV(const char *file,
const char* theMeshName,
bool theAutoGroups)
- throw(SALOME_Exception)
+
{
std::string medfilename(file);
medfilename += ".med";
//================================================================================
void SMESH_Mesh::ExportDAT(const char * file,
- const SMESHDS_Mesh* meshPart) throw(SALOME_Exception)
+ const SMESHDS_Mesh* meshPart)
{
Unexpect aCatch(SalomeException);
DriverDAT_W_SMDS_Mesh myWriter;
//================================================================================
void SMESH_Mesh::ExportUNV(const char * file,
- const SMESHDS_Mesh* meshPart) throw(SALOME_Exception)
+ const SMESHDS_Mesh* meshPart)
{
Unexpect aCatch(SalomeException);
DriverUNV_W_SMDS_Mesh myWriter;
void SMESH_Mesh::ExportSTL(const char * file,
const bool isascii,
const char * name,
- const SMESHDS_Mesh* meshPart) throw(SALOME_Exception)
+ const SMESHDS_Mesh* meshPart)
{
Unexpect aCatch(SalomeException);
DriverSTL_W_SMDS_Mesh myWriter;
*/
//================================================================================
-int SMESH_Mesh::NbNodes() const throw(SALOME_Exception)
+int SMESH_Mesh::NbNodes() const
{
Unexpect aCatch(SalomeException);
return _myMeshDS->NbNodes();
*/
//================================================================================
-int SMESH_Mesh::Nb0DElements() const throw(SALOME_Exception)
+int SMESH_Mesh::Nb0DElements() const
{
Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().Nb0DElements();
*/
//================================================================================
-int SMESH_Mesh::NbEdges(SMDSAbs_ElementOrder order) const throw(SALOME_Exception)
+int SMESH_Mesh::NbEdges(SMDSAbs_ElementOrder order) const
{
Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbEdges(order);
*/
//================================================================================
-int SMESH_Mesh::NbFaces(SMDSAbs_ElementOrder order) const throw(SALOME_Exception)
+int SMESH_Mesh::NbFaces(SMDSAbs_ElementOrder order) const
{
Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbFaces(order);
*/
//================================================================================
-int SMESH_Mesh::NbTriangles(SMDSAbs_ElementOrder order) const throw(SALOME_Exception)
+int SMESH_Mesh::NbTriangles(SMDSAbs_ElementOrder order) const
{
Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbTriangles(order);
*/
//================================================================================
-int SMESH_Mesh::NbBiQuadTriangles() const throw(SALOME_Exception)
+int SMESH_Mesh::NbBiQuadTriangles() const
{
Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbBiQuadTriangles();
*/
//================================================================================
-int SMESH_Mesh::NbQuadrangles(SMDSAbs_ElementOrder order) const throw(SALOME_Exception)
+int SMESH_Mesh::NbQuadrangles(SMDSAbs_ElementOrder order) const
{
Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbQuadrangles(order);
*/
//================================================================================
-int SMESH_Mesh::NbBiQuadQuadrangles() const throw(SALOME_Exception)
+int SMESH_Mesh::NbBiQuadQuadrangles() const
{
Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbBiQuadQuadrangles();
*/
//================================================================================
-int SMESH_Mesh::NbPolygons(SMDSAbs_ElementOrder order) const throw(SALOME_Exception)
+int SMESH_Mesh::NbPolygons(SMDSAbs_ElementOrder order) const
{
Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbPolygons(order);
*/
//================================================================================
-int SMESH_Mesh::NbVolumes(SMDSAbs_ElementOrder order) const throw(SALOME_Exception)
+int SMESH_Mesh::NbVolumes(SMDSAbs_ElementOrder order) const
{
Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbVolumes(order);
*/
//================================================================================
-int SMESH_Mesh::NbTetras(SMDSAbs_ElementOrder order) const throw(SALOME_Exception)
+int SMESH_Mesh::NbTetras(SMDSAbs_ElementOrder order) const
{
Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbTetras(order);
*/
//================================================================================
-int SMESH_Mesh::NbHexas(SMDSAbs_ElementOrder order) const throw(SALOME_Exception)
+int SMESH_Mesh::NbHexas(SMDSAbs_ElementOrder order) const
{
Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbHexas(order);
*/
//================================================================================
-int SMESH_Mesh::NbTriQuadraticHexas() const throw(SALOME_Exception)
+int SMESH_Mesh::NbTriQuadraticHexas() const
{
Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbTriQuadHexas();
*/
//================================================================================
-int SMESH_Mesh::NbPyramids(SMDSAbs_ElementOrder order) const throw(SALOME_Exception)
+int SMESH_Mesh::NbPyramids(SMDSAbs_ElementOrder order) const
{
Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbPyramids(order);
*/
//================================================================================
-int SMESH_Mesh::NbPrisms(SMDSAbs_ElementOrder order) const throw(SALOME_Exception)
+int SMESH_Mesh::NbPrisms(SMDSAbs_ElementOrder order) const
{
Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbPrisms(order);
}
-int SMESH_Mesh::NbQuadPrisms() const throw (SALOME_Exception)
+int SMESH_Mesh::NbQuadPrisms() const
{
Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbQuadPrisms();
}
-int SMESH_Mesh::NbBiQuadPrisms() const throw (SALOME_Exception)
+int SMESH_Mesh::NbBiQuadPrisms() const
{
Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbBiQuadPrisms();
*/
//================================================================================
-int SMESH_Mesh::NbHexagonalPrisms() const throw(SALOME_Exception)
+int SMESH_Mesh::NbHexagonalPrisms() const
{
Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbHexPrisms();
*/
//================================================================================
-int SMESH_Mesh::NbPolyhedrons() const throw(SALOME_Exception)
+int SMESH_Mesh::NbPolyhedrons() const
{
Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbPolyhedrons();
*/
//================================================================================
-int SMESH_Mesh::NbBalls() const throw(SALOME_Exception)
+int SMESH_Mesh::NbBalls() const
{
Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbBalls();
*/
//================================================================================
-int SMESH_Mesh::NbSubMesh() const throw(SALOME_Exception)
+int SMESH_Mesh::NbSubMesh() const
{
Unexpect aCatch(SalomeException);
return _myMeshDS->NbSubMesh();
*/
//================================================================================
-SMESH_Group* SMESH_Mesh::AddGroup (SMESHDS_GroupBase* groupDS) throw(SALOME_Exception)
+SMESH_Group* SMESH_Mesh::AddGroup (SMESHDS_GroupBase* groupDS)
{
if ( !groupDS )
throw SALOME_Exception(LOCALIZED ("SMESH_Mesh::AddGroup(): NULL SMESHDS_GroupBase"));
SMESH_Hypothesis::Hypothesis_Status
AddHypothesis(const TopoDS_Shape & aSubShape, int anHypId, std::string* error=0)
- throw(SALOME_Exception);
+ ;
SMESH_Hypothesis::Hypothesis_Status
RemoveHypothesis(const TopoDS_Shape & aSubShape, int anHypId)
- throw(SALOME_Exception);
+ ;
const std::list <const SMESHDS_Hypothesis * >&
GetHypothesisList(const TopoDS_Shape & aSubShape) const
- throw(SALOME_Exception);
+ ;
const SMESH_Hypothesis * GetHypothesis(const TopoDS_Shape & aSubShape,
const SMESH_HypoFilter& aFilter,
SMESH_Hypothesis * GetHypothesis(const int aHypID) const;
- const std::list<SMESHDS_Command*> & GetLog() throw(SALOME_Exception);
+ const std::list<SMESHDS_Command*> & GetLog() ;
- void ClearLog() throw(SALOME_Exception);
+ void ClearLog() ;
int GetId() const { return _id; }
SMESH_Gen *GetGen() { return _gen; }
SMESH_subMesh *GetSubMesh(const TopoDS_Shape & aSubShape)
- throw(SALOME_Exception);
+ ;
SMESH_subMesh *GetSubMeshContaining(const TopoDS_Shape & aSubShape) const
- throw(SALOME_Exception);
+ ;
SMESH_subMesh *GetSubMeshContaining(const int aShapeID) const
- throw(SALOME_Exception);
+ ;
/*!
* \brief Return submeshes of groups containing the given subshape
*/
std::list<SMESH_subMesh*> GetGroupSubMeshesContaining(const TopoDS_Shape & shape) const
- throw(SALOME_Exception);
+ ;
/*!
* \brief Say all submeshes that theChangedHyp has been modified
*/
*/
const TopTools_ListOfShape& GetAncestors(const TopoDS_Shape& theSubShape) const;
- void SetAutoColor(bool theAutoColor) throw(SALOME_Exception);
+ void SetAutoColor(bool theAutoColor) ;
- bool GetAutoColor() throw(SALOME_Exception);
+ bool GetAutoColor() ;
/*!
* \brief Set the flag meaning that the mesh has been edited "manually".
bool theAddODOnVertices = false,
double theZTolerance = -1.,
bool theAllElemsToGroup = false)
- throw(SALOME_Exception);
+ ;
void ExportDAT(const char * file,
- const SMESHDS_Mesh* meshPart = 0) throw(SALOME_Exception);
+ const SMESHDS_Mesh* meshPart = 0) ;
void ExportUNV(const char * file,
- const SMESHDS_Mesh* meshPart = 0) throw(SALOME_Exception);
+ const SMESHDS_Mesh* meshPart = 0) ;
void ExportSTL(const char * file,
const bool isascii,
const char * name = 0,
- const SMESHDS_Mesh* meshPart = 0) throw(SALOME_Exception);
+ const SMESHDS_Mesh* meshPart = 0) ;
void ExportCGNS(const char * file,
const SMESHDS_Mesh* mesh,
const char * meshName = 0,
bool withRequiredGroups = true );
void ExportSAUV(const char *file,
const char* theMeshName = NULL,
- bool theAutoGroups = true) throw(SALOME_Exception);
+ bool theAutoGroups = true) ;
double GetComputeProgress() const;
- int NbNodes() const throw(SALOME_Exception);
- int Nb0DElements() const throw(SALOME_Exception);
- int NbBalls() const throw(SALOME_Exception);
+ int NbNodes() const ;
+ int Nb0DElements() const ;
+ int NbBalls() const ;
- int NbEdges(SMDSAbs_ElementOrder order = ORDER_ANY) const throw(SALOME_Exception);
+ int NbEdges(SMDSAbs_ElementOrder order = ORDER_ANY) const ;
- int NbFaces(SMDSAbs_ElementOrder order = ORDER_ANY) const throw(SALOME_Exception);
- int NbTriangles(SMDSAbs_ElementOrder order = ORDER_ANY) const throw(SALOME_Exception);
- int NbQuadrangles(SMDSAbs_ElementOrder order = ORDER_ANY) const throw(SALOME_Exception);
- int NbBiQuadQuadrangles() const throw(SALOME_Exception);
- int NbBiQuadTriangles() const throw(SALOME_Exception);
- int NbPolygons(SMDSAbs_ElementOrder order = ORDER_ANY) const throw(SALOME_Exception);
+ int NbFaces(SMDSAbs_ElementOrder order = ORDER_ANY) const ;
+ int NbTriangles(SMDSAbs_ElementOrder order = ORDER_ANY) const ;
+ int NbQuadrangles(SMDSAbs_ElementOrder order = ORDER_ANY) const ;
+ int NbBiQuadQuadrangles() const ;
+ int NbBiQuadTriangles() const ;
+ int NbPolygons(SMDSAbs_ElementOrder order = ORDER_ANY) const ;
- int NbVolumes(SMDSAbs_ElementOrder order = ORDER_ANY) const throw(SALOME_Exception);
- int NbTetras(SMDSAbs_ElementOrder order = ORDER_ANY) const throw(SALOME_Exception);
- int NbHexas(SMDSAbs_ElementOrder order = ORDER_ANY) const throw(SALOME_Exception);
- int NbTriQuadraticHexas() const throw(SALOME_Exception);
- int NbPyramids(SMDSAbs_ElementOrder order = ORDER_ANY) const throw(SALOME_Exception);
- int NbPrisms(SMDSAbs_ElementOrder order = ORDER_ANY) const throw(SALOME_Exception);
- int NbQuadPrisms() const throw(SALOME_Exception);
- int NbBiQuadPrisms() const throw(SALOME_Exception);
- int NbHexagonalPrisms() const throw(SALOME_Exception);
- int NbPolyhedrons() const throw(SALOME_Exception);
+ int NbVolumes(SMDSAbs_ElementOrder order = ORDER_ANY) const ;
+ int NbTetras(SMDSAbs_ElementOrder order = ORDER_ANY) const ;
+ int NbHexas(SMDSAbs_ElementOrder order = ORDER_ANY) const ;
+ int NbTriQuadraticHexas() const ;
+ int NbPyramids(SMDSAbs_ElementOrder order = ORDER_ANY) const ;
+ int NbPrisms(SMDSAbs_ElementOrder order = ORDER_ANY) const ;
+ int NbQuadPrisms() const ;
+ int NbBiQuadPrisms() const ;
+ int NbHexagonalPrisms() const ;
+ int NbPolyhedrons() const ;
- int NbSubMesh() const throw(SALOME_Exception);
+ int NbSubMesh() const ;
int NbGroup() const { return _mapGroup.size(); }
const TopoDS_Shape& theShape = TopoDS_Shape(),
const SMESH_PredicatePtr& thePredicate = SMESH_PredicatePtr());
- SMESH_Group* AddGroup (SMESHDS_GroupBase* groupDS) throw(SALOME_Exception);
+ SMESH_Group* AddGroup (SMESHDS_GroupBase* groupDS) ;
typedef boost::shared_ptr< SMDS_Iterator<SMESH_Group*> > GroupIteratorPtr;
GroupIteratorPtr GetGroups() const;
protected: // methods of SMDS_ElementHolder; remove elements before mesh compacting or clearing
virtual SMDS_ElemIteratorPtr getElements() { Clear(); return GetElements(); }
virtual void tmpClear() {}
- virtual void add( const SMDS_MeshElement* element ) {}
+ virtual void add( const SMDS_MeshElement* /*element*/ ) {}
virtual void compact() {}
virtual void clear() { Clear(); }
};
//purpose :
//=======================================================================
-void SMESHDS_Mesh::Renumber (const bool isNodes, const int startID, const int deltaID)
+void SMESHDS_Mesh::Renumber (const bool /*isNodes*/, const int /*startID*/, const int /*deltaID*/)
{
// TODO not possible yet to have node numbers not starting to O and continuous.
if ( !this->IsCompacted() )
//purpose :
//=======================================================================
-static void removeFromContainers (SMESHDS_Mesh* theMesh,
+static void removeFromContainers (SMESHDS_Mesh* /*theMesh*/,
std::set<SMESHDS_GroupBase*>& theGroups,
std::vector<const SMDS_MeshElement*>& theElems)
{
//================================================================================
bool SMESH_Block::findUVAround( const gp_Pnt& thePoint,
- const gp_XY& theUV,
+ const gp_XY& /*theUV*/,
const SMESH_Block::TFace& tface,
gp_XYZ& theParams,
int nbGetWorstLimit )
*/
//================================================================================
- void bndSegsToMesh( const vector< vector< BndSeg > >& bndSegsPerEdge )
+ void bndSegsToMesh( const vector< vector< BndSeg > >& /*bndSegsPerEdge*/ )
{
#ifdef _MYDEBUG_
if ( !getenv("bndSegsToMesh")) return;
bool getTranslatedPosition( const SMDS_MeshNode* theNewNode,
const double theOffset,
- const double theTol,
+ const double /*theTol*/,
const double theSign,
const std::vector< gp_XYZ >& theFaceNormals,
SMDS_Mesh& theSrcMesh,
*/
//================================================================================
- void CutFace::AddPoint( const CutLink& p1, const CutLink& p2, double tol ) const
+ void CutFace::AddPoint( const CutLink& p1, const CutLink& p2, double /*tol*/ ) const
{
if ( myInitFace->GetNodeIndex( p1.IntNode() ) >= 0 ||
myInitFace->GetNodeIndex( p2.IntNode() ) >= 0 )
const double theSign,
const std::vector< gp_XYZ >& theNormals,
std::vector< EdgePart >& theCutOffLinks,
- TLinkMap& theCutOffCoplanarLinks) const
+ TLinkMap& /*theCutOffCoplanarLinks*/) const
{
EdgePart sideEdge;
boost::container::flat_set< const SMDS_MeshElement* > checkedCoplanar;
const Segment* findTooCloseSegment( const IntPoint& p,
const double minDist,
- const double tol,
+ const double /*tol*/,
const Segment* curSegment,
const SMDS_MeshNode* curNode,
const TSegmentsOfNode& segmentsOfNode )
#include <unistd.h>
#endif
-IMPLEMENT_STANDARD_RTTIEXT(_pyObject ,Standard_Transient);
-IMPLEMENT_STANDARD_RTTIEXT(_pyCommand ,Standard_Transient);
-IMPLEMENT_STANDARD_RTTIEXT(_pyHypothesisReader,Standard_Transient);
-IMPLEMENT_STANDARD_RTTIEXT(_pyGen ,_pyObject);
-IMPLEMENT_STANDARD_RTTIEXT(_pyMesh ,_pyObject);
-IMPLEMENT_STANDARD_RTTIEXT(_pySubMesh ,_pyObject);
-IMPLEMENT_STANDARD_RTTIEXT(_pyMeshEditor ,_pyObject);
-IMPLEMENT_STANDARD_RTTIEXT(_pyHypothesis ,_pyObject);
-IMPLEMENT_STANDARD_RTTIEXT(_pySelfEraser ,_pyObject);
-IMPLEMENT_STANDARD_RTTIEXT(_pyGroup ,_pyObject);
-IMPLEMENT_STANDARD_RTTIEXT(_pyFilter ,_pyObject);
-IMPLEMENT_STANDARD_RTTIEXT(_pyAlgorithm ,_pyHypothesis);
-IMPLEMENT_STANDARD_RTTIEXT(_pyComplexParamHypo,_pyHypothesis);
-IMPLEMENT_STANDARD_RTTIEXT(_pyNumberOfSegmentsHyp,_pyHypothesis);
-IMPLEMENT_STANDARD_RTTIEXT(_pyLayerDistributionHypo,_pyHypothesis);
-IMPLEMENT_STANDARD_RTTIEXT(_pySegmentLengthAroundVertexHyp,_pyHypothesis);
+IMPLEMENT_STANDARD_RTTIEXT(_pyObject ,Standard_Transient)
+IMPLEMENT_STANDARD_RTTIEXT(_pyCommand ,Standard_Transient)
+IMPLEMENT_STANDARD_RTTIEXT(_pyHypothesisReader,Standard_Transient)
+IMPLEMENT_STANDARD_RTTIEXT(_pyGen ,_pyObject)
+IMPLEMENT_STANDARD_RTTIEXT(_pyMesh ,_pyObject)
+IMPLEMENT_STANDARD_RTTIEXT(_pySubMesh ,_pyObject)
+IMPLEMENT_STANDARD_RTTIEXT(_pyMeshEditor ,_pyObject)
+IMPLEMENT_STANDARD_RTTIEXT(_pyHypothesis ,_pyObject)
+IMPLEMENT_STANDARD_RTTIEXT(_pySelfEraser ,_pyObject)
+IMPLEMENT_STANDARD_RTTIEXT(_pyGroup ,_pyObject)
+IMPLEMENT_STANDARD_RTTIEXT(_pyFilter ,_pyObject)
+IMPLEMENT_STANDARD_RTTIEXT(_pyAlgorithm ,_pyHypothesis)
+IMPLEMENT_STANDARD_RTTIEXT(_pyComplexParamHypo,_pyHypothesis)
+IMPLEMENT_STANDARD_RTTIEXT(_pyNumberOfSegmentsHyp,_pyHypothesis)
+IMPLEMENT_STANDARD_RTTIEXT(_pyLayerDistributionHypo,_pyHypothesis)
+IMPLEMENT_STANDARD_RTTIEXT(_pySegmentLengthAroundVertexHyp,_pyHypothesis)
using namespace std;
using SMESH::TPythonDump;
class _pyAlgorithm;
class _pyHypothesisReader;
-DEFINE_STANDARD_HANDLE (_pyCommand ,Standard_Transient);
-DEFINE_STANDARD_HANDLE (_pyObject ,Standard_Transient);
-DEFINE_STANDARD_HANDLE (_pyHypothesisReader,Standard_Transient);
-DEFINE_STANDARD_HANDLE (_pyGen ,_pyObject);
-DEFINE_STANDARD_HANDLE (_pyMesh ,_pyObject);
-DEFINE_STANDARD_HANDLE (_pySubMesh ,_pyObject);
-DEFINE_STANDARD_HANDLE (_pyGroup ,_pySubMesh);
-DEFINE_STANDARD_HANDLE (_pyMeshEditor ,_pyObject);
-DEFINE_STANDARD_HANDLE (_pyHypothesis ,_pyObject);
-DEFINE_STANDARD_HANDLE (_pyAlgorithm ,_pyHypothesis);
+DEFINE_STANDARD_HANDLE (_pyCommand ,Standard_Transient)
+DEFINE_STANDARD_HANDLE (_pyObject ,Standard_Transient)
+DEFINE_STANDARD_HANDLE (_pyHypothesisReader,Standard_Transient)
+DEFINE_STANDARD_HANDLE (_pyGen ,_pyObject)
+DEFINE_STANDARD_HANDLE (_pyMesh ,_pyObject)
+DEFINE_STANDARD_HANDLE (_pySubMesh ,_pyObject)
+DEFINE_STANDARD_HANDLE (_pyGroup ,_pySubMesh)
+DEFINE_STANDARD_HANDLE (_pyMeshEditor ,_pyObject)
+DEFINE_STANDARD_HANDLE (_pyHypothesis ,_pyObject)
+DEFINE_STANDARD_HANDLE (_pyAlgorithm ,_pyHypothesis)
typedef TCollection_AsciiString _pyID;
typedef TCollection_AsciiString _AString;
DEFINE_STANDARD_RTTIEXT(_pyComplexParamHypo,_pyHypothesis)
};
-DEFINE_STANDARD_HANDLE (_pyComplexParamHypo, _pyHypothesis);
+DEFINE_STANDARD_HANDLE (_pyComplexParamHypo, _pyHypothesis)
// -------------------------------------------------------------------------------------
/*!
DEFINE_STANDARD_RTTIEXT(_pyLayerDistributionHypo,_pyHypothesis)
};
-DEFINE_STANDARD_HANDLE (_pyLayerDistributionHypo, _pyHypothesis);
+DEFINE_STANDARD_HANDLE (_pyLayerDistributionHypo, _pyHypothesis)
// -------------------------------------------------------------------------------------
/*!
DEFINE_STANDARD_RTTIEXT(_pyNumberOfSegmentsHyp,_pyHypothesis)
};
-DEFINE_STANDARD_HANDLE (_pyNumberOfSegmentsHyp, _pyHypothesis);
+DEFINE_STANDARD_HANDLE (_pyNumberOfSegmentsHyp, _pyHypothesis)
// -------------------------------------------------------------------------------------
/*!
const _pyID& theMesh);
DEFINE_STANDARD_RTTIEXT(_pySegmentLengthAroundVertexHyp,_pyHypothesis)
};
-DEFINE_STANDARD_HANDLE (_pySegmentLengthAroundVertexHyp, _pyHypothesis);
+DEFINE_STANDARD_HANDLE (_pySegmentLengthAroundVertexHyp, _pyHypothesis)
// -------------------------------------------------------------------------------------
/*!
DEFINE_STANDARD_RTTIEXT(_pySelfEraser,_pyObject)
};
-DEFINE_STANDARD_HANDLE (_pySelfEraser, _pyObject);
+DEFINE_STANDARD_HANDLE (_pySelfEraser, _pyObject)
// -------------------------------------------------------------------------------------
/*!
DEFINE_STANDARD_RTTIEXT(_pyFilter,_pyObject)
};
-DEFINE_STANDARD_HANDLE (_pyFilter, _pyObject);
+DEFINE_STANDARD_HANDLE (_pyFilter, _pyObject)
// -------------------------------------------------------------------------------------
/*!
}
void ConnectedElements_i::SetVertex( GEOM::GEOM_Object_ptr vertex )
- throw (SALOME::SALOME_Exception)
{
TopoDS_Shape shape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( vertex );
if ( shape.IsNull() )
}
void ConnectedElements_i::SetNode ( CORBA::Long nodeID )
- throw (SALOME::SALOME_Exception)
{
if ( nodeID < 1 )
THROW_SALOME_CORBA_EXCEPTION( "ConnectedElements_i::SetNode(): nodeID must be > 0",
*/
void ConnectedElements_i::SetThreshold ( const char* threshold,
SMESH::ConnectedElements::ThresholdType type )
- throw (SALOME::SALOME_Exception)
{
if ( !threshold )
THROW_SALOME_CORBA_EXCEPTION( "ConnectedElements_i::SetThreshold(): NULL threshold",
void SetElementType( ElementType theType );
void SetPoint( CORBA::Double x, CORBA::Double y, CORBA::Double z );
void SetVertex( GEOM::GEOM_Object_ptr vertex )
- throw (SALOME::SALOME_Exception);
+ ;
void SetNode ( CORBA::Long nodeID )
- throw (SALOME::SALOME_Exception);
+ ;
void SetThreshold ( const char* threshold,
SMESH::ConnectedElements::ThresholdType type )
- throw (SALOME::SALOME_Exception);
+ ;
char* GetThreshold ( SMESH::ConnectedElements::ThresholdType& type );
private:
GenericHypothesisCreator_i* SMESH_Gen_i::getHypothesisCreator(const char* theHypName,
const char* theLibName,
std::string& thePlatformLibName)
- throw (SALOME::SALOME_Exception)
+
{
std::string aPlatformLibName;
/* It's Need to translate lib name for WIN32 or X platform */
//=============================================================================
SMESH::SMESH_Mesh_ptr SMESH_Gen_i::createMesh()
- throw ( SALOME::SALOME_Exception )
+
{
Unexpect aCatch(SALOME_SalomeException);
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::createMesh" );
SMESH::SMESH_Hypothesis_ptr SMESH_Gen_i::CreateHypothesis( const char* theHypName,
const char* theLibName )
- throw ( SALOME::SALOME_Exception )
+
{
Unexpect aCatch(SALOME_SalomeException);
// Create hypothesis/algorithm
const char* theLibName,
CORBA::Double theAverageLength,
CORBA::Boolean theQuadDominated)
- throw ( SALOME::SALOME_Exception )
+
{
SMESH::HypInitParams initParams = { ::SMESH_Hypothesis::BY_AVERAGE_LENGTH,
theAverageLength, theQuadDominated };
SMESH::SMESH_Mesh_ptr theMesh,
GEOM::GEOM_Object_ptr theGeom,
const SMESH::HypInitParams& theParams)
- throw ( SALOME::SALOME_Exception )
+
{
Unexpect aCatch(SALOME_SalomeException);
//=============================================================================
void SMESH_Gen_i::SetBoundaryBoxSegmentation( CORBA::Long theNbSegments )
- throw ( SALOME::SALOME_Exception )
+
{
if ( theNbSegments > 0 )
myGen.SetBoundaryBoxSegmentation( int( theNbSegments ));
//=============================================================================
void SMESH_Gen_i::SetDefaultNbSegments(CORBA::Long theNbSegments)
- throw ( SALOME::SALOME_Exception )
+
{
if ( theNbSegments > 0 )
myGen.SetDefaultNbSegments( int(theNbSegments) );
//=============================================================================
SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateMesh( GEOM::GEOM_Object_ptr theShapeObject )
- throw ( SALOME::SALOME_Exception )
+
{
Unexpect aCatch(SALOME_SalomeException);
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::CreateMesh" );
//=============================================================================
SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateEmptyMesh()
- throw ( SALOME::SALOME_Exception )
+
{
Unexpect aCatch(SALOME_SalomeException);
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::CreateMesh" );
*/
//================================================================================
- void checkFileReadable( const char* theFileName ) throw ( SALOME::SALOME_Exception )
+ void checkFileReadable( const char* theFileName )
{
SMESH_File f ( theFileName );
if ( !f )
//=============================================================================
SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateMeshesFromUNV( const char* theFileName )
- throw ( SALOME::SALOME_Exception )
+
{
Unexpect aCatch(SALOME_SalomeException);
SMESH::mesh_array* SMESH_Gen_i::CreateMeshesFromMED( const char* theFileName,
SMESH::DriverMED_ReadStatus& theStatus)
- throw ( SALOME::SALOME_Exception )
+
{
Unexpect aCatch(SALOME_SalomeException);
checkFileReadable( theFileName );
SMESH::mesh_array* SMESH_Gen_i::CreateMeshesFromSAUV( const char* theFileName,
SMESH::DriverMED_ReadStatus& theStatus)
- throw ( SALOME::SALOME_Exception )
+
{
Unexpect aCatch(SALOME_SalomeException);
checkFileReadable( theFileName );
//=============================================================================
SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateMeshesFromSTL( const char* theFileName )
- throw ( SALOME::SALOME_Exception )
+
{
Unexpect aCatch(SALOME_SalomeException);
checkFileReadable( theFileName );
SMESH::mesh_array* SMESH_Gen_i::CreateMeshesFromCGNS( const char* theFileName,
SMESH::DriverMED_ReadStatus& theStatus)
- throw ( SALOME::SALOME_Exception )
+
{
Unexpect aCatch(SALOME_SalomeException);
checkFileReadable( theFileName );
SMESH_Gen_i::CreateMeshesFromGMF( const char* theFileName,
CORBA::Boolean theMakeRequiredGroups,
SMESH::ComputeError_out theError)
- throw ( SALOME::SALOME_Exception )
+
{
Unexpect aCatch(SALOME_SalomeException);
checkFileReadable( theFileName );
CORBA::Boolean SMESH_Gen_i::IsReadyToCompute( SMESH::SMESH_Mesh_ptr theMesh,
GEOM::GEOM_Object_ptr theShapeObject )
- throw ( SALOME::SALOME_Exception )
+
{
Unexpect aCatch(SALOME_SalomeException);
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::IsReadyToCompute" );
SMESH::compute_error_array* SMESH_Gen_i::GetComputeErrors( SMESH::SMESH_Mesh_ptr theMesh,
GEOM::GEOM_Object_ptr theSubObject )
- throw ( SALOME::SALOME_Exception )
+
{
Unexpect aCatch(SALOME_SalomeException);
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::GetComputeErrors()" );
SMESH::MeshPreviewStruct*
SMESH_Gen_i::GetBadInputElements( SMESH::SMESH_Mesh_ptr theMesh,
CORBA::Short theSubShapeID )
- throw ( SALOME::SALOME_Exception )
+
{
Unexpect aCatch(SALOME_SalomeException);
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::GetBadInputElements()" );
SMESH_Gen_i::MakeGroupsOfBadInputElements( SMESH::SMESH_Mesh_ptr theMesh,
CORBA::Short theSubShapeID,
const char* theGroupName )
- throw ( SALOME::SALOME_Exception )
+
{
Unexpect aCatch(SALOME_SalomeException);
SMESH::algo_error_array* SMESH_Gen_i::GetAlgoState( SMESH::SMESH_Mesh_ptr theMesh,
GEOM::GEOM_Object_ptr theSubObject )
- throw ( SALOME::SALOME_Exception )
+
{
Unexpect aCatch(SALOME_SalomeException);
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::GetAlgoState()" );
SMESH::long_array*
SMESH_Gen_i::GetSubShapesId( GEOM::GEOM_Object_ptr theMainShapeObject,
const SMESH::object_array& theListOfSubShapeObject )
- throw ( SALOME::SALOME_Exception )
+
{
Unexpect aCatch(SALOME_SalomeException);
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::GetSubShapesId" );
CORBA::Boolean SMESH_Gen_i::Compute( SMESH::SMESH_Mesh_ptr theMesh,
GEOM::GEOM_Object_ptr theShapeObject )
- throw ( SALOME::SALOME_Exception )
+
{
//MEMOSTAT;
Unexpect aCatch(SALOME_SalomeException);
GEOM::GEOM_Object_ptr theShapeObject,
SMESH::Dimension theDimension,
SMESH::long_array& theShapesId)
- throw ( SALOME::SALOME_Exception )
+
{
Unexpect aCatch(SALOME_SalomeException);
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::Precompute" );
SMESH::long_array* SMESH_Gen_i::Evaluate(SMESH::SMESH_Mesh_ptr theMesh,
GEOM::GEOM_Object_ptr theShapeObject)
// SMESH::long_array& theNbElems)
- throw ( SALOME::SALOME_Exception )
+
{
Unexpect aCatch(SALOME_SalomeException);
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::Evaluate" );
SMESH_Gen_i::GetGeometryByMeshElement( SMESH::SMESH_Mesh_ptr theMesh,
CORBA::Long theElementID,
const char* theGeomName)
- throw ( SALOME::SALOME_Exception )
+
{
Unexpect aCatch(SALOME_SalomeException);
GEOM::GEOM_Object_ptr
SMESH_Gen_i::FindGeometryByMeshElement( SMESH::SMESH_Mesh_ptr theMesh,
CORBA::Long theElementID)
- throw ( SALOME::SALOME_Exception )
+
{
Unexpect aCatch(SALOME_SalomeException);
if ( CORBA::is_nil( theMesh ) )
CORBA::Boolean theMergeNodesAndElements,
CORBA::Double theMergeTolerance,
SMESH::SMESH_Mesh_ptr theMeshToAppendTo)
- throw ( SALOME::SALOME_Exception )
+
{
return ConcatenateCommon(theMeshesArray,
theUniteIdenticalGroups,
CORBA::Boolean theMergeNodesAndElements,
CORBA::Double theMergeTolerance,
SMESH::SMESH_Mesh_ptr theMeshToAppendTo)
- throw ( SALOME::SALOME_Exception )
+
{
return ConcatenateCommon(theMeshesArray,
theUniteIdenticalGroups,
CORBA::Double theMergeTolerance,
CORBA::Boolean theCommonGroups,
SMESH::SMESH_Mesh_ptr theMeshToAppendTo)
- throw ( SALOME::SALOME_Exception )
+
{
std::unique_ptr< TPythonDump > pPythonDump( new TPythonDump );
TPythonDump& pythonDump = *pPythonDump; // prevent dump of called methods
const char* meshName,
CORBA::Boolean toCopyGroups,
CORBA::Boolean toKeepIDs)
- throw ( SALOME::SALOME_Exception )
+
{
Unexpect aCatch(SALOME_SalomeException);
SMESH::submesh_array_out theNewSubmeshes,
SMESH::ListOfHypothesis_out theNewHypotheses,
SMESH::string_array_out theInvalidEntries)
-throw ( SALOME::SALOME_Exception )
+
{
if ( CORBA::is_nil( theSourceMesh ) ||
CORBA::is_nil( theNewGeometry ))
// Create hypothesis/algorithm of given type
SMESH::SMESH_Hypothesis_ptr CreateHypothesis (const char* theHypType,
const char* theLibName)
- throw ( SALOME::SALOME_Exception );
+ ;
SMESH::SMESH_Hypothesis_ptr CreateHypothesisByAverageLength( const char* theHypType,
const char* theLibName,
CORBA::Double theAverageLength,
CORBA::Boolean theQuadDominated)
- throw ( SALOME::SALOME_Exception );
+ ;
// Return hypothesis of given type holding parameter values of the existing mesh
SMESH::SMESH_Hypothesis_ptr
SMESH::SMESH_Mesh_ptr theMesh,
GEOM::GEOM_Object_ptr theGeom,
const SMESH::HypInitParams& theWay)
- throw ( SALOME::SALOME_Exception );
+ ;
/*
* Returns True if a hypothesis is assigned to a sole sub-mesh in a current Study
* Sets number of segments per diagonal of boundary box of geometry by which
* default segment length of appropriate 1D hypotheses is defined
*/
- void SetBoundaryBoxSegmentation( CORBA::Long theNbSegments ) throw ( SALOME::SALOME_Exception );
+ void SetBoundaryBoxSegmentation( CORBA::Long theNbSegments ) ;
/*!
* \brief Sets default number of segments per edge
*/
- void SetDefaultNbSegments(CORBA::Long theNbSegments) throw ( SALOME::SALOME_Exception );
+ void SetDefaultNbSegments(CORBA::Long theNbSegments) ;
/*!
Set an option value
// Create empty mesh on a shape
SMESH::SMESH_Mesh_ptr CreateMesh( GEOM::GEOM_Object_ptr theShapeObject )
- throw ( SALOME::SALOME_Exception );
+ ;
// Create empty mesh
SMESH::SMESH_Mesh_ptr CreateEmptyMesh()
- throw ( SALOME::SALOME_Exception );
+ ;
// Create a mesh and import data from an UNV file
SMESH::SMESH_Mesh_ptr CreateMeshesFromUNV( const char* theFileName )
- throw ( SALOME::SALOME_Exception );
+ ;
// Create mesh(es) and import data from MED file
SMESH::mesh_array* CreateMeshesFromMED( const char* theFileName,
SMESH::DriverMED_ReadStatus& theStatus )
- throw ( SALOME::SALOME_Exception );
+ ;
// Create mesh(es) and import data from MED file
SMESH::mesh_array* CreateMeshesFromSAUV( const char* theFileName,
SMESH::DriverMED_ReadStatus& theStatus )
- throw ( SALOME::SALOME_Exception );
+ ;
// Create a mesh and import data from a STL file
SMESH::SMESH_Mesh_ptr CreateMeshesFromSTL( const char* theFileName )
- throw ( SALOME::SALOME_Exception );
+ ;
// Create mesh(es) and import data from CGNS file
SMESH::mesh_array* CreateMeshesFromCGNS( const char* theFileName,
SMESH::DriverMED_ReadStatus& theStatus )
- throw ( SALOME::SALOME_Exception );
+ ;
// Create a mesh and import data from a GMF file
SMESH::SMESH_Mesh_ptr CreateMeshesFromGMF( const char* theFileName,
CORBA::Boolean theMakeRequiredGroups,
SMESH::ComputeError_out theError)
- throw ( SALOME::SALOME_Exception );
+ ;
// Copy a part of mesh
SMESH::SMESH_Mesh_ptr CopyMesh(SMESH::SMESH_IDSource_ptr meshPart,
const char* meshName,
CORBA::Boolean toCopyGroups,
CORBA::Boolean toKeepIDs)
- throw ( SALOME::SALOME_Exception );
+ ;
// Create a mesh by copying definitions of another mesh to a given geometry
CORBA::Boolean CopyMeshWithGeom( SMESH::SMESH_Mesh_ptr sourceMesh,
SMESH::submesh_array_out newSubmeshes,
SMESH::ListOfHypothesis_out newHypotheses,
SMESH::string_array_out invalidEntries)
- throw ( SALOME::SALOME_Exception );
+ ;
// Compute mesh on a shape
CORBA::Boolean Compute( SMESH::SMESH_Mesh_ptr theMesh,
GEOM::GEOM_Object_ptr theShapeObject )
- throw ( SALOME::SALOME_Exception );
+ ;
// Cancel Compute mesh on a shape
void CancelCompute( SMESH::SMESH_Mesh_ptr theMesh,
*/
SMESH::compute_error_array* GetComputeErrors(SMESH::SMESH_Mesh_ptr theMesh,
GEOM::GEOM_Object_ptr theShapeObject )
- throw ( SALOME::SALOME_Exception );
+ ;
/*!
* Evaluate mesh on a shape and
*/
SMESH::long_array* Evaluate(SMESH::SMESH_Mesh_ptr theMesh,
GEOM::GEOM_Object_ptr theShapeObject)
- throw ( SALOME::SALOME_Exception );
+ ;
// Returns true if mesh contains enough data to be computed
CORBA::Boolean IsReadyToCompute( SMESH::SMESH_Mesh_ptr theMesh,
GEOM::GEOM_Object_ptr theShapeObject )
- throw ( SALOME::SALOME_Exception );
+ ;
/*!
* Calculate Mesh as preview till indicated dimension on shape
GEOM::GEOM_Object_ptr theSubObject,
SMESH::Dimension theDimension,
SMESH::long_array& theShapesId )
- throw ( SALOME::SALOME_Exception );
+ ;
// Returns errors of hypotheses definition
SMESH::algo_error_array* GetAlgoState( SMESH::SMESH_Mesh_ptr theMesh,
GEOM::GEOM_Object_ptr theSubObject )
- throw ( SALOME::SALOME_Exception );
+ ;
// Return mesh elements preventing computation of a subshape
SMESH::MeshPreviewStruct* GetBadInputElements( SMESH::SMESH_Mesh_ptr theMesh,
CORBA::Short theSubShapeID )
- throw ( SALOME::SALOME_Exception );
+ ;
// Create groups of elements preventing computation of a sub-shape
SMESH::ListOfGroups* MakeGroupsOfBadInputElements( SMESH::SMESH_Mesh_ptr theMesh,
CORBA::Short theSubShapeID,
const char* theGroupName)
- throw ( SALOME::SALOME_Exception );
+ ;
// Get sub-shapes unique ID's list
SMESH::long_array* GetSubShapesId( GEOM::GEOM_Object_ptr theMainShapeObject,
const SMESH::object_array& theListOfSubShape )
- throw ( SALOME::SALOME_Exception );
+ ;
// Return geometrical object the given element is built on. Publish it in study.
GEOM::GEOM_Object_ptr GetGeometryByMeshElement( SMESH::SMESH_Mesh_ptr theMesh,
CORBA::Long theElementID,
const char* theGeomName)
- throw ( SALOME::SALOME_Exception );
+ ;
// Return geometrical object the given element is built on. Don't publish it in study.
GEOM::GEOM_Object_ptr FindGeometryByMeshElement( SMESH::SMESH_Mesh_ptr theMesh,
CORBA::Long theElementID)
- throw ( SALOME::SALOME_Exception );
+ ;
// Concatenate the given meshes into one mesh
SMESH::SMESH_Mesh_ptr ConcatenateCommon(const SMESH::ListOfIDSources& meshesArray,
CORBA::Double mergeTolerance,
CORBA::Boolean commonGroups,
SMESH::SMESH_Mesh_ptr meshToAppendTo)
- throw ( SALOME::SALOME_Exception );
+ ;
// Concatenate the given meshes into one mesh
SMESH::SMESH_Mesh_ptr Concatenate(const SMESH::ListOfIDSources& meshesArray,
CORBA::Boolean mergeNodesAndElements,
CORBA::Double mergeTolerance,
SMESH::SMESH_Mesh_ptr meshToAppendTo)
- throw ( SALOME::SALOME_Exception );
+ ;
// Concatenate the given meshes into one mesh
// Create the groups of all elements from initial meshes
CORBA::Boolean mergeNodesAndElements,
CORBA::Double mergeTolerance,
SMESH::SMESH_Mesh_ptr meshToAppendTo)
- throw ( SALOME::SALOME_Exception );
+ ;
// Get version of MED format being used.
char* GetMEDFileVersion();
SALOMEDS::SObject_ptr PublishInStudy( SALOMEDS::SObject_ptr theSObject,
CORBA::Object_ptr theObject,
const char* theName )
- throw ( SALOME::SALOME_Exception );
+ ;
// Copy-paste methods - returns true if object can be copied to the clipboard
- CORBA::Boolean CanCopy( SALOMEDS::SObject_ptr theObject ) { return false; }
+ CORBA::Boolean CanCopy( SALOMEDS::SObject_ptr /*theObject*/ ) { return false; }
// Copy-paste methods - copy object to the clipboard
- SALOMEDS::TMPFile* CopyFrom( SALOMEDS::SObject_ptr theObject, CORBA::Long& theObjectID ) { return NULL; }
+ SALOMEDS::TMPFile* CopyFrom( SALOMEDS::SObject_ptr /*theObject*/, CORBA::Long& /*theObjectID*/ ) { return NULL; }
// Copy-paste methods - returns true if object can be pasted from the clipboard
- CORBA::Boolean CanPaste( const char* theComponentName, CORBA::Long theObjectID ) { return false; }
+ CORBA::Boolean CanPaste( const char* /*theComponentName*/, CORBA::Long /*theObjectID*/ ) { return false; }
// Copy-paste methods - paste object from the clipboard
- SALOMEDS::SObject_ptr PasteInto( const SALOMEDS::TMPFile& theStream,
- CORBA::Long theObjectID,
- SALOMEDS::SObject_ptr theObject ) {
+ SALOMEDS::SObject_ptr PasteInto( const SALOMEDS::TMPFile& /*theStream*/,
+ CORBA::Long /*theObjectID*/,
+ SALOMEDS::SObject_ptr /*theObject*/ ) {
SALOMEDS::SObject_var aResultSO;
return aResultSO._retn();
}
GenericHypothesisCreator_i* getHypothesisCreator( const char* theHypName,
const char* theLibName,
std::string& thePlatformLibName)
- throw ( SALOME::SALOME_Exception );
+ ;
// Create hypothesis of given type
SMESH::SMESH_Hypothesis_ptr createHypothesis( const char* theHypName,
const char* theLibName);
// Create empty mesh on shape
SMESH::SMESH_Mesh_ptr createMesh()
- throw ( SALOME::SALOME_Exception );
+ ;
// Check mesh icon
bool isGeomModifIcon( SMESH::SMESH_Mesh_ptr mesh );
SALOMEDS::SObject_ptr SMESH_Gen_i::PublishInStudy(SALOMEDS::SObject_ptr theSObject,
CORBA::Object_ptr theIOR,
const char* theName)
- throw (SALOME::SALOME_Exception)
{
Unexpect aCatch(SALOME_SalomeException);
SALOMEDS::SObject_wrap aSO;
//================================================================================
void SMESH_GroupOnFilter_i::SetFilter(SMESH::Filter_ptr theFilter)
- throw (SALOME::SALOME_Exception)
{
if ( myFilter->_is_equivalent( theFilter ))
return;
static SMESH_PredicatePtr GetPredicate( SMESH::Filter_ptr );
// CORBA interface implementation
- void SetFilter(SMESH::Filter_ptr theFilter) throw (SALOME::SALOME_Exception);
+ void SetFilter(SMESH::Filter_ptr theFilter) ;
SMESH::Filter_ptr GetFilter();
virtual CORBA::Boolean IsUpToDate();
virtual SMESH::long_array* GetListOfID();
//================================================================================
SMESH::MeshPreviewStruct* SMESH_MeshEditor_i::GetPreviewData()
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
const bool hasBadElems = ( getEditor().GetError() && getEditor().GetError()->HasBadElems() );
//================================================================================
SMESH::long_array* SMESH_MeshEditor_i::GetLastCreatedNodes()
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
SMESH::long_array_var myLastCreatedNodes = new SMESH::long_array();
//================================================================================
SMESH::long_array* SMESH_MeshEditor_i::GetLastCreatedElems()
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
SMESH::long_array_var myLastCreatedElems = new SMESH::long_array();
//purpose : Clears sequences of last created elements and nodes
//=======================================================================
-void SMESH_MeshEditor_i::ClearLastCreated() throw (SALOME::SALOME_Exception)
+void SMESH_MeshEditor_i::ClearLastCreated()
{
SMESH_TRY;
getEditor().ClearLastCreated();
//=======================================================================
SMESH::ComputeError* SMESH_MeshEditor_i::GetLastError()
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
SMESH::ComputeError_var errOut = new SMESH::ComputeError;
CORBA::Boolean
SMESH_MeshEditor_i::RemoveElements(const SMESH::long_array & IDsOfElements)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
initData();
//=============================================================================
CORBA::Boolean SMESH_MeshEditor_i::RemoveNodes(const SMESH::long_array & IDsOfNodes)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
initData();
//=============================================================================
CORBA::Long SMESH_MeshEditor_i::RemoveOrphanNodes()
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
initData();
//=============================================================================
CORBA::Long SMESH_MeshEditor_i::AddNode(CORBA::Double x,CORBA::Double y, CORBA::Double z)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
initData();
CORBA::Long SMESH_MeshEditor_i::Add0DElement(CORBA::Long IDOfNode,
CORBA::Boolean DuplicateElements)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
initData();
//=============================================================================
CORBA::Long SMESH_MeshEditor_i::AddBall(CORBA::Long IDOfNode, CORBA::Double diameter)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
initData();
//=============================================================================
CORBA::Long SMESH_MeshEditor_i::AddEdge(const SMESH::long_array & IDsOfNodes)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
initData();
//=============================================================================
CORBA::Long SMESH_MeshEditor_i::AddFace(const SMESH::long_array & IDsOfNodes)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
initData();
//=============================================================================
CORBA::Long SMESH_MeshEditor_i::AddPolygonalFace (const SMESH::long_array & IDsOfNodes)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
initData();
//=============================================================================
CORBA::Long SMESH_MeshEditor_i::AddQuadPolygonalFace (const SMESH::long_array & IDsOfNodes)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
initData();
//=============================================================================
CORBA::Long SMESH_MeshEditor_i::AddVolume(const SMESH::long_array & IDsOfNodes)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
initData();
//=============================================================================
CORBA::Long SMESH_MeshEditor_i::AddPolyhedralVolume (const SMESH::long_array & IDsOfNodes,
const SMESH::long_array & Quantities)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
initData();
//=============================================================================
CORBA::Long SMESH_MeshEditor_i::AddPolyhedralVolumeByFaces (const SMESH::long_array & IdsOfFaces)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
initData();
SMESH_MeshEditor_i::Create0DElementsOnAllNodes(SMESH::SMESH_IDSource_ptr theObject,
const char* theGroupName,
CORBA::Boolean theDuplicateElements)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
initData();
//=============================================================================
void SMESH_MeshEditor_i::SetNodeOnVertex(CORBA::Long NodeID, CORBA::Long VertexID)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
void SMESH_MeshEditor_i::SetNodeOnEdge(CORBA::Long NodeID, CORBA::Long EdgeID,
CORBA::Double paramOnEdge)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
void SMESH_MeshEditor_i::SetNodeOnFace(CORBA::Long NodeID, CORBA::Long FaceID,
CORBA::Double u, CORBA::Double v)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
SMESHDS_Mesh * mesh = getMeshDS();
//=============================================================================
void SMESH_MeshEditor_i::SetNodeInVolume(CORBA::Long NodeID, CORBA::Long SolidID)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
SMESHDS_Mesh * mesh = getMeshDS();
void SMESH_MeshEditor_i::SetMeshElementOnShape(CORBA::Long ElementID,
CORBA::Long ShapeID)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
SMESHDS_Mesh * mesh = getMeshDS();
CORBA::Boolean SMESH_MeshEditor_i::InverseDiag(CORBA::Long NodeID1,
CORBA::Long NodeID2)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
initData();
CORBA::Boolean SMESH_MeshEditor_i::DeleteDiag(CORBA::Long NodeID1,
CORBA::Long NodeID2)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
initData();
//=============================================================================
CORBA::Boolean SMESH_MeshEditor_i::Reorient(const SMESH::long_array & IDsOfElements)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
initData();
//=============================================================================
CORBA::Boolean SMESH_MeshEditor_i::ReorientObject(SMESH::SMESH_IDSource_ptr theObject)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
initData();
const SMESH::DirStruct& theDirection,
CORBA::Long theFace,
const SMESH::PointStruct& thePoint)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
initData(/*deleteSearchers=*/false);
CORBA::Long SMESH_MeshEditor_i::Reorient2DBy3D(const SMESH::ListOfIDSources& faceGroups,
SMESH::SMESH_IDSource_ptr volumeGroup,
CORBA::Boolean outsideNormal)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
initData();
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();
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();
CORBA::Boolean SMESH_MeshEditor_i::QuadToTri (const SMESH::long_array & IDsOfElements,
SMESH::NumericalFunctor_ptr Criterion)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
initData();
CORBA::Boolean SMESH_MeshEditor_i::QuadToTriObject (SMESH::SMESH_IDSource_ptr theObject,
SMESH::NumericalFunctor_ptr Criterion)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
initData();
//================================================================================
void SMESH_MeshEditor_i::QuadTo4Tri (SMESH::SMESH_IDSource_ptr theObject)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
initData();
CORBA::Boolean SMESH_MeshEditor_i::SplitQuad (const SMESH::long_array & IDsOfElements,
CORBA::Boolean Diag13)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
initData();
CORBA::Boolean SMESH_MeshEditor_i::SplitQuadObject (SMESH::SMESH_IDSource_ptr theObject,
CORBA::Boolean Diag13)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
initData();
CORBA::Long SMESH_MeshEditor_i::BestSplit (CORBA::Long IDOfQuad,
SMESH::NumericalFunctor_ptr Criterion)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
initData();
void SMESH_MeshEditor_i::SplitVolumesIntoTetra (SMESH::SMESH_IDSource_ptr elems,
CORBA::Short methodFlags)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
initData();
const SMESH::DirStruct& facetToSplitNormal,
CORBA::Short methodFlags,
CORBA::Boolean allDomains)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
initData();
//================================================================================
void SMESH_MeshEditor_i::SplitBiQuadraticIntoLinear(const SMESH::ListOfIDSources& theElems)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
initData();
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();
CORBA::Double MaxAspectRatio,
SMESH::SMESH_MeshEditor::Smooth_Method Method,
bool IsParametric)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
initData();
//=============================================================================
void SMESH_MeshEditor_i::RenumberNodes()
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
// Update Python script
//=============================================================================
void SMESH_MeshEditor_i::RenumberElements()
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
// Update Python script
//=======================================================================
SMESH::ListOfGroups* SMESH_MeshEditor_i::getGroups(const std::list<int>* groupIDs)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
if ( !groupIDs )
CORBA::Long theNbOfSteps,
CORBA::Double theTolerance,
const bool theMakeGroups)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
initData();
const SMESH::double_array & theBasePoint,
const SMESH::double_array & theAngles,
CORBA::Boolean theAnglesVariation)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
initData();
CORBA::Boolean useInputElemsOnly,
CORBA::Boolean makeGroups,
CORBA::Short dim)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
initData();
CORBA::Long theExtrFlags,
CORBA::Double theSewTolerance,
CORBA::Boolean theMakeGroups)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
initData();
const SMESH::double_array & theScaleFactors,
CORBA::Boolean theScalesVariation,
SMESH::SMESH_MeshEditor::Extrusion_Error& theError)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
initData();
CORBA::Boolean theCopy,
bool theMakeGroups,
::SMESH_Mesh* theTargetMesh)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
initData();
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()
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()
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();
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()
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()
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;
CORBA::Boolean theCopy,
bool theMakeGroups,
::SMESH_Mesh* theTargetMesh)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
initData();
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()
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()
CORBA::Double theAngleInRadians,
CORBA::Boolean theCopyGroups,
const char* theMeshName)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
SMESH::SMESH_Mesh_var mesh;
CORBA::Double theAngleInRadians,
CORBA::Boolean theCopyGroups,
const char* theMeshName)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
SMESH::SMESH_Mesh_var mesh;
CORBA::Boolean theCopy,
bool theMakeGroups,
::SMESH_Mesh* theTargetMesh)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
initData();
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()
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;
CORBA::Boolean theCopyElements,
const char* theMeshName,
SMESH::ListOfGroups_out theGroups)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
initData();
FindCoincidentNodes (CORBA::Double Tolerance,
SMESH::array_of_long_array_out GroupsOfNodes,
CORBA::Boolean SeparateCornersAndMedium)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
initData();
CORBA::Double Tolerance,
SMESH::array_of_long_array_out GroupsOfNodes,
CORBA::Boolean SeparateCornersAndMedium)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
initData();
SMESH::array_of_long_array_out theGroupsOfNodes,
const SMESH::ListOfIDSources& theExceptSubMeshOrGroups,
CORBA::Boolean theSeparateCornersAndMedium)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
initData();
void SMESH_MeshEditor_i::MergeNodes (const SMESH::array_of_long_array& GroupsOfNodes,
const SMESH::ListOfIDSources& NodesToKeep,
CORBA::Boolean AvoidMakingHoles)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
initData();
void SMESH_MeshEditor_i::FindEqualElements(const SMESH::ListOfIDSources& theObjects,
const SMESH::ListOfIDSources& theExceptObjects,
SMESH::array_of_long_array_out theGroupsOfElementsID)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
initData();
void SMESH_MeshEditor_i::MergeElements(const SMESH::array_of_long_array& theGroupsOfElementsID,
const SMESH::ListOfIDSources& theElementsToKeep)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
initData();
//=======================================================================
void SMESH_MeshEditor_i::MergeEqualElements()
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
initData();
CORBA::Double x,
CORBA::Double y,
CORBA::Double z)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
initData(/*deleteSearchers=*/false);
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
CORBA::Double y,
CORBA::Double z,
CORBA::Long theNodeID)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
// We keep theNodeSearcher until any mesh modification:
CORBA::Double y,
CORBA::Double z,
SMESH::ElementType type)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
SMESH::long_array_var res = new SMESH::long_array;
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::ElementType type,
SMESH::SMESH_IDSource_ptr meshObject,
SMESH::double_array_out projecton)
- throw (SALOME::SALOME_Exception)
+
{
if ( CORBA::is_nil( meshObject ))
THROW_SALOME_CORBA_EXCEPTION("NULL meshObject", SALOME::BAD_PARAM);
CORBA::Short SMESH_MeshEditor_i::GetPointState(CORBA::Double x,
CORBA::Double y,
CORBA::Double z)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
theSearchersDeleter.Set( myMesh );
//=======================================================================
CORBA::Boolean SMESH_MeshEditor_i::IsManifold()
- throw (SALOME::SALOME_Exception)
+
{
bool isManifold = true;
//=======================================================================
CORBA::Boolean SMESH_MeshEditor_i::IsCoherentOrientation2D()
- throw (SALOME::SALOME_Exception)
+
{
bool isGoodOri = true;
SMESH_MeshEditor_i::Get1DBranches( SMESH::SMESH_IDSource_ptr theEdges,
CORBA::Long theStartNode,
SMESH::array_of_long_array_out theNodeGroups )
- throw (SALOME::SALOME_Exception)
+
{
if ( CORBA::is_nil( theEdges ))
THROW_SALOME_CORBA_EXCEPTION("Get1DBranches(): NULL group given", SALOME::BAD_PARAM);
SMESH::ListOfEdges* SMESH_MeshEditor_i::FindSharpEdges(CORBA::Double theAngle,
CORBA::Boolean theAddExisting)
- throw (SALOME::SALOME_Exception)
+
{
SMESH::ListOfEdges_var resultEdges = new SMESH::ListOfEdges;
SMESH_TRY;
//=======================================================================
SMESH::ListOfFreeBorders* SMESH_MeshEditor_i::FindFreeBorders(CORBA::Boolean closedOnly)
- throw (SALOME::SALOME_Exception)
+
{
SMESH::ListOfFreeBorders_var resBorders = new SMESH::ListOfFreeBorders;
SMESH_TRY;
SMESH::SMESH_Group_ptr
SMESH_MeshEditor_i::FillHole(const SMESH::FreeBorder& theHole,
const char* theGroupName)
- throw (SALOME::SALOME_Exception)
+
{
initData();
SewCoincidentFreeBorders(const SMESH::CoincidentFreeBorders& freeBorders,
CORBA::Boolean createPolygons,
CORBA::Boolean createPolyhedra)
- throw (SALOME::SALOME_Exception)
+
{
CORBA::Short nbSewed = 0;
CORBA::Long LastNodeID2,
CORBA::Boolean CreatePolygons,
CORBA::Boolean CreatePolyedrs)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
initData();
CORBA::Long LastNodeID1,
CORBA::Long FirstNodeID2,
CORBA::Long SecondNodeID2)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
initData();
CORBA::Long LastNodeIDOnSide,
CORBA::Boolean CreatePolygons,
CORBA::Boolean CreatePolyedrs)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
initData();
CORBA::Long NodeID1OfSide2ToMerge,
CORBA::Long NodeID2OfSide1ToMerge,
CORBA::Long NodeID2OfSide2ToMerge)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
initData();
CORBA::Boolean SMESH_MeshEditor_i::ChangeElemNodes(CORBA::Long ide,
const SMESH::long_array& newIDs)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
initData();
void SMESH_MeshEditor_i::convertToQuadratic(CORBA::Boolean theForce3d,
CORBA::Boolean theToBiQuad,
SMESH::SMESH_IDSource_ptr theObject)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
initData();
//=======================================================================
CORBA::Boolean SMESH_MeshEditor_i::ConvertFromQuadratic()
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
initData();
//=======================================================================
void SMESH_MeshEditor_i::ConvertToQuadratic(CORBA::Boolean theForce3d)
- throw (SALOME::SALOME_Exception)
+
{
convertToQuadratic( theForce3d, false );
TPythonDump() << this << ".ConvertToQuadratic("<<theForce3d<<")";
void SMESH_MeshEditor_i::ConvertToQuadraticObject(CORBA::Boolean theForce3d,
SMESH::SMESH_IDSource_ptr theObject)
- throw (SALOME::SALOME_Exception)
+
{
convertToQuadratic( theForce3d, false, theObject );
TPythonDump() << this << ".ConvertToQuadraticObject("<<theForce3d<<", "<<theObject<<")";
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)
+
{
SMESH_TRY;
initData();
SMESH::SMESH_Group_ptr
SMESH_MeshEditor_i::DoubleElements(SMESH::SMESH_IDSource_ptr theElements,
const char* theGroupName)
- throw (SALOME::SALOME_Exception)
+
{
SMESH::SMESH_Group_var newGroup;
CORBA::Boolean SMESH_MeshEditor_i::DoubleNodes( const SMESH::long_array& theNodes,
const SMESH::long_array& theModifiedElems )
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
initData();
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;
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 )
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;
CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeGroups(const SMESH::ListOfGroups& theNodes,
const SMESH::ListOfGroups& theModifiedElems )
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
initData();
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();
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();
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 )
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,
SMESH::SMESH_GroupBase_ptr theAffectedElems,
CORBA::Boolean theElemGroupNeeded,
CORBA::Boolean theNodeGroupNeeded)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
SMESH::SMESH_Group_var aNewElemGroup, aNewNodeGroup;
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 )
SMESH_MeshEditor_i::DoubleNodeElemGroups(const SMESH::ListOfGroups& theElems,
const SMESH::ListOfGroups& theNodesNot,
const SMESH::ListOfGroups& theAffectedElems)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
initData();
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,
const SMESH::ListOfGroups& theAffectedElems,
CORBA::Boolean theElemGroupNeeded,
CORBA::Boolean theNodeGroupNeeded)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
SMESH::SMESH_Group_var aNewElemGroup, aNewNodeGroup;
SMESH_MeshEditor_i::DoubleNodeElemGroupsInRegion(const SMESH::ListOfGroups& theElems,
const SMESH::ListOfGroups& theNodesNot,
GEOM::GEOM_Object_ptr theShape )
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
initData();
SMESH_MeshEditor_i::AffectedElemGroupsInRegion( const SMESH::ListOfGroups& theElems,
const SMESH::ListOfGroups& theNodesNot,
GEOM::GEOM_Object_ptr theShape )
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
SMESH::ListOfGroups_var aListOfGroups = new SMESH::ListOfGroups();
//================================================================================
CORBA::Boolean SMESH_MeshEditor_i::Make2DMeshFrom3D()
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
initData();
SMESH_MeshEditor_i::DoubleNodesOnGroupBoundaries( const SMESH::ListOfGroups& theDomains,
CORBA::Boolean createJointElems,
CORBA::Boolean onAllBoundaries )
- throw (SALOME::SALOME_Exception)
+
{
bool isOK = false;
CORBA::Boolean
SMESH_MeshEditor_i::CreateFlatElementsOnFacesGroups( const SMESH::ListOfGroups& theGroupsOfFaces )
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
initData();
const char* groupName,
const SMESH::double_array& theNodesCoords,
SMESH::array_of_long_array_out GroupsOfNodes)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
CORBA::Boolean toCopyElements,
CORBA::Boolean toCopyExistingBondary,
SMESH::SMESH_Group_out group)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
initData();
const SMESH::ListOfIDSources& groups,
SMESH::SMESH_Mesh_out mesh,
SMESH::SMESH_Group_out group)
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
initData();
void SMESH_MeshEditor_i::MakePolyLine(SMESH::ListOfPolySegments& theSegments,
const char* theGroupName)
- throw (SALOME::SALOME_Exception)
+
{
if ( theSegments.length() == 0 )
THROW_SALOME_CORBA_EXCEPTION("No segments given", SALOME::BAD_PARAM );
SMESH::ListOfEdges* SMESH_MeshEditor_i::MakeSlot(SMESH::SMESH_GroupBase_ptr theSegments,
CORBA::Double theWidth)
- throw (SALOME::SALOME_Exception)
+
{
if ( CORBA::is_nil( theSegments ) ||
theSegments->GetType() != SMESH::EDGE )
/*!
* Return data of mesh edition preview
*/
- SMESH::MeshPreviewStruct* GetPreviewData() throw (SALOME::SALOME_Exception);
+ SMESH::MeshPreviewStruct* GetPreviewData() ;
/*!
* 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() throw (SALOME::SALOME_Exception);
+ SMESH::long_array* GetLastCreatedNodes() ;
/*!
* 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() throw (SALOME::SALOME_Exception);
+ SMESH::long_array* GetLastCreatedElems() ;
/*!
* \brief Clears sequences of last created elements and nodes
*/
- void ClearLastCreated() throw (SALOME::SALOME_Exception);
+ void ClearLastCreated() ;
/*!
* \brief Returns description of an error/warning occurred during the last operation
*/
- SMESH::ComputeError* GetLastError() throw (SALOME::SALOME_Exception);
+ SMESH::ComputeError* GetLastError() ;
/*!
* \brief Wrap a sequence of ids in a SMESH_IDSource
std::string GenerateGroupName(const std::string& thePrefix);
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)
- throw (SALOME::SALOME_Exception);
+ ;
CORBA::Long Add0DElement(CORBA::Long IDOfNode, CORBA::Boolean DuplicateElements)
- 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)
- 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 AddQuadPolygonalFace(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)
- 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
SMESH::SMESH_IDSource_ptr Create0DElementsOnAllNodes(SMESH::SMESH_IDSource_ptr theObject,
const char* theGroupName,
CORBA::Boolean theDuplicateElements)
- throw (SALOME::SALOME_Exception);
+ ;
/*!
* \brief Bind a node to a vertex
* \param VertexID - vertex ID available through GEOM_Object.GetSubShapeIndices()[0]
*/
void SetNodeOnVertex(CORBA::Long NodeID, CORBA::Long VertexID)
- throw (SALOME::SALOME_Exception);
+ ;
/*!
* \brief Store node position on an edge
* \param NodeID - node ID
*/
void SetNodeOnEdge(CORBA::Long NodeID, CORBA::Long EdgeID,
CORBA::Double paramOnEdge)
- throw (SALOME::SALOME_Exception);
+ ;
/*!
* \brief Store node position on a face
* \param NodeID - node ID
*/
void SetNodeOnFace(CORBA::Long NodeID, CORBA::Long FaceID,
CORBA::Double u, CORBA::Double v)
- throw (SALOME::SALOME_Exception);
+ ;
/*!
* \brief Bind a node to a solid
* \param NodeID - node ID
* \param SolidID - vertex ID available through GEOM_Object.GetSubShapeIndices()[0]
*/
void SetNodeInVolume(CORBA::Long NodeID, CORBA::Long SolidID)
- throw (SALOME::SALOME_Exception);
+ ;
/*!
* \brief Bind an element to a shape
* \param ElementID - element ID
* \param ShapeID - shape ID available through GEOM_Object.GetSubShapeIndices()[0]
*/
void SetMeshElementOnShape(CORBA::Long ElementID, CORBA::Long ShapeID)
- throw (SALOME::SALOME_Exception);
+ ;
CORBA::Boolean MoveNode(CORBA::Long NodeID,
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);
+ ;
/*!
* \brief Reorient faces contained in \a the2Dgroup.
CORBA::Long Reorient2D(SMESH::SMESH_IDSource_ptr the2Dgroup,
const SMESH::DirStruct& theDirection,
CORBA::Long theFace,
- const SMESH::PointStruct& thePoint) throw (SALOME::SALOME_Exception);
+ const SMESH::PointStruct& thePoint) ;
/*!
* \brief Reorient faces basing on orientation of adjacent volumes.
* \param faces - a list of objects containing face to reorient
CORBA::Long Reorient2DBy3D(const SMESH::ListOfIDSources & faces,
SMESH::SMESH_IDSource_ptr volumes,
CORBA::Boolean outsideNormal)
- throw (SALOME::SALOME_Exception);
+ ;
// Split/Join
CORBA::Boolean TriToQuad (const SMESH::long_array & IDsOfElements,
SMESH::NumericalFunctor_ptr Criterion,
CORBA::Double MaxAngle)
- throw (SALOME::SALOME_Exception);
+ ;
CORBA::Boolean TriToQuadObject (SMESH::SMESH_IDSource_ptr theObject,
SMESH::NumericalFunctor_ptr Criterion,
CORBA::Double MaxAngle)
- throw (SALOME::SALOME_Exception);
+ ;
CORBA::Boolean QuadToTri (const SMESH::long_array & IDsOfElements,
SMESH::NumericalFunctor_ptr Criterion)
- throw (SALOME::SALOME_Exception);
+ ;
CORBA::Boolean QuadToTriObject (SMESH::SMESH_IDSource_ptr theObject,
SMESH::NumericalFunctor_ptr Criterion)
- throw (SALOME::SALOME_Exception);
+ ;
void QuadTo4Tri (SMESH::SMESH_IDSource_ptr theObject)
- throw (SALOME::SALOME_Exception);
+ ;
CORBA::Boolean SplitQuad (const SMESH::long_array & IDsOfElements,
CORBA::Boolean Diag13)
- throw (SALOME::SALOME_Exception);
+ ;
CORBA::Boolean SplitQuadObject (SMESH::SMESH_IDSource_ptr theObject,
CORBA::Boolean Diag13)
- throw (SALOME::SALOME_Exception);
+ ;
CORBA::Long BestSplit (CORBA::Long IDOfQuad,
SMESH::NumericalFunctor_ptr Criterion)
- throw (SALOME::SALOME_Exception);
+ ;
void SplitVolumesIntoTetra(SMESH::SMESH_IDSource_ptr elems,
CORBA::Short methodFlags)
- throw (SALOME::SALOME_Exception);
+ ;
void SplitHexahedraIntoPrisms(SMESH::SMESH_IDSource_ptr elems,
const SMESH::PointStruct & startHexPoint,
const SMESH::DirStruct& facetToSplitNormal,
CORBA::Short methodFlags,
CORBA::Boolean allDomains)
- throw (SALOME::SALOME_Exception);
+ ;
void SplitBiQuadraticIntoLinear(const SMESH::ListOfIDSources& elems)
- 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)
- 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)
- 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)
- 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)
- 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)
- 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)
- throw (SALOME::SALOME_Exception);
+ ;
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 ConvertToBiQuadratic(CORBA::Boolean theForce3d,
SMESH::SMESH_IDSource_ptr theObject)
- throw (SALOME::SALOME_Exception);
+ ;
- void RenumberNodes() throw (SALOME::SALOME_Exception);
- void RenumberElements() throw (SALOME::SALOME_Exception);
+ void RenumberNodes() ;
+ void RenumberElements() ;
SMESH::ListOfGroups* RotationSweepObjects(const SMESH::ListOfIDSources & Nodes,
const SMESH::ListOfIDSources & Edges,
CORBA::Long NbOfSteps,
CORBA::Double Tolerance,
CORBA::Boolean ToMakeGroups)
- throw (SALOME::SALOME_Exception);
+ ;
SMESH::ListOfGroups* ExtrusionSweepObjects(const SMESH::ListOfIDSources & Nodes,
const SMESH::ListOfIDSources & Edges,
const SMESH::double_array & BasePoint,
const SMESH::double_array & Angles,
CORBA::Boolean AnglesVariation)
- throw (SALOME::SALOME_Exception);
+ ;
SMESH::ListOfGroups* ExtrusionByNormal(const SMESH::ListOfIDSources& objects,
CORBA::Double stepSize,
CORBA::Boolean useInputElemsOnly,
CORBA::Boolean makeGroups,
CORBA::Short dim)
- 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,
CORBA::Boolean theMakeGroups)
- throw (SALOME::SALOME_Exception);
+ ;
SMESH::ListOfGroups*
ExtrusionAlongPathObjects(const SMESH::ListOfIDSources & Nodes,
const SMESH::double_array & ScaleFactors,
CORBA::Boolean ScalesVariation,
SMESH::SMESH_MeshEditor::Extrusion_Error& Error)
- throw (SALOME::SALOME_Exception);
+ ;
SMESH::double_array* LinearAnglesVariation(SMESH::SMESH_Mesh_ptr PathMesh,
GEOM::GEOM_Object_ptr PathShape,
const SMESH::AxisStruct & Axis,
SMESH::SMESH_MeshEditor::MirrorType MirrorType,
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)
- throw (SALOME::SALOME_Exception);
+ ;
void Translate(const SMESH::long_array & IDsOfElements,
const SMESH::DirStruct & Vector,
CORBA::Boolean Copy)
- throw (SALOME::SALOME_Exception);
+ ;
void TranslateObject(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::DirStruct & Vector,
CORBA::Boolean Copy)
- throw (SALOME::SALOME_Exception);
+ ;
void Rotate(const SMESH::long_array & IDsOfElements,
const SMESH::AxisStruct & Axis,
CORBA::Double Angle,
CORBA::Boolean Copy)
- throw (SALOME::SALOME_Exception);
+ ;
void RotateObject(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::AxisStruct & Axis,
CORBA::Double Angle,
CORBA::Boolean Copy)
- throw (SALOME::SALOME_Exception);
+ ;
SMESH::ListOfGroups* MirrorMakeGroups(const SMESH::long_array& IDsOfElements,
const SMESH::AxisStruct& Mirror,
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)
- throw (SALOME::SALOME_Exception);
+ ;
SMESH::ListOfGroups* TranslateMakeGroups(const SMESH::long_array& IDsOfElements,
const SMESH::DirStruct& Vector)
- throw (SALOME::SALOME_Exception);
+ ;
SMESH::ListOfGroups* TranslateObjectMakeGroups(SMESH::SMESH_IDSource_ptr Object,
const SMESH::DirStruct& Vector)
- throw (SALOME::SALOME_Exception);
+ ;
SMESH::ListOfGroups* RotateMakeGroups(const SMESH::long_array& IDsOfElements,
const SMESH::AxisStruct& Axis,
CORBA::Double AngleInRadians)
- throw (SALOME::SALOME_Exception);
+ ;
SMESH::ListOfGroups* RotateObjectMakeGroups(SMESH::SMESH_IDSource_ptr Object,
const SMESH::AxisStruct& Axis,
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)
- 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)
- throw (SALOME::SALOME_Exception);
+ ;
SMESH::SMESH_Mesh_ptr TranslateMakeMesh(const SMESH::long_array& IDsOfElements,
const SMESH::DirStruct& Vector,
CORBA::Boolean CopyGroups,
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)
- 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)
- 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)
- throw (SALOME::SALOME_Exception);
+ ;
void Scale(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::PointStruct& thePoint,
const SMESH::double_array& theScaleFact,
CORBA::Boolean theCopy)
- throw (SALOME::SALOME_Exception);
+ ;
SMESH::ListOfGroups* ScaleMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::PointStruct& thePoint,
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)
- throw (SALOME::SALOME_Exception);
+ ;
SMESH::SMESH_Mesh_ptr Offset( SMESH::SMESH_IDSource_ptr theObject,
CORBA::Double Value,
CORBA::Boolean CopyElements,
const char* MeshName,
SMESH::ListOfGroups_out Groups)
- throw (SALOME::SALOME_Exception);
+ ;
void FindCoincidentNodes (CORBA::Double Tolerance,
SMESH::array_of_long_array_out GroupsOfNodes,
CORBA::Boolean SeparateCornersAndMedium)
- throw (SALOME::SALOME_Exception);
+ ;
void FindCoincidentNodesOnPart(SMESH::SMESH_IDSource_ptr Object,
CORBA::Double Tolerance,
SMESH::array_of_long_array_out GroupsOfNodes,
CORBA::Boolean SeparateCornersAndMedium)
- throw (SALOME::SALOME_Exception);
+ ;
void FindCoincidentNodesOnPartBut(const SMESH::ListOfIDSources& Objects,
CORBA::Double Tolerance,
SMESH::array_of_long_array_out GroupsOfNodes,
const SMESH::ListOfIDSources& ExceptSubMeshOrGroups,
CORBA::Boolean SeparateCornersAndMedium)
- throw (SALOME::SALOME_Exception);
+ ;
void MergeNodes (const SMESH::array_of_long_array& GroupsOfNodes,
const SMESH::ListOfIDSources& NodesToKeep,
CORBA::Boolean AvoidMakingHoles )
- throw (SALOME::SALOME_Exception);
+ ;
void FindEqualElements(const SMESH::ListOfIDSources& Objects,
const SMESH::ListOfIDSources& ExceptSubMeshOrGroups,
SMESH::array_of_long_array_out GroupsOfElementsID)
- throw (SALOME::SALOME_Exception);
+ ;
void MergeElements(const SMESH::array_of_long_array& GroupsOfElementsID,
const SMESH::ListOfIDSources& ElementsToKeep)
- 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)
- 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)
- 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
CORBA::Double y,
CORBA::Double z,
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 y,
CORBA::Double z,
SMESH::ElementType type)
- throw (SALOME::SALOME_Exception);
+ ;
/*!
* Project a point to a mesh object.
SMESH::ElementType type,
SMESH::SMESH_IDSource_ptr meshObject,
SMESH::double_array_out projecton)
- 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)
- throw (SALOME::SALOME_Exception);
+ ;
/*!
* Check if a 2D mesh is manifold
*/
CORBA::Boolean IsManifold()
- throw (SALOME::SALOME_Exception);
+ ;
/*!
* Check if orientation of 2D elements is coherent
*/
CORBA::Boolean IsCoherentOrientation2D()
- throw (SALOME::SALOME_Exception);
+ ;
/*!
* Partition given 1D elements into groups of contiguous edges.
SMESH::array_of_long_array* Get1DBranches( SMESH::SMESH_IDSource_ptr edges,
CORBA::Long startNode,
SMESH::array_of_long_array_out nodeGroups)
- throw (SALOME::SALOME_Exception);
+ ;
/*!
* Return sharp edges of faces and non-manifold ones. Optionally adds existing edges.
*/
SMESH::ListOfEdges* FindSharpEdges(CORBA::Double angle, CORBA::Boolean addExisting)
- throw (SALOME::SALOME_Exception);
+ ;
/*!
* Returns all or only closed FreeBorder's.
*/
SMESH::ListOfFreeBorders* FindFreeBorders(CORBA::Boolean closedOnly)
- throw (SALOME::SALOME_Exception);
+ ;
/*!
* Fill with 2D elements a hole defined by a FreeBorder.
*/
SMESH::SMESH_Group_ptr FillHole(const SMESH::FreeBorder& hole,
const char* groupName)
- throw (SALOME::SALOME_Exception);
+ ;
SMESH::CoincidentFreeBorders* FindCoincidentFreeBorders(CORBA::Double tolerance);
CORBA::Short SewCoincidentFreeBorders(const SMESH::CoincidentFreeBorders& freeBorders,
CORBA::Boolean createPolygons,
CORBA::Boolean createPolyedrs)
- 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) throw (SALOME::SALOME_Exception);
+ CORBA::Boolean CreatePolyedrs) ;
SMESH::SMESH_MeshEditor::Sew_Error
SewConformFreeBorders(CORBA::Long FirstNodeID1,
CORBA::Long SecondNodeID1,
CORBA::Long LastNodeID1,
CORBA::Long FirstNodeID2,
- CORBA::Long SecondNodeID2) throw (SALOME::SALOME_Exception);
+ CORBA::Long SecondNodeID2) ;
SMESH::SMESH_MeshEditor::Sew_Error
SewBorderToSide(CORBA::Long FirstNodeIDOnFreeBorder,
CORBA::Long SecondNodeIDOnFreeBorder,
CORBA::Long FirstNodeIDOnSide,
CORBA::Long LastNodeIDOnSide,
CORBA::Boolean CreatePolygons,
- CORBA::Boolean CreatePolyedrs) throw (SALOME::SALOME_Exception);
+ CORBA::Boolean CreatePolyedrs) ;
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) throw (SALOME::SALOME_Exception);
+ CORBA::Long NodeID2OfSide2ToMerge) ;
/*!
* Set new nodes for given element.
* element - returns false
*/
CORBA::Boolean ChangeElemNodes(CORBA::Long ide, const SMESH::long_array& newIDs)
- throw (SALOME::SALOME_Exception);
+ ;
SMESH::SMESH_Group_ptr DoubleElements(SMESH::SMESH_IDSource_ptr theElements,
const char* theGroupName)
- throw (SALOME::SALOME_Exception);
+ ;
CORBA::Boolean DoubleNodes( const SMESH::long_array& theNodes,
const SMESH::long_array& theModifiedElems )
- throw (SALOME::SALOME_Exception);
+ ;
CORBA::Boolean DoubleNode( CORBA::Long theNodeId,
const SMESH::long_array& theModifiedElems )
- throw (SALOME::SALOME_Exception);
+ ;
CORBA::Boolean DoubleNodeGroup( SMESH::SMESH_GroupBase_ptr theNodes,
SMESH::SMESH_GroupBase_ptr theModifiedElems )
- throw (SALOME::SALOME_Exception);
+ ;
/*!
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements.
*/
SMESH::SMESH_Group_ptr DoubleNodeGroupNew( SMESH::SMESH_GroupBase_ptr theNodes,
SMESH::SMESH_GroupBase_ptr theModifiedElems )
- throw (SALOME::SALOME_Exception);
+ ;
CORBA::Boolean DoubleNodeGroups( const SMESH::ListOfGroups& theNodes,
const SMESH::ListOfGroups& theModifiedElems )
- throw (SALOME::SALOME_Exception);
+ ;
SMESH::SMESH_Group_ptr DoubleNodeGroupsNew( const SMESH::ListOfGroups& theNodes,
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 )
- 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 )
- 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 )
- 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 )
- 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)
- 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 )
- 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 )
- 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 )
- 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)
- 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 )
- 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 )
- throw (SALOME::SALOME_Exception);
+ ;
/*!
* \brief Double nodes on shared faces between groups of volumes and create flat elements on demand.
CORBA::Boolean DoubleNodesOnGroupBoundaries( const SMESH::ListOfGroups& theDomains,
CORBA::Boolean createJointElems,
CORBA::Boolean onAllBoundaries )
- throw (SALOME::SALOME_Exception);
+ ;
/*!
* \brief Double nodes on some external faces and create flat elements.
* Flat elements are mainly used by some types of mechanic calculations.
* @return TRUE if operation has been completed successfully, FALSE otherwise
*/
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
const char* groupName,
const SMESH::double_array& theNodesCoords,
SMESH::array_of_long_array_out GroupsOfNodes)
- throw (SALOME::SALOME_Exception);
+ ;
/*!
* \brief Generated skin mesh (containing 2D cells) from 3D mesh
* \return TRUE if operation has been completed successfully, FALSE otherwise
*/
CORBA::Boolean Make2DMeshFrom3D()
- throw (SALOME::SALOME_Exception);
+ ;
SMESH::SMESH_Mesh_ptr MakeBoundaryMesh(SMESH::SMESH_IDSource_ptr elements,
SMESH::Bnd_Dimension dimension,
CORBA::Boolean toCopyElements,
CORBA::Boolean toCopyMissingBondary,
SMESH::SMESH_Group_out group)
- throw (SALOME::SALOME_Exception);
+ ;
CORBA::Long MakeBoundaryElements(SMESH::Bnd_Dimension dimension,
const char* groupName,
const SMESH::ListOfIDSources& groups,
SMESH::SMESH_Mesh_out mesh,
SMESH::SMESH_Group_out group)
- throw (SALOME::SALOME_Exception);
+ ;
/*!
* \brief Create a polyline consisting of 1D mesh elements each lying on a 2D element of
*/
void MakePolyLine(SMESH::ListOfPolySegments& segments,
const char* groupName)
- throw (SALOME::SALOME_Exception);
+ ;
/*!
* \brief Create a slot of given width around given 1D elements lying on a triangle mesh.
*/
SMESH::ListOfEdges* MakeSlot(SMESH::SMESH_GroupBase_ptr segments,
CORBA::Double width)
- throw (SALOME::SALOME_Exception);
+ ;
private: //!< private methods
* \brief Return groups by their IDs
*/
SMESH::ListOfGroups* getGroups(const std::list<int>* groupIDs)
- throw (SALOME::SALOME_Exception);
+ ;
SMESH::ListOfGroups* mirror(TIDSortedElemSet & IDsOfElements,
const SMESH::AxisStruct & Axis,
CORBA::Boolean Copy,
bool MakeGroups,
::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)
- 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)
- throw (SALOME::SALOME_Exception);
+ ;
SMESH::ListOfGroups* scale(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::PointStruct& thePoint,
CORBA::Boolean theCopy,
bool theMakeGroups,
::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 SMESH_Mesh_i::SetShape( GEOM::GEOM_Object_ptr theShapeObject )
- throw (SALOME::SALOME_Exception)
+
{
Unexpect aCatch(SALOME_SalomeException);
try {
//================================================================================
CORBA::Boolean SMESH_Mesh_i::HasShapeToMesh()
- throw (SALOME::SALOME_Exception)
+
{
Unexpect aCatch(SALOME_SalomeException);
bool res = false;
//================================================================================
GEOM::GEOM_Object_ptr SMESH_Mesh_i::GetShapeToMesh()
- throw (SALOME::SALOME_Exception)
+
{
Unexpect aCatch(SALOME_SalomeException);
GEOM::GEOM_Object_var aShapeObj;
*/
//================================================================================
-CORBA::Boolean SMESH_Mesh_i::IsLoaded() throw (SALOME::SALOME_Exception)
+CORBA::Boolean SMESH_Mesh_i::IsLoaded()
{
Unexpect aCatch(SALOME_SalomeException);
return !_preMeshInfo;
*/
//================================================================================
-void SMESH_Mesh_i::Load() throw (SALOME::SALOME_Exception)
+void SMESH_Mesh_i::Load()
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
*/
//================================================================================
-void SMESH_Mesh_i::Clear() throw (SALOME::SALOME_Exception)
+void SMESH_Mesh_i::Clear()
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
//================================================================================
void SMESH_Mesh_i::ClearSubMesh(CORBA::Long ShapeID)
- throw (SALOME::SALOME_Exception)
+
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
SMESH::DriverMED_ReadStatus
SMESH_Mesh_i::ImportMEDFile( const char* theFileName, const char* theMeshName )
- throw ( SALOME::SALOME_Exception )
{
Unexpect aCatch(SALOME_SalomeException);
int status;
SMESH::DriverMED_ReadStatus SMESH_Mesh_i::ImportCGNSFile( const char* theFileName,
const int theMeshIndex,
std::string& theMeshName )
- throw ( SALOME::SALOME_Exception )
+
{
Unexpect aCatch(SALOME_SalomeException);
int status;
//=============================================================================
int SMESH_Mesh_i::ImportUNVFile( const char* theFileName )
- throw ( SALOME::SALOME_Exception )
+
{
SMESH_TRY;
//=============================================================================
int SMESH_Mesh_i::ImportSTLFile( const char* theFileName )
- throw ( SALOME::SALOME_Exception )
+
{
SMESH_TRY;
SMESH::ComputeError* SMESH_Mesh_i::ImportGMFFile( const char* theFileName,
bool theMakeRequiredGroups )
- throw (SALOME::SALOME_Exception)
+
{
SMESH_ComputeErrorPtr error;
SMESH_Mesh_i::AddHypothesis(GEOM::GEOM_Object_ptr aSubShape,
SMESH::SMESH_Hypothesis_ptr anHyp,
CORBA::String_out anErrorText)
- throw(SALOME::SALOME_Exception)
+
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
SMESH::Hypothesis_Status SMESH_Mesh_i::RemoveHypothesis(GEOM::GEOM_Object_ptr aSubShape,
SMESH::SMESH_Hypothesis_ptr anHyp)
- throw(SALOME::SALOME_Exception)
+
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
SMESH::ListOfHypothesis *
SMESH_Mesh_i::GetHypothesisList(GEOM::GEOM_Object_ptr aSubShape)
-throw(SALOME::SALOME_Exception)
+
{
Unexpect aCatch(SALOME_SalomeException);
if (MYDEBUG) MESSAGE("GetHypothesisList");
*/
//================================================================================
-SMESH::submesh_array* SMESH_Mesh_i::GetSubMeshes() throw (SALOME::SALOME_Exception)
+SMESH::submesh_array* SMESH_Mesh_i::GetSubMeshes()
{
Unexpect aCatch(SALOME_SalomeException);
if (MYDEBUG) MESSAGE("GetSubMeshes");
SMESH::SMESH_subMesh_ptr SMESH_Mesh_i::GetSubMesh(GEOM::GEOM_Object_ptr aSubShape,
const char* theName )
- throw(SALOME::SALOME_Exception)
+
{
Unexpect aCatch(SALOME_SalomeException);
if (CORBA::is_nil(aSubShape))
//================================================================================
void SMESH_Mesh_i::RemoveSubMesh( SMESH::SMESH_subMesh_ptr theSubMesh )
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
SMESH::SMESH_Group_ptr SMESH_Mesh_i::CreateGroup( SMESH::ElementType theElemType,
const char* theName )
- throw(SALOME::SALOME_Exception)
+
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
SMESH_Mesh_i::CreateGroupFromGEOM (SMESH::ElementType theElemType,
const char* theName,
GEOM::GEOM_Object_ptr theGeomObj)
- throw(SALOME::SALOME_Exception)
+
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
SMESH_Mesh_i::CreateGroupFromFilter(SMESH::ElementType theElemType,
const char* theName,
SMESH::Filter_ptr theFilter )
- throw (SALOME::SALOME_Exception)
+
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
//================================================================================
void SMESH_Mesh_i::RemoveGroup( SMESH::SMESH_GroupBase_ptr theGroup )
- throw (SALOME::SALOME_Exception)
+
{
if ( theGroup->_is_nil() )
return;
//=============================================================================
void SMESH_Mesh_i::RemoveGroupWithContents( SMESH::SMESH_GroupBase_ptr theGroup )
- throw (SALOME::SALOME_Exception)
+
{
SMESH_TRY;
if ( _preMeshInfo )
*/
//================================================================================
-SMESH::ListOfGroups * SMESH_Mesh_i::GetGroups() throw(SALOME::SALOME_Exception)
+SMESH::ListOfGroups * SMESH_Mesh_i::GetGroups()
{
Unexpect aCatch(SALOME_SalomeException);
if (MYDEBUG) MESSAGE("GetGroups");
*/
//=============================================================================
-CORBA::Long SMESH_Mesh_i::NbGroups() throw (SALOME::SALOME_Exception)
+CORBA::Long SMESH_Mesh_i::NbGroups()
{
Unexpect aCatch(SALOME_SalomeException);
return _mapGroups.size();
SMESH::SMESH_Group_ptr SMESH_Mesh_i::UnionGroups( SMESH::SMESH_GroupBase_ptr theGroup1,
SMESH::SMESH_GroupBase_ptr theGroup2,
const char* theName )
- throw (SALOME::SALOME_Exception)
+
{
SMESH::SMESH_Group_var aResGrp;
SMESH::SMESH_Group_ptr SMESH_Mesh_i::UnionListOfGroups(const SMESH::ListOfGroups& theGroups,
const char* theName )
- throw (SALOME::SALOME_Exception)
+
{
SMESH::SMESH_Group_var aResGrp;
SMESH::SMESH_Group_ptr SMESH_Mesh_i::IntersectGroups( SMESH::SMESH_GroupBase_ptr theGroup1,
SMESH::SMESH_GroupBase_ptr theGroup2,
const char* theName )
- throw (SALOME::SALOME_Exception)
+
{
SMESH::SMESH_Group_var aResGrp;
SMESH::SMESH_Group_ptr
SMESH_Mesh_i::IntersectListOfGroups(const SMESH::ListOfGroups& theGroups,
const char* theName )
- throw (SALOME::SALOME_Exception)
+
{
SMESH::SMESH_Group_var aResGrp;
SMESH::SMESH_Group_ptr SMESH_Mesh_i::CutGroups( SMESH::SMESH_GroupBase_ptr theGroup1,
SMESH::SMESH_GroupBase_ptr theGroup2,
const char* theName )
- throw (SALOME::SALOME_Exception)
+
{
SMESH::SMESH_Group_var aResGrp;
SMESH_Mesh_i::CutListOfGroups(const SMESH::ListOfGroups& theMainGroups,
const SMESH::ListOfGroups& theToolGroups,
const char* theName )
- throw (SALOME::SALOME_Exception)
+
{
SMESH::SMESH_Group_var aResGrp;
const char* theName,
SMESH::NB_COMMON_NODES_ENUM theNbCommonNodes,
CORBA::Boolean theUnderlyingOnly)
- throw (SALOME::SALOME_Exception)
+
{
SMESH::SMESH_Group_var aResGrp;
SMESH_Mesh_i::FaceGroupsSeparatedByEdges( CORBA::Double theSharpAngle,
CORBA::Boolean theCreateEdges,
CORBA::Boolean theUseExistingEdges )
- throw (SALOME::SALOME_Exception)
+
{
if ( theSharpAngle < 0 || theSharpAngle > 180 )
THROW_SALOME_CORBA_EXCEPTION("Invalid sharp angle, it must be between 0 and 180 degrees",
//================================================================================
void SMESH_Mesh_i::ReplaceShape(GEOM::GEOM_Object_ptr theNewGeom)
- throw (SALOME::SALOME_Exception)
+
{
// check if geometry changed
bool geomChanged = true;
//=============================================================================
SMESH::SMESH_Group_ptr SMESH_Mesh_i::ConvertToStandalone( SMESH::SMESH_GroupBase_ptr theGroup )
- throw (SALOME::SALOME_Exception)
+
{
SMESH::SMESH_Group_var aGroup;
//================================================================================
SMESH::log_array * SMESH_Mesh_i::GetLog(CORBA::Boolean clearAfterGet)
- throw(SALOME::SALOME_Exception)
+
{
SMESH::log_array_var aLog;
*/
//================================================================================
-void SMESH_Mesh_i::ClearLog() throw(SALOME::SALOME_Exception)
+void SMESH_Mesh_i::ClearLog()
{
SMESH_TRY;
_impl->ClearLog();
*/
//================================================================================
-CORBA::Long SMESH_Mesh_i::GetId()throw(SALOME::SALOME_Exception)
+CORBA::Long SMESH_Mesh_i::GetId()
{
return _id;
}
//=============================================================================
SMESH::SMESH_MeshEditor_ptr SMESH_Mesh_i::GetMeshEditor()
- throw (SALOME::SALOME_Exception)
+
{
SMESH::SMESH_MeshEditor_var aMeshEdVar;
//=============================================================================
SMESH::SMESH_MeshEditor_ptr SMESH_Mesh_i::GetMeshEditPreviewer()
- throw (SALOME::SALOME_Exception)
+
{
SMESH::SMESH_MeshEditor_var aMeshEdVar;
*/
//================================================================================
-CORBA::Boolean SMESH_Mesh_i::HasModificationsToDiscard() throw(SALOME::SALOME_Exception)
+CORBA::Boolean SMESH_Mesh_i::HasModificationsToDiscard()
{
Unexpect aCatch(SALOME_SalomeException);
return _impl->HasModificationsToDiscard();
*/
//=============================================================================
-void SMESH_Mesh_i::SetAutoColor(CORBA::Boolean theAutoColor) throw(SALOME::SALOME_Exception)
+void SMESH_Mesh_i::SetAutoColor(CORBA::Boolean theAutoColor)
{
Unexpect aCatch(SALOME_SalomeException);
_impl->SetAutoColor(theAutoColor);
*/
//=============================================================================
-CORBA::Boolean SMESH_Mesh_i::GetAutoColor() throw(SALOME::SALOME_Exception)
+CORBA::Boolean SMESH_Mesh_i::GetAutoColor()
{
Unexpect aCatch(SALOME_SalomeException);
return _impl->GetAutoColor();
CORBA::Long version,
CORBA::Boolean overwrite,
CORBA::Boolean autoDimension)
- throw(SALOME::SALOME_Exception)
+
{
//MESSAGE("MED minor version: "<< minor);
SMESH_TRY;
void SMESH_Mesh_i::ExportSAUV (const char* file,
CORBA::Boolean auto_groups)
- throw(SALOME::SALOME_Exception)
+
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
//================================================================================
void SMESH_Mesh_i::ExportDAT (const char *file)
- throw(SALOME::SALOME_Exception)
+
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
//================================================================================
void SMESH_Mesh_i::ExportUNV (const char *file)
- throw(SALOME::SALOME_Exception)
+
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
//================================================================================
void SMESH_Mesh_i::ExportSTL (const char *file, const bool isascii)
- throw(SALOME::SALOME_Exception)
+
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
const GEOM::ListOfFields& fields,
const char* geomAssocFields,
CORBA::Double ZTolerance)
- throw (SALOME::SALOME_Exception)
+
{
MESSAGE("MED version: "<< version);
SMESH_TRY;
void SMESH_Mesh_i::ExportPartToDAT(::SMESH::SMESH_IDSource_ptr meshPart,
const char* file)
- throw (SALOME::SALOME_Exception)
+
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
void SMESH_Mesh_i::ExportPartToUNV(::SMESH::SMESH_IDSource_ptr meshPart,
const char* file)
- throw (SALOME::SALOME_Exception)
+
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
void SMESH_Mesh_i::ExportPartToSTL(::SMESH::SMESH_IDSource_ptr meshPart,
const char* file,
::CORBA::Boolean isascii)
- throw (SALOME::SALOME_Exception)
+
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
const char* file,
CORBA::Boolean overwrite,
CORBA::Boolean groupElemsByType)
- throw (SALOME::SALOME_Exception)
+
{
#ifdef WITH_CGNS
Unexpect aCatch(SALOME_SalomeException);
void SMESH_Mesh_i::ExportGMF(::SMESH::SMESH_IDSource_ptr meshPart,
const char* file,
bool withRequiredGroups)
- throw (SALOME::SALOME_Exception)
+
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
*/
//================================================================================
-CORBA::Long SMESH_Mesh_i::NbNodes()throw(SALOME::SALOME_Exception)
+CORBA::Long SMESH_Mesh_i::NbNodes()
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
*/
//================================================================================
-CORBA::Long SMESH_Mesh_i::NbElements()throw (SALOME::SALOME_Exception)
+CORBA::Long SMESH_Mesh_i::NbElements()
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
*/
//================================================================================
-CORBA::Long SMESH_Mesh_i::Nb0DElements()throw (SALOME::SALOME_Exception)
+CORBA::Long SMESH_Mesh_i::Nb0DElements()
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
*/
//================================================================================
-CORBA::Long SMESH_Mesh_i::NbBalls() throw (SALOME::SALOME_Exception)
+CORBA::Long SMESH_Mesh_i::NbBalls()
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
*/
//================================================================================
-CORBA::Long SMESH_Mesh_i::NbEdges()throw(SALOME::SALOME_Exception)
+CORBA::Long SMESH_Mesh_i::NbEdges()
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
//================================================================================
CORBA::Long SMESH_Mesh_i::NbEdgesOfOrder(SMESH::ElementOrder order)
- throw(SALOME::SALOME_Exception)
+
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
*/
//================================================================================
-CORBA::Long SMESH_Mesh_i::NbFaces()throw(SALOME::SALOME_Exception)
+CORBA::Long SMESH_Mesh_i::NbFaces()
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
*/
//================================================================================
-CORBA::Long SMESH_Mesh_i::NbTriangles()throw(SALOME::SALOME_Exception)
+CORBA::Long SMESH_Mesh_i::NbTriangles()
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
*/
//================================================================================
-CORBA::Long SMESH_Mesh_i::NbBiQuadTriangles()throw(SALOME::SALOME_Exception)
+CORBA::Long SMESH_Mesh_i::NbBiQuadTriangles()
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
return _impl->NbBiQuadTriangles();
}
-CORBA::Long SMESH_Mesh_i::NbQuadrangles()throw(SALOME::SALOME_Exception)
+CORBA::Long SMESH_Mesh_i::NbQuadrangles()
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
return _impl->NbQuadrangles();
}
-CORBA::Long SMESH_Mesh_i::NbBiQuadQuadrangles()throw(SALOME::SALOME_Exception)
+CORBA::Long SMESH_Mesh_i::NbBiQuadQuadrangles()
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
return _impl->NbBiQuadQuadrangles();
}
-CORBA::Long SMESH_Mesh_i::NbPolygons() throw(SALOME::SALOME_Exception)
+CORBA::Long SMESH_Mesh_i::NbPolygons()
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
return _impl->NbPolygons();
}
-CORBA::Long SMESH_Mesh_i::NbPolygonsOfOrder(SMESH::ElementOrder order) throw(SALOME::SALOME_Exception)
+CORBA::Long SMESH_Mesh_i::NbPolygonsOfOrder(SMESH::ElementOrder order)
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
}
CORBA::Long SMESH_Mesh_i::NbFacesOfOrder(SMESH::ElementOrder order)
- throw(SALOME::SALOME_Exception)
+
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
}
CORBA::Long SMESH_Mesh_i::NbTrianglesOfOrder(SMESH::ElementOrder order)
- throw(SALOME::SALOME_Exception)
+
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
}
CORBA::Long SMESH_Mesh_i::NbQuadranglesOfOrder(SMESH::ElementOrder order)
- throw(SALOME::SALOME_Exception)
+
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
//=============================================================================
-CORBA::Long SMESH_Mesh_i::NbVolumes()throw(SALOME::SALOME_Exception)
+CORBA::Long SMESH_Mesh_i::NbVolumes()
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
return _impl->NbVolumes();
}
-CORBA::Long SMESH_Mesh_i::NbTetras()throw(SALOME::SALOME_Exception)
+CORBA::Long SMESH_Mesh_i::NbTetras()
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
return _impl->NbTetras();
}
-CORBA::Long SMESH_Mesh_i::NbHexas()throw(SALOME::SALOME_Exception)
+CORBA::Long SMESH_Mesh_i::NbHexas()
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
return _impl->NbHexas();
}
-CORBA::Long SMESH_Mesh_i::NbTriQuadraticHexas()throw(SALOME::SALOME_Exception)
+CORBA::Long SMESH_Mesh_i::NbTriQuadraticHexas()
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
return _impl->NbTriQuadraticHexas();
}
-CORBA::Long SMESH_Mesh_i::NbPyramids()throw(SALOME::SALOME_Exception)
+CORBA::Long SMESH_Mesh_i::NbPyramids()
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
return _impl->NbPyramids();
}
-CORBA::Long SMESH_Mesh_i::NbPrisms()throw(SALOME::SALOME_Exception)
+CORBA::Long SMESH_Mesh_i::NbPrisms()
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
return _impl->NbPrisms();
}
-CORBA::Long SMESH_Mesh_i::NbHexagonalPrisms()throw(SALOME::SALOME_Exception)
+CORBA::Long SMESH_Mesh_i::NbHexagonalPrisms()
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
return _impl->NbHexagonalPrisms();
}
-CORBA::Long SMESH_Mesh_i::NbPolyhedrons()throw(SALOME::SALOME_Exception)
+CORBA::Long SMESH_Mesh_i::NbPolyhedrons()
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
}
CORBA::Long SMESH_Mesh_i::NbVolumesOfOrder(SMESH::ElementOrder order)
- throw(SALOME::SALOME_Exception)
+
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
}
CORBA::Long SMESH_Mesh_i::NbTetrasOfOrder(SMESH::ElementOrder order)
- throw(SALOME::SALOME_Exception)
+
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
}
CORBA::Long SMESH_Mesh_i::NbHexasOfOrder(SMESH::ElementOrder order)
- throw(SALOME::SALOME_Exception)
+
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
}
CORBA::Long SMESH_Mesh_i::NbPyramidsOfOrder(SMESH::ElementOrder order)
- throw(SALOME::SALOME_Exception)
+
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
}
CORBA::Long SMESH_Mesh_i::NbPrismsOfOrder(SMESH::ElementOrder order)
- throw(SALOME::SALOME_Exception)
+
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
*/
//=============================================================================
-CORBA::Long SMESH_Mesh_i::NbSubMesh()throw(SALOME::SALOME_Exception)
+CORBA::Long SMESH_Mesh_i::NbSubMesh()
{
Unexpect aCatch(SALOME_SalomeException);
return _mapSubMesh_i.size();
//=============================================================================
SMESH::long_array* SMESH_Mesh_i::GetElementsId()
- throw (SALOME::SALOME_Exception)
+
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
//=============================================================================
SMESH::long_array* SMESH_Mesh_i::GetElementsByType( SMESH::ElementType theElemType )
- throw (SALOME::SALOME_Exception)
+
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
//=============================================================================
SMESH::long_array* SMESH_Mesh_i::GetNodesId()
- throw (SALOME::SALOME_Exception)
+
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
//=============================================================================
SMESH::ElementType SMESH_Mesh_i::GetElementType( const CORBA::Long id, const bool iselem )
- throw (SALOME::SALOME_Exception)
+
{
SMESH::ElementType type = SMESH::ALL;
SMESH_TRY;
//=============================================================================
SMESH::EntityType SMESH_Mesh_i::GetElementGeomType( const CORBA::Long id )
- throw (SALOME::SALOME_Exception)
+
{
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
//=============================================================================
SMESH::GeometryType SMESH_Mesh_i::GetElementShape( const CORBA::Long id )
- throw (SALOME::SALOME_Exception)
+
{
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
//=============================================================================
SMESH::long_array* SMESH_Mesh_i::GetSubMeshElementsId(const CORBA::Long ShapeID)
- throw (SALOME::SALOME_Exception)
+
{
SMESH::long_array_var aResult = new SMESH::long_array();
SMESH::long_array* SMESH_Mesh_i::GetSubMeshNodesId(const CORBA::Long ShapeID,
CORBA::Boolean all)
- throw (SALOME::SALOME_Exception)
+
{
SMESH::long_array_var aResult = new SMESH::long_array();
//=============================================================================
SMESH::ElementType SMESH_Mesh_i::GetSubMeshElementType(const CORBA::Long ShapeID)
- throw (SALOME::SALOME_Exception)
+
{
SMESH::ElementType type = SMESH::ALL;
SMESH::ListOfGroups*
SMESH_Mesh_i::MakeGroupsOfBadInputElements( int theSubShapeID,
const char* theGroupName )
- throw ( SALOME::SALOME_Exception )
+
{
Unexpect aCatch(SALOME_SalomeException);
// --- CORBA
void SetShape( GEOM::GEOM_Object_ptr theShapeObject )
- throw (SALOME::SALOME_Exception);
+ ;
CORBA::Boolean HasShapeToMesh()
- throw (SALOME::SALOME_Exception);
+ ;
GEOM::GEOM_Object_ptr GetShapeToMesh()
- throw (SALOME::SALOME_Exception);
+ ;
virtual void ReplaceShape(GEOM::GEOM_Object_ptr theNewGeom)
- throw (SALOME::SALOME_Exception);
+ ;
CORBA::Boolean IsLoaded()
- throw (SALOME::SALOME_Exception);
+ ;
void Load()
- throw (SALOME::SALOME_Exception);
+ ;
void Clear()
- throw (SALOME::SALOME_Exception);
+ ;
void ClearSubMesh(CORBA::Long ShapeID)
- throw (SALOME::SALOME_Exception);
+ ;
SMESH::Hypothesis_Status AddHypothesis(GEOM::GEOM_Object_ptr aSubShape,
SMESH::SMESH_Hypothesis_ptr anHyp,
CORBA::String_out anErrorText)
- throw (SALOME::SALOME_Exception);
+ ;
SMESH::Hypothesis_Status RemoveHypothesis(GEOM::GEOM_Object_ptr aSubShape,
SMESH::SMESH_Hypothesis_ptr anHyp)
- throw (SALOME::SALOME_Exception);
+ ;
SMESH::ListOfHypothesis* GetHypothesisList(GEOM::GEOM_Object_ptr aSubShape)
- throw (SALOME::SALOME_Exception);
+ ;
SMESH::submesh_array* GetSubMeshes()
- throw (SALOME::SALOME_Exception);
+ ;
SMESH::SMESH_subMesh_ptr GetSubMesh(GEOM::GEOM_Object_ptr aSubShape, const char* theName)
- throw (SALOME::SALOME_Exception);
+ ;
void RemoveSubMesh( SMESH::SMESH_subMesh_ptr theSubMesh )
- throw (SALOME::SALOME_Exception);
+ ;
SMESH::SMESH_Group_ptr CreateGroup( SMESH::ElementType theElemType, const char* theName )
- throw (SALOME::SALOME_Exception);
+ ;
SMESH::SMESH_GroupOnGeom_ptr CreateGroupFromGEOM(SMESH::ElementType theElemType,
const char* theName,
GEOM::GEOM_Object_ptr theGeomObj )
- throw (SALOME::SALOME_Exception);
+ ;
SMESH::SMESH_GroupOnFilter_ptr CreateGroupFromFilter(SMESH::ElementType theElemType,
const char* theName,
SMESH::Filter_ptr theFilter )
- throw (SALOME::SALOME_Exception);
+ ;
void RemoveGroup( SMESH::SMESH_GroupBase_ptr theGroup )
- throw (SALOME::SALOME_Exception);
+ ;
void RemoveGroupWithContents( SMESH::SMESH_GroupBase_ptr theGroup )
- throw (SALOME::SALOME_Exception);
+ ;
SMESH::ListOfGroups* GetGroups()
- throw (SALOME::SALOME_Exception);
+ ;
CORBA::Long NbGroups()
- throw (SALOME::SALOME_Exception);
+ ;
SMESH::SMESH_Group_ptr UnionGroups( SMESH::SMESH_GroupBase_ptr theGroup1,
SMESH::SMESH_GroupBase_ptr theGroup2,
const char* theName )
- throw (SALOME::SALOME_Exception);
+ ;
SMESH::SMESH_Group_ptr UnionListOfGroups( const SMESH::ListOfGroups& theGroups,
const char* theName)
- throw (SALOME::SALOME_Exception);
+ ;
SMESH::SMESH_Group_ptr IntersectGroups( SMESH::SMESH_GroupBase_ptr theGroup1,
SMESH::SMESH_GroupBase_ptr theGroup2,
const char* theName )
- throw (SALOME::SALOME_Exception);
+ ;
SMESH::SMESH_Group_ptr IntersectListOfGroups( const SMESH::ListOfGroups& theGroups,
const char* theName )
- throw (SALOME::SALOME_Exception);
+ ;
SMESH::SMESH_Group_ptr CutGroups( SMESH::SMESH_GroupBase_ptr theGroup1,
SMESH::SMESH_GroupBase_ptr theGroup2,
const char* theName )
- throw (SALOME::SALOME_Exception);
+ ;
SMESH::SMESH_Group_ptr CutListOfGroups( const SMESH::ListOfGroups& theMainGroups,
const SMESH::ListOfGroups& theToolGroups,
const char* theName )
- throw (SALOME::SALOME_Exception);
+ ;
SMESH::SMESH_Group_ptr CreateDimGroup( const SMESH::ListOfIDSources& theGroups,
SMESH::ElementType theElemType,
const char* theName,
SMESH::NB_COMMON_NODES_ENUM theNbCommonNodes,
CORBA::Boolean theUnderlyingOnly )
- throw (SALOME::SALOME_Exception);
+ ;
SMESH::ListOfGroups* FaceGroupsSeparatedByEdges( CORBA::Double theSharpAngle,
CORBA::Boolean theCreateEdges,
CORBA::Boolean theUseExistingEdges )
- throw (SALOME::SALOME_Exception);
+ ;
SMESH::SMESH_Group_ptr ConvertToStandalone( SMESH::SMESH_GroupBase_ptr theGroupOn )
- throw (SALOME::SALOME_Exception);
+ ;
SMESH::log_array* GetLog(CORBA::Boolean clearAfterGet)
- throw (SALOME::SALOME_Exception);
+ ;
- SMESH::SMESH_MeshEditor_ptr GetMeshEditor() throw (SALOME::SALOME_Exception);
+ SMESH::SMESH_MeshEditor_ptr GetMeshEditor() ;
- SMESH::SMESH_MeshEditor_ptr GetMeshEditPreviewer() throw (SALOME::SALOME_Exception);
+ SMESH::SMESH_MeshEditor_ptr GetMeshEditPreviewer() ;
- CORBA::Boolean HasModificationsToDiscard() throw (SALOME::SALOME_Exception);
+ CORBA::Boolean HasModificationsToDiscard() ;
- void ClearLog() throw (SALOME::SALOME_Exception);
+ void ClearLog() ;
- CORBA::Long GetId() throw (SALOME::SALOME_Exception);
+ CORBA::Long GetId() ;
// --- C++ interface
SMESH_Gen_i* GetGen() { return _gen_i; }
int ImportUNVFile( const char* theFileName )
- throw (SALOME::SALOME_Exception);
+ ;
int ImportSTLFile( const char* theFileName )
- throw (SALOME::SALOME_Exception);
+ ;
SMESH::ComputeError* ImportGMFFile( const char* theFileName,
bool theMakeRequiredGroups)
- throw (SALOME::SALOME_Exception);
+ ;
/*!
* consult DriverMED_R_SMESHDS_Mesh::ReadStatus for returned value
*/
SMESH::DriverMED_ReadStatus ImportMEDFile( const char* theFileName, const char* theMeshName )
- throw (SALOME::SALOME_Exception);
+ ;
SMESH::DriverMED_ReadStatus ImportCGNSFile( const char* theFileName,
const int theMeshIndex,
std::string& theMeshName)
- throw (SALOME::SALOME_Exception);
+ ;
/*!
* Auto color
*/
void SetAutoColor(CORBA::Boolean theAutoColor)
- throw (SALOME::SALOME_Exception);
+ ;
CORBA::Boolean GetAutoColor()
- throw (SALOME::SALOME_Exception);
+ ;
/*! Check group names for duplications.
* Consider maximum group name length stored in MED file.
CORBA::Boolean auto_groups,
CORBA::Long version,
CORBA::Boolean overwrite,
- CORBA::Boolean autoDimension = true) throw (SALOME::SALOME_Exception);
+ CORBA::Boolean autoDimension = true) ;
- void ExportSAUV( const char* file, CORBA::Boolean auto_groups ) throw (SALOME::SALOME_Exception);
+ void ExportSAUV( const char* file, CORBA::Boolean auto_groups ) ;
- void ExportDAT( const char* file ) throw (SALOME::SALOME_Exception);
- void ExportUNV( const char* file ) throw (SALOME::SALOME_Exception);
- void ExportSTL( const char* file, bool isascii ) throw (SALOME::SALOME_Exception);
+ void ExportDAT( const char* file ) ;
+ void ExportUNV( const char* file ) ;
+ void ExportSTL( const char* file, bool isascii ) ;
void ExportCGNS(SMESH::SMESH_IDSource_ptr meshPart,
const char* file,
CORBA::Boolean overwrite,
- CORBA::Boolean groupElemsByType) throw (SALOME::SALOME_Exception);
+ CORBA::Boolean groupElemsByType) ;
void ExportGMF(SMESH::SMESH_IDSource_ptr meshPart,
const char* file,
- CORBA::Boolean withRequiredGroups) throw (SALOME::SALOME_Exception);
+ CORBA::Boolean withRequiredGroups) ;
void ExportPartToMED(SMESH::SMESH_IDSource_ptr meshPart,
const char* file,
CORBA::Boolean autoDim,
const GEOM::ListOfFields& fields,
const char* geomAssocFields,
- CORBA::Double ZTolerance) throw (SALOME::SALOME_Exception);
+ CORBA::Double ZTolerance) ;
void ExportPartToDAT(SMESH::SMESH_IDSource_ptr meshPart,
- const char* file) throw (SALOME::SALOME_Exception);
+ const char* file) ;
void ExportPartToUNV(SMESH::SMESH_IDSource_ptr meshPart,
- const char* file) throw (SALOME::SALOME_Exception);
+ const char* file) ;
void ExportPartToSTL(SMESH::SMESH_IDSource_ptr meshPart,
const char* file,
- CORBA::Boolean isascii) throw (SALOME::SALOME_Exception);
+ CORBA::Boolean isascii) ;
CORBA::Double GetComputeProgress();
CORBA::Long NbNodes()
- throw (SALOME::SALOME_Exception);
+ ;
CORBA::Long NbElements()
- throw (SALOME::SALOME_Exception);
+ ;
CORBA::Long Nb0DElements()
- throw (SALOME::SALOME_Exception);
+ ;
CORBA::Long NbBalls()
- throw (SALOME::SALOME_Exception);
+ ;
CORBA::Long NbEdges()
- throw (SALOME::SALOME_Exception);
+ ;
CORBA::Long NbEdgesOfOrder(SMESH::ElementOrder order)
- throw (SALOME::SALOME_Exception);
+ ;
CORBA::Long NbFaces()
- throw (SALOME::SALOME_Exception);
+ ;
CORBA::Long NbFacesOfOrder(SMESH::ElementOrder order)
- throw (SALOME::SALOME_Exception);
+ ;
CORBA::Long NbTriangles()
- throw (SALOME::SALOME_Exception);
+ ;
CORBA::Long NbTrianglesOfOrder(SMESH::ElementOrder order)
- throw (SALOME::SALOME_Exception);
+ ;
CORBA::Long NbBiQuadTriangles()
- throw (SALOME::SALOME_Exception);
+ ;
CORBA::Long NbQuadrangles()
- throw (SALOME::SALOME_Exception);
+ ;
CORBA::Long NbQuadranglesOfOrder(SMESH::ElementOrder order)
- throw (SALOME::SALOME_Exception);
+ ;
CORBA::Long NbBiQuadQuadrangles()
- throw (SALOME::SALOME_Exception);
+ ;
CORBA::Long NbPolygons()
- throw (SALOME::SALOME_Exception);
+ ;
CORBA::Long NbPolygonsOfOrder(SMESH::ElementOrder order = SMESH::ORDER_ANY)
- throw (SALOME::SALOME_Exception);
+ ;
CORBA::Long NbVolumes()
- throw (SALOME::SALOME_Exception);
+ ;
CORBA::Long NbVolumesOfOrder(SMESH::ElementOrder order)
- throw (SALOME::SALOME_Exception);
+ ;
CORBA::Long NbTetras()
- throw (SALOME::SALOME_Exception);
+ ;
CORBA::Long NbTetrasOfOrder(SMESH::ElementOrder order)
- throw (SALOME::SALOME_Exception);
+ ;
CORBA::Long NbHexas()
- throw (SALOME::SALOME_Exception);
+ ;
CORBA::Long NbHexasOfOrder(SMESH::ElementOrder order)
- throw (SALOME::SALOME_Exception);
+ ;
CORBA::Long NbTriQuadraticHexas()
- throw (SALOME::SALOME_Exception);
+ ;
CORBA::Long NbPyramids()
- throw (SALOME::SALOME_Exception);
+ ;
CORBA::Long NbPyramidsOfOrder(SMESH::ElementOrder order)
- throw (SALOME::SALOME_Exception);
+ ;
CORBA::Long NbPrisms()
- throw (SALOME::SALOME_Exception);
+ ;
CORBA::Long NbPrismsOfOrder(SMESH::ElementOrder order)
- throw (SALOME::SALOME_Exception);
+ ;
CORBA::Long NbHexagonalPrisms()
- throw (SALOME::SALOME_Exception);
+ ;
CORBA::Long NbPolyhedrons()
- throw (SALOME::SALOME_Exception);
+ ;
CORBA::Long NbSubMesh()
- throw (SALOME::SALOME_Exception);
+ ;
SMESH::long_array* GetElementsId()
- throw (SALOME::SALOME_Exception);
+ ;
SMESH::long_array* GetElementsByType( SMESH::ElementType theElemType )
- throw (SALOME::SALOME_Exception);
+ ;
SMESH::long_array* GetNodesId()
- throw (SALOME::SALOME_Exception);
+ ;
SMESH::ElementType GetElementType( CORBA::Long id, bool iselem )
- throw (SALOME::SALOME_Exception);
+ ;
SMESH::EntityType GetElementGeomType( CORBA::Long id )
- throw (SALOME::SALOME_Exception);
+ ;
SMESH::GeometryType GetElementShape( CORBA::Long id )
- throw (SALOME::SALOME_Exception);
+ ;
/*!
* Returns ID of elements for given submesh
*/
SMESH::long_array* GetSubMeshElementsId(CORBA::Long ShapeID)
- throw (SALOME::SALOME_Exception);
+ ;
/*!
* Returns ID of nodes for given submesh
* returns only nodes on shapes.
*/
SMESH::long_array* GetSubMeshNodesId(CORBA::Long ShapeID, CORBA::Boolean all)
- throw (SALOME::SALOME_Exception);
+ ;
/*!
* Returns type of elements for given submesh
*/
SMESH::ElementType GetSubMeshElementType(CORBA::Long ShapeID)
- throw (SALOME::SALOME_Exception);
+ ;
char* Dump();
// Create groups of elements preventing computation of a sub-shape
SMESH::ListOfGroups* MakeGroupsOfBadInputElements( int theSubShapeID,
const char* theGroupName)
- throw (SALOME::SALOME_Exception);
+ ;
// ===================================================
// Internal methods not available through CORBA
//=============================================================================
CORBA::Long SMESH_subMesh_i::GetNumberOfElements()
- throw (SALOME::SALOME_Exception)
+
{
Unexpect aCatch(SALOME_SalomeException);
//=============================================================================
CORBA::Long SMESH_subMesh_i::GetNumberOfNodes(CORBA::Boolean all)
- throw (SALOME::SALOME_Exception)
+
{
Unexpect aCatch(SALOME_SalomeException);
//=============================================================================
SMESH::long_array* SMESH_subMesh_i::GetElementsId()
- throw (SALOME::SALOME_Exception)
+
{
Unexpect aCatch(SALOME_SalomeException);
//=============================================================================
SMESH::long_array* SMESH_subMesh_i::GetElementsByType( SMESH::ElementType theElemType )
- throw (SALOME::SALOME_Exception)
+
{
Unexpect aCatch(SALOME_SalomeException);
//=============================================================================
SMESH::long_array* SMESH_subMesh_i::GetNodesId()
- throw (SALOME::SALOME_Exception)
+
{
Unexpect aCatch(SALOME_SalomeException);
//=============================================================================
SMESH::SMESH_Mesh_ptr SMESH_subMesh_i::GetFather()
- throw (SALOME::SALOME_Exception)
+
{
Unexpect aCatch(SALOME_SalomeException);
return _mesh_i->_this();
//=======================================================================
GEOM::GEOM_Object_ptr SMESH_subMesh_i::GetSubShape()
- throw (SALOME::SALOME_Exception)
+
{
Unexpect aCatch(SALOME_SalomeException);
GEOM::GEOM_Object_var aShapeObj;
*/
//=============================================================================
SMESH::ElementType SMESH_subMesh_i::GetElementType( const CORBA::Long id, const bool iselem )
- throw (SALOME::SALOME_Exception)
+
{
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
//=======================================================================
GEOM::GEOM_Object_ptr SMESH_Invalid_subMesh_i::GetSubShape()
- throw (SALOME::SALOME_Exception)
+
{
return GEOM::GEOM_Object::_duplicate( _geom );
}
~SMESH_subMesh_i();
CORBA::Long GetNumberOfElements()
- throw (SALOME::SALOME_Exception);
+ ;
CORBA::Long GetNumberOfNodes( CORBA::Boolean all )
- throw (SALOME::SALOME_Exception);
+ ;
SMESH::long_array* GetElementsId()
- throw (SALOME::SALOME_Exception);
+ ;
SMESH::long_array* GetElementsByType( SMESH::ElementType theElemType )
- throw (SALOME::SALOME_Exception);
+ ;
SMESH::ElementType GetElementType( CORBA::Long id, bool iselem )
- throw (SALOME::SALOME_Exception);
+ ;
SMESH::long_array* GetNodesId()
- throw (SALOME::SALOME_Exception);
+ ;
SMESH::SMESH_Mesh_ptr GetFather()
- throw (SALOME::SALOME_Exception);
+ ;
GEOM::GEOM_Object_ptr GetSubShape()
- throw (SALOME::SALOME_Exception);
+ ;
CORBA::Long GetId();
GEOM::GEOM_Object_ptr shape);
virtual GEOM::GEOM_Object_ptr GetSubShape()
- throw (SALOME::SALOME_Exception);
+ ;
protected:
//function : SetDeflection
//purpose :
void StdMeshers_Adaptive1D::SetDeflection(double value)
- throw(SALOME_Exception)
{
if (value <= std::numeric_limits<double>::min() )
throw SALOME_Exception("Deflection must be greater that zero");
//function : SetMinSize
//purpose : Sets minimal allowed segment length
void StdMeshers_Adaptive1D::SetMinSize(double minSize)
- throw(SALOME_Exception)
{
if (minSize <= std::numeric_limits<double>::min() )
throw SALOME_Exception("Min size must be greater that zero");
//function : SetMaxSize
//purpose : Sets maximal allowed segment length
void StdMeshers_Adaptive1D::SetMaxSize(double maxSize)
- throw(SALOME_Exception)
{
if (maxSize <= std::numeric_limits<double>::min() )
throw SALOME_Exception("Max size must be greater that zero");
/*!
* Sets minimal allowed segment length
*/
- void SetMinSize( double minSegLen ) throw (SALOME_Exception);
+ void SetMinSize( double minSegLen ) ;
double GetMinSize() const { return myMinSize; }
/*!
* Sets maximal allowed segment length
*/
- void SetMaxSize( double maxSegLen ) throw (SALOME_Exception);
+ void SetMaxSize( double maxSegLen ) ;
double GetMaxSize() const { return myMaxSize; }
/*!
* Sets <deflection> parameter value,
* i.e. a maximal allowed distance between a segment and an edge.
*/
- void SetDeflection(double value) throw(SALOME_Exception);
+ void SetDeflection(double value) ;
double GetDeflection() const { return myDeflection; }
virtual std::ostream & SaveTo(std::ostream & save);
//=============================================================================
void StdMeshers_Arithmetic1D::SetLength(double length, bool isStartLength)
- throw(SALOME_Exception)
{
if ( (isStartLength ? _begLength : _endLength) != length ) {
if (length <= 0)
StdMeshers_Arithmetic1D(int hypId, SMESH_Gen* gen);
virtual ~StdMeshers_Arithmetic1D();
- void SetLength(double length, bool isStartLength) throw(SALOME_Exception);
+ void SetLength(double length, bool isStartLength) ;
double GetLength(bool isStartLength) const;
const double theFineConst = 4.5;
void StdMeshers_AutomaticLength::SetFineness(double theFineness)
- throw(SALOME_Exception)
+
{
if ( theFineness < 0.0 || theFineness > 1.0 )
throw SALOME_Exception(LOCALIZED("theFineness is out of range [0.0-1.0]"));
double StdMeshers_AutomaticLength::GetLength(const SMESH_Mesh* theMesh,
const double theEdgeLength)
- throw(SALOME_Exception)
+
{
if ( !theMesh ) throw SALOME_Exception(LOCALIZED("NULL Mesh"));
double StdMeshers_AutomaticLength::GetLength(const SMESH_Mesh* theMesh,
const TopoDS_Shape& anEdge)
- throw(SALOME_Exception)
+
{
if ( !theMesh ) throw SALOME_Exception(LOCALIZED("NULL Mesh"));
* \brief Computes segment for a given edge
*/
double GetLength(const SMESH_Mesh* aMesh, const TopoDS_Shape& anEdge)
- throw(SALOME_Exception);
+ ;
/*!
* \brief Computes segment length for an edge of given length
*/
double GetLength(const SMESH_Mesh* aMesh, const double edgeLength)
- throw(SALOME_Exception);
+ ;
/*!
* \brief Set Fineness
* is divided by (0.5 + 4.5 x theFineness)
*/
void SetFineness(double theFineness)
- throw(SALOME_Exception);
+ ;
/*!
* \brief Return mesh Fineness
void checkGridSpacing(std::vector<std::string>& spaceFunctions,
std::vector<double>& internalPoints,
const std::string& axis)
- throw ( SALOME_Exception )
+
{
if ( spaceFunctions.empty() )
throw SALOME_Exception(SMESH_Comment("Empty space function for ") << axis );
//=======================================================================
void StdMeshers_CartesianParameters3D::SetGrid(std::vector<double>& coords, int axis)
- throw ( SALOME_Exception )
+
{
checkAxis( axis );
void StdMeshers_CartesianParameters3D::SetGridSpacing(std::vector<string>& xSpaceFuns,
std::vector<double>& xInternalPoints,
const int axis)
- throw ( SALOME_Exception )
+
{
checkAxis( axis );
//=======================================================================
void StdMeshers_CartesianParameters3D::SetSizeThreshold(const double threshold)
- throw ( SALOME_Exception )
+
{
if ( threshold <= 1.0 )
throw SALOME_Exception(LOCALIZED("threshold must be > 1.0"));
void StdMeshers_CartesianParameters3D::GetGridSpacing(std::vector<std::string>& spaceFunctions,
std::vector<double>& internalPoints,
const int axis) const
- throw ( SALOME_Exception )
+
{
if ( !IsGridBySpacing(axis) )
throw SALOME_Exception(LOCALIZED("The grid is defined by coordinates and not by spacing"));
//=======================================================================
bool StdMeshers_CartesianParameters3D::IsGridBySpacing(const int axis) const
- throw ( SALOME_Exception )
+
{
checkAxis(axis);
return !_spaceFunctions[axis].empty();
vector<double>& coords,
const string& axis,
const double* xForced )
- throw ( SALOME_Exception )
+
{
checkGridSpacing( theSpaceFuns, thePoints, axis );
std::vector<double>& yNodes,
std::vector<double>& zNodes,
const Bnd_Box& bndBox) const
- throw ( SALOME_Exception )
+
{
double x0,y0,z0, x1,y1,z1;
if ( IsGridBySpacing(0) || IsGridBySpacing(1) || IsGridBySpacing(2))
//=======================================================================
void StdMeshers_CartesianParameters3D::SetAxisDirs(const double* the9DirComps)
- throw ( SALOME_Exception )
+
{
gp_Vec x( the9DirComps[0],
the9DirComps[1],
//=======================================================================
void StdMeshers_CartesianParameters3D::GetGrid(std::vector<double>& coords, int axis) const
- throw ( SALOME_Exception )
+
{
if ( IsGridBySpacing(axis) )
throw SALOME_Exception(LOCALIZED("The grid is defined by spacing and not by coordinates"));
/*!
* Sets coordinates of node positions along an axis (countered from 0)
*/
- void SetGrid(std::vector<double>& xNodes, int axis) throw ( SALOME_Exception );
+ void SetGrid(std::vector<double>& xNodes, int axis) ;
/*!
* Return coordinates of node positions along the three axes
*/
- void GetGrid(std::vector<double>& xNodes, int axis) const throw ( SALOME_Exception );
+ void GetGrid(std::vector<double>& xNodes, int axis) const ;
/*!
* \brief Set grid spacing along the three axes
*/
void SetGridSpacing(std::vector<std::string>& spaceFunctions,
std::vector<double>& internalPoints,
- const int axis) throw ( SALOME_Exception );
+ const int axis) ;
void GetGridSpacing(std::vector<std::string>& spaceFunctions,
std::vector<double>& internalPoints,
- const int axis) const throw ( SALOME_Exception );
+ const int axis) const ;
- bool IsGridBySpacing(const int axis) const throw ( SALOME_Exception );
+ bool IsGridBySpacing(const int axis) const ;
/*!
* Set/unset a fixed point, at which a node will be created provided that grid
std::vector<double>& points,
std::vector<double>& coords,
const std::string& axis,
- const double* xForced=0) throw (SALOME_Exception);
+ const double* xForced=0) ;
/*!
* Return coordinates of node positions along the three axes.
* If the grid is defined by spacing functions, the coordinates are computed
void GetCoordinates(std::vector<double>& xNodes,
std::vector<double>& yNodes,
std::vector<double>& zNodes,
- const Bnd_Box& bndBox) const throw ( SALOME_Exception );
+ const Bnd_Box& bndBox) const ;
/*!
* \brief Set custom direction of axes
*/
- void SetAxisDirs(const double* the9DirComps) throw ( SALOME_Exception );
+ void SetAxisDirs(const double* the9DirComps) ;
const double* GetAxisDirs() const { return _axisDirs; }
/*!
* \brief Returns axes at which number of hexahedra is maximal
* hexahedron by geometry boundary is considered small and is removed if
* it's size is \athreshold times less than the size of the initial hexahedron.
*/
- void SetSizeThreshold(const double threshold) throw ( SALOME_Exception );
+ void SetSizeThreshold(const double threshold) ;
/*!
* \brief Return size threshold
*/
//=============================================================================
void StdMeshers_Deflection1D::SetDeflection(double value)
- throw(SALOME_Exception)
{
if (_value != value) {
if (value <= 0.)
StdMeshers_Deflection1D(int hypId, SMESH_Gen * gen);
virtual ~ StdMeshers_Deflection1D();
- void SetDeflection(double value) throw(SALOME_Exception);
+ void SetDeflection(double value) ;
double GetDeflection() const;
//=============================================================================
void StdMeshers_FixedPoints1D::SetPoints(const std::vector<double>& listParams)
- throw(SALOME_Exception)
+
{
_params = listParams;
NotifySubMeshesHypothesisModification();
//=============================================================================
void StdMeshers_FixedPoints1D::SetNbSegments(const std::vector<int>& listNbSeg)
- throw(SALOME_Exception)
+
{
_nbsegs = listNbSeg;
NotifySubMeshesHypothesisModification();
virtual ~StdMeshers_FixedPoints1D();
void SetPoints(const std::vector<double>& listParams)
- throw(SALOME_Exception);
+ ;
void SetNbSegments(const std::vector<int>& listNbSeg)
- throw(SALOME_Exception);
+ ;
const std::vector<double>& GetPoints() const { return _params; }
//=============================================================================
void StdMeshers_Geometric1D::SetStartLength(double length)
- throw(SALOME_Exception)
{
if ( _begLength != length )
{
//=============================================================================
void StdMeshers_Geometric1D::SetCommonRatio(double factor)
- throw(SALOME_Exception)
{
if ( _ratio != factor )
{
public:
StdMeshers_Geometric1D(int hypId, SMESH_Gen* gen);
- void SetStartLength(double length) throw(SALOME_Exception);
- void SetCommonRatio(double factor) throw(SALOME_Exception);
+ void SetStartLength(double length) ;
+ void SetCommonRatio(double factor) ;
double GetStartLength() const;
double GetCommonRatio() const;
//=============================================================================
void StdMeshers_LayerDistribution::SetLayerDistribution(SMESH_Hypothesis* hyp1D)
- throw ( SALOME_Exception )
{
if ( myHyp != hyp1D ) {
if ( myHyp && hyp1D->GetDim() != 1 )
* \param hyp1D - 1D hypothesis
*/
void SetLayerDistribution(SMESH_Hypothesis* hyp1D)
- throw ( SALOME_Exception );
+ ;
/*!
* \brief Returns 1D hypothesis specifying distribution of layers
//=============================================================================
void StdMeshers_LengthFromEdges::SetMode(int mode)
- throw (SALOME_Exception)
{
int oldMode = _mode;
if (mode <= 0)
StdMeshers_LengthFromEdges(int hypId, SMESH_Gen* gen);
virtual ~StdMeshers_LengthFromEdges();
- void SetMode(int mode)
- throw (SALOME_Exception);
+ void SetMode(int mode);
int GetMode();
*/
//=============================================================================
-void StdMeshers_LocalLength::SetLength(double length) throw(SALOME_Exception)
+void StdMeshers_LocalLength::SetLength(double length)
{
double oldLength = _length;
if (length <= 0)
*
*/
//=============================================================================
-void StdMeshers_LocalLength::SetPrecision (double thePrecision) throw(SALOME_Exception)
+void StdMeshers_LocalLength::SetPrecision (double thePrecision)
{
double oldPrecision = _precision;
if (_precision < 0)
StdMeshers_LocalLength(int hypId, SMESH_Gen * gen);
virtual ~ StdMeshers_LocalLength();
- void SetLength(double length) throw(SALOME_Exception);
- void SetPrecision(double precision) throw(SALOME_Exception);
+ void SetLength(double length) ;
+ void SetPrecision(double precision) ;
double GetLength() const;
double GetPrecision() const;
//=============================================================================
void StdMeshers_MaxElementArea::SetMaxArea(double maxArea)
- throw (SALOME_Exception)
{
double oldArea = _maxArea;
if (maxArea <= 0)
StdMeshers_MaxElementArea(int hypId, SMESH_Gen * gen);
virtual ~ StdMeshers_MaxElementArea();
- void SetMaxArea(double maxArea) throw(SALOME_Exception);
+ void SetMaxArea(double maxArea);
double GetMaxArea() const;
//=============================================================================
void StdMeshers_MaxElementVolume::SetMaxVolume(double maxVolume)
- throw (SALOME_Exception)
{
double oldVolume = _maxVolume;
if (maxVolume <= 0)
StdMeshers_MaxElementVolume(int hypId, SMESH_Gen* gen);
virtual ~StdMeshers_MaxElementVolume();
- void SetMaxVolume(double maxVolume)
- throw (SALOME_Exception);
+ void SetMaxVolume(double maxVolume);
double GetMaxVolume() const;
*/
//=============================================================================
-void StdMeshers_MaxLength::SetLength(double length) throw(SALOME_Exception)
+void StdMeshers_MaxLength::SetLength(double length)
{
if (length <= 0)
throw SALOME_Exception(LOCALIZED("length must be positive"));
StdMeshers_MaxLength(int hypId, SMESH_Gen * gen);
virtual ~ StdMeshers_MaxLength();
- void SetLength(double length) throw(SALOME_Exception);
+ void SetLength(double length) ;
double GetLength() const;
bool HavePreestimatedLength() const { return _preestimated > 0.; }
//=============================================================================
void StdMeshers_NumberOfLayers::SetNumberOfLayers(int numberOfLayers)
- throw ( SALOME_Exception )
{
if ( _nbLayers != numberOfLayers ) {
if ( numberOfLayers <= 0 )
virtual ~StdMeshers_NumberOfLayers();
// Sets <number of segments> parameter value
- void SetNumberOfLayers(int numberOfLayers) throw ( SALOME_Exception );
+ void SetNumberOfLayers(int numberOfLayers) ;
// Returns <number of layers> parameter value
int GetNumberOfLayers() const;
//=============================================================================
const vector<double>&
StdMeshers_NumberOfSegments::BuildDistributionExpr( const char* expr,int nbSeg,int conv )
- throw ( SALOME_Exception )
+
{
if( !buildDistribution( TCollection_AsciiString( ( Standard_CString )expr ), conv, 0.0, 1.0, nbSeg, _distr, 1E-4 ) )
_distr.resize( 0 );
StdMeshers_NumberOfSegments::BuildDistributionTab( const vector<double>& tab,
int nbSeg,
int conv )
- throw ( SALOME_Exception )
+
{
if( !buildDistribution( tab, conv, 0.0, 1.0, nbSeg, _distr, 1E-4 ) )
_distr.resize( 0 );
//=============================================================================
void StdMeshers_NumberOfSegments::SetNumberOfSegments(int segmentsNumber)
-throw(SALOME_Exception)
+
{
int oldNumberOfSegments = _numberOfSegments;
if (segmentsNumber <= 0)
//================================================================================
void StdMeshers_NumberOfSegments::SetDistrType(DistrType typ)
- throw(SALOME_Exception)
+
{
if (typ < DT_Regular || typ > DT_ExprFunc)
throw SALOME_Exception(LOCALIZED("distribution type is out of range"));
//================================================================================
void StdMeshers_NumberOfSegments::SetScaleFactor(double scaleFactor)
- throw(SALOME_Exception)
+
{
if (scaleFactor < PRECISION)
throw SALOME_Exception(LOCALIZED("scale factor must be positive"));
//================================================================================
double StdMeshers_NumberOfSegments::GetScaleFactor() const
- throw(SALOME_Exception)
+
{
if (_distrType != DT_Scale)
throw SALOME_Exception(LOCALIZED("not a scale distribution"));
//================================================================================
void StdMeshers_NumberOfSegments::SetTableFunction(const vector<double>& table)
- throw(SALOME_Exception)
+
{
if (_distrType != DT_TabFunc)
_distrType = DT_TabFunc;
//================================================================================
const vector<double>& StdMeshers_NumberOfSegments::GetTableFunction() const
- throw(SALOME_Exception)
+
{
if (_distrType != DT_TabFunc)
throw SALOME_Exception(LOCALIZED("not a table function distribution"));
//================================================================================
void StdMeshers_NumberOfSegments::SetExpressionFunction(const char* expr)
- throw(SALOME_Exception)
+
{
if (_distrType != DT_ExprFunc)
_distrType = DT_ExprFunc;
std::string
StdMeshers_NumberOfSegments::CheckExpressionFunction( const std::string& expr,
const int convMode)
- throw (SALOME_Exception)
+
{
// remove white spaces
TCollection_AsciiString str((Standard_CString)expr.c_str());
//================================================================================
const char* StdMeshers_NumberOfSegments::GetExpressionFunction() const
- throw(SALOME_Exception)
+
{
if (_distrType != DT_ExprFunc)
throw SALOME_Exception(LOCALIZED("not an expression function distribution"));
//================================================================================
void StdMeshers_NumberOfSegments::SetConversionMode( int conv )
- throw(SALOME_Exception)
+
{
// if (_distrType != DT_TabFunc && _distrType != DT_ExprFunc)
// throw SALOME_Exception(LOCALIZED("not a functional distribution"));
//================================================================================
int StdMeshers_NumberOfSegments::ConversionMode() const
- throw(SALOME_Exception)
+
{
// if (_distrType != DT_TabFunc && _distrType != DT_ExprFunc)
// throw SALOME_Exception(LOCALIZED("not a functional distribution"));
virtual ~StdMeshers_NumberOfSegments();
// Builds point distribution according to passed function
- const std::vector<double>& BuildDistributionExpr( const char*, int, int ) throw ( SALOME_Exception );
- const std::vector<double>& BuildDistributionTab( const std::vector<double>&, int, int ) throw ( SALOME_Exception );
+ const std::vector<double>& BuildDistributionExpr( const char*, int, int ) ;
+ const std::vector<double>& BuildDistributionTab( const std::vector<double>&, int, int ) ;
/*!
* \brief Set the number of segments
* \param segmentsNumber - must be greater than zero
*/
void SetNumberOfSegments(int segmentsNumber)
- throw (SALOME_Exception);
+ ;
/*!
* \brief Get the number of segments
* \brief Set distribution type
*/
void SetDistrType(DistrType typ)
- throw (SALOME_Exception);
+ ;
/*!
* \brief Get distribution type
* or scaleFactor is not a positive value different from 1
*/
virtual void SetScaleFactor(double scaleFactor)
- throw (SALOME_Exception);
+ ;
/*!
* \brief Get scale factor for scale distribution
* Throws SALOME_Exception if distribution type is not DT_Scale
*/
double GetScaleFactor() const
- throw (SALOME_Exception);
+ ;
/*!
* \brief Set table function for distribution DT_TabFunc
* Throws SALOME_Exception if distribution type is not DT_TabFunc
*/
void SetTableFunction(const std::vector<double>& table)
- throw (SALOME_Exception);
+ ;
/*!
* \brief Get table function for distribution DT_TabFunc
* Throws SALOME_Exception if distribution type is not DT_TabFunc
*/
const std::vector<double>& GetTableFunction() const
- throw (SALOME_Exception);
+ ;
/*!
* \brief Set expression function for distribution DT_ExprFunc
* Throws SALOME_Exception if distribution type is not DT_ExprFunc
*/
void SetExpressionFunction( const char* expr)
- throw (SALOME_Exception);
+ ;
/*!
* \brief Get expression function for distribution DT_ExprFunc
* Throws SALOME_Exception if distribution type is not DT_ExprFunc
*/
const char* GetExpressionFunction() const
- throw (SALOME_Exception);
+ ;
/*!
* \brief Checks validity of the expression of the function f(t), e.g. "sin(t)".
*/
static std::string CheckExpressionFunction( const std::string& expr,
const int convMode)
- throw (SALOME_Exception);
+ ;
/*!
* \brief Set conversion mode. When it is 0, it means "exponent mode":
* Throws SALOME_Exception if distribution type is not functional
*/
void SetConversionMode( int conv )
- throw (SALOME_Exception);
+ ;
/*!
* \brief Returns conversion mode
* Throws SALOME_Exception if distribution type is not functional
*/
int ConversionMode() const
- throw (SALOME_Exception);
+ ;
/*!
* \brief Initialize number of segments by the mesh built on the geometry
//=============================================================================
void StdMeshers_ProjectionSource1D::SetSourceEdge(const TopoDS_Shape& edge)
- throw ( SALOME_Exception )
{
if ( edge.IsNull() )
throw SALOME_Exception(LOCALIZED("Null edge is not allowed"));
void StdMeshers_ProjectionSource1D::SetVertexAssociation(const TopoDS_Shape& sourceVertex,
const TopoDS_Shape& targetVertex)
- throw ( SALOME_Exception )
{
if ( sourceVertex.IsNull() != targetVertex.IsNull() )
throw SALOME_Exception(LOCALIZED("Two or none vertices must be provided"));
* Sets source <edge> to take a mesh pattern from
*/
void SetSourceEdge(const TopoDS_Shape& edge)
- throw ( SALOME_Exception );
+ ;
/*!
* Returns the source edge or a group containing edges
*/
void SetVertexAssociation(const TopoDS_Shape& sourceVertex,
const TopoDS_Shape& targetVertex)
- throw ( SALOME_Exception );
+ ;
/*!
* Returns the vertex associated with the target vertex.
//=============================================================================
void StdMeshers_ProjectionSource2D::SetSourceFace(const TopoDS_Shape& Face)
- throw ( SALOME_Exception )
{
if ( Face.IsNull() )
throw SALOME_Exception(LOCALIZED("Null Face is not allowed"));
void StdMeshers_ProjectionSource2D::SetVertexAssociation(const TopoDS_Shape& sourceVertex1,
const TopoDS_Shape& sourceVertex2,
const TopoDS_Shape& targetVertex1,
- const TopoDS_Shape& targetVertex2)
- throw ( SALOME_Exception )
+ const TopoDS_Shape& targetVertex2)
{
if ( sourceVertex1.IsNull() != targetVertex1.IsNull() ||
sourceVertex2.IsNull() != targetVertex2.IsNull() )
//=============================================================================
TopoDS_Vertex StdMeshers_ProjectionSource2D::GetSourceVertex(int i) const
- throw ( SALOME_Exception )
{
if ( i == 1 )
return _sourceVertex1;
//=============================================================================
TopoDS_Vertex StdMeshers_ProjectionSource2D::GetTargetVertex(int i) const
- throw ( SALOME_Exception )
{
if ( i == 1 )
return _targetVertex1;
* Sets a source <face> to take a mesh pattern from
*/
void SetSourceFace(const TopoDS_Shape& face)
- throw ( SALOME_Exception );
+ ;
/*!
* Returns the source face or a group containing faces
const TopoDS_Shape& sourceVertex2,
const TopoDS_Shape& targetVertex1,
const TopoDS_Shape& targetVertex2)
- throw ( SALOME_Exception );
+ ;
/*!
* Returns the <i>-th source vertex associated with the <i>-th target vertex.
* Result may be nil if association not set.
* Valid indices are 1 and 2
*/
- TopoDS_Vertex GetSourceVertex(int i) const throw ( SALOME_Exception );
+ TopoDS_Vertex GetSourceVertex(int i) const ;
/*!
* Returns the <i>-th target vertex associated with the <i>-th source vertex.
* Result may be nil if association not set.
* Valid indices are 1 and 2
*/
- TopoDS_Vertex GetTargetVertex(int i) const throw ( SALOME_Exception );
+ TopoDS_Vertex GetTargetVertex(int i) const ;
/*!
* \brief Test if vertex association defined
//=============================================================================
void StdMeshers_ProjectionSource3D::SetSource3DShape(const TopoDS_Shape& Shape)
- throw ( SALOME_Exception )
{
if ( Shape.IsNull() )
throw SALOME_Exception(LOCALIZED("Null Shape is not allowed"));
const TopoDS_Shape& sourceVertex2,
const TopoDS_Shape& targetVertex1,
const TopoDS_Shape& targetVertex2)
- throw ( SALOME_Exception )
{
if ( sourceVertex1.IsNull() != targetVertex1.IsNull() ||
sourceVertex2.IsNull() != targetVertex2.IsNull() ||
//=============================================================================
TopoDS_Vertex StdMeshers_ProjectionSource3D::GetSourceVertex(int i) const
- throw ( SALOME_Exception )
{
if ( i == 1 )
return _sourceVertex1;
//=============================================================================
TopoDS_Vertex StdMeshers_ProjectionSource3D::GetTargetVertex(int i) const
- throw ( SALOME_Exception )
{
if ( i == 1 )
return _targetVertex1;
* Sets a source <shape> to take a mesh pattern from
*/
void SetSource3DShape(const TopoDS_Shape& shape)
- throw ( SALOME_Exception );
+ ;
/*!
* Returns the source shape
const TopoDS_Shape& sourceVertex2,
const TopoDS_Shape& targetVertex1,
const TopoDS_Shape& targetVertex2)
- throw ( SALOME_Exception );
+ ;
/*!
* Returns the <i>-th source vertex associated with the <i>-th target vertex.
* Result may be nil if association not set.
*/
- TopoDS_Vertex GetSourceVertex(int i) const throw ( SALOME_Exception );
+ TopoDS_Vertex GetSourceVertex(int i) const ;
/*!
* Returns the <i>-th target vertex associated with the <i>-th source vertex.
* Result may be nil if association not set.
*/
- TopoDS_Vertex GetTargetVertex(int i) const throw ( SALOME_Exception );
+ TopoDS_Vertex GetTargetVertex(int i) const ;
/*!
* \brief Test if vertex association defined
*/
//=============================================================================
-void StdMeshers_SegmentLengthAroundVertex::SetLength(double length) throw(SALOME_Exception)
+void StdMeshers_SegmentLengthAroundVertex::SetLength(double length)
{
if (length <= 0)
throw SALOME_Exception(LOCALIZED("length must be positive"));
StdMeshers_SegmentLengthAroundVertex(int hypId, SMESH_Gen * gen);
virtual ~ StdMeshers_SegmentLengthAroundVertex();
- void SetLength(double length) throw(SALOME_Exception);
+ void SetLength(double length) ;
double GetLength() const;
//=============================================================================
void StdMeshers_StartEndLength::SetLength(double length, bool isStartLength)
- throw(SALOME_Exception)
{
if ( (isStartLength ? _begLength : _endLength) != length ) {
if (length <= 0)
StdMeshers_StartEndLength(int hypId, SMESH_Gen * gen);
virtual ~ StdMeshers_StartEndLength();
- void SetLength(double length, bool isStartLength) throw(SALOME_Exception);
+ void SetLength(double length, bool isStartLength) ;
double GetLength(bool isStartLength) const;
//=======================================================================
void StdMeshers_Adaptive1D_i::SetMinSize( CORBA::Double minSegLen )
- throw (SALOME::SALOME_Exception)
{
ASSERT( myBaseImpl );
try {
//=======================================================================
void StdMeshers_Adaptive1D_i::SetMaxSize( CORBA::Double maxSegLen )
- throw (SALOME::SALOME_Exception)
{
ASSERT( myBaseImpl );
try {
//=======================================================================
void StdMeshers_Adaptive1D_i::SetDeflection( CORBA::Double theValue )
- throw ( SALOME::SALOME_Exception )
{
ASSERT( myBaseImpl );
try {
/*!
* Sets minimal allowed segment length
*/
- void SetMinSize( CORBA::Double minSegLen ) throw (SALOME::SALOME_Exception);
+ void SetMinSize( CORBA::Double minSegLen );
CORBA::Double GetMinSize();
/*!
* Sets maximal allowed segment length
*/
- void SetMaxSize( CORBA::Double maxSegLen ) throw (SALOME::SALOME_Exception);
+ void SetMaxSize( CORBA::Double maxSegLen );
CORBA::Double GetMaxSize();
/*!
* Sets <deflection> parameter value,
* i.e. a maximal allowed distance between a segment and an edge.
*/
- void SetDeflection( CORBA::Double theLength ) throw (SALOME::SALOME_Exception);
+ void SetDeflection( CORBA::Double theLength );
CORBA::Double GetDeflection();
void StdMeshers_Arithmetic1D_i::SetLength(CORBA::Double theLength,
CORBA::Boolean theIsStart )
- throw ( SALOME::SALOME_Exception )
{
ASSERT( myBaseImpl );
try {
//=============================================================================
void StdMeshers_Arithmetic1D_i::SetStartLength( CORBA::Double length)
- throw (SALOME::SALOME_Exception)
{
SetLength( length, true );
}
//=============================================================================
void StdMeshers_Arithmetic1D_i::SetEndLength( CORBA::Double length)
- throw (SALOME::SALOME_Exception)
{
SetLength( length, false );
}
// Set length
// * OBSOLETE *. Avoid such a way of interface design
- void SetLength( CORBA::Double theLength, CORBA::Boolean theIsStart )
- throw ( SALOME::SALOME_Exception );
+ void SetLength( CORBA::Double theLength, CORBA::Boolean theIsStart );
// Sets <start segment length> parameter value
- void SetStartLength( CORBA::Double length) throw (SALOME::SALOME_Exception);
+ void SetStartLength( CORBA::Double length);
// Sets <end segment length> parameter value
- void SetEndLength( CORBA::Double length) throw (SALOME::SALOME_Exception);
+ void SetEndLength( CORBA::Double length);
// Get length
CORBA::Double GetLength(CORBA::Boolean theIsStart);
//=============================================================================
void StdMeshers_AutomaticLength_i::SetFineness( CORBA::Double theFineness )
- throw ( SALOME::SALOME_Exception )
{
ASSERT( myBaseImpl );
try {
virtual ~StdMeshers_AutomaticLength_i();
// Set Fineness
- void SetFineness( CORBA::Double theFineness )
- throw ( SALOME::SALOME_Exception );
+ void SetFineness( CORBA::Double theFineness );
// Get Fineness
CORBA::Double GetFineness();
void StdMeshers_CartesianParameters3D_i::SetGrid(const SMESH::double_array& coords,
CORBA::Short axis)
- throw (SALOME::SALOME_Exception)
+
{
std::vector<double> coordVec;//, yCoords, zCoords;
_array2vec( coords, coordVec, );
//=============================================================================
SMESH::double_array* StdMeshers_CartesianParameters3D_i::GetGrid(CORBA::Short axis)
- throw (SALOME::SALOME_Exception)
+
{
std::vector<double> coordVec;
ASSERT( myBaseImpl );
//=============================================================================
void StdMeshers_CartesianParameters3D_i::SetSizeThreshold(CORBA::Double threshold)
- throw (SALOME::SALOME_Exception)
+
{
ASSERT( myBaseImpl );
try {
void StdMeshers_CartesianParameters3D_i::SetGridSpacing(const SMESH::string_array& spaceFunctions,
const SMESH::double_array& internalPoints,
CORBA::Short axis)
- throw (SALOME::SALOME_Exception)
+
{
std::vector<std::string> funVec;
std::vector<double> pointVec;
void StdMeshers_CartesianParameters3D_i::GetGridSpacing(SMESH::string_array_out xSpaceFunctions,
SMESH::double_array_out xInternalPoints,
CORBA::Short axis)
- throw (SALOME::SALOME_Exception)
+
{
ASSERT( myBaseImpl );
try {
void StdMeshers_CartesianParameters3D_i::SetAxesDirs(const SMESH::DirStruct& xDir,
const SMESH::DirStruct& yDir,
const SMESH::DirStruct& zDir)
- throw (SALOME::SALOME_Exception)
+
{
double coords[9];
coords[0] = xDir.PS.x;
SMESH::DirStruct& xDir,
SMESH::DirStruct& yDir,
SMESH::DirStruct& zDir)
- throw (SALOME::SALOME_Exception)
+
{
TopoDS_Shape shape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( go );
if ( shape.IsNull() )
const SMESH::string_array& spaceFuns,
const SMESH::double_array& points,
const char* axisName )
- throw (SALOME::SALOME_Exception)
+
{
std::vector<std::string> xFuns;
std::vector<double> xPoints, coords;
* it's size is \athreshold times less than the size of the initial hexahedron.
* threshold must be > 1.0
*/
- void SetSizeThreshold(CORBA::Double threshold) throw (SALOME::SALOME_Exception);
+ void SetSizeThreshold(CORBA::Double threshold) ;
CORBA::Double GetSizeThreshold();
/*!
* \brief Set node coordinates along an axis (counterd from zero)
*/
void SetGrid(const SMESH::double_array& coords,
- CORBA::Short axis) throw (SALOME::SALOME_Exception);
- SMESH::double_array* GetGrid(CORBA::Short axis) throw (SALOME::SALOME_Exception);
+ CORBA::Short axis) ;
+ SMESH::double_array* GetGrid(CORBA::Short axis) ;
/*!
* \brief Set grid spacing along an axis
*/
void SetGridSpacing(const SMESH::string_array& spaceFunctions,
const SMESH::double_array& internalPoints,
- CORBA::Short axis) throw (SALOME::SALOME_Exception);
+ CORBA::Short axis) ;
void GetGridSpacing(SMESH::string_array_out xSpaceFunctions,
SMESH::double_array_out xInternalPoints,
- CORBA::Short axis) throw (SALOME::SALOME_Exception);
+ CORBA::Short axis) ;
/*!
* Set custom direction of axes
*/
void SetAxesDirs(const SMESH::DirStruct& x,
const SMESH::DirStruct& y,
- const SMESH::DirStruct& z) throw (SALOME::SALOME_Exception);
+ const SMESH::DirStruct& z) ;
void GetAxesDirs(SMESH::DirStruct& x,
SMESH::DirStruct& y,
SMESH::DirStruct& z);
CORBA::Boolean isOrthogonal,
SMESH::DirStruct& x,
SMESH::DirStruct& y,
- SMESH::DirStruct& z) throw (SALOME::SALOME_Exception);
+ SMESH::DirStruct& z) ;
/*!
* \brief Compute node coordinates by spacing functions
* \param x0 - lower coordinate
const SMESH::string_array& spaceFuns,
const SMESH::double_array& points,
const char* axisName )
- throw (SALOME::SALOME_Exception);
+ ;
// Get implementation
::StdMeshers_CartesianParameters3D* GetImpl();
//=============================================================================
void StdMeshers_Deflection1D_i::SetDeflection( CORBA::Double theValue )
- throw ( SALOME::SALOME_Exception )
{
ASSERT( myBaseImpl );
try {
// Set deflection
void SetDeflection( CORBA::Double theLength )
- throw ( SALOME::SALOME_Exception );
+ ;
// Get deflection
CORBA::Double GetDeflection();
//=============================================================================
void StdMeshers_FixedPoints1D_i::SetNbSegments(const SMESH::long_array& listNbSeg)
- throw ( SALOME::SALOME_Exception )
+
{
ASSERT( myBaseImpl );
try {
//=============================================================================
void StdMeshers_FixedPoints1D_i::SetPoints(const SMESH::double_array& listParams)
- throw ( SALOME::SALOME_Exception )
+
{
ASSERT( myBaseImpl );
try {
// create list of reversed edges if it is needed) and sets numbers
// of segments between given points (default values are equals 1)
void SetPoints(const SMESH::double_array& listParams)
- throw ( SALOME::SALOME_Exception );
+ ;
void SetNbSegments(const SMESH::long_array& listNbSeg)
- throw ( SALOME::SALOME_Exception );
+ ;
// Returns list of point's parameters
SMESH::double_array* GetPoints();
//=============================================================================
void StdMeshers_Geometric1D_i::SetStartLength( CORBA::Double theLength )
- throw (SALOME::SALOME_Exception)
{
try {
this->GetImpl()->SetStartLength( theLength );
//=============================================================================
void StdMeshers_Geometric1D_i::SetCommonRatio( CORBA::Double factor )
- throw (SALOME::SALOME_Exception)
{
try {
this->GetImpl()->SetCommonRatio( factor );
StdMeshers_Geometric1D_i( PortableServer::POA_ptr thePOA,
::SMESH_Gen* theGenImpl );
- void SetStartLength(CORBA::Double length) throw(SALOME::SALOME_Exception);
- void SetCommonRatio(CORBA::Double factor) throw(SALOME::SALOME_Exception);
+ void SetStartLength(CORBA::Double length) ;
+ void SetCommonRatio(CORBA::Double factor) ;
CORBA::Double GetStartLength();
CORBA::Double GetCommonRatio();
//=============================================================================
void StdMeshers_LayerDistribution_i::SetLayerDistribution(SMESH::SMESH_Hypothesis_ptr hyp1D)
- throw ( SALOME::SALOME_Exception )
{
ASSERT( myBaseImpl );
try {
* \brief Sets 1D hypothesis specifying distribution of layers
* \param hyp1D - 1D hypothesis
*/
- void SetLayerDistribution(SMESH::SMESH_Hypothesis_ptr hyp1D)
- throw ( SALOME::SALOME_Exception );
+ void SetLayerDistribution(SMESH::SMESH_Hypothesis_ptr hyp1D);
/*!
* \brief Returns 1D hypothesis specifying distribution of layers
//=============================================================================
void StdMeshers_LengthFromEdges_i::SetMode( CORBA::Long theMode )
- throw (SALOME::SALOME_Exception)
{
ASSERT( myBaseImpl );
try {
virtual ~StdMeshers_LengthFromEdges_i();
// Set mode
- void SetMode( CORBA::Long theMode )
- throw ( SALOME::SALOME_Exception );
+ void SetMode( CORBA::Long theMode );
// Get mode
CORBA::Long GetMode();
*/
//=============================================================================
void StdMeshers_LocalLength_i::SetLength( CORBA::Double theLength )
- throw ( SALOME::SALOME_Exception )
{
ASSERT( myBaseImpl );
try {
*/
//=============================================================================
void StdMeshers_LocalLength_i::SetPrecision( CORBA::Double thePrecision )
- throw ( SALOME::SALOME_Exception )
{
ASSERT( myBaseImpl );
try {
// Set length
void SetLength( CORBA::Double theLength )
- throw ( SALOME::SALOME_Exception );
+ ;
// Set precision
void SetPrecision( CORBA::Double thePrecision )
- throw ( SALOME::SALOME_Exception );
+ ;
// Get length
CORBA::Double GetLength();
//=============================================================================
void StdMeshers_MaxElementArea_i::SetMaxElementArea( CORBA::Double theArea )
- throw ( SALOME::SALOME_Exception )
{
ASSERT( myBaseImpl );
try {
// Set maximum element area
void SetMaxElementArea( CORBA::Double theArea )
- throw ( SALOME::SALOME_Exception );
+ ;
// Get maximum element area
CORBA::Double GetMaxElementArea();
//=============================================================================
void StdMeshers_MaxElementVolume_i::SetMaxElementVolume( CORBA::Double theVolume )
- throw ( SALOME::SALOME_Exception )
{
ASSERT( myBaseImpl );
try {
virtual ~StdMeshers_MaxElementVolume_i();
// Set maximum element volume
- void SetMaxElementVolume( CORBA::Double theVolume )
- throw (SALOME::SALOME_Exception);
+ void SetMaxElementVolume( CORBA::Double theVolume );
// Get maximum element volume
CORBA::Double GetMaxElementVolume();
*/
//=============================================================================
void StdMeshers_MaxLength_i::SetLength( CORBA::Double theLength )
- throw ( SALOME::SALOME_Exception )
{
ASSERT( myBaseImpl );
try {
*/
//=============================================================================
void StdMeshers_MaxLength_i::SetUsePreestimatedLength( CORBA::Boolean toUse )
- throw ( SALOME::SALOME_Exception )
{
ASSERT( myBaseImpl );
try {
// Set length
void SetLength( CORBA::Double theLength )
- throw ( SALOME::SALOME_Exception );
+ ;
// Set precision
// Sets preestimation flag
void SetUsePreestimatedLength( CORBA::Boolean toUse)
- throw ( SALOME::SALOME_Exception );
+ ;
// Get length
CORBA::Double GetLength();
//=============================================================================
void StdMeshers_NumberOfLayers_i::SetNumberOfLayers(CORBA::Long numberOfLayers)
- throw ( SALOME::SALOME_Exception )
{
ASSERT( myBaseImpl );
try {
// Sets <number of segments> parameter value
void SetNumberOfLayers(CORBA::Long numberOfLayers)
- throw ( SALOME::SALOME_Exception );
+ ;
// Returns <number of layers> parameter value
CORBA::Long GetNumberOfLayers();
SMESH::double_array* StdMeshers_NumberOfSegments_i::BuildDistributionExpr( const char* func,
CORBA::Long nbSeg,
CORBA::Long conv )
- throw ( SALOME::SALOME_Exception )
+
{
ASSERT( myBaseImpl );
try
StdMeshers_NumberOfSegments_i::BuildDistributionTab( const SMESH::double_array& func,
CORBA::Long nbSeg,
CORBA::Long conv )
- throw ( SALOME::SALOME_Exception )
+
{
ASSERT( myBaseImpl );
//=============================================================================
void StdMeshers_NumberOfSegments_i::SetNumberOfSegments( CORBA::Long theSegmentsNumber )
- throw ( SALOME::SALOME_Exception )
+
{
ASSERT( myBaseImpl );
try {
//=============================================================================
void StdMeshers_NumberOfSegments_i::SetDistrType(CORBA::Long typ)
- throw ( SALOME::SALOME_Exception )
+
{
ASSERT( myBaseImpl );
try {
//=============================================================================
void StdMeshers_NumberOfSegments_i::SetScaleFactor( CORBA::Double theScaleFactor )
- throw ( SALOME::SALOME_Exception )
+
{
ASSERT( myBaseImpl );
try {
//=============================================================================
CORBA::Double StdMeshers_NumberOfSegments_i::GetScaleFactor()
- throw ( SALOME::SALOME_Exception )
+
{
ASSERT( myBaseImpl );
double scale;
//=============================================================================
void StdMeshers_NumberOfSegments_i::SetTableFunction(const SMESH::double_array& table)
- throw ( SALOME::SALOME_Exception )
+
{
ASSERT( myBaseImpl );
std::vector<double> tbl( table.length() );
//=============================================================================
SMESH::double_array* StdMeshers_NumberOfSegments_i::GetTableFunction()
- throw ( SALOME::SALOME_Exception )
+
{
ASSERT( myBaseImpl );
const std::vector<double>* tbl;
//=============================================================================
void StdMeshers_NumberOfSegments_i::SetExpressionFunction(const char* expr)
- throw ( SALOME::SALOME_Exception )
+
{
ASSERT( myBaseImpl );
try {
//=============================================================================
char* StdMeshers_NumberOfSegments_i::GetExpressionFunction()
- throw ( SALOME::SALOME_Exception )
+
{
ASSERT( myBaseImpl );
const char* expr;
//=============================================================================
void StdMeshers_NumberOfSegments_i::SetConversionMode(CORBA::Long conv )
- throw ( SALOME::SALOME_Exception )
+
{
ASSERT( myBaseImpl );
try {
//=============================================================================
CORBA::Long StdMeshers_NumberOfSegments_i::ConversionMode()
- throw ( SALOME::SALOME_Exception )
+
{
ASSERT( myBaseImpl );
int conv;
// Builds point distribution according to passed function
SMESH::double_array* BuildDistributionExpr( const char*, CORBA::Long, CORBA::Long )
- throw ( SALOME::SALOME_Exception );
+ ;
SMESH::double_array* BuildDistributionTab( const SMESH::double_array&, CORBA::Long, CORBA::Long )
- throw ( SALOME::SALOME_Exception );
+ ;
// Set number of segments
void SetNumberOfSegments( CORBA::Long theSegmentsNumber )
- throw ( SALOME::SALOME_Exception );
+ ;
// Get number of segments
CORBA::Long GetNumberOfSegments();
// Set distribution type
void SetDistrType(CORBA::Long typ)
- throw ( SALOME::SALOME_Exception );
+ ;
// Get distribution type
CORBA::Long GetDistrType();
// Set scalar factor
void SetScaleFactor( CORBA::Double theScaleFactor )
- throw ( SALOME::SALOME_Exception );
+ ;
// Get scalar factor
CORBA::Double GetScaleFactor()
- throw ( SALOME::SALOME_Exception );
+ ;
// Set table function for distribution DT_TabFunc
void SetTableFunction(const SMESH::double_array& table)
- throw ( SALOME::SALOME_Exception );
+ ;
// Get table function for distribution DT_TabFunc
SMESH::double_array* GetTableFunction()
- throw ( SALOME::SALOME_Exception );
+ ;
// Set expression function for distribution DT_ExprFunc
void SetExpressionFunction(const char* expr)
- throw ( SALOME::SALOME_Exception );
+ ;
// Get expression function for distribution DT_ExprFunc
char* GetExpressionFunction()
- throw ( SALOME::SALOME_Exception );
+ ;
// Set the exponent mode on/off
void SetConversionMode( CORBA::Long conv )
- throw ( SALOME::SALOME_Exception );
+ ;
// Returns true if the exponent mode is set
CORBA::Long ConversionMode()
- throw ( SALOME::SALOME_Exception );
+ ;
// Get implementation
::StdMeshers_NumberOfSegments* GetImpl();
//=============================================================================
void StdMeshers_ProjectionSource1D_i::SetSourceEdge(GEOM::GEOM_Object_ptr edge)
- throw ( SALOME::SALOME_Exception )
+
{
ASSERT( myBaseImpl );
try {
void StdMeshers_ProjectionSource1D_i::SetVertexAssociation(GEOM::GEOM_Object_ptr sourceVertex,
GEOM::GEOM_Object_ptr targetVertex)
- throw ( SALOME::SALOME_Exception )
+
{
ASSERT( myBaseImpl );
try {
//=============================================================================
void StdMeshers_ProjectionSource1D_i::SetSourceMesh(SMESH::SMESH_Mesh_ptr theMesh)
- throw ( SALOME::SALOME_Exception )
+
{
ASSERT( myBaseImpl );
* Sets source <edge> or a group containing edges to take a mesh pattern from
*/
void SetSourceEdge(GEOM::GEOM_Object_ptr edge)
- throw ( SALOME::SALOME_Exception );
+ ;
/*!
* Returns the source edge or a group containing edges
* Sets source <mesh> to take a mesh pattern from
*/
void SetSourceMesh(SMESH::SMESH_Mesh_ptr mesh)
- throw ( SALOME::SALOME_Exception );
+ ;
/*!
* Return source mesh
*/
void SetVertexAssociation(GEOM::GEOM_Object_ptr sourceVertex,
GEOM::GEOM_Object_ptr targetVertex)
- throw ( SALOME::SALOME_Exception );
+ ;
/*!
* Returns the vertex associated with the target vertex.
//=============================================================================
void StdMeshers_ProjectionSource2D_i::SetSourceFace(GEOM::GEOM_Object_ptr face)
- throw ( SALOME::SALOME_Exception )
+
{
ASSERT( myBaseImpl );
try {
//=============================================================================
void StdMeshers_ProjectionSource2D_i::SetSourceMesh(SMESH::SMESH_Mesh_ptr theMesh)
- throw ( SALOME::SALOME_Exception )
+
{
ASSERT( myBaseImpl );
GEOM::GEOM_Object_ptr sourceVertex2,
GEOM::GEOM_Object_ptr targetVertex1,
GEOM::GEOM_Object_ptr targetVertex2)
- throw ( SALOME::SALOME_Exception )
+
{
ASSERT( myBaseImpl );
try {
* Sets a source <face> to take a mesh pattern from
*/
void SetSourceFace(GEOM::GEOM_Object_ptr face)
- throw ( SALOME::SALOME_Exception );
+ ;
/*!
* Returns the source face
* Sets source <mesh> to take a mesh pattern from
*/
void SetSourceMesh(SMESH::SMESH_Mesh_ptr mesh)
- throw ( SALOME::SALOME_Exception );
+ ;
/*!
* Return source mesh
GEOM::GEOM_Object_ptr sourceVertex2,
GEOM::GEOM_Object_ptr targetVertex1,
GEOM::GEOM_Object_ptr targetVertex2)
- throw ( SALOME::SALOME_Exception );
+ ;
/*!
* Returns the <i>-th source vertex associated with the <i>-th target vertex.
//=============================================================================
void StdMeshers_ProjectionSource3D_i::SetSource3DShape(GEOM::GEOM_Object_ptr shape)
- throw ( SALOME::SALOME_Exception )
+
{
ASSERT( myBaseImpl );
try {
//=============================================================================
void StdMeshers_ProjectionSource3D_i::SetSourceMesh(SMESH::SMESH_Mesh_ptr theMesh)
- throw ( SALOME::SALOME_Exception )
+
{
ASSERT( myBaseImpl );
GEOM::GEOM_Object_ptr sourceVertex2,
GEOM::GEOM_Object_ptr targetVertex1,
GEOM::GEOM_Object_ptr targetVertex2)
- throw ( SALOME::SALOME_Exception )
+
{
ASSERT( myBaseImpl );
try {
* Sets a source <shape> to take a mesh pattern from
*/
void SetSource3DShape(GEOM::GEOM_Object_ptr shape)
- throw ( SALOME::SALOME_Exception );
+ ;
/*!
* Returns the source shape
* Sets source <mesh> to take a mesh pattern from
*/
void SetSourceMesh(SMESH::SMESH_Mesh_ptr mesh)
- throw ( SALOME::SALOME_Exception );
+ ;
/*!
* Return source mesh
GEOM::GEOM_Object_ptr sourceVertex2,
GEOM::GEOM_Object_ptr targetVertex1,
GEOM::GEOM_Object_ptr targetVertex2)
- throw ( SALOME::SALOME_Exception );
+ ;
/*!
* Returns the <i>-th source vertex associated with the <i>-th target vertex.
void StdMeshers_QuadrangleParams_i::SetEnforcedNodes(const GEOM::ListOfGO& theVertices,
const SMESH::nodes_array& thePoints)
- throw ( SALOME::SALOME_Exception )
{
try {
std::vector< TopoDS_Shape > shapes;
// Set positions of enforced nodes
void SetEnforcedNodes(const GEOM::ListOfGO& vertices,
- const SMESH::nodes_array& points) throw ( SALOME::SALOME_Exception );
+ const SMESH::nodes_array& points);
// Returns positions of enforced nodes
void GetEnforcedNodes(GEOM::ListOfGO_out vertices, SMESH::nodes_array_out points);
//=============================================================================
void StdMeshers_SegmentLengthAroundVertex_i::SetLength( CORBA::Double theLength )
- throw ( SALOME::SALOME_Exception )
{
ASSERT( myBaseImpl );
try {
// Set length
void SetLength( CORBA::Double theLength )
- throw ( SALOME::SALOME_Exception );
+ ;
// Get length
CORBA::Double GetLength();
void StdMeshers_StartEndLength_i::SetLength(CORBA::Double theLength,
CORBA::Boolean theIsStart )
- throw ( SALOME::SALOME_Exception )
{
ASSERT( myBaseImpl );
try {
//=============================================================================
void StdMeshers_StartEndLength_i::SetStartLength( CORBA::Double length)
- throw (SALOME::SALOME_Exception)
{
SetLength( length, true );
}
//=============================================================================
void StdMeshers_StartEndLength_i::SetEndLength( CORBA::Double length)
- throw (SALOME::SALOME_Exception)
{
SetLength( length, false );
}
// Set length
// * OBSOLETE *. Avoid such a way of interface design
void SetLength( CORBA::Double theLength, CORBA::Boolean theIsStart )
- throw ( SALOME::SALOME_Exception );
+ ;
// Sets <start segment length> parameter value
- void SetStartLength( CORBA::Double length) throw (SALOME::SALOME_Exception);
+ void SetStartLength( CORBA::Double length) ;
// Sets <end segment length> parameter value
- void SetEndLength( CORBA::Double length) throw (SALOME::SALOME_Exception);
+ void SetEndLength( CORBA::Double length) ;
// Get length
CORBA::Double GetLength(CORBA::Boolean theIsStart);
//================================================================================
void StdMeshers_ViscousLayers2D_i::SetEdges(const ::SMESH::long_array& edgeIDs,
- CORBA::Boolean toIgnore)
- throw ( SALOME::SALOME_Exception )
+ CORBA::Boolean toIgnore)
{
vector<int> ids( edgeIDs.length() );
for ( unsigned i = 0; i < ids.size(); ++i )
//================================================================================
void StdMeshers_ViscousLayers2D_i::SetIgnoreEdges(const ::SMESH::long_array& edgeIDs)
- throw ( SALOME::SALOME_Exception )
+
{
SMESH::TPythonDump pyDump;
this->SetEdges( edgeIDs, true );
//================================================================================
void StdMeshers_ViscousLayers2D_i::SetTotalThickness(::CORBA::Double thickness)
-throw ( SALOME::SALOME_Exception )
+
{
if ( thickness < 1e-100 )
THROW_SALOME_CORBA_EXCEPTION( "Invalid thickness", SALOME::BAD_PARAM );
//================================================================================
void StdMeshers_ViscousLayers2D_i::SetNumberLayers(::CORBA::Short nb)
-throw ( SALOME::SALOME_Exception )
+
{
if ( nb < 1 )
THROW_SALOME_CORBA_EXCEPTION( "Invalid number of layers", SALOME::BAD_PARAM );
//================================================================================
void StdMeshers_ViscousLayers2D_i::SetStretchFactor(::CORBA::Double factor)
-throw ( SALOME::SALOME_Exception )
+
{
if ( factor < 1 )
THROW_SALOME_CORBA_EXCEPTION( "Invalid stretch factor, it must be >= 1.0", SALOME::BAD_PARAM );
// Destructor
virtual ~StdMeshers_ViscousLayers2D_i();
- void SetIgnoreEdges(const SMESH::long_array& edgeIDs) throw ( SALOME::SALOME_Exception );
+ void SetIgnoreEdges(const SMESH::long_array& edgeIDs) ;
SMESH::long_array* GetIgnoreEdges();
void SetEdges(const SMESH::long_array& edgeIDs,
- CORBA::Boolean toIgnore) throw (SALOME::SALOME_Exception);
+ CORBA::Boolean toIgnore);
SMESH::long_array* GetEdges();
CORBA::Boolean GetIsToIgnoreEdges();
- void SetTotalThickness(::CORBA::Double thickness) throw ( SALOME::SALOME_Exception );
+ void SetTotalThickness(::CORBA::Double thickness) ;
::CORBA::Double GetTotalThickness();
- void SetNumberLayers(::CORBA::Short nb) throw ( SALOME::SALOME_Exception );
+ void SetNumberLayers(::CORBA::Short nb) ;
::CORBA::Short GetNumberLayers();
- void SetStretchFactor(::CORBA::Double factor) throw ( SALOME::SALOME_Exception );
+ void SetStretchFactor(::CORBA::Double factor) ;
::CORBA::Double GetStretchFactor();
void SetGroupName(const char* name);
void StdMeshers_ViscousLayers_i::SetFaces(const ::SMESH::long_array& faceIDs,
CORBA::Boolean toIgnore)
- throw ( SALOME::SALOME_Exception )
+
{
vector<int> ids( faceIDs.length() );
for ( unsigned i = 0; i < ids.size(); ++i )
//================================================================================
void StdMeshers_ViscousLayers_i::SetIgnoreFaces(const ::SMESH::long_array& faceIDs)
-throw ( SALOME::SALOME_Exception )
+
{
vector<int> ids( faceIDs.length() );
for ( unsigned i = 0; i < ids.size(); ++i )
//================================================================================
void StdMeshers_ViscousLayers_i::SetTotalThickness(::CORBA::Double thickness)
-throw ( SALOME::SALOME_Exception )
+
{
if ( thickness < 1e-100 )
THROW_SALOME_CORBA_EXCEPTION( "Invalid thickness", SALOME::BAD_PARAM );
//================================================================================
void StdMeshers_ViscousLayers_i::SetNumberLayers(::CORBA::Short nb)
-throw ( SALOME::SALOME_Exception )
+
{
if ( nb < 1 )
THROW_SALOME_CORBA_EXCEPTION( "Invalid number of layers", SALOME::BAD_PARAM );
//================================================================================
void StdMeshers_ViscousLayers_i::SetStretchFactor(::CORBA::Double factor)
-throw ( SALOME::SALOME_Exception )
+
{
if ( factor < 1 )
THROW_SALOME_CORBA_EXCEPTION( "Invalid stretch factor, it must be >= 1.0", SALOME::BAD_PARAM );
// Destructor
virtual ~StdMeshers_ViscousLayers_i();
- void SetIgnoreFaces(const ::SMESH::long_array& faceIDs) throw ( SALOME::SALOME_Exception );
+ void SetIgnoreFaces(const ::SMESH::long_array& faceIDs) ;
SMESH::long_array* GetIgnoreFaces();
void SetFaces(const SMESH::long_array& faceIDs,
- CORBA::Boolean toIgnore) throw (SALOME::SALOME_Exception);
+ CORBA::Boolean toIgnore) ;
SMESH::long_array* GetFaces();
CORBA::Boolean GetIsToIgnoreFaces();
- void SetTotalThickness(::CORBA::Double thickness) throw ( SALOME::SALOME_Exception );
+ void SetTotalThickness(::CORBA::Double thickness) ;
::CORBA::Double GetTotalThickness();
- void SetNumberLayers(::CORBA::Short nb) throw ( SALOME::SALOME_Exception );
+ void SetNumberLayers(::CORBA::Short nb) ;
::CORBA::Short GetNumberLayers();
- void SetStretchFactor(::CORBA::Double factor) throw ( SALOME::SALOME_Exception );
+ void SetStretchFactor(::CORBA::Double factor) ;
::CORBA::Double GetStretchFactor();
void SetMethod( ::StdMeshers::VLExtrusionMethod how );
