STRING(TOUPPER ${PROJECT_NAME} PROJECT_NAME_UC)
SET(${PROJECT_NAME_UC}_MAJOR_VERSION 9)
-SET(${PROJECT_NAME_UC}_MINOR_VERSION 5)
+SET(${PROJECT_NAME_UC}_MINOR_VERSION 6)
SET(${PROJECT_NAME_UC}_PATCH_VERSION 0)
SET(${PROJECT_NAME_UC}_VERSION
${${PROJECT_NAME_UC}_MAJOR_VERSION}.${${PROJECT_NAME_UC}_MINOR_VERSION}.${${PROJECT_NAME_UC}_PATCH_VERSION})
SET(SALOME_SMESH_ENABLE_MEFISTO ON)
MESSAGE(STATUS "Build MEFISTO2D mesher using Fortran to C generator")
ELSE(${F2C_FOUND})
- MESSAGE(STATUS "Fortran to C generator is not found: MEFISTO2D mesher will be unavailable.")
+ MESSAGE(FATAL "Fortran to C generator is not found: MEFISTO2D mesher cannot be compiled! Please define F2C_ROOT_DIR !")
ENDIF(${F2C_FOUND})
ENDIF(WIN32)
#. run your python code, which creates a 2D mesh,
#. invoke **Compute** command, which computes a 3D mesh.
-.. warning:: **Use Edges to be Created Manually** and **Use Faces to be Created Manually** algorithms should be assigned *before* mesh generation by the Python code.
+ .. warning::
+ * **Use Edges to be Created Manually** and **Use Faces to be Created Manually** algorithms should be assigned *before* mesh generation by the Python code.
+ * Nodes and elements created in your script must be assigned to geometry entities by calling *SetMeshElementOnShape*, *SetNodeOnVertex*, *SetNodeOnEdge* etc. in order to be used by an algorithm of upper dimension.
Consider trying a sample script demonstrating the usage of :ref:`Use Faces to be Created Manually <tui_use_existing_faces>` algorithm for construction of a 2D mesh using Python commands.
*/
//================================================================================
-double MultiConnection::GetValue( const TSequenceOfXYZ& P )
+double MultiConnection::GetValue( const TSequenceOfXYZ& /*P*/ )
{
return 0;
}
*/
//================================================================================
-double MultiConnection2D::GetValue( const TSequenceOfXYZ& P )
+double MultiConnection2D::GetValue( const TSequenceOfXYZ& /*P*/ )
{
return 0;
}
bool isOutOfFace (const gp_Pnt& p);
bool isOutOfEdge (const gp_Pnt& p);
bool isOutOfVertex(const gp_Pnt& p);
- bool isOutOfNone (const gp_Pnt& p) { return true; }
+ bool isOutOfNone (const gp_Pnt& /*p*/) { return true; }
bool isBox (const TopoDS_Shape& s);
TopoDS_Shape prepareSolid( const TopoDS_Shape& theSolid );
NumericalFunctor();
virtual void SetMesh( const SMDS_Mesh* theMesh );
virtual double GetValue( long theElementId );
- virtual double GetValue(const TSequenceOfXYZ& thePoints) { return -1.0;};
+ virtual double GetValue(const TSequenceOfXYZ& /*thePoints*/) { return -1.0;};
void GetHistogram(int nbIntervals,
std::vector<int>& nbEvents,
std::vector<double>& funValues,
protected:
PredicatePtr myPredicate;
};
- };
-};
+ }
+}
#endif
// how many bytes follow?
int len = 0;
- if (s[i] >> 5 == 0b110 ) len = 1;
- else if (s[i] >> 4 == 0b1110 ) len = 2;
- else if (s[i] >> 3 == 0b11110) len = 3;
+ if (s[i] >> 5 == 0b110 ) len = 1; // todo: binary constants are a GCC extension
+ else if (s[i] >> 4 == 0b1110 ) len = 2; // todo: binary constants are a GCC extension
+ else if (s[i] >> 3 == 0b11110) len = 3; // todo: binary constants are a GCC extension
else
invalid = true;
// check the bytes
for ( int j = 0; j < len && !invalid; ++j )
- invalid = ( s[i+j+1] >> 6 != 0b10 );
+ invalid = ( s[i+j+1] >> 6 != 0b10 ); // todo: binary constants are a GCC extension
if ( invalid )
fixed[i] = '?';
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;
ids[2] = ids[0] + _sizeX + 1;
ids[3] = ids[0] + ( k==_sizeZ ? _sizeX : 1);
}
- void IEdgeNodes( int i, int j, int k, cgsize_t* ids ) const // edge perpendiculaire to X (2D)
+ void IEdgeNodes( int i, int j, int /*k*/, cgsize_t* ids ) const // edge perpendiculaire to X (2D)
{
ids[0] = NodeID( i, j, 0 );
ids[1] = ids[0] + _sizeX;
}
- void JEdgeNodes( int i, int j, int k, cgsize_t* ids ) const
+ void JEdgeNodes( int i, int j, int /*k*/, cgsize_t* ids ) const
{
ids[0] = NodeID( i, j, 0 );
ids[1] = ids[0] + 1;
}
gp_XYZ Next()
{
- gp_XYZ res( _cur[0], _cur[1], _cur[2] );
+ gp_XYZ res( _cur[0], _cur[1], _cur[2] ); // todo: _cur can be used uninitialized
for ( int i = 0; i < _dim; ++i )
{
_cur[i] += _dir[i];
size *= _dir[i]*(_end[i]-_beg[i]);
return size;
}
- gp_XYZ Begin() const { return gp_XYZ( _beg[0], _beg[1], _beg[2] ); }
+ gp_XYZ Begin() const { return gp_XYZ( _beg[0], _beg[1], _beg[2] ); } // todo: _beg can be used uninitialized
//gp_XYZ End() const { return gp_XYZ( _end[0]-1, _end[1]-1, _end[2]-1 ); }
};
}
// fill nodeReplacementMap
- TPointRangeIterator rangeIt1( range, _meshDim );
+ TPointRangeIterator rangeIt1( range, _meshDim ); // todo: rangeIt1: _end[i], _dir[i], _beg[i], _cur[i] may be used uninitialized
TPointRangeIterator rangeIt2( donorRange, _meshDim );
gp_XYZ begin1 = rangeIt1.Begin(), begin2 = rangeIt2.Begin(), index1, index2;
if ( &zone2 == this )
static int GmfIniFlg=0;
static GmfMshSct *GmfMshTab[ MaxMsh + 1 ];
-// see MeshGems/Docs/meshgems_formats_description.pdf
+/* see MeshGems/Docs/meshgems_formats_description.pdf */
static const char *GmfKwdFmt[ GmfMaxKwd + 1 ][4] =
{ {"Reserved", "", "", ""},
{"MeshVersionFormatted", "", "", "i"},
{
for(i=0;i<kwd->SolSiz;i++)
if(kwd->fmt[i] == 'r')
- fprintf(msh->hdl, "%.15lg ", va_arg(VarArg, double));
+ fprintf(msh->hdl, "%.15lg ", va_arg(VarArg, double)); /* todo: ISO C90 does not support the '%lg' gnu_printf format */
else if(kwd->fmt[i] == 'n') {
nb_repeat = va_arg(VarArg, int);
fprintf(msh->hdl, "%d ", nb_repeat);
if(msh->typ & Asc)
for(j=0;j<kwd->SolSiz;j++)
- fprintf(msh->hdl, "%.15lg ", DblSolTab[j]);
+ fprintf(msh->hdl, "%.15lg ", DblSolTab[j]); /* todo: ISO C90 does not support the '%lg' gnu_printf format */
else
RecBlk(msh, (unsigned char *)DblSolTab, kwd->NmbWrd);
}
{
/* Search which kwd code this string is associated with,
then get its header and save the current position in file (just before the data) */
- // printf("libmesh ScaKwdTab %s\n", str);
+ /* printf("libmesh ScaKwdTab %s\n", str); */
for(KwdCod=1; KwdCod<= GmfMaxKwd; KwdCod++)
if(!strcmp(str, GmfKwdFmt[ KwdCod ][0]))
{
i = kwd->SolSiz = kwd->NmbWrd = 0;
- while(i < strlen(InpFmt))
+ while(i < (int)strlen(InpFmt))
{
chr = InpFmt[ i++ ];
/* Defines */
/*----------------------------------------------------------*/
-#include "SMESH_DriverGMF.hxx"
+#ifdef WIN32
+ #if defined MESHDriverGMF_EXPORTS || defined MeshDriverGMF_EXPORTS
+ #define MESHDriverGMF_EXPORT __declspec( dllexport )
+ #else
+ #define MESHDriverGMF_EXPORT __declspec( dllimport )
+ #endif
+#else
+ #define MESHDriverGMF_EXPORT
+#endif
#define GmfStrSiz 1024
#define GmfMaxTyp 1000
#define GmfFloat 1
#define GmfDouble 2
-// see MeshGems/Docs/meshgems_formats_description.pdf
+/* see MeshGems/Docs/meshgems_formats_description.pdf */
enum GmfKwdCod
{
GmfReserved1, \
else
_dblValues.reserve( nbElems * nbComps );
- return nbElems * nbComps;
+ return nbElems && nbComps;
}
//================================================================================
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 );
}
if ( myAutoDimension && aMeshDimension < 3 )
{
SMDS_NodeIteratorPtr aNodesIter = myMesh->nodesIterator();
- double aBounds[6];
+ double aBounds[6] = {0.,0.,0.,0.,0.,0.};
if(aNodesIter->more()){
const SMDS_MeshNode* aNode = aNodesIter->next();
aBounds[0] = aBounds[1] = aNode->X();
MESHDRIVERUNV_EXPORT void
Write(std::ofstream& out_stream );
-};
+}
#endif
MESHDRIVERUNV_EXPORT void
Write(std::ofstream& out_stream, const TDataSet& theDataSet);
-};
+}
#endif
MESHDRIVERUNV_EXPORT bool
IsVolume(int theFeDescriptorId);
-};
+}
#endif
void ReadGroup(const std::string& myGroupLabel, std::ifstream& in_stream, TDataSet& theDataSet);
void Write(std::ofstream& out_stream, const TDataSet& theDataSet);
-};
+}
#endif
const std::string& part_name); // can store a mesh name
// const TDataSet& theDataSet);
-};
+}
#endif
resLine.resize( resLine.size()-1 );
return resLine;
}
-};
+}
#ifndef MESSAGE
static int MYDEBUG = 0;
static int MYVALUEDEBUG = 0;
#else
-static int MYDEBUG = 0;
-static int MYVALUEDEBUG = 0;
+static int MYDEBUG = 0; // todo: unused in release mode
+static int MYVALUEDEBUG = 0; // todo: unused in release mode
#endif
namespace MED
//---------------------------------------------------------------
TEntity2FamilySet
- GetEntity2FamilySet(const PWrapper& theWrapper,
+ GetEntity2FamilySet(const PWrapper& /*theWrapper*/,
const TEntity2TGeom2ElemInfo& theEntity2TGeom2ElemInfo,
const TFamilyInfoSet& theFamilyInfoSet)
{
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;
}
static int MYDEBUG = 0;
static int MYVALUEDEBUG = 0;
#else
-static int MYDEBUG = 0;
-static int MYVALUEDEBUG = 0;
+static int MYDEBUG = 0; // todo: unused in release mode
+static int MYVALUEDEBUG = 0; // todo: unused in release mode
#endif
namespace MED
TGaussInfo::TLess
::operator()(const TGaussInfo& theLeft, const TGaussInfo& theRight) const
{
- if(!&theLeft)
+ if(!&theLeft) // todo: address of reference can be assumed always non-null by compiler
return true;
- if(!&theRight)
+ if(!&theRight) // todo: address of reference can be assumed always non-null by compiler
return false;
if(theLeft.myGeom != theRight.myGeom)
switch(aDim){
case 3:
aCoord[2] = myCoord[aDim*theId+2];
+ // fall through
case 2:
aCoord[1] = myCoord[aDim*theId+1];
- case 1:{
+ // fall through
+ case 1:
aCoord[0] = myCoord[aDim*theId];
break;
}
- }
} else {
TFloatVector aVecX = this->GetIndexes(0);
const TGeom2Size& theGeom2Size,
const TGeom2NbGauss& theGeom2NbGauss,
TInt theNumDt,
- TInt theNumOrd,
+ TInt /*theNumOrd*/,
TFloat theDt,
const std::string& theUnitDt,
const TGeom2Gauss& theGeom2Gauss)
#ifdef _DEBUG_
static int MYDEBUG = 0;
#else
-static int MYDEBUG = 0;
+static int MYDEBUG = 0; // todo: unused in release mode
#endif
int MED::PrefixPrinter::myCounter = 0;
MSG(MYDEBUG,"MED::PrefixPrinter::PrefixPrinter(...)- "<<myCounter);
}
-MED::PrefixPrinter::~PrefixPrinter()
+MED::PrefixPrinter::~PrefixPrinter() noexcept(false)
{
if(myIsActive){
myCounter--;
bool myIsActive;
public:
PrefixPrinter(bool theIsActive = true);
- ~PrefixPrinter();
+ ~PrefixPrinter() noexcept(false);
static std::string GetPrefix();
};
static int MYDEBUG = 0;
static int MYVALUEDEBUG = 0;
#else
-static int MYDEBUG = 0;
-static int MYVALUEDEBUG = 0;
+static int MYDEBUG = 0; // todo: unused in release mode
+static int MYVALUEDEBUG = 0; // todo: unused in release mode
#endif
namespace MED
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????
}
minor = release = -1;
}
- printf("%d.%d.%d\n", major, minor, release);
+ printf("%d.%d.%d\n", (int)major, (int)minor, (int)release);
return 0;
}
#endif
#endif
qualitetrte( R3 *mnpxyd,
- Z & mosoar, Z & mxsoar, Z *mnsoar,
+ Z & mosoar, Z & /*mxsoar*/, Z *mnsoar,
Z & moartr, Z & mxartr, Z *mnartr,
Z & nbtria, R & quamoy, R & quamin )
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
}
-void SMESH_ActorDef::Render(vtkRenderer *ren)
+void SMESH_ActorDef::Render(vtkRenderer* /*ren*/)
{
vtkMTimeType aTime = myTimeStamp->GetMTime();
vtkMTimeType anObjTime = myVisualObj->GetUnstructuredGrid()->GetMTime();
static SMESH_Actor* New() { return NULL;}
public:
- vtkTypeMacro(SMESH_Actor,SALOME_Actor);
+ vtkTypeMacro(SMESH_Actor,SALOME_Actor)
static SMESH_Actor* New(TVisualObjPtr theVisualObj,
const char* theEntry,
const char* theName,
friend class SMESH_Actor;
public:
- vtkTypeMacro(SMESH_ActorDef,SMESH_Actor);
+ vtkTypeMacro(SMESH_ActorDef,SMESH_Actor)
virtual void Delete();
#include <vtkUnstructuredGrid.h>
#include <vtkCellData.h>
-vtkStandardNewMacro(SMESH_CellLabelActor);
+vtkStandardNewMacro(SMESH_CellLabelActor)
/*!
Constructor.
void SMESH_CellLabelActor::ProcessEvents(vtkObject* vtkNotUsed(theObject),
- unsigned long theEvent,
+ unsigned long /*theEvent*/,
void* theClientData,
void* vtkNotUsed(theCallData))
{
void* theCallData);
- vtkTypeMacro(SMESH_CellLabelActor, SMESH_DeviceActor);
+ vtkTypeMacro(SMESH_CellLabelActor, SMESH_DeviceActor)
virtual void SetCellsLabeled(bool theIsCellsLabeled);
using namespace std;
-vtkStandardNewMacro(SMESH_DeviceActor);
+vtkStandardNewMacro(SMESH_DeviceActor)
SMESH_DeviceActor
aNbCells = 0;
for(; anIter != aValues.end(); anIter++){
const Length2D::Value& aValue = *anIter;
- int aNode[2] = {
+ vtkIdType aNode[2] = {
myVisualObj->GetNodeVTKId(aValue.myPntId[0]),
myVisualObj->GetNodeVTKId(aValue.myPntId[1])
};
aNbCells = 0;
for(; anIter != aValues.end(); anIter++){
const MultiConnection2D::Value& aValue = (*anIter).first;
- int aNode[2] = {
+ vtkIdType aNode[2] = {
myVisualObj->GetNodeVTKId(aValue.myPntId[0]),
myVisualObj->GetNodeVTKId(aValue.myPntId[1])
};
FreeEdges::TBorders::const_iterator anIter = aBorders.begin();
for(; anIter != aBorders.end(); anIter++){
const FreeEdges::Border& aBorder = *anIter;
- int aNode[2] = {
+ vtkIdType aNode[2] = {
myVisualObj->GetNodeVTKId(aBorder.myPntId[0]),
myVisualObj->GetNodeVTKId(aBorder.myPntId[1])
};
friend class SMESH_ActorDef;
public:
- vtkTypeMacro(SMESH_DeviceActor,vtkLODActor);
+ vtkTypeMacro(SMESH_DeviceActor,vtkLODActor)
static SMESH_DeviceActor* New();
void SetStoreClippingMapping(bool theStoreMapping);
#endif
-vtkStandardNewMacro(SMESH_ExtractGeometry);
+vtkStandardNewMacro(SMESH_ExtractGeometry)
SMESH_ExtractGeometry::SMESH_ExtractGeometry()
class SMESHOBJECT_EXPORT SMESH_ExtractGeometry : public vtkExtractGeometry{
public:
- vtkTypeMacro(SMESH_ExtractGeometry,vtkExtractGeometry);
+ vtkTypeMacro(SMESH_ExtractGeometry,vtkExtractGeometry)
static SMESH_ExtractGeometry *New();
#define PI 3.14159265359
-vtkStandardNewMacro(SMESH_FaceOrientationFilter);
+vtkStandardNewMacro(SMESH_FaceOrientationFilter)
/*!
* \class SMESH_FaceOrientationFilter
* Execute method. Output calculation.
*/
int SMESH_FaceOrientationFilter::RequestData(
- vtkInformation *request,
+ vtkInformation * /*request*/,
vtkInformationVector **inputVector,
vtkInformationVector *outputVector)
{
class SMESHOBJECT_EXPORT SMESH_FaceOrientationFilter : public vtkPolyDataAlgorithm
{
public:
- vtkTypeMacro( SMESH_FaceOrientationFilter, vtkPolyDataAlgorithm );
+ vtkTypeMacro( SMESH_FaceOrientationFilter, vtkPolyDataAlgorithm )
/*!Create a new SMESH_FaceOrientationFilter.*/
static SMESH_FaceOrientationFilter *New();
#include <vtkRenderer.h>
#include <vtkUnstructuredGrid.h>
-vtkStandardNewMacro(SMESH_NodeLabelActor);
+vtkStandardNewMacro(SMESH_NodeLabelActor)
/*!
Constructor.
void SMESH_NodeLabelActor::ProcessEvents(vtkObject* vtkNotUsed(theObject),
- unsigned long theEvent,
+ unsigned long /*theEvent*/,
void* theClientData,
void* vtkNotUsed(theCallData))
{
void* theCallData);
- vtkTypeMacro(SMESH_NodeLabelActor, SMESH_DeviceActor);
+ vtkTypeMacro(SMESH_NodeLabelActor, SMESH_DeviceActor)
virtual void SetPointsLabeled(bool theIsPointsLabeled);
#include <Utils_SALOME_Exception.hxx>
-vtkStandardNewMacro(SMESH_SVTKActor);
+vtkStandardNewMacro(SMESH_SVTKActor)
/*!
Constructor
public:
static SMESH_SVTKActor* New();
- vtkTypeMacro(SMESH_SVTKActor, SVTK_Actor);
+ vtkTypeMacro(SMESH_SVTKActor, SVTK_Actor)
void SetBallScale(double theSize);
void SetBallSize(float theSize);
#define SHRINK_COEF 0.08;
-vtkStandardNewMacro(SMESH_ScalarBarActor);
+vtkStandardNewMacro(SMESH_ScalarBarActor)
-vtkCxxSetObjectMacro(SMESH_ScalarBarActor,LookupTable,vtkScalarsToColors);
-vtkCxxSetObjectMacro(SMESH_ScalarBarActor,LabelTextProperty,vtkTextProperty);
-vtkCxxSetObjectMacro(SMESH_ScalarBarActor,TitleTextProperty,vtkTextProperty);
+vtkCxxSetObjectMacro(SMESH_ScalarBarActor,LookupTable,vtkScalarsToColors)
+vtkCxxSetObjectMacro(SMESH_ScalarBarActor,LabelTextProperty,vtkTextProperty)
+vtkCxxSetObjectMacro(SMESH_ScalarBarActor,TitleTextProperty,vtkTextProperty)
//----------------------------------------------------------------------------
// Instantiate object with 64 maximum colors; 5 labels; %%-#6.3g label
public:
void PrintSelf(ostream& os, vtkIndent indent);
- vtkTypeMacro(SMESH_ScalarBarActor,vtkActor2D);
+ vtkTypeMacro(SMESH_ScalarBarActor,vtkActor2D)
// Description:
// Instantiate object with 64 maximum colors; 5 labels; %%-#6.3g label
namespace PluginUtils
{
PLUGINUTILS_EXPORT QString PrintDoubleValue( double, int = 16 );
-};
+}
#endif // _GEOMSELECTIONTOOLS_H_
*
* @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];
* \brief Return ranges of indices (from,to) of elements having a given value
*/
bool GetIndices( const attr_t theValue, TIndexRanges & theIndices,
- const attr_t* theMinValue = 0, const attr_t* theMaxValue = 0) const
+ const attr_t* /*theMinValue*/ = 0, const attr_t* /*theMaxValue*/ = 0) const
{
bool isFound = false;
{ 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
#include <iostream>
#endif
-int main (int argc, char ** argv)
+int main ()
{
// To better understand what is going on here, consult bug [SALOME platform 0019911]
#if !defined WIN32 && !defined __APPLE__
*/
//================================================================================
-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;
void SetType (const SMDSAbs_ElementType theType);
void Clear();
- void Reserve(size_t nbElems) {}
+ void Reserve(size_t /*nbElems*/) {}
bool Add(const SMDS_MeshElement * theElem);
bool Remove(const SMDS_MeshElement * theElem);
bool IsEmpty() const { return myElements.empty(); }
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 SMDSAbs_GeometryType GetGeomType() const { return SMDSGeom_POLYGON; }
virtual bool IsPoly() const { return true; }
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 NbNodes(); }
virtual int NbNodes() const;
SMDS_Ptr( T * pos = (T *) 0, bool isOwner=true ):
std::unique_ptr< T >( pos ), myIsOwner( isOwner ) {}
- SMDS_Ptr( const SMDS_Ptr& from ) : myIsOwner( from.myIsOwner )
+ SMDS_Ptr( const SMDS_Ptr& from ) : std::unique_ptr< T >(), myIsOwner( from.myIsOwner )
{ this->swap( const_cast<SMDS_Ptr&>( from )); }
SMDS_Ptr& operator=( const SMDS_Ptr& from )
template <typename VALUE>
struct PassAllValueFilter
{
- bool operator()(const VALUE& t ) { return true; }
+ bool operator()(const VALUE& /*t*/ ) { return true; }
};
template <typename VALUE>
}
void SMDS_UnstructuredGrid::copyNodes(vtkPoints * newPoints,
- std::vector<int>& idNodesOldToNew,
+ std::vector<int>& /*idNodesOldToNew*/,
int& alreadyCopied,
int start,
int end)
* Downward connectivity is no more valid if vtkUnstructuredGrid is modified.
*
*/
-void SMDS_UnstructuredGrid::BuildDownwardConnectivity(bool withEdges)
+void SMDS_UnstructuredGrid::BuildDownwardConnectivity(bool /*withEdges*/)
{
MESSAGE("SMDS_UnstructuredGrid::BuildDownwardConnectivity");CHRONO(2);
// TODO calcul partiel sans edges
GuessSize[VTK_QUADRATIC_HEXAHEDRON] = nbQuadHexa;
GuessSize[VTK_TRIQUADRATIC_HEXAHEDRON] = nbQuadHexa;
GuessSize[VTK_HEXAGONAL_PRISM] = nbHexPrism;
+ (void)GuessSize; // unused in Release mode
_downArray[VTK_LINE] ->allocate(nbLineGuess);
_downArray[VTK_QUADRATIC_EDGE] ->allocate(nbQuadEdgeGuess);
case 15:
if ( faceIndex == 0 || faceIndex == 1 )
ind = 1 - faceIndex;
- break;
+ break;
case 8:
case 12:
if ( faceIndex <= 1 ) // top or bottom
case QUAD_TETRA:
{
switch ( minInd ) {
- case 0: if( maxInd==4 || maxInd==6 || maxInd==7 ) return true;
- case 1: if( maxInd==4 || maxInd==5 || maxInd==8 ) return true;
- case 2: if( maxInd==5 || maxInd==6 || maxInd==9 ) return true;
- case 3: if( maxInd==7 || maxInd==8 || maxInd==9 ) return true;
+ case 0: if( maxInd==4 || maxInd==6 || maxInd==7 ) return true; // fall through
+ case 1: if( maxInd==4 || maxInd==5 || maxInd==8 ) return true; // fall through
+ case 2: if( maxInd==5 || maxInd==6 || maxInd==9 ) return true; // fall through
+ case 3: if( maxInd==7 || maxInd==8 || maxInd==9 ) return true; // fall through
default:;
}
break;
case QUAD_HEXA:
{
switch ( minInd ) {
- case 0: if( maxInd==8 || maxInd==11 || maxInd==16 ) return true;
- case 1: if( maxInd==8 || maxInd==9 || maxInd==17 ) return true;
- case 2: if( maxInd==9 || maxInd==10 || maxInd==18 ) return true;
- case 3: if( maxInd==10 || maxInd==11 || maxInd==19 ) return true;
- case 4: if( maxInd==12 || maxInd==15 || maxInd==16 ) return true;
- case 5: if( maxInd==12 || maxInd==13 || maxInd==17 ) return true;
- case 6: if( maxInd==13 || maxInd==14 || maxInd==18 ) return true;
- case 7: if( maxInd==14 || maxInd==15 || maxInd==19 ) return true;
+ case 0: if( maxInd==8 || maxInd==11 || maxInd==16 ) return true; // fall through
+ case 1: if( maxInd==8 || maxInd==9 || maxInd==17 ) return true; // fall through
+ case 2: if( maxInd==9 || maxInd==10 || maxInd==18 ) return true; // fall through
+ case 3: if( maxInd==10 || maxInd==11 || maxInd==19 ) return true; // fall through
+ case 4: if( maxInd==12 || maxInd==15 || maxInd==16 ) return true; // fall through
+ case 5: if( maxInd==12 || maxInd==13 || maxInd==17 ) return true; // fall through
+ case 6: if( maxInd==13 || maxInd==14 || maxInd==18 ) return true; // fall through
+ case 7: if( maxInd==14 || maxInd==15 || maxInd==19 ) return true; // fall through
default:;
}
break;
case QUAD_PYRAM:
{
switch ( minInd ) {
- case 0: if( maxInd==5 || maxInd==8 || maxInd==9 ) return true;
- case 1: if( maxInd==5 || maxInd==6 || maxInd==10 ) return true;
- case 2: if( maxInd==6 || maxInd==7 || maxInd==11 ) return true;
- case 3: if( maxInd==7 || maxInd==8 || maxInd==12 ) return true;
+ case 0: if( maxInd==5 || maxInd==8 || maxInd==9 ) return true; // fall through
+ case 1: if( maxInd==5 || maxInd==6 || maxInd==10 ) return true; // fall through
+ case 2: if( maxInd==6 || maxInd==7 || maxInd==11 ) return true; // fall through
+ case 3: if( maxInd==7 || maxInd==8 || maxInd==12 ) return true; // fall through
case 4: if( maxInd==9 || maxInd==10 || maxInd==11 || maxInd==12 ) return true;
default:;
}
case QUAD_PENTA:
{
switch ( minInd ) {
- case 0: if( maxInd==6 || maxInd==8 || maxInd==12 ) return true;
- case 1: if( maxInd==6 || maxInd==7 || maxInd==13 ) return true;
- case 2: if( maxInd==7 || maxInd==8 || maxInd==14 ) return true;
- case 3: if( maxInd==9 || maxInd==11 || maxInd==12 ) return true;
- case 4: if( maxInd==9 || maxInd==10 || maxInd==13 ) return true;
- case 5: if( maxInd==10 || maxInd==11 || maxInd==14 ) return true;
+ case 0: if( maxInd==6 || maxInd==8 || maxInd==12 ) return true; // fall through
+ case 1: if( maxInd==6 || maxInd==7 || maxInd==13 ) return true; // fall through
+ case 2: if( maxInd==7 || maxInd==8 || maxInd==14 ) return true; // fall through
+ case 3: if( maxInd==9 || maxInd==11 || maxInd==12 ) return true; // fall through
+ case 4: if( maxInd==9 || maxInd==10 || maxInd==13 ) return true; // fall through
+ case 5: if( maxInd==10 || maxInd==11 || maxInd==14 ) return true; // fall through
default:;
}
break;
OCC_CATCH_SIGNALS;
return BRepLProp::Continuity(C1, C2, u1, u2, tol, angTol);
}
- catch (Standard_Failure) {
+ catch (Standard_Failure&) {
}
return GeomAbs_C0;
}
//purpose : Return true if the algorithm can mesh a given shape
//=======================================================================
-bool SMESH_Algo::IsApplicableToShape(const TopoDS_Shape & shape, bool toCheckAll) const
+bool SMESH_Algo::IsApplicableToShape(const TopoDS_Shape & /*shape*/, bool /*toCheckAll*/) const
{
return true;
}
{
_error = COMPERR_OK;
_comment.clear();
- list<const SMDS_MeshElement*>::iterator elem = _badInputElements.begin();
- for ( ; elem != _badInputElements.end(); ++elem )
- if ( (*elem)->GetID() < 1 )
- delete *elem;
+ for ( const SMDS_MeshElement* & elem : _badInputElements )
+ if ( !elem->IsNull() && elem->GetID() < 1 )
+ delete elem;
_badInputElements.clear();
_mesh = 0;
SMDS_ElemIteratorPtr eIt = sm->GetElements();
while ( eIt->more() ) addBadInputElement( eIt->next() );
}
+ _mesh = sm->GetParent();
}
}
//purpose : Return true if the algorithm can mesh a given shape
//=======================================================================
-bool SMESH_1D_Algo::IsApplicableToShape(const TopoDS_Shape & shape, bool toCheckAll) const
+bool SMESH_1D_Algo::IsApplicableToShape(const TopoDS_Shape & shape, bool /*toCheckAll*/) const
{
return ( !shape.IsNull() && TopExp_Explorer( shape, TopAbs_EDGE ).More() );
}
//purpose : Return true if the algorithm can mesh a given shape
//=======================================================================
-bool SMESH_2D_Algo::IsApplicableToShape(const TopoDS_Shape & shape, bool toCheckAll) const
+bool SMESH_2D_Algo::IsApplicableToShape(const TopoDS_Shape & shape, bool /*toCheckAll*/) const
{
return ( !shape.IsNull() && TopExp_Explorer( shape, TopAbs_FACE ).More() );
}
//purpose : Return true if the algorithm can mesh a given shape
//=======================================================================
-bool SMESH_3D_Algo::IsApplicableToShape(const TopoDS_Shape & shape, bool toCheckAll) const
+bool SMESH_3D_Algo::IsApplicableToShape(const TopoDS_Shape & shape, bool /*toCheckAll*/) const
{
return ( !shape.IsNull() && TopExp_Explorer( shape, TopAbs_SOLID ).More() );
}
#define env_sep ':'
#endif
+namespace
+{
+ // a structure used to nullify SMESH_Gen field of SMESH_Hypothesis,
+ // which is needed for SMESH_Hypothesis not deleted before ~SMESH_Gen()
+ struct _Hyp : public SMESH_Hypothesis
+ {
+ void NullifyGen()
+ {
+ _gen = 0;
+ }
+ };
+
+ //================================================================================
+ /*!
+ * \brief Fill a map of shapes with all sub-shape of a sub-mesh
+ */
+ //================================================================================
+
+ TopTools_IndexedMapOfShape * fillAllowed( SMESH_subMesh* sm,
+ const bool toFill,
+ TopTools_IndexedMapOfShape * allowedSub )
+ {
+ if ( !toFill || !allowedSub )
+ {
+ return nullptr;
+ }
+ if ( allowedSub->IsEmpty() )
+ {
+ allowedSub->ReSize( sm->DependsOn().size() + 1 );
+ allowedSub->Add( sm->GetSubShape() );
+ for ( const auto & key_sm : sm->DependsOn() )
+ allowedSub->Add( key_sm.second->GetSubShape() );
+ }
+ return allowedSub;
+ }
+}
+
//=============================================================================
/*!
* Constructor
_compute_canceled = false;
}
-namespace
-{
- // a structure used to nullify SMESH_Gen field of SMESH_Hypothesis,
- // which is needed for SMESH_Hypothesis not deleted before ~SMESH_Gen()
- struct _Hyp : public SMESH_Hypothesis
- {
- void NullifyGen()
- {
- _gen = 0;
- }
- };
-}
-
//=============================================================================
/*!
* Destructor
//=============================================================================
SMESH_Mesh* SMESH_Gen::CreateMesh(bool theIsEmbeddedMode)
- throw(SALOME_Exception)
{
Unexpect aCatch(SalomeException);
*/
//=============================================================================
-bool SMESH_Gen::Compute(SMESH_Mesh & aMesh,
- const TopoDS_Shape & aShape,
- const int aFlags /*= COMPACT_MESH*/,
- const ::MeshDimension aDim /*=::MeshDim_3D*/,
- TSetOfInt* aShapesId /*=0*/)
+bool SMESH_Gen::Compute(SMESH_Mesh & aMesh,
+ const TopoDS_Shape & aShape,
+ const int aFlags /*= COMPACT_MESH*/,
+ const ::MeshDimension aDim /*=::MeshDim_3D*/,
+ TSetOfInt* aShapesId /*=0*/,
+ TopTools_IndexedMapOfShape* anAllowedSubShapes/*=0*/)
{
MEMOSTAT;
bool ret = true;
- SMESH_subMesh *sm = aMesh.GetSubMesh(aShape);
+ SMESH_subMesh *sm, *shapeSM = aMesh.GetSubMesh(aShape);
const bool includeSelf = true;
const bool complexShapeFirst = true;
if ( !aMesh.HasShapeToMesh() )
computeEvent = SMESH_subMesh::COMPUTE_NOGEOM; // if several algos and no geometry
+ TopTools_IndexedMapOfShape *allowedSubShapes = anAllowedSubShapes, allowedSub;
+ if ( aShapeOnly && !allowedSubShapes )
+ allowedSubShapes = &allowedSub;
+
if ( anUpward ) // is called from the below code in this method
{
// ===============================================
// Mesh all the sub-shapes starting from vertices
// ===============================================
- smIt = sm->getDependsOnIterator(includeSelf, !complexShapeFirst);
+ smIt = shapeSM->getDependsOnIterator(includeSelf, !complexShapeFirst);
while ( smIt->more() )
{
SMESH_subMesh* smToCompute = smIt->next();
{
if (_compute_canceled)
return false;
+ smToCompute->SetAllowedSubShapes( fillAllowed( shapeSM, aShapeOnly, allowedSubShapes ));
setCurrentSubMesh( smToCompute );
smToCompute->ComputeStateEngine( computeEvent );
- setCurrentSubMesh( NULL );
+ setCurrentSubMesh( nullptr );
+ smToCompute->SetAllowedSubShapes( nullptr );
}
// we check all the sub-meshes here and detect if any of them failed to compute
TopoDS_Shape algoShape;
int prevShapeDim = -1, aShapeDim;
- smIt = sm->getDependsOnIterator(includeSelf, complexShapeFirst);
+ smIt = shapeSM->getDependsOnIterator(includeSelf, complexShapeFirst);
while ( smIt->more() )
{
SMESH_subMesh* smToCompute = smIt->next();
{
if (_compute_canceled)
return false;
+ smToCompute->SetAllowedSubShapes( fillAllowed( shapeSM, aShapeOnly, allowedSubShapes ));
setCurrentSubMesh( smToCompute );
smToCompute->ComputeStateEngine( computeEvent );
- setCurrentSubMesh( NULL );
+ setCurrentSubMesh( nullptr );
+ smToCompute->SetAllowedSubShapes( nullptr );
if ( aShapesId )
aShapesId->insert( smToCompute->GetId() );
}
const TopoDS_Shape& aSubShape = smToCompute->GetSubShape();
const int aShapeDim = GetShapeDim( aSubShape );
- //if ( aSubShape.ShapeType() == TopAbs_VERTEX ) continue;
if ( aShapeDim < 1 ) continue;
// check for preview dimension limitations
if ( SMESH_Algo* subAlgo = (SMESH_Algo*) aMesh.GetHypothesis( smToCompute, filter, true))
{
if ( ! subAlgo->NeedDiscreteBoundary() ) continue;
+ TopTools_IndexedMapOfShape* localAllowed = allowedSubShapes;
+ if ( localAllowed && localAllowed->IsEmpty() )
+ localAllowed = 0; // prevent fillAllowed() with aSubShape
+
SMESH_Hypothesis::Hypothesis_Status status;
if ( subAlgo->CheckHypothesis( aMesh, aSubShape, status ))
// mesh a lower smToCompute starting from vertices
- Compute( aMesh, aSubShape, aFlags | SHAPE_ONLY_UPWARD, aDim, aShapesId );
- // Compute( aMesh, aSubShape, aShapeOnly, /*anUpward=*/true, aDim, aShapesId );
+ Compute( aMesh, aSubShape, aFlags | SHAPE_ONLY_UPWARD, aDim, aShapesId, localAllowed );
}
}
}
if (_compute_canceled)
return false;
+ sm->SetAllowedSubShapes( fillAllowed( shapeSM, aShapeOnly, allowedSubShapes ));
setCurrentSubMesh( sm );
sm->ComputeStateEngine( computeEvent );
setCurrentSubMesh( NULL );
+ sm->SetAllowedSubShapes( nullptr );
if ( aShapesId )
aShapesId->insert( sm->GetId() );
}
// -----------------------------------------------
// mesh the rest sub-shapes starting from vertices
// -----------------------------------------------
- ret = Compute( aMesh, aShape, aFlags | UPWARD, aDim, aShapesId );
+ ret = Compute( aMesh, aShape, aFlags | UPWARD, aDim, aShapesId, allowedSubShapes );
}
MEMOSTAT;
SMESH_MesherHelper aHelper( aMesh );
if ( aHelper.IsQuadraticMesh() != SMESH_MesherHelper::LINEAR )
{
- aHelper.FixQuadraticElements( sm->GetComputeError() );
+ aHelper.FixQuadraticElements( shapeSM->GetComputeError() );
}
}
* Prepare Compute a mesh
*/
//=============================================================================
-void SMESH_Gen::PrepareCompute(SMESH_Mesh & aMesh,
- const TopoDS_Shape & aShape)
+void SMESH_Gen::PrepareCompute(SMESH_Mesh & /*aMesh*/,
+ const TopoDS_Shape & /*aShape*/)
{
_compute_canceled = false;
resetCurrentSubMesh();
* Cancel Compute a mesh
*/
//=============================================================================
-void SMESH_Gen::CancelCompute(SMESH_Mesh & aMesh,
- const TopoDS_Shape & aShape)
+void SMESH_Gen::CancelCompute(SMESH_Mesh & /*aMesh*/,
+ const TopoDS_Shape & /*aShape*/)
{
_compute_canceled = true;
if ( const SMESH_subMesh* sm = GetCurrentSubMesh() )
}
// get a separator from rootDir
- for ( pos = strlen( rootDir )-1; pos >= 0 && sep.empty(); --pos )
- if ( rootDir[pos] == '/' || rootDir[pos] == '\\' )
+ for ( int i = strlen( rootDir )-1; i >= 0 && sep.empty(); --i )
+ if ( rootDir[i] == '/' || rootDir[i] == '\\' )
{
- sep = rootDir[pos];
+ sep = rootDir[i];
break;
}
#ifdef WIN32
#include <string>
#include <TopoDS_Shape.hxx>
+#include <TopTools_IndexedMapOfShape.hxx>
class SMESHDS_Document;
class SMESH_Algo;
SMESH_Gen();
~SMESH_Gen();
- SMESH_Mesh* CreateMesh(bool theIsEmbeddedMode)
- throw(SALOME_Exception);
+ SMESH_Mesh* CreateMesh(bool theIsEmbeddedMode);
enum ComputeFlags
{
* \param aFlags - ComputeFlags. By default compute the whole mesh and compact at the end.
* \param aDim - upper level dimension of the mesh computation (for preview)
* \param aShapesId - list of shapes with computed mesh entities (elements or nodes)
+ * \param anAllowedSubShapes - shapes to mesh only. Mesh all if empty or nullptr
* \retval bool - true if none sub-mesh failed to compute
*/
- bool Compute(::SMESH_Mesh & aMesh,
- const TopoDS_Shape & aShape,
- const int aFlags = COMPACT_MESH,
- const ::MeshDimension aDim=::MeshDim_3D,
- TSetOfInt* aShapesId=0);
+ bool Compute(::SMESH_Mesh & aMesh,
+ const TopoDS_Shape & aShape,
+ const int aFlags = COMPACT_MESH,
+ const ::MeshDimension aDim=::MeshDim_3D,
+ TSetOfInt* aShapesId=0,
+ TopTools_IndexedMapOfShape* anAllowedSubShapes=0);
void PrepareCompute(::SMESH_Mesh & aMesh,
const TopoDS_Shape & aShape);
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 ));
//=======================================================================
//function : IsMoreLocalThanPredicate::IsOk
-//purpose :
+//purpose : Check if aShape is more local than this->_shape
//=======================================================================
bool SMESH_HypoFilter::IsMoreLocalThanPredicate::IsOk(const SMESH_Hypothesis* aHyp,
if ( SMESH_MesherHelper::IsSubShape( aShape, /*mainShape=*/_shape ))
return true;
- if ( aShape.ShapeType() == TopAbs_COMPOUND &&
+ if ( aShape.ShapeType() == TopAbs_COMPOUND &&
!SMESH_MesherHelper::IsSubShape( _shape, /*mainShape=*/aShape)) // issue 0020963
{
- for ( int type = TopAbs_SOLID; type < TopAbs_SHAPE; ++type )
- if ( aHyp->GetDim() == SMESH_Gen::GetShapeDim( TopAbs_ShapeEnum( type )))
- for ( TopExp_Explorer exp( aShape, TopAbs_ShapeEnum( type )); exp.More(); exp.Next())
- if ( SMESH_MesherHelper::IsSubShape( exp.Current(), /*mainShape=*/_shape ))
- return true;
+ // [bos#22320] compound of FACEs is MORE local than compound of SOLIDs
+ TopAbs_ShapeEnum givenType = SMESH_MesherHelper::GetGroupType( _shape );
+ TopAbs_ShapeEnum hypType = SMESH_MesherHelper::GetGroupType( aShape );
+ if ( SMESH_Gen::GetShapeDim( givenType ) > SMESH_Gen::GetShapeDim( hypType ))
+ {
+ for ( int type = TopAbs_SOLID; type < TopAbs_SHAPE; ++type )
+ if ( aHyp->GetDim() == SMESH_Gen::GetShapeDim( TopAbs_ShapeEnum( type )))
+ for ( TopExp_Explorer exp( aShape, TopAbs_ShapeEnum( type )); exp.More(); exp.Next())
+ if ( SMESH_MesherHelper::IsSubShape( exp.Current(), /*mainShape=*/_shape ))
+ return true;
+ }
}
+ // take forced sub-mesh priority into account
if ( _preferableShapes.Contains( aShape ))
return true; // issue 21559, Mesh_6
//=======================================================================
//function : SMESH_HypoFilter
-//purpose :
+//purpose :
//=======================================================================
SMESH_HypoFilter::SMESH_HypoFilter()
enum Logical { AND, AND_NOT, OR, OR_NOT };
enum Comparison { EQUAL, NOT_EQUAL, MORE, LESS };
- SMESH_HypoFilter(const SMESH_HypoFilter& other){}
+ SMESH_HypoFilter(const SMESH_HypoFilter& /*other*/){}
void add( Logical bool_op, SMESH_HypoPredicate* pred )
{
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 );
-
return aSubMesh;
}
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"));
bool SMESH_Mesh::SortByMeshOrder(std::vector<SMESH_subMesh*>& theListToSort) const
{
- if ( !_mySubMeshOrder.size() || theListToSort.size() < 2)
+ if ( _mySubMeshOrder.empty() || theListToSort.size() < 2 )
return true;
-
- bool res = false;
- std::vector<SMESH_subMesh*> onlyOrderedList, smVec;
- // collect all ordered submeshes in one list as pointers
+
+ // collect all ordered sub-meshes in smVec as pointers
// and get their positions within theListToSort
+
+ std::vector<SMESH_subMesh*> smVec;
typedef std::vector<SMESH_subMesh*>::iterator TPosInList;
- std::map< int, TPosInList > sortedPos;
+ std::map< size_t, size_t > sortedPos; // index in theListToSort to order
TPosInList smBeg = theListToSort.begin(), smEnd = theListToSort.end();
TListOfListOfInt::const_iterator listIdsIt = _mySubMeshOrder.begin();
+ bool needSort = false;
for( ; listIdsIt != _mySubMeshOrder.end(); listIdsIt++)
{
const TListOfInt& listOfId = *listIdsIt;
// find smVec items in theListToSort
for ( size_t i = 0; i < smVec.size(); ++i )
{
- TPosInList smPos = find( smBeg, smEnd, smVec[i] );
- if ( smPos != smEnd ) {
- sortedPos[ std::distance( smBeg, smPos )] = smPos;
- if ( sortedPos.size() > onlyOrderedList.size() )
- onlyOrderedList.push_back( smVec[i] );
+ TPosInList smPos = find( smBeg, smEnd, smVec[i] ); // position in theListToSort
+ if ( smPos != smEnd )
+ {
+ size_t posInList = std::distance( smBeg, smPos );
+ size_t order = sortedPos.size();
+ sortedPos.insert( std::make_pair( posInList, order ));
+ if ( posInList != order )
+ needSort = true;
}
}
}
- if (onlyOrderedList.size() < 2)
- return res;
- res = true;
+ if ( ! needSort )
+ return false;
- std::vector<SMESH_subMesh*>::iterator onlyBIt = onlyOrderedList.begin();
- std::vector<SMESH_subMesh*>::iterator onlyEIt = onlyOrderedList.end();
+ // set sm of sortedPos from theListToSort to front of orderedSM
+ // and the rest of theListToSort to orderedSM end
- // iterate on ordered sub-meshes and insert them in detected positions
- std::map< int, TPosInList >::iterator i_pos = sortedPos.begin();
- for ( ; onlyBIt != onlyEIt; ++onlyBIt, ++i_pos )
- *(i_pos->second) = *onlyBIt;
+ std::vector<SMESH_subMesh*> orderedSM;
+ orderedSM.reserve( theListToSort.size() );
+ orderedSM.resize( sortedPos.size() );
- return res;
+ size_t iPrev = 0;
+ sortedPos.insert( std::make_pair( theListToSort.size(), sortedPos.size() ));
+ for ( const auto & pos_order : sortedPos )
+ {
+ const size_t& posInList = pos_order.first;
+ const size_t& order = pos_order.second;
+ if ( order < sortedPos.size() - 1 )
+ orderedSM[ order ] = theListToSort[ posInList ];
+
+ if ( iPrev < posInList )
+ orderedSM.insert( orderedSM.end(),
+ theListToSort.begin() + iPrev,
+ theListToSort.begin() + posInList );
+ iPrev = posInList + 1;
+ }
+
+ theListToSort.swap( orderedSM );
+
+ return true;
}
//================================================================================
bool theMakeRequiredGroups = true );
SMESH_Hypothesis::Hypothesis_Status
- AddHypothesis(const TopoDS_Shape & aSubShape, int anHypId, std::string* error=0)
- throw(SALOME_Exception);
+ AddHypothesis(const TopoDS_Shape & aSubShape, int anHypId, std::string* error=0);
SMESH_Hypothesis::Hypothesis_Status
- RemoveHypothesis(const TopoDS_Shape & aSubShape, int anHypId)
- throw(SALOME_Exception);
+ RemoveHypothesis(const TopoDS_Shape & aSubShape, int anHypId);
const std::list <const SMESHDS_Hypothesis * >&
- GetHypothesisList(const TopoDS_Shape & aSubShape) const
- throw(SALOME_Exception);
+ GetHypothesisList(const TopoDS_Shape & aSubShape) const;
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 *GetSubMesh(const TopoDS_Shape & aSubShape);
- SMESH_subMesh *GetSubMeshContaining(const TopoDS_Shape & aSubShape) const
- throw(SALOME_Exception);
+ SMESH_subMesh *GetSubMeshContaining(const TopoDS_Shape & aSubShape) const;
- SMESH_subMesh *GetSubMeshContaining(const int aShapeID) const
- throw(SALOME_Exception);
+ SMESH_subMesh *GetSubMeshContaining(const int aShapeID) const;
/*!
* \brief Return submeshes of groups containing the given subshape
*/
- std::list<SMESH_subMesh*> GetGroupSubMeshesContaining(const TopoDS_Shape & shape) const
- throw(SALOME_Exception);
+ std::list<SMESH_subMesh*> GetGroupSubMeshesContaining(const TopoDS_Shape & shape) const;
/*!
* \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 theAutoDimension = false,
bool theAddODOnVertices = false,
double theZTolerance = -1.,
- bool theAllElemsToGroup = false)
- throw(SALOME_Exception);
+ bool theAllElemsToGroup = false);
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;
SMESH_MesherHelper helper( *GetMesh() );
helper.SetElementsOnShape( true );
- SMDS_ElemIteratorPtr faceIt;
- if ( theElems.empty() ) faceIt = GetMeshDS()->elementsIterator(SMDSAbs_Face);
- else faceIt = SMESHUtils::elemSetIterator( theElems );
+ // get standalone groups of faces
+ vector< SMDS_MeshGroup* > allFaceGroups, faceGroups;
+ for ( SMESHDS_GroupBase* grBase : GetMeshDS()->GetGroups() )
+ if ( SMESHDS_Group* group = dynamic_cast<SMESHDS_Group*>( grBase ))
+ if ( group->GetType() == SMDSAbs_Face && !group->IsEmpty() )
+ allFaceGroups.push_back( & group->SMDSGroup() );
bool checkUV;
gp_XY uv [9]; uv[8] = gp_XY(0,0);
Handle(Geom_Surface) surface;
TopLoc_Location loc;
+ SMDS_ElemIteratorPtr faceIt;
+ if ( theElems.empty() ) faceIt = GetMeshDS()->elementsIterator(SMDSAbs_Face);
+ else faceIt = SMESHUtils::elemSetIterator( theElems );
+
while ( faceIt->more() )
{
const SMDS_MeshElement* quad = faceIt->next();
myLastCreatedNodes.push_back( nCentral );
}
- // create 4 triangles
-
helper.SetIsQuadratic ( nodes.size() > 4 );
helper.SetIsBiQuadratic( nodes.size() == 9 );
if ( helper.GetIsQuadratic() )
helper.AddTLinks( static_cast< const SMDS_MeshFace*>( quad ));
+ // select groups to update
+ faceGroups.clear();
+ for ( SMDS_MeshGroup* group : allFaceGroups )
+ if ( group->Remove( quad ))
+ faceGroups.push_back( group );
+
+ // create 4 triangles
+
GetMeshDS()->RemoveFreeElement( quad, subMeshDS, /*fromGroups=*/false );
for ( int i = 0; i < 4; ++i )
SMDS_MeshElement* tria = helper.AddFace( nodes[ i ],
nodes[(i+1)%4],
nCentral );
- ReplaceElemInGroups( tria, quad, GetMeshDS() );
myLastCreatedElems.push_back( tria );
+ for ( SMDS_MeshGroup* group : faceGroups )
+ group->Add( tria );
}
}
}
}
else {
if ( isUPeriodic )
- newUV.SetX( ElCLib::InPeriod( newUV.X(), u1, u2 ));
+ newUV.SetX( ElCLib::InPeriod( newUV.X(), u1, u2 )); // todo: u may be used unitialized
if ( isVPeriodic )
- newUV.SetY( ElCLib::InPeriod( newUV.Y(), v1, v2 ));
+ newUV.SetY( ElCLib::InPeriod( newUV.Y(), v1, v2 )); // todo: v may be used unitialized
// check new UV
// if ( posType != SMDS_TOP_3DSPACE )
// dist2 = pNode.SquareDistance( surface->Value( newUV.X(), newUV.Y() ));
//=======================================================================
int SMESH_MeshEditor::ExtrusParam::
-makeNodesByNormal1D( SMESHDS_Mesh* mesh,
- const SMDS_MeshNode* srcNode,
- std::list<const SMDS_MeshNode*> & newNodes,
- const bool makeMediumNodes)
+makeNodesByNormal1D( SMESHDS_Mesh* /*mesh*/,
+ const SMDS_MeshNode* /*srcNode*/,
+ std::list<const SMDS_MeshNode*> & /*newNodes*/,
+ const bool /*makeMediumNodes*/)
{
throw SALOME_Exception("Extrusion 1D by Normal not implemented");
return 0;
if ( nbEdges > 0 )
break;
}
+ // fall through
default:
{
for ( int di = -1; di <= 1; di += 2 )
//int& GroupID() const { return const_cast< int& >( myGroupID ); }
ComparableElement( const ComparableElement& theSource ) // move copy
+ : boost::container::flat_set< int >()
{
ComparableElement& src = const_cast< ComparableElement& >( theSource );
(int_set&) (*this ) = boost::move( src );
int SMESH_MeshEditor::removeQuadElem(SMESHDS_SubMesh * theSm,
SMDS_ElemIteratorPtr theItr,
- const int theShapeID)
+ const int /*theShapeID*/)
{
int nbElem = 0;
SMESHDS_Mesh* meshDS = GetMeshDS();
if ( SMESH_MeshAlgos::FaceNormal( _elems[1], norm ))
avgNorm += norm;
- gp_XYZ bordDir( SMESH_NodeXYZ( _nodes[0] ) - SMESH_NodeXYZ( _nodes[1] ));
+ gp_XYZ bordDir( SMESH_NodeXYZ( _nodes[0] ) - SMESH_NodeXYZ( _nodes[1] )); // todo: compiler complains about zero-size array
norm = bordDir ^ avgNorm;
}
else
try {
return n2.AngleWithRef(n1, vref);
}
- catch ( Standard_Failure ) {
+ catch ( Standard_Failure& ) {
}
return Max( v1.Magnitude(), v2.Magnitude() );
}
const SMDS_MeshNode* n11,
const SMDS_MeshNode* n12,
const int id,
- bool force3d)
+ bool /*force3d*/)
{
SMESHDS_Mesh * meshDS = GetMeshDS();
SMDS_MeshVolume* elem = 0;
/*!
* \brief Dump QLink and QFace
*/
- ostream& operator << (ostream& out, const QLink& l)
+ ostream& operator << (ostream& out, const QLink& l) // todo: unused in release mode
{
out <<"QLink nodes: "
<< l.node1()->GetID() << " - "
<< l.node2()->GetID() << endl;
return out;
}
- ostream& operator << (ostream& out, const QFace& f)
+ ostream& operator << (ostream& out, const QFace& f) // todo: unused in release mode
{
out <<"QFace nodes: "/*<< &f << " "*/;
for ( TIDSortedNodeSet::const_iterator n = f.begin(); n != f.end(); ++n )
#ifdef _DEBUG_
_face = face;
#endif
+ (void)face; // unused in release mode
}
//================================================================================
/*!
*/
//================================================================================
- bool QFace::IsSpoiled(const QLink* bentLink ) const
+ bool QFace::IsSpoiled(const QLink* bentLink ) const // todo: unused
{
// code is valid for convex faces only
gp_XYZ gc(0,0,0);
if ( curvNorm * D2 > 0 )
continue; // convex edge
}
- catch ( Standard_Failure )
+ catch ( Standard_Failure& )
{
continue;
}
if ( concaveU || concaveV )
concaveFaces.push_back( face );
}
- catch ( Standard_Failure )
+ catch ( Standard_Failure& )
{
concaveFaces.push_back( face );
}
try {
gp_Vec x = x01.Normalized() + x12.Normalized();
trsf.SetTransformation( gp_Ax3( gp::Origin(), link1->Normal(), x), gp_Ax3() );
- } catch ( Standard_Failure ) {
+ } catch ( Standard_Failure& ) {
trsf.Invert();
}
move.Transform(trsf);
case '-': // real number
case '+':
case '.':
- isNumber = true;
+ isNumber = true; // fall through
default: // data
isNumber = isNumber || ( *theLineBeg >= '0' && *theLineBeg <= '9' );
if ( isNumber ) {
elem = aMeshDS->AddFace (nodes[0], nodes[1], nodes[2], nodes[3],
nodes[4], nodes[5] ); break;
} // else do not break but create a polygon
+ // fall through
case 8:
if ( !onMeshElements ) {// create a quadratic face
elem = aMeshDS->AddFace (nodes[0], nodes[1], nodes[2], nodes[3],
nodes[4], nodes[5], nodes[6], nodes[7] ); break;
} // else do not break but create a polygon
+ // fall through
default:
elem = aMeshDS->AddPolygonalFace( nodes );
}
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(); }
};
}
_computeCost = 0; // how costly is to compute this sub-mesh
_realComputeCost = 0;
+ _allowedSubShapes = nullptr;
}
//=============================================================================
return false;
}
+//================================================================================
+/*!
+ * \brief Check if any upper level sub-shape is not computed.
+ * Used to update a sub-mesh icon
+ */
+//================================================================================
+
+bool SMESH_subMesh::IsComputedPartially() const
+{
+ SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(/*includeSelf=*/true,
+ /*SolidFirst=*/true);
+ bool allComputed = true;
+ TopAbs_ShapeEnum readyType = TopAbs_VERTEX; // max value
+ while ( smIt->more() && allComputed )
+ {
+ SMESH_subMesh* sm = smIt->next();
+
+ if ( sm->GetSubShape().ShapeType() > readyType )
+ break; // lower dimension -> stop
+ if ( sm->GetComputeState() != SMESH_subMesh::NOT_READY )
+ readyType = sm->GetSubShape().ShapeType();
+
+ switch ( sm->GetComputeState() )
+ {
+ case SMESH_subMesh::READY_TO_COMPUTE:
+ case SMESH_subMesh::FAILED_TO_COMPUTE:
+ allComputed = false;// sm->IsMeshComputed();
+ break;
+ case SMESH_subMesh::NOT_READY:
+ case SMESH_subMesh::COMPUTE_OK:
+ continue;
+ }
+ }
+ return !allComputed;
+}
+
//=============================================================================
/*!
* Return true if all sub-meshes have been meshed
loadDependentMeshes();
ComputeSubMeshStateEngine( SUBMESH_LOADED );
//break;
+ // fall through
case CHECK_COMPUTE_STATE:
if ( IsMeshComputed() )
_computeState = COMPUTE_OK;
}
break;
}
+ // fall through
case COMPUTE:
case COMPUTE_SUBMESH:
{
if (_father->HasShapeToMesh() ) {
bool subComputed = false, subFailed = false;
if (!algo->OnlyUnaryInput()) {
- if ( event == COMPUTE /*&&
- ( algo->NeedDiscreteBoundary() || algo->SupportSubmeshes() )*/)
- shape = getCollection( gen, algo, subComputed, subFailed, algo->SubMeshesToCompute());
- else
- subComputed = SubMeshesComputed( & subFailed );
+ // --- commented for bos#22320 to compute all sub-shapes at once if possible;
+ // --- in case COMPUTE_SUBMESH, set of sub-shapes is limited
+ // --- by calling SetAllowedSubShapes()
+ // if ( event == COMPUTE )
+ // shape = getCollection( gen, algo, subComputed, subFailed, algo->SubMeshesToComput;
+ // else
+ // subComputed = SubMeshesComputed( & subFailed );
+ shape = getCollection( gen, algo, subComputed, subFailed, algo->SubMeshesToCompute());
}
else {
subComputed = SubMeshesComputed();
((SMESHDS_Hypothesis*)hyps.front())->SaveTo( hypStr.Stream() );
hypStr << " ";
}
- cout << _algo->GetName()
- << " " << _father->GetSubMesh( subS.Current() )->GetId()
+ cout << _father->GetSubMesh( subS.Current() )->GetId()
+ << " " << ( ret ? "OK" : "FAIL" )
+ << " " << _algo->GetName()
<< " " << hypStr << endl;
}
#endif
loadDependentMeshes();
ComputeSubMeshStateEngine( SUBMESH_LOADED );
//break;
+ // fall through
case CHECK_COMPUTE_STATE:
if ( IsMeshComputed() )
_computeState = COMPUTE_OK;
break;
case COMPUTE: // nothing to do
break;
+ case COMPUTE_SUBMESH: // nothing to do
+ break;
case COMPUTE_CANCELED: // nothing to do
break;
case CLEAN:
// meshed at once along with _subShape
//=======================================================================
-TopoDS_Shape SMESH_subMesh::getCollection(SMESH_Gen * theGen,
+TopoDS_Shape SMESH_subMesh::getCollection(SMESH_Gen * /*theGen*/,
SMESH_Algo* theAlgo,
bool & theSubComputed,
bool & theSubFailed,
const TopoDS_Shape& S = subMesh->_subShape;
if ( S.ShapeType() != this->_subShape.ShapeType() )
continue;
+ if ( _allowedSubShapes && !_allowedSubShapes->IsEmpty() && !_allowedSubShapes->Contains( S ))
+ continue;
if ( subMesh == this )
{
aBuilder.Add( aCompound, S );
#include "Utils_SALOME_Exception.hxx"
#include <TopoDS_Shape.hxx>
+#include <TopTools_IndexedMapOfShape.hxx>
#include <list>
#include <map>
bool IsMeshComputed() const;
// check if _subMeshDS contains mesh elements unless _alwaysComputed==true
+ bool IsComputedPartially() const;
+ // check if any upper level sub-shape is not computed
+
+ /*!
+ * \brief Set sub-shapes that are allowed to compute at once by a multidimensional algo
+ */
+ void SetAllowedSubShapes( const TopTools_IndexedMapOfShape* subShapes )
+ { _allowedSubShapes = subShapes; }
+
/*!
* \brief Allow algo->Compute() if a subshape of lower dim is meshed but
* none mesh entity is bound to it
// mesh several edges as a whole and leave some of them without mesh entities
bool _alwaysComputed;
+ const TopTools_IndexedMapOfShape* _allowedSubShapes; // allowed to be returned by getCollection()
+
};
#endif
virtual ~SMESH_subMeshEventListener() {}
bool IsDeletable() const { return myIsDeletable; }
const char* GetName() const { return myName; }
- virtual void BeforeDelete(SMESH_subMesh* subMesh,
- SMESH_subMeshEventListenerData* data)
+ virtual void BeforeDelete(SMESH_subMesh* /*subMesh*/,
+ SMESH_subMeshEventListenerData* /*data*/)
{}
/*!
* \brief Do something on a certain event
//=======================================================================
//function : ChangePolyhedronNodes
//=======================================================================
- inline void ChangePolyhedronNodes (SMDS_Mesh* theMesh,
- SMESH::log_array_var& theSeq,
- CORBA::Long theId)
+ inline void ChangePolyhedronNodes (SMDS_Mesh* /*theMesh*/,
+ SMESH::log_array_var& /*theSeq*/,
+ CORBA::Long /*theId*/)
{
// const SMESH::long_array& anIndexes = theSeq[theId].indexes;
// CORBA::Long iind = 0, aNbElems = theSeq[theId].number;
//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)
{
OCC_CATCH_SIGNALS;
SMESH::UpdateView();
}
- catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
+ catch (std::bad_alloc&) { // PAL16774 (Crash after display of many groups)
SMESH::OnVisuException();
}
catch (...) { // PAL16774 (Crash after display of many groups)
case SMESHOp::OpCreateSubMesh:
if ( warnOnGeomModif() )
break; // action forbiden as geometry modified
-
+ // fall through
case SMESHOp::OpCreateMesh:
case SMESHOp::OpCompute:
case SMESHOp::OpComputeSubMesh:
*
*/
//=============================================================================
-bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
+bool SMESHGUI::OnMousePress( QMouseEvent * /*pe*/, SUIT_ViewWindow * /*wnd*/ )
{
return false;
}
*
*/
//=============================================================================
-bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
+bool SMESHGUI::OnMouseMove( QMouseEvent * /*pe*/, SUIT_ViewWindow * /*wnd*/ )
{
return true;
}
*
*/
//=============================================================================
-bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
+bool SMESHGUI::OnKeyPress( QKeyEvent * /*pe*/, SUIT_ViewWindow * /*wnd*/ )
{
return true;
}
void SMESHGUI::ProcessEvents( vtkObject* theObject,
unsigned long theEvent,
void* theClientData,
- void* theCallData )
+ void* /*theCallData*/ )
{
if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
if( theObject && (int) theEvent == SMESH::DeleteActorEvent ) {
// purpose :
//=================================================================================
-void SMESHGUI_AddQuadraticElementDlg::onReverse (int state)
+void SMESHGUI_AddQuadraticElementDlg::onReverse (int /*state*/)
{
mySimulation->SetVisibility(false);
displaySimulation();
// purpose :
//=================================================================================
-void SMESHGUI_AddQuadraticElementDlg::onCellDoubleClicked( int theRow, int theCol )
+void SMESHGUI_AddQuadraticElementDlg::onCellDoubleClicked( int /*theRow*/, int /*theCol*/ )
{
myCurrentLineEdit = 0;
displaySimulation();
// purpose :
//=================================================================================
-void SMESHGUI_AddQuadraticElementDlg::onCellTextChange(int theRow, int theCol)
+void SMESHGUI_AddQuadraticElementDlg::onCellTextChange(int /*theRow*/, int /*theCol*/)
{
myCurrentLineEdit = 0;
displaySimulation();
public:
static OrientedPlane *New();
static OrientedPlane *New(SVTK_ViewWindow* theViewWindow);
- vtkTypeMacro (OrientedPlane, vtkPlane);
+ vtkTypeMacro (OrientedPlane, vtkPlane)
QPointer<SVTK_ViewWindow> myViewWindow;
SMESH::Orientation myRelativeOrientation;
typedef std::vector<TPlane> TPlaneVector;
typedef std::vector<TPlaneData> TPlaneDataVector;
-};
+}
//=================================================================================
// class : SMESHGUI_ClippingDlg
SMESHGUI_Displayer::SMESHGUI_Displayer( SalomeApp_Application* app )
: LightApp_Displayer(),
- myApp( app )
+ myApp( app ),
+ isNeedFitAll(false)
{
}
anActor = SMESH::CreateActor( entry.toUtf8().data(), true );
if( anActor )
{
+ isNeedFitAll = SMESH::NoSmeshActors();
SMESH::DisplayActor( wnd, anActor );
prs = LightApp_Displayer::buildPresentation( entry.toUtf8().data(), aViewFrame );
}
}
return res;
}
+
+void SMESHGUI_Displayer::Display( const QStringList& theList, const bool anUpdateViewer, SALOME_View* theView )
+{
+ LightApp_Displayer::Display( theList, anUpdateViewer, theView );
+
+ if (isNeedFitAll) {
+ SMESH::FitAll();
+ isNeedFitAll = false;
+ }
+}
\ No newline at end of file
SMESHGUI_Displayer( SalomeApp_Application* );
~SMESHGUI_Displayer();
- virtual SALOME_Prs* buildPresentation( const QString&, SALOME_View* = 0 );
- virtual bool canBeDisplayed( const QString&, const QString& ) const;
+ virtual SALOME_Prs* buildPresentation( const QString&, SALOME_View* = 0 ) override;
+ virtual bool canBeDisplayed( const QString&, const QString& ) const override;
+ virtual void Display( const QStringList&, const bool = true, SALOME_View* = 0) override;
protected:
SalomeApp_Study* study() const;
private:
SalomeApp_Application* myApp;
+ bool isNeedFitAll;
};
#endif // SMESHGUI_DISPLAYER_H
/*!
* \brief SLOT called when a tree item is checked
*/
-void SMESHGUI_FieldSelectorWdg::onItemCheck(QTreeWidgetItem * item, int column)
+void SMESHGUI_FieldSelectorWdg::onItemCheck(QTreeWidgetItem * item, int /*column*/)
{
myTree->blockSignals( true );
if ( !item->parent() ) // mesh item
FirstEntityTypeFilter = FirstGeometryTypeFilter + SMDSGeom_NONE,
LastFilter = FirstEntityTypeFilter + SMDSEntity_Last
};
-};
+}
/*
Class : SMESHGUI_Filter
void SMESHGUI_FilterTable::ComboDelegate::updateEditorGeometry( QWidget* editor,
const QStyleOptionViewItem& option,
- const QModelIndex& index ) const
+ const QModelIndex& /*index*/ ) const
{
editor->setGeometry( option.rect );
}
{
case SMESH::NODE:
typeIds.append( SMDSEntity_Node );
+ break;
case SMESH::EDGE:
typeIds.append( SMDSEntity_Edge );
typeIds.append( SMDSEntity_Quad_Edge );
// Purpose : Provides reaction on change of criterion
//=======================================================================
-void SMESHGUI_FilterTable::onCriterionChanged (const int row, const int col, const int entityType)
+void SMESHGUI_FilterTable::onCriterionChanged (const int row, const int /*col*/, const int entityType)
{
int aType = entityType == -1 ? GetType() : entityType;
Table* aTable = myTables[ aType ];
// Purpose : Create table
//=======================================================================
SMESHGUI_FilterTable::Table* SMESHGUI_FilterTable::createTable (QWidget* theParent,
- const int theType)
+ const int /*theType*/)
{
// create table
Table* aTable= new Table(0, 6, theParent);
myTable->SetThreshold(aRow, SMESH::toQStr( grp->GetName() ));
myTable->SetID (aRow, anIO->getEntry() );
}
+ break;
}
default: // get a GEOM object
{
// name : SMESHGUI_FilterLibraryDlg::onEntityTypeChanged
// Purpose : SLOT. Called when entiyt type changed
//=======================================================================
-void SMESHGUI_FilterLibraryDlg::onEntityTypeChanged(const int theType)
+void SMESHGUI_FilterLibraryDlg::onEntityTypeChanged(const int /*theType*/)
{
if (myLibrary->_is_nil())
return;
case SMESH::FT_BelongToMeshGroup: // get a group name and IOR
{
myTable->SetThreshold(aRow, anIO->getName() );
+ break;
}
default: // get a GEOM object
{
{
GEOM::GEOM_Gen_var GetGEOMGen( GEOM::GEOM_Object_ptr go )
{
- GEOM::GEOM_Gen_ptr gen;
+ GEOM::GEOM_Gen_ptr gen = GEOM::GEOM_Gen::_nil();
if ( !CORBA::is_nil( go ))
gen = go->GetGen();
return gen;
// function : onNameChanged()
// purpose :
//=================================================================================
-void SMESHGUI_GroupDlg::onNameChanged (const QString& text)
+void SMESHGUI_GroupDlg::onNameChanged (const QString& /*text*/)
{
myOldName = myName->text();
updateButtons();
// function : onColorChanged()
// purpose : Color button management
//=================================================================================
-void SMESHGUI_GroupDlg::onColorChanged(QColor theColor)
+void SMESHGUI_GroupDlg::onColorChanged(QColor /*theColor*/)
{
updateButtons();
}
SMESH::SMESH_Hypothesis_ptr CreateHypothesis(const QString& aHypType,
const QString& aHypName,
- const bool isAlgo)
+ const bool /*isAlgo*/)
{
if(MYDEBUG) MESSAGE("Create " << aHypType.toLatin1().data() <<
" with name " << aHypName.toLatin1().data());
}
}
-SUIT_SelectionFilter* SMESHGUI_Make2DFrom3DOp::createFilter( const int theId ) const
+SUIT_SelectionFilter* SMESHGUI_Make2DFrom3DOp::createFilter( const int /*theId*/ ) const
{
SMESHGUI_Make2DFrom3DOp* me = (SMESHGUI_Make2DFrom3DOp*) this;
class SMESHGUI_EXPORT SMESHGUI_MinDistance : public QWidget
{
- Q_OBJECT;
+ Q_OBJECT
enum { NoTgt, FirstTgt, SecondTgt };
enum { OriginTgt, NodeTgt, ElementTgt, ObjectTgt };
class SMESHGUI_EXPORT SMESHGUI_BoundingBox : public QWidget
{
- Q_OBJECT;
+ Q_OBJECT
enum { ObjectsSrc, NodesSrc, ElementsSrc };
class SMESHGUI_EXPORT SMESHGUI_BasicProperties : public QWidget
{
- Q_OBJECT;
+ Q_OBJECT
public:
//! Property type
class SMESHGUI_EXPORT SMESHGUI_Angle : public QWidget
{
- Q_OBJECT;
+ Q_OBJECT
public:
class SMESHGUI_EXPORT SMESHGUI_MeasureDlg : public QDialog
{
- Q_OBJECT;
+ Q_OBJECT
enum { NodeMode, ElemMode };
// IDs to groups or vice versa
//=======================================================================
-void SMESHGUI_MergeDlg::onKeepSourceChanged(int isGroup)
+void SMESHGUI_MergeDlg::onKeepSourceChanged(int /*isGroup*/)
{
KeepList->clear();
SelectKeepButton->click();
//=================================================================================
class SMESHGUI_EXPORT SMESHGUI_MergeDlg : public QDialog
{
- Q_OBJECT;
+ Q_OBJECT
public:
SMESHGUI_MergeDlg( SMESHGUI*, int );
writer->write( SMESHGUI_AddInfo::tr( "TYPE" ), SMESHGUI_AddInfo::tr( "GROUP_ON_FILTER" ) );
}
int size = group.size();
- if ( size != -1 );
- writer->write( SMESHGUI_AddInfo::tr( "SIZE" ), size );
+ if ( size != -1 )
+ writer->write( SMESHGUI_AddInfo::tr( "SIZE" ), size );
QColor color = group.color();
if ( color.isValid() )
writer->write( SMESHGUI_AddInfo::tr( "COLOR" ), color.name() );
writer->write( SMESHGUI_AddInfo::tr( "TYPE" ), SMESHGUI_AddInfo::tr( "GROUP_ON_FILTER" ) );
}
int size = group.size();
- if ( size != -1 );
+ if ( size != -1 )
writer->write( SMESHGUI_AddInfo::tr( "SIZE" ), size );
QColor color = group.color();
if ( color.isValid() )
\param nbNodes number of unique nodes in element
\param parentItem parent item of tree
*/
-void SMESHGUI_TreeElemInfo::nodeInfo( const SMDS_MeshNode* node, int index,
- int nbNodes, QTreeWidgetItem* parentItem )
+void SMESHGUI_TreeElemInfo::nodeInfo( const SMDS_MeshNode* /*node*/, int /*index*/,
+ int /*nbNodes*/, QTreeWidgetItem* /*parentItem*/ )
{
// int precision = SMESHGUI::resourceMgr()->integerValue( "SMESH", "length_precision", 6 );
// // node number and ID
}
}
-void SMESHGUI_TreeElemInfo::itemDoubleClicked( QTreeWidgetItem* theItem, int theColumn )
+void SMESHGUI_TreeElemInfo::itemDoubleClicked( QTreeWidgetItem* theItem, int /*theColumn*/ )
{
if ( theItem ) {
int type = theItem->data( 1, TypeRole ).toInt();
class SMESHGUI_EXPORT SMESHGUI_BaseInfo : public SMESHGUI_Info
{
- Q_OBJECT;
+ Q_OBJECT
enum
{
class SMESHGUI_EXPORT SMESHGUI_ElemInfo : public SMESHGUI_Info
{
- Q_OBJECT;
+ Q_OBJECT
public:
SMESHGUI_ElemInfo( QWidget* = 0 );
class SMESHGUI_EXPORT SMESHGUI_SimpleElemInfo : public SMESHGUI_ElemInfo
{
- Q_OBJECT;
+ Q_OBJECT
public:
SMESHGUI_SimpleElemInfo( QWidget* = 0 );
class SMESHGUI_EXPORT SMESHGUI_TreeElemInfo : public SMESHGUI_ElemInfo
{
- Q_OBJECT;
+ Q_OBJECT
class ItemDelegate;
class ItemCreator;
class InfoComputor: public QObject
{
- Q_OBJECT;
+ Q_OBJECT
public:
enum { GrpSize, GrpNbNodes };
class SMESHGUI_EXPORT SMESHGUI_AddInfo : public SMESHGUI_Info
{
- Q_OBJECT;
+ Q_OBJECT
public:
SMESHGUI_AddInfo( QWidget* = 0 );
class SMESHGUI_EXPORT SMESHGUI_CtrlInfo : public SMESHGUI_Info
{
- Q_OBJECT;
+ Q_OBJECT
public:
SMESHGUI_CtrlInfo( QWidget* = 0 );
class SMESHGUI_EXPORT SMESHGUI_MeshInfoDlg : public QDialog
{
- Q_OBJECT;
+ Q_OBJECT
enum { NodeMode, ElemMode, GroupMode };
class SMESHGUI_EXPORT SMESHGUI_CtrlInfoDlg : public QDialog
{
- Q_OBJECT;
+ Q_OBJECT
public:
SMESHGUI_CtrlInfoDlg( QWidget* = 0 );
THypDataList& theDataList,
HypothesisData* thePrevAlgoData,
HypothesisData* theNextAlgoData,
- const QString& theMeshType)
+ const QString& /*theMeshType*/)
{
theDataList.clear();
theHyps.clear();
* 1 = accepted
*/
//================================================================================
-void SMESHGUI_MeshOp::onHypoEdited( int result )
+void SMESHGUI_MeshOp::onHypoEdited( int /*result*/ )
{
int obj = myDlg->getActiveObject();
onActivateObject( obj ); // Issue 0020170. Restore filters
* \param theIndex - Index of current type of mesh
*/
//================================================================================
-void SMESHGUI_MeshOp::onAlgoSetByMeshType( const int theTabIndex, const int theIndex )
+void SMESHGUI_MeshOp::onAlgoSetByMeshType( const int /*theTabIndex*/, const int /*theIndex*/ )
{
setFilteredAlgoData();
}
{
myDlg = new SMESHGUI_MeshOrderDlg( desktop() );
- myHelpFileName = "constructing_meshes.html#mesh-order-anchor";
+ myHelpFileName = "constructing_meshes.html#submesh-order-anchor";
}
//================================================================================
aNF = aFilterMgr->CreateMultiConnection2D();
else if (myComboBoxFunctor->currentText() == tr("MIN_DIAG_ELEMENTS"))
aNF = aFilterMgr->CreateMaxElementLength2D();
- else;
return aNF._retn();
}
// function : ValueChangedInSpinBox()
// purpose :
//=================================================================================
-void SMESHGUI_NodesDlg::ValueChangedInSpinBox( double newValue )
+void SMESHGUI_NodesDlg::ValueChangedInSpinBox( double /*newValue*/ )
{
if ( !myMesh->_is_nil() ) {
double vx = SpinBox_X->GetValue();
return myMesh;
}
-bool SMESHGUI_PreVisualObj::Update( int theIsClear = true )
+bool SMESHGUI_PreVisualObj::Update( int /*theIsClear*/)
{
return false;
}
// function : onDisplaySimulation
// purpose :
//=================================================================================
-void SMESHGUI_PreviewDlg::onDisplaySimulation(bool toDisplayPreview) {
+void SMESHGUI_PreviewDlg::onDisplaySimulation(bool /*toDisplayPreview*/) {
//Empty implementation here
}
// function : onDisplaySimulation
// purpose :
//=================================================================================
-void SMESHGUI_MultiPreviewDlg::onDisplaySimulation( bool toDisplayPreview )
+void SMESHGUI_MultiPreviewDlg::onDisplaySimulation( bool /*toDisplayPreview*/ )
{
//Empty implementation here
}
// function : enterEvent()
// purpose :
//=================================================================================
-void SMESHGUI_RenumberingDlg::enterEvent(QEvent* e)
+void SMESHGUI_RenumberingDlg::enterEvent(QEvent* /*e*/)
{
if (GroupConstructors->isEnabled())
return;
// function : onAngleTextChange()
// purpose :
//=======================================================================
-void SMESHGUI_RevolutionDlg::onAngleTextChange (const QString& theNewText)
+void SMESHGUI_RevolutionDlg::onAngleTextChange (const QString& /*theNewText*/)
{
bool isNumber;
SpinBox_Angle->text().toDouble( &isNumber );
// name : onDeactivateObject
// purpose :
//=================================================================================
-void SMESHGUI_SelectionOp::onDeactivateObject( int id )
+void SMESHGUI_SelectionOp::onDeactivateObject( int /*id*/ )
{
removeCustomFilters();
}
{
aPRT.node1 = ( aPRT.node1 + size + dn ) % size;
aPRT.node2 = ( aPRT.node2 + size + dn ) % size;
- break;
}
+ break;
case MOVE_LEFT_2:
case MOVE_RIGHT_2:
if (( isClosed ) ||
( 0 <= aPRT.nodeLast+dn && aPRT.nodeLast+dn < size ))
{
aPRT.nodeLast = ( aPRT.nodeLast + size + dn ) % size;
- break;
}
+ break;
default:
return; // impossible to move
}
if (e)
newIndices.Add(e->GetID());
- if (!isEvenOneExists)
- isEvenOneExists = true;
+ if (!isEvenOneExists)
+ isEvenOneExists = true;
}
mySelector->AddOrRemoveIndex(myActor->getIO(), newIndices, false);
// function : enterEvent()
// purpose :
//=================================================================================
-void SMESHGUI_SewingDlg::enterEvent (QEvent* e)
+void SMESHGUI_SewingDlg::enterEvent (QEvent* /*e*/)
{
if (!ConstructorsBox->isEnabled()) {
SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI );
//purpose : SLOT. Called when element type changed.
//=======================================================================
-void SMESHGUI_ShapeByMeshOp::onTypeChanged (int theType)
+void SMESHGUI_ShapeByMeshOp::onTypeChanged (int /*theType*/)
{
setElementID("");
activateSelection();
// name : isValid()
// Purpose : Verify validity of input data
//=======================================================================
-bool SMESHGUI_SingleEditDlg::isValid (const bool theMess) const
+bool SMESHGUI_SingleEditDlg::isValid (const bool /*theMess*/) const
{
int id1, id2;
return getNodeIds(myEdge->text(), id1, id2);
//function : onTextChange()
//purpose :
//=======================================================================
-void SMESHGUI_SingleEditDlg::onTextChange (const QString& theNewText)
+void SMESHGUI_SingleEditDlg::onTextChange (const QString& /*theNewText*/)
{
if (myBusy) return;
BusyLocker lock(myBusy);
*/
//================================================================================
- bool noSmeshActors(SUIT_ViewWindow *theWnd)
+ bool NoSmeshActors(SUIT_ViewWindow *theWnd)
{
- if(SVTK_ViewWindow* aViewWindow = GetVtkViewWindow(theWnd)) {
+ SUIT_ViewWindow* aWnd = ( theWnd == nullptr ) ? GetActiveWindow() : theWnd;
+ if(SVTK_ViewWindow* aViewWindow = GetVtkViewWindow(aWnd)) {
vtkRenderer *aRenderer = aViewWindow->getRenderer();
VTK::ActorCollectionCopy aCopy(aRenderer->GetActors());
vtkActorCollection *aCollection = aCopy.GetActors();
}
aStudy->setVisibilityStateForAll(Qtx::HiddenState);
}
+ // fall through
default: {
if (SMESH_Actor *anActor = FindActorByEntry(theWnd,theEntry)) {
switch (theAction) {
if ( (aVisualObj = GetVisualObj(theEntry)) && aVisualObj->IsValid())
{
if ((anActor = CreateActor(theEntry,true))) {
- bool needFitAll = noSmeshActors(theWnd); // fit for the first object only
+ bool needFitAll = NoSmeshActors(theWnd); // fit for the first object only
DisplayActor(theWnd,anActor);
anActor->SetVisibility(true);
aStudy->setVisibilityState(theEntry, Qtx::ShownState);
int GetSelected(LightApp_SelectionMgr* theMgr,
TColStd_IndexedMapOfInteger& theMap,
- const bool theIsElement)
+ const bool /*theIsElement*/)
{
theMap.Clear();
SALOME_ListIO selected; theMgr->selectedObjects( selected );
SMESHGUI_EXPORT
void UpdateActorsAfterUpdateStudy();
+
+ SMESHGUI_EXPORT
+ bool NoSmeshActors(SUIT_ViewWindow *theWnd=nullptr);
+
};
#endif // SMESHGUI_VTKUTILS_H
//================================================================================
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 )
++cnt;
bordNodes.resize( cnt + 1 );
- BEdge* beLast;
+ BEdge* beLast = 0;
for ( be = borders[i], cnt = 0;
be && cnt < bordNodes.size()-1;
be = be->myNext, ++cnt )
bordNodes[ cnt ] = be->myBNode1->Node();
beLast = be;
}
- bordNodes.back() = beLast->myBNode2->Node();
+ if ( beLast )
+ bordNodes.back() = beLast->myBNode2->Node();
}
}
*/
//================================================================================
- void bndSegsToMesh( const vector< vector< BndSeg > >& bndSegsPerEdge )
+ void bndSegsToMesh( const vector< vector< BndSeg > >& /*bndSegsPerEdge*/ )
{
#ifdef _MYDEBUG_
if ( !getenv("bndSegsToMesh")) return;
{
delete _ebbTree[i]; _ebbTree[i] = NULL;
}
- if ( _nodeSearcher ) delete _nodeSearcher; _nodeSearcher = 0;
+ if ( _nodeSearcher ) delete _nodeSearcher;
+ _nodeSearcher = 0;
}
virtual int FindElementsByPoint(const gp_Pnt& point,
SMDSAbs_ElementType type,
try {
tgtCS = gp_Ax3( xyz[0], OZ, OX );
}
- catch ( Standard_Failure ) {
+ catch ( Standard_Failure& ) {
return badDistance;
}
trsf.SetTransformation( tgtCS );
*/
//====================================================================================
-const bool SMESH_OctreeNode::isInside ( const gp_XYZ& p, const double precision )
+bool SMESH_OctreeNode::isInside ( const gp_XYZ& p, const double precision )
{
if ( precision <= 0.)
return !( getBox()->IsOut(p) );
virtual ~SMESH_OctreeNode () {};
// Tells us if Node is inside the current box with the precision "precision"
- virtual const bool isInside(const gp_XYZ& p, const double precision = 0.);
+ virtual bool isInside(const gp_XYZ& p, const double precision = 0.);
// Return in Result a list of Nodes potentials to be near Node
void AllNodesAround(const SMDS_MeshNode * node,
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::Dump() const
+ void CutFace::Dump() const // todo: unused in release mode
{
std::cout << std::endl << "INI F " << myInitFace->GetID() << std::endl;
for ( size_t i = 0; i < myLinks.size(); ++i )
*/
//================================================================================
- 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 )
// add links connecting internal loops with the boundary ones
// find a pair of closest nodes
- const SMDS_MeshNode *closestNode1, *closestNode2;
+ const SMDS_MeshNode *closestNode1 = 0, *closestNode2 = 0;
double minDist = 1e100;
for ( size_t iE = 0; iE < loop.myLinks.size(); ++iE )
{
}
}
- size_t i = myLinks.size();
- myLinks.resize( i + 2 );
- myLinks[ i ].Set( closestNode1, closestNode2 );
- myLinks[ i+1 ].Set( closestNode2, closestNode1 );
+ if ( closestNode1 && closestNode2 ) {
+ size_t i = myLinks.size();
+ myLinks.resize( i + 2 );
+ myLinks[ i ].Set( closestNode1, closestNode2 );
+ myLinks[ i+1 ].Set( closestNode2, closestNode1 );
+ }
}
return true;
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;
if ( face2 )
polySeg.myFace[ iP ] = face2;
else
- ;// ??
+ {} // todo: ??
for ( int i = 0; i < 3; ++i )
{
nodes[ i ] = polySeg.myFace[ iP ]->GetNode( i );
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 )
try {
axes = gp_Ax2( p0, normal, v01 );
}
- catch ( Standard_Failure ) {
+ catch ( Standard_Failure& ) {
return false;
}
double factor = 1.0, modulus = normal.Modulus();
void SMESH::doNothing(const char* txt)
{
+ (void)txt; // unused in release mode
MESSAGE( txt << " " << __FILE__ << ": " << __LINE__ );
}
#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;
if ( -1 < iGeom && iGeom < nbTypes )
Threshold = SMESH + types[ iGeom ];
#ifdef _DEBUG_
- // is types complete? (compilation failure mains that enum GeometryType changed)
- int _asrt[( sizeof(types) / sizeof(const char*) == nbTypes ) ? 2 : -1 ]; _asrt[0]=_asrt[1];
+ // is types complete? (compilation failure means that enum GeometryType changed)
+ int _asrt[( sizeof(types) / sizeof(const char*) == nbTypes ) ? 2 : -1 ]; _asrt[0]=_asrt[1]; // _asrt[1] may be used uninitialized => replace this with static_assert?
#endif
}
if (Type == "SMESH.FT_EntityType")
if ( -1 < iGeom && iGeom < nbTypes )
Threshold = SMESH + types[ iGeom ];
#ifdef _DEBUG_
- // is 'types' complete? (compilation failure mains that enum EntityType changed)
- int _asrt[( sizeof(types) / sizeof(const char*) == nbTypes ) ? 2 : -1 ]; _asrt[0]=_asrt[1];
+ // is 'types' complete? (compilation failure means that enum EntityType changed)
+ int _asrt[( sizeof(types) / sizeof(const char*) == nbTypes ) ? 2 : -1 ]; _asrt[0]=_asrt[1]; // _asrt[1] may be used uninitialized => replace this with static_assert?
#endif
}
}
*/
//================================================================================
-void _pyGen::PlaceSubmeshAfterItsCreation( Handle(_pyCommand) theCmdUsingSubmesh ) const
+void _pyGen::PlaceSubmeshAfterItsCreation( Handle(_pyCommand) /*theCmdUsingSubmesh*/ ) const
{
// map< _pyID, Handle(_pyObject) >::const_iterator id_obj = myObjects.begin();
// for ( ; id_obj != myObjects.end(); ++id_obj )
*/
//================================================================================
-bool _pySubMesh::CanBeArgOfMethod(const _AString& theMethodName)
+bool _pySubMesh::CanBeArgOfMethod(const _AString& /*theMethodName*/)
{
return false;
// names of all methods where a sub-mesh can be used as argument
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;
virtual bool Addition2Creation( const Handle(_pyCommand)& theAdditionCmd,
const _pyID& theMesh);
virtual const char* AccessorMethod() const { return "GetAlgorithm()"; }
- virtual bool IsWrappable(const _pyID& theMesh) { return !myIsWrapped; }
+ virtual bool IsWrappable(const _pyID& /*theMesh*/) { return !myIsWrapped; }
DEFINE_STANDARD_RTTIEXT(_pyAlgorithm,_pyHypothesis)
};
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)
// -------------------------------------------------------------------------------------
/*!
*/
//================================================================================
-bool SMESH_Algo_i::getObjectsDependOn( std::vector< std::string > & entryArray,
- std::vector< int > & subIDArray ) const
+bool SMESH_Algo_i::getObjectsDependOn( std::vector< std::string > & /*entryArray*/,
+ std::vector< int > & /*subIDArray*/ ) const
{
return false;
}
*/
//================================================================================
-bool SMESH_Algo_i::setObjectsDependOn( std::vector< std::string > & entryArray,
- std::vector< int > & subIDArray )
+bool SMESH_Algo_i::setObjectsDependOn( std::vector< std::string > & /*entryArray*/,
+ std::vector< int > & /*subIDArray*/ )
{
return true;
}
{
Controls::PredicatePtr control( new Controls::BadOrientedVolume() );
myFunctorPtr = myPredicatePtr = control;
-};
+}
FunctorType BadOrientedVolume_i::GetFunctorType()
{
{
Controls::PredicatePtr control( new Controls::BareBorderVolume() );
myFunctorPtr = myPredicatePtr = control;
-};
+}
FunctorType BareBorderVolume_i::GetFunctorType()
{
{
Controls::PredicatePtr control( new Controls::BareBorderFace() );
myFunctorPtr = myPredicatePtr = control;
-};
+}
FunctorType BareBorderFace_i::GetFunctorType()
{
{
Controls::PredicatePtr control( new Controls::OverConstrainedVolume() );
myFunctorPtr = myPredicatePtr = control;
-};
+}
FunctorType OverConstrainedVolume_i::GetFunctorType()
{
{
Controls::PredicatePtr control( new Controls::OverConstrainedFace() );
myFunctorPtr = myPredicatePtr = control;
-};
+}
FunctorType OverConstrainedFace_i::GetFunctorType()
{
std::string BelongToMeshGroup_i::GetGroupID()
{
if ( myGroup->_is_nil() )
- SMESH::SMESH_GroupBase_var( GetGroup() );
+ SMESH::SMESH_GroupBase_var( GetGroup() ); // todo: unnecessary parentheses?
if ( !myGroup->_is_nil() )
myID = SMESH_Gen_i::GetORB()->object_to_string( myGroup );
}
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",
*/
struct NotifyerAndWaiter
{
- virtual void OnBaseObjModified(NotifyerAndWaiter* obj, bool removed) {};
+ virtual void OnBaseObjModified(NotifyerAndWaiter* /*obj*/, bool /*removed*/) {};
// specific reaction on modification of a base object
void Modified( bool removed=false, NotifyerAndWaiter* who = 0);
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 SetVertex( GEOM::GEOM_Object_ptr vertex );
+ void SetNode ( CORBA::Long nodeID );
void SetThreshold ( const char* threshold,
- SMESH::ConnectedElements::ThresholdType type )
- throw (SALOME::SALOME_Exception);
+ SMESH::ConnectedElements::ThresholdType type );
char* GetThreshold ( SMESH::ConnectedElements::ThresholdType& type );
private:
#include <cstdlib>
#include <memory>
+#include <boost/archive/text_oarchive.hpp>
+#include <boost/archive/text_iarchive.hpp>
+#include <boost/serialization/list.hpp>
+#include <boost/serialization/string.hpp>
+
using namespace std;
using SMESH::TPythonDump;
using SMESH::TVar;
GEOM::GEOM_Gen_var SMESH_Gen_i::GetGeomEngine( GEOM::GEOM_Object_ptr go )
{
- GEOM::GEOM_Gen_ptr gen;
+ GEOM::GEOM_Gen_ptr gen = GEOM::GEOM_Gen::_nil();
if ( !CORBA::is_nil( go ))
gen = go->GetGen();
return gen;
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 */
hypothesis_i = myHypothesis_i->_this();
int nextId = RegisterObject( hypothesis_i );
if(MYDEBUG) { MESSAGE( "Add hypo to map with id = "<< nextId ); }
- else { nextId = 0; } // avoid "unused variable" warning in release mode
+ else { (void)nextId; } // avoid "unused variable" warning in release mode
}
return hypothesis_i._retn();
}
//=============================================================================
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_Mesh_var mesh = SMESH::SMESH_Mesh::_narrow( meshServant->_this() );
int nextId = RegisterObject( mesh );
if(MYDEBUG) { MESSAGE( "Add mesh to map with id = "<< nextId); }
- else { nextId = 0; } // avoid "unused variable" warning in release mode
+ else { (void)nextId; } // avoid "unused variable" warning in release mode
return mesh._retn();
}
catch (SALOME_Exception& S_ex) {
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);
return ok;
}
}
- catch ( std::bad_alloc ) {
+ catch ( std::bad_alloc& ) {
INFOS( "Compute(): lack of memory" );
}
catch ( SALOME_Exception& S_ex ) {
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" );
}
}
}
- catch ( std::bad_alloc ) {
+ catch ( std::bad_alloc& ) {
INFOS( "Precompute(): lack of memory" );
}
catch ( SALOME_Exception& S_ex ) {
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" );
return nbels._retn();
}
}
- catch ( std::bad_alloc ) {
+ catch ( std::bad_alloc& ) {
INFOS( "Evaluate(): lack of memory" );
}
catch ( SALOME_Exception& S_ex ) {
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 ))
// store submesh order if any
const TListOfListOfInt& theOrderIds = myLocMesh.GetMeshOrder();
- if ( theOrderIds.size() ) {
+ const bool isNewOrederVersion = true; // old version saves ids, new one, entries
+ if ( !theOrderIds.empty() && !isNewOrederVersion ) { // keep old version for reference
char order_list[ 30 ];
strcpy( order_list, "Mesh Order" );
// count number of submesh ids
//
delete[] smIDs;
}
+ if ( !theOrderIds.empty() && isNewOrederVersion )
+ {
+ // convert ids to entries
+ std::list< std::list< std::string > > orderEntryLists;
+ for ( const TListOfInt& idList : theOrderIds )
+ {
+ orderEntryLists.emplace_back();
+ std::list< std::string > & entryList = orderEntryLists.back();
+ for ( const int& id : idList )
+ {
+ const TopoDS_Shape& shape = mySMESHDSMesh->IndexToShape( id );
+ GEOM::GEOM_Object_var go = ShapeToGeomObject( shape );
+ SALOMEDS::SObject_var so = ObjectToSObject( go );
+ if ( !so->_is_nil() )
+ {
+ CORBA::String_var entry = so->GetID();
+ entryList.emplace_back( entry.in() );
+ }
+ }
+ }
+ // convert orderEntryLists to string
+ std::ostringstream ostream;
+ boost::archive::text_oarchive( ostream ) << orderEntryLists;
+ std::string orderEntryString = ostream.str();
+
+ // write HDF group
+ aSize[ 0 ] = orderEntryString.size() + 1;
+ aDataset = new HDFdataset( "MeshOrder_new", aTopGroup, HDF_STRING, aSize, 1 );
+ aDataset->CreateOnDisk();
+ aDataset->WriteOnDisk((char*) orderEntryString.data() );
+ aDataset->CloseOnDisk();
+ }
// groups root sub-branch
SALOMEDS::SObject_wrap myGroupsBranch;
}
// read Sub-Mesh ORDER if any
- if ( aTopGroup->ExistInternalObject( "Mesh Order" )) {
+ if ( aTopGroup->ExistInternalObject( "Mesh Order" )) { // old version keeps ids
aDataset = new HDFdataset( "Mesh Order", aTopGroup );
aDataset->OpenOnDisk();
size = aDataset->GetSize();
myNewMeshImpl->GetImpl().SetMeshOrder( anOrderIds );
delete [] smIDs;
}
+ if ( aTopGroup->ExistInternalObject( "MeshOrder_new" )) // new version keeps entries
+ {
+ aDataset = new HDFdataset( "MeshOrder_new", aTopGroup );
+ aDataset->OpenOnDisk();
+ size = aDataset->GetSize();
+ std::string dataString; dataString.resize( size );
+ aDataset->ReadFromDisk((char*) dataString.data() );
+ aDataset->CloseOnDisk();
+
+ std::istringstream istream( dataString.data() );
+ boost::archive::text_iarchive archive( istream );
+ std::list< std::list< std::string > > orderEntryLists;
+ try {
+ archive >> orderEntryLists;
+ }
+ catch (...) {}
+
+ TListOfListOfInt anOrderIds;
+ for ( const std::list< std::string >& entryList : orderEntryLists )
+ {
+ anOrderIds.emplace_back();
+ for ( const std::string & entry : entryList )
+ {
+ GEOM::GEOM_Object_var go = GetGeomObjectByEntry( entry );
+ TopoDS_Shape shape = GeomObjectToShape( go );
+ if ( SMESH_subMesh* sm = myNewMeshImpl->GetImpl().GetSubMesh( shape ))
+ anOrderIds.back().emplace_back( sm->GetId() );
+ }
+ }
+ myNewMeshImpl->GetImpl().SetMeshOrder( anOrderIds );
+ }
} // loop on meshes
// update hyps needing full mesh data restored (issue 20918)
}
}
}
- pd << ""; // prevent optimizing pd out
// creation of tree nodes for all data objects in the study
// to support tree representation customization and drag-n-drop:
SMESH_TRY;
std::string aPlatformLibName;
- typedef GenericHypothesisCreator_i* (*GetHypothesisCreator)(const char*);
+ //typedef GenericHypothesisCreator_i* (*GetHypothesisCreator)(const char*);
GenericHypothesisCreator_i* aCreator =
getHypothesisCreator(theAlgoType, theLibName, aPlatformLibName);
if (aCreator)
// Create hypothesis/algorithm of given type
SMESH::SMESH_Hypothesis_ptr CreateHypothesis (const char* theHypType,
- const char* theLibName)
- throw ( SALOME::SALOME_Exception );
+ const char* theLibName);
SMESH::SMESH_Hypothesis_ptr CreateHypothesisByAverageLength( const char* theHypType,
const char* theLibName,
CORBA::Double theAverageLength,
- CORBA::Boolean theQuadDominated)
- throw ( SALOME::SALOME_Exception );
+ CORBA::Boolean theQuadDominated);
// Return hypothesis of given type holding parameter values of the existing mesh
SMESH::SMESH_Hypothesis_ptr
const char* theLibName,
SMESH::SMESH_Mesh_ptr theMesh,
GEOM::GEOM_Object_ptr theGeom,
- const SMESH::HypInitParams& theWay)
- throw ( SALOME::SALOME_Exception );
+ const SMESH::HypInitParams& theWay);
/*
* 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 );
+ SMESH::SMESH_Mesh_ptr CreateMesh( GEOM::GEOM_Object_ptr theShapeObject );
// Create empty mesh
- SMESH::SMESH_Mesh_ptr CreateEmptyMesh()
- throw ( SALOME::SALOME_Exception );
+ SMESH::SMESH_Mesh_ptr CreateEmptyMesh();
// Create a mesh and import data from an UNV file
- SMESH::SMESH_Mesh_ptr CreateMeshesFromUNV( const char* theFileName )
- throw ( SALOME::SALOME_Exception );
+ SMESH::SMESH_Mesh_ptr CreateMeshesFromUNV( const char* theFileName );
// Create mesh(es) and import data from MED file
SMESH::mesh_array* CreateMeshesFromMED( const char* theFileName,
- SMESH::DriverMED_ReadStatus& theStatus )
- throw ( SALOME::SALOME_Exception );
+ SMESH::DriverMED_ReadStatus& theStatus );
// Create mesh(es) and import data from MED file
SMESH::mesh_array* CreateMeshesFromSAUV( const char* theFileName,
- SMESH::DriverMED_ReadStatus& theStatus )
- throw ( SALOME::SALOME_Exception );
+ SMESH::DriverMED_ReadStatus& theStatus );
// Create a mesh and import data from a STL file
- SMESH::SMESH_Mesh_ptr CreateMeshesFromSTL( const char* theFileName )
- throw ( SALOME::SALOME_Exception );
+ SMESH::SMESH_Mesh_ptr CreateMeshesFromSTL( const char* theFileName );
// Create mesh(es) and import data from CGNS file
SMESH::mesh_array* CreateMeshesFromCGNS( const char* theFileName,
- SMESH::DriverMED_ReadStatus& theStatus )
- throw ( SALOME::SALOME_Exception );
+ SMESH::DriverMED_ReadStatus& theStatus );
// 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 );
+ SMESH::ComputeError_out theError);
// 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 );
+ CORBA::Boolean toKeepIDs);
// Create a mesh by copying definitions of another mesh to a given geometry
CORBA::Boolean CopyMeshWithGeom( SMESH::SMESH_Mesh_ptr sourceMesh,
SMESH::ListOfGroups_out newGroups,
SMESH::submesh_array_out newSubmeshes,
SMESH::ListOfHypothesis_out newHypotheses,
- SMESH::string_array_out invalidEntries)
- throw ( SALOME::SALOME_Exception );
+ SMESH::string_array_out invalidEntries);
// Compute mesh on a shape
CORBA::Boolean Compute( SMESH::SMESH_Mesh_ptr theMesh,
- GEOM::GEOM_Object_ptr theShapeObject )
- throw ( SALOME::SALOME_Exception );
+ GEOM::GEOM_Object_ptr theShapeObject );
// Cancel Compute mesh on a shape
void CancelCompute( SMESH::SMESH_Mesh_ptr theMesh,
* \brief Return errors of mesh computation
*/
SMESH::compute_error_array* GetComputeErrors(SMESH::SMESH_Mesh_ptr theMesh,
- GEOM::GEOM_Object_ptr theShapeObject )
- throw ( SALOME::SALOME_Exception );
+ GEOM::GEOM_Object_ptr theShapeObject );
/*!
* Evaluate mesh on a shape and
* Result array of number enityties
*/
SMESH::long_array* Evaluate(SMESH::SMESH_Mesh_ptr theMesh,
- GEOM::GEOM_Object_ptr theShapeObject)
- throw ( SALOME::SALOME_Exception );
+ GEOM::GEOM_Object_ptr theShapeObject);
// 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 );
+ GEOM::GEOM_Object_ptr theShapeObject );
/*!
* Calculate Mesh as preview till indicated dimension on shape
SMESH::MeshPreviewStruct* Precompute( SMESH::SMESH_Mesh_ptr theMesh,
GEOM::GEOM_Object_ptr theSubObject,
SMESH::Dimension theDimension,
- SMESH::long_array& theShapesId )
- throw ( SALOME::SALOME_Exception );
+ SMESH::long_array& theShapesId );
// Returns errors of hypotheses definition
SMESH::algo_error_array* GetAlgoState( SMESH::SMESH_Mesh_ptr theMesh,
- GEOM::GEOM_Object_ptr theSubObject )
- throw ( SALOME::SALOME_Exception );
+ GEOM::GEOM_Object_ptr theSubObject );
// Return mesh elements preventing computation of a subshape
SMESH::MeshPreviewStruct* GetBadInputElements( SMESH::SMESH_Mesh_ptr theMesh,
- CORBA::Short theSubShapeID )
- throw ( SALOME::SALOME_Exception );
+ CORBA::Short theSubShapeID );
// 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 );
+ const char* theGroupName);
// 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 );
+ const SMESH::object_array& theListOfSubShape );
// 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 );
+ const char* theGeomName);
// 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 );
+ CORBA::Long theElementID);
// Concatenate the given meshes into one mesh
SMESH::SMESH_Mesh_ptr ConcatenateCommon(const SMESH::ListOfIDSources& meshesArray,
CORBA::Boolean mergeNodesAndElements,
CORBA::Double mergeTolerance,
CORBA::Boolean commonGroups,
- SMESH::SMESH_Mesh_ptr meshToAppendTo)
- throw ( SALOME::SALOME_Exception );
+ SMESH::SMESH_Mesh_ptr meshToAppendTo);
// Concatenate the given meshes into one mesh
SMESH::SMESH_Mesh_ptr Concatenate(const SMESH::ListOfIDSources& meshesArray,
CORBA::Boolean uniteIdenticalGroups,
CORBA::Boolean mergeNodesAndElements,
CORBA::Double mergeTolerance,
- SMESH::SMESH_Mesh_ptr meshToAppendTo)
- throw ( SALOME::SALOME_Exception );
+ SMESH::SMESH_Mesh_ptr meshToAppendTo);
// Concatenate the given meshes into one mesh
// Create the groups of all elements from initial meshes
CORBA::Boolean uniteIdenticalGroups,
CORBA::Boolean mergeNodesAndElements,
CORBA::Double mergeTolerance,
- SMESH::SMESH_Mesh_ptr meshToAppendTo)
- throw ( SALOME::SALOME_Exception );
+ SMESH::SMESH_Mesh_ptr meshToAppendTo);
// Get version of MED format being used.
char* GetMEDFileVersion();
// Publish object in the study
SALOMEDS::SObject_ptr PublishInStudy( SALOMEDS::SObject_ptr theSObject,
CORBA::Object_ptr theObject,
- const char* theName )
- throw ( SALOME::SALOME_Exception );
+ const char* theName );
// 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();
}
// Get hypothesis creator
GenericHypothesisCreator_i* getHypothesisCreator( const char* theHypName,
const char* theLibName,
- std::string& thePlatformLibName)
- throw ( SALOME::SALOME_Exception );
+ std::string& thePlatformLibName);
// 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 );
+ SMESH::SMESH_Mesh_ptr createMesh();
// Check mesh icon
bool isGeomModifIcon( SMESH::SMESH_Mesh_ptr mesh );
*/
//=============================================================================
-SALOMEDS::SObject_ptr SMESH_Gen_i::PublishInStudy(SALOMEDS::SObject_ptr theSObject,
+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;
{
SMESH::array_of_ElementType_var elemTypes = idSrc->GetTypes();
isEmpty = ( elemTypes->length() == 0 );
+
+ if ( !isEmpty )
+ {
+ // check if all sub-shapes of sub-mesh on group are computed
+ // (pb: "Compute sub-mesh" menu is missing if a sub-mesh is partially computed)
+ SMESH::SMESH_subMesh_var subMesh = SMESH::SMESH_subMesh::_narrow( obj );
+ if ( !subMesh->_is_nil() )
+ if ( SMESH_subMesh* sm = mesh_i->GetImpl().GetSubMeshContaining( subMesh->GetId() ))
+ if ( sm->IsComputedPartially() )
+ {
+ SetPixMap( so, "ICON_SMESH_TREE_MESH_PARTIAL" );
+ continue;
+ }
+ }
}
}
+
if ( isEmpty )
SetPixMap( so, "ICON_SMESH_TREE_MESH_WARN");
else if ( !isGroup )
SetPixMap( so, "ICON_SMESH_TREE_GROUP_ON_FILTER" );
else
SetPixMap( so, "ICON_SMESH_TREE_GROUP" );
- }
- }
+
+ } // loop on sub-meshes or groups
+ } // loop on roots
}
//=======================================================================
SMESH_GroupBase_i::~SMESH_GroupBase_i()
{
- if ( myPreMeshInfo ) delete myPreMeshInfo; myPreMeshInfo = NULL;
+ if ( myPreMeshInfo ) delete myPreMeshInfo;
+ myPreMeshInfo = NULL;
}
//=======================================================================
//================================================================================
void SMESH_GroupOnFilter_i::SetFilter(SMESH::Filter_ptr theFilter)
- throw (SALOME::SALOME_Exception)
{
if ( myFilter->_is_equivalent( theFilter ))
return;
*/
//================================================================================
-void SMESH_GroupOnFilter_i::OnBaseObjModified(NotifyerAndWaiter* filter, bool /*removed*/)
+void SMESH_GroupOnFilter_i::OnBaseObjModified(NotifyerAndWaiter* /*filter*/, bool /*removed*/)
{
if ( myPreMeshInfo )
myPreMeshInfo->FullLoadFromFile();
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();
: SALOME::GenericObj_i( thePOA )
{
myBaseImpl = 0;
-};
+}
//=============================================================================
/*!
//MESSAGE( "SMESH_Hypothesis_i::~SMESH_Hypothesis_i" );
if ( myBaseImpl )
delete myBaseImpl;
-};
+}
//=============================================================================
/*!
char* SMESH_Hypothesis_i::GetName()
{
return CORBA::string_dup( myBaseImpl->GetName() );
-};
+}
//=============================================================================
/*!
char* SMESH_Hypothesis_i::GetLibName()
{
return CORBA::string_dup( myBaseImpl->GetLibName() );
-};
+}
//=============================================================================
/*!
void SMESH_Hypothesis_i::SetLibName(const char* theLibName)
{
myBaseImpl->SetLibName( theLibName );
-};
+}
//=============================================================================
/*!
// method used to convert variable parameters stored in an old study
// into myMethod2VarParams. It should return a method name for an index of
// variable parameters. Index is countered from zero
- virtual std::string getMethodOfParameter(const int paramIndex, int nbVars) const { return ""; }
+ virtual std::string getMethodOfParameter(const int /*paramIndex*/, int /*nbVars*/) const { return ""; }
// method intended to remove explicit treatment of Netgen hypotheses from SMESH_NoteBook
- virtual int getParamIndex(const TCollection_AsciiString& method, int nbVars) const { return -1; }
+ virtual int getParamIndex(const TCollection_AsciiString& /*method*/, int /*nbVars*/) const { return -1; }
};
// ======================================================
virtual std::string GetModuleName() = 0;
// Check if an algorithm is applicable to a shape
- virtual bool IsApplicable( const TopoDS_Shape &S, bool toCheckAll, int algoDim )
+ virtual bool IsApplicable( const TopoDS_Shape &S, bool /*toCheckAll*/, int algoDim )
{
return IsShapeOfDim( S, algoDim );
}
//!< Delete theNodeSearcher
static void Delete()
{
- if ( theNodeSearcher ) delete theNodeSearcher; theNodeSearcher = 0;
- if ( theElementSearcher ) delete theElementSearcher; theElementSearcher = 0;
+ if ( theNodeSearcher ) { delete theNodeSearcher; } theNodeSearcher = 0;
+ if ( theElementSearcher ) { delete theElementSearcher; } theElementSearcher = 0;
}
typedef map < int, SMESH_subMesh * > TDependsOnMap;
//!< The meshod called by submesh: do my main job
//================================================================================
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();
getEditor().QuadTo4Tri( faces );
TPythonDump() << this << ".QuadTo4Tri( " << theObject << " )";
+ declareMeshModified( /*isReComputeSafe=*/false );
+
SMESH_CATCH( SMESH::throwCorbaException );
}
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);
+ CORBA::Boolean RemoveElements(const SMESH::long_array & IDsOfElements);
+ CORBA::Boolean RemoveNodes (const SMESH::long_array & IDsOfNodes);
+ CORBA::Long RemoveOrphanNodes();
/*!
* 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 AddNode(CORBA::Double x, CORBA::Double y, CORBA::Double z);
+ CORBA::Long Add0DElement(CORBA::Long IDOfNode, CORBA::Boolean DuplicateElements);
+ CORBA::Long AddBall(CORBA::Long IDOfNodem, CORBA::Double diameter);
+ CORBA::Long AddEdge(const SMESH::long_array & IDsOfNodes);
+ CORBA::Long AddFace(const SMESH::long_array & IDsOfNodes);
+ CORBA::Long AddPolygonalFace(const SMESH::long_array & IDsOfNodes);
+ CORBA::Long AddQuadPolygonalFace(const SMESH::long_array & IDsOfNodes);
+ CORBA::Long AddVolume(const SMESH::long_array & IDsOfNodes);
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);
+ const SMESH::long_array & Quantities);
+ CORBA::Long AddPolyhedralVolumeByFaces(const SMESH::long_array & IdsOfFaces);
/*!
* \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);
+ CORBA::Boolean theDuplicateElements);
/*!
* \brief Bind a node to a vertex
* \param NodeID - node ID
* \param VertexID - vertex ID available through GEOM_Object.GetSubShapeIndices()[0]
*/
- void SetNodeOnVertex(CORBA::Long NodeID, CORBA::Long VertexID)
- throw (SALOME::SALOME_Exception);
+ void SetNodeOnVertex(CORBA::Long NodeID, CORBA::Long VertexID);
/*!
* \brief Store node position on an edge
* \param NodeID - node ID
* \param paramOnEdge - parameter on edge where the node is located
*/
void SetNodeOnEdge(CORBA::Long NodeID, CORBA::Long EdgeID,
- CORBA::Double paramOnEdge)
- throw (SALOME::SALOME_Exception);
+ CORBA::Double paramOnEdge);
/*!
* \brief Store node position on a face
* \param NodeID - node ID
* \param v - V parameter on face where the node is located
*/
void SetNodeOnFace(CORBA::Long NodeID, CORBA::Long FaceID,
- CORBA::Double u, CORBA::Double v)
- throw (SALOME::SALOME_Exception);
+ CORBA::Double u, CORBA::Double v);
/*!
* \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);
+ void SetNodeInVolume(CORBA::Long NodeID, CORBA::Long SolidID);
/*!
* \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);
+ void SetMeshElementOnShape(CORBA::Long ElementID, CORBA::Long ShapeID);
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);
+ CORBA::Double x, CORBA::Double y, CORBA::Double z);
+
+ CORBA::Boolean InverseDiag(CORBA::Long NodeID1, CORBA::Long NodeID2);
+ CORBA::Boolean DeleteDiag(CORBA::Long NodeID1, CORBA::Long NodeID2);
+ CORBA::Boolean Reorient(const SMESH::long_array & IDsOfElements);
+ CORBA::Boolean ReorientObject(SMESH::SMESH_IDSource_ptr theObject);
/*!
* \brief Reorient faces contained in \a the2Dgroup.
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);
+ CORBA::Boolean outsideNormal);
// Split/Join
CORBA::Boolean TriToQuad (const SMESH::long_array & IDsOfElements,
SMESH::NumericalFunctor_ptr Criterion,
- CORBA::Double MaxAngle)
- throw (SALOME::SALOME_Exception);
+ CORBA::Double MaxAngle);
CORBA::Boolean TriToQuadObject (SMESH::SMESH_IDSource_ptr theObject,
SMESH::NumericalFunctor_ptr Criterion,
- CORBA::Double MaxAngle)
- throw (SALOME::SALOME_Exception);
+ CORBA::Double MaxAngle);
CORBA::Boolean QuadToTri (const SMESH::long_array & IDsOfElements,
- SMESH::NumericalFunctor_ptr Criterion)
- throw (SALOME::SALOME_Exception);
+ SMESH::NumericalFunctor_ptr Criterion);
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);
+ SMESH::NumericalFunctor_ptr Criterion);
+ void QuadTo4Tri (SMESH::SMESH_IDSource_ptr theObject);
CORBA::Boolean SplitQuad (const SMESH::long_array & IDsOfElements,
- CORBA::Boolean Diag13)
- throw (SALOME::SALOME_Exception);
+ CORBA::Boolean Diag13);
CORBA::Boolean SplitQuadObject (SMESH::SMESH_IDSource_ptr theObject,
- CORBA::Boolean Diag13)
- throw (SALOME::SALOME_Exception);
+ CORBA::Boolean Diag13);
CORBA::Long BestSplit (CORBA::Long IDOfQuad,
- SMESH::NumericalFunctor_ptr Criterion)
- throw (SALOME::SALOME_Exception);
+ SMESH::NumericalFunctor_ptr Criterion);
void SplitVolumesIntoTetra(SMESH::SMESH_IDSource_ptr elems,
- CORBA::Short methodFlags)
- throw (SALOME::SALOME_Exception);
+ CORBA::Short methodFlags);
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 allDomains);
+ void SplitBiQuadraticIntoLinear(const SMESH::ListOfIDSources& elems);
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);
+ SMESH::SMESH_MeshEditor::Smooth_Method Method);
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);
+ SMESH::SMESH_MeshEditor::Smooth_Method Method);
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);
+ SMESH::SMESH_MeshEditor::Smooth_Method Method) ;
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);
+ SMESH::SMESH_MeshEditor::Smooth_Method Method);
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);
+ bool IsParametric);
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);
+ bool IsParametric);
+
+ CORBA::Boolean ConvertFromQuadratic();
+ void ConvertFromQuadraticObject(SMESH::SMESH_IDSource_ptr theObject);
+ void ConvertToQuadratic(CORBA::Boolean Force3d);
void ConvertToQuadraticObject(CORBA::Boolean theForce3d,
- SMESH::SMESH_IDSource_ptr theObject)
- throw (SALOME::SALOME_Exception);
+ SMESH::SMESH_IDSource_ptr theObject);
void ConvertToBiQuadratic(CORBA::Boolean theForce3d,
- SMESH::SMESH_IDSource_ptr theObject)
- throw (SALOME::SALOME_Exception);
+ SMESH::SMESH_IDSource_ptr theObject);
- 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::Double AngleInRadians,
CORBA::Long NbOfSteps,
CORBA::Double Tolerance,
- CORBA::Boolean ToMakeGroups)
- throw (SALOME::SALOME_Exception);
+ CORBA::Boolean ToMakeGroups);
SMESH::ListOfGroups* ExtrusionSweepObjects(const SMESH::ListOfIDSources & Nodes,
const SMESH::ListOfIDSources & Edges,
CORBA::Boolean ScalesVariation,
const SMESH::double_array & BasePoint,
const SMESH::double_array & Angles,
- CORBA::Boolean AnglesVariation)
- throw (SALOME::SALOME_Exception);
+ CORBA::Boolean AnglesVariation);
SMESH::ListOfGroups* ExtrusionByNormal(const SMESH::ListOfIDSources& objects,
CORBA::Double stepSize,
CORBA::Boolean byAverageNormal,
CORBA::Boolean useInputElemsOnly,
CORBA::Boolean makeGroups,
- CORBA::Short dim)
- throw (SALOME::SALOME_Exception);
+ CORBA::Short dim);
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);
+ CORBA::Boolean theMakeGroups);
SMESH::ListOfGroups*
ExtrusionAlongPathObjects(const SMESH::ListOfIDSources & Nodes,
bool MakeGroups,
const SMESH::double_array & ScaleFactors,
CORBA::Boolean ScalesVariation,
- SMESH::SMESH_MeshEditor::Extrusion_Error& Error)
- throw (SALOME::SALOME_Exception);
+ SMESH::SMESH_MeshEditor::Extrusion_Error& Error);
SMESH::double_array* LinearAnglesVariation(SMESH::SMESH_Mesh_ptr PathMesh,
GEOM::GEOM_Object_ptr PathShape,
void Mirror(const SMESH::long_array & IDsOfElements,
const SMESH::AxisStruct & Axis,
SMESH::SMESH_MeshEditor::MirrorType MirrorType,
- CORBA::Boolean Copy)
- throw (SALOME::SALOME_Exception);
+ CORBA::Boolean Copy);
void MirrorObject(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::AxisStruct & Axis,
SMESH::SMESH_MeshEditor::MirrorType MirrorType,
- CORBA::Boolean Copy)
- throw (SALOME::SALOME_Exception);
+ CORBA::Boolean Copy);
void Translate(const SMESH::long_array & IDsOfElements,
const SMESH::DirStruct & Vector,
- CORBA::Boolean Copy)
- throw (SALOME::SALOME_Exception);
+ CORBA::Boolean Copy);
void TranslateObject(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::DirStruct & Vector,
- CORBA::Boolean Copy)
- throw (SALOME::SALOME_Exception);
+ CORBA::Boolean Copy);
void Rotate(const SMESH::long_array & IDsOfElements,
const SMESH::AxisStruct & Axis,
CORBA::Double Angle,
- CORBA::Boolean Copy)
- throw (SALOME::SALOME_Exception);
+ CORBA::Boolean Copy);
void RotateObject(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::AxisStruct & Axis,
CORBA::Double Angle,
- CORBA::Boolean Copy)
- throw (SALOME::SALOME_Exception);
+ CORBA::Boolean Copy);
SMESH::ListOfGroups* MirrorMakeGroups(const SMESH::long_array& IDsOfElements,
const SMESH::AxisStruct& Mirror,
- SMESH::SMESH_MeshEditor::MirrorType MirrorType)
- throw (SALOME::SALOME_Exception);
+ SMESH::SMESH_MeshEditor::MirrorType MirrorType);
SMESH::ListOfGroups* MirrorObjectMakeGroups(SMESH::SMESH_IDSource_ptr Object,
const SMESH::AxisStruct& Mirror,
- SMESH::SMESH_MeshEditor::MirrorType MirrorType)
- throw (SALOME::SALOME_Exception);
+ SMESH::SMESH_MeshEditor::MirrorType MirrorType);
SMESH::ListOfGroups* TranslateMakeGroups(const SMESH::long_array& IDsOfElements,
- const SMESH::DirStruct& Vector)
- throw (SALOME::SALOME_Exception);
+ const SMESH::DirStruct& Vector);
SMESH::ListOfGroups* TranslateObjectMakeGroups(SMESH::SMESH_IDSource_ptr Object,
- const SMESH::DirStruct& Vector)
- throw (SALOME::SALOME_Exception);
+ const SMESH::DirStruct& Vector);
SMESH::ListOfGroups* RotateMakeGroups(const SMESH::long_array& IDsOfElements,
const SMESH::AxisStruct& Axis,
- CORBA::Double AngleInRadians)
- throw (SALOME::SALOME_Exception);
+ CORBA::Double AngleInRadians);
SMESH::ListOfGroups* RotateObjectMakeGroups(SMESH::SMESH_IDSource_ptr Object,
const SMESH::AxisStruct& Axis,
- CORBA::Double AngleInRadians)
- throw (SALOME::SALOME_Exception);
+ CORBA::Double AngleInRadians);
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);
+ const char* MeshName);
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);
+ const char* MeshName);
SMESH::SMESH_Mesh_ptr TranslateMakeMesh(const SMESH::long_array& IDsOfElements,
const SMESH::DirStruct& Vector,
CORBA::Boolean CopyGroups,
- const char* MeshName)
- throw (SALOME::SALOME_Exception);
+ const char* MeshName);
SMESH::SMESH_Mesh_ptr TranslateObjectMakeMesh(SMESH::SMESH_IDSource_ptr Object,
const SMESH::DirStruct& Vector,
CORBA::Boolean CopyGroups,
- const char* MeshName)
- throw (SALOME::SALOME_Exception);
+ const char* MeshName);
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);
+ const char* MeshName);
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);
+ const char* MeshName);
void Scale(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::PointStruct& thePoint,
const SMESH::double_array& theScaleFact,
- CORBA::Boolean theCopy)
- throw (SALOME::SALOME_Exception);
+ CORBA::Boolean theCopy);
SMESH::ListOfGroups* ScaleMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::PointStruct& thePoint,
- const SMESH::double_array& theScaleFact)
- throw (SALOME::SALOME_Exception);
+ const SMESH::double_array& theScaleFact);
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);
+ const char* MeshName);
SMESH::SMESH_Mesh_ptr Offset( SMESH::SMESH_IDSource_ptr theObject,
CORBA::Double Value,
CORBA::Boolean CopyGroups,
CORBA::Boolean CopyElements,
const char* MeshName,
- SMESH::ListOfGroups_out Groups)
- throw (SALOME::SALOME_Exception);
+ SMESH::ListOfGroups_out Groups);
void FindCoincidentNodes (CORBA::Double Tolerance,
SMESH::array_of_long_array_out GroupsOfNodes,
- CORBA::Boolean SeparateCornersAndMedium)
- throw (SALOME::SALOME_Exception);
+ CORBA::Boolean SeparateCornersAndMedium);
void FindCoincidentNodesOnPart(SMESH::SMESH_IDSource_ptr Object,
CORBA::Double Tolerance,
SMESH::array_of_long_array_out GroupsOfNodes,
- CORBA::Boolean SeparateCornersAndMedium)
- throw (SALOME::SALOME_Exception);
+ CORBA::Boolean SeparateCornersAndMedium);
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);
+ CORBA::Boolean SeparateCornersAndMedium);
void MergeNodes (const SMESH::array_of_long_array& GroupsOfNodes,
const SMESH::ListOfIDSources& NodesToKeep,
- CORBA::Boolean AvoidMakingHoles )
- throw (SALOME::SALOME_Exception);
+ CORBA::Boolean AvoidMakingHoles );
void FindEqualElements(const SMESH::ListOfIDSources& Objects,
const SMESH::ListOfIDSources& ExceptSubMeshOrGroups,
- SMESH::array_of_long_array_out GroupsOfElementsID)
- throw (SALOME::SALOME_Exception);
+ SMESH::array_of_long_array_out GroupsOfElementsID);
void MergeElements(const SMESH::array_of_long_array& GroupsOfElementsID,
- const SMESH::ListOfIDSources& ElementsToKeep)
- throw (SALOME::SALOME_Exception);
- void MergeEqualElements()
- throw (SALOME::SALOME_Exception);
+ const SMESH::ListOfIDSources& ElementsToKeep);
+ void MergeEqualElements();
CORBA::Long MoveClosestNodeToPoint(CORBA::Double x,
CORBA::Double y,
CORBA::Double z,
- CORBA::Long nodeID)
- throw (SALOME::SALOME_Exception);
+ CORBA::Long nodeID);
/*!
* \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);
+ CORBA::Double z);
/*!
* Return elements of given type where the given point is IN or ON.
* 'ALL' type means elements of any type excluding nodes
SMESH::long_array* FindElementsByPoint(CORBA::Double x,
CORBA::Double y,
CORBA::Double z,
- SMESH::ElementType type)
- throw (SALOME::SALOME_Exception);
+ SMESH::ElementType type);
/*!
* Searching among the given elements, return elements of given type
* where the given point is IN or ON.
CORBA::Double x,
CORBA::Double y,
CORBA::Double z,
- SMESH::ElementType type)
- throw (SALOME::SALOME_Exception);
+ SMESH::ElementType type);
/*!
* Project a point to a mesh object.
CORBA::Double z,
SMESH::ElementType type,
SMESH::SMESH_IDSource_ptr meshObject,
- SMESH::double_array_out projecton)
- throw (SALOME::SALOME_Exception);
+ SMESH::double_array_out projecton);
/*!
* 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);
+ CORBA::Short GetPointState(CORBA::Double x, CORBA::Double y, CORBA::Double z);
/*!
* Check if a 2D mesh is manifold
*/
- CORBA::Boolean IsManifold()
- throw (SALOME::SALOME_Exception);
+ CORBA::Boolean IsManifold();
/*!
* Check if orientation of 2D elements is coherent
*/
- CORBA::Boolean IsCoherentOrientation2D()
- throw (SALOME::SALOME_Exception);
+ CORBA::Boolean IsCoherentOrientation2D();
/*!
* 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);
+ SMESH::array_of_long_array_out nodeGroups);
/*!
* 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);
+ SMESH::ListOfEdges* FindSharpEdges(CORBA::Double angle, CORBA::Boolean addExisting);
/*!
* Returns all or only closed FreeBorder's.
*/
- SMESH::ListOfFreeBorders* FindFreeBorders(CORBA::Boolean closedOnly)
- throw (SALOME::SALOME_Exception);
+ SMESH::ListOfFreeBorders* FindFreeBorders(CORBA::Boolean closedOnly);
/*!
* Fill with 2D elements a hole defined by a FreeBorder.
* Optionally add new faces to a given group, which is returned
*/
SMESH::SMESH_Group_ptr FillHole(const SMESH::FreeBorder& hole,
- const char* groupName)
- throw (SALOME::SALOME_Exception);
+ const char* groupName);
SMESH::CoincidentFreeBorders* FindCoincidentFreeBorders(CORBA::Double tolerance);
CORBA::Short SewCoincidentFreeBorders(const SMESH::CoincidentFreeBorders& freeBorders,
CORBA::Boolean createPolygons,
- CORBA::Boolean createPolyedrs)
- throw (SALOME::SALOME_Exception);
+ CORBA::Boolean createPolyedrs);
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.
* If number of nodes is not corresponded to type of
* element - returns false
*/
- CORBA::Boolean ChangeElemNodes(CORBA::Long ide, const SMESH::long_array& newIDs)
- throw (SALOME::SALOME_Exception);
+ CORBA::Boolean ChangeElemNodes(CORBA::Long ide, const SMESH::long_array& newIDs);
SMESH::SMESH_Group_ptr DoubleElements(SMESH::SMESH_IDSource_ptr theElements,
- const char* theGroupName)
- throw (SALOME::SALOME_Exception);
+ const char* theGroupName);
CORBA::Boolean DoubleNodes( const SMESH::long_array& theNodes,
- const SMESH::long_array& theModifiedElems )
- throw (SALOME::SALOME_Exception);
+ const SMESH::long_array& theModifiedElems );
CORBA::Boolean DoubleNode( CORBA::Long theNodeId,
- const SMESH::long_array& theModifiedElems )
- throw (SALOME::SALOME_Exception);
+ const SMESH::long_array& theModifiedElems );
CORBA::Boolean DoubleNodeGroup( SMESH::SMESH_GroupBase_ptr theNodes,
- SMESH::SMESH_GroupBase_ptr theModifiedElems )
- throw (SALOME::SALOME_Exception);
+ SMESH::SMESH_GroupBase_ptr theModifiedElems );
/*!
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements.
* \sa DoubleNodeGroup()
*/
SMESH::SMESH_Group_ptr DoubleNodeGroupNew( SMESH::SMESH_GroupBase_ptr theNodes,
- SMESH::SMESH_GroupBase_ptr theModifiedElems )
- throw (SALOME::SALOME_Exception);
+ SMESH::SMESH_GroupBase_ptr theModifiedElems );
CORBA::Boolean DoubleNodeGroups( const SMESH::ListOfGroups& theNodes,
- const SMESH::ListOfGroups& theModifiedElems )
- throw (SALOME::SALOME_Exception);
+ const SMESH::ListOfGroups& theModifiedElems );
SMESH::SMESH_Group_ptr DoubleNodeGroupsNew( const SMESH::ListOfGroups& theNodes,
- const SMESH::ListOfGroups& theModifiedElems )
- throw (SALOME::SALOME_Exception);
+ const SMESH::ListOfGroups& theModifiedElems );
/*!
* \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);
+ const SMESH::long_array& theAffectedElems );
/*!
* \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);
+ GEOM::GEOM_Object_ptr theShape );
/*!
* \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);
+ SMESH::SMESH_GroupBase_ptr theAffectedElems );
/*!
* \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::SMESH_GroupBase_ptr theAffectedElems );
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);
+ CORBA::Boolean theNodeGroupNeeded);
/*!
* \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);
+ GEOM::GEOM_Object_ptr theShape );
/*!
* \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);
+ const SMESH::ListOfGroups& theAffectedElems );
/*!
* \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);
+ const SMESH::ListOfGroups& theAffectedElems );
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);
+ CORBA::Boolean theNodeGroupNeeded);
/*!
* \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);
+ GEOM::GEOM_Object_ptr theShape );
/*!
* \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);
+ GEOM::GEOM_Object_ptr theShape );
/*!
* \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);
+ CORBA::Boolean onAllBoundaries );
/*!
* \brief Double nodes on some external faces and create flat elements.
* Flat elements are mainly used by some types of mechanic calculations.
* @param theGroupsOfFaces - list of groups of faces
* @return TRUE if operation has been completed successfully, FALSE otherwise
*/
- CORBA::Boolean CreateFlatElementsOnFacesGroups( const SMESH::ListOfGroups& theGroupsOfFaces )
- throw (SALOME::SALOME_Exception);
+ CORBA::Boolean CreateFlatElementsOnFacesGroups( const SMESH::ListOfGroups& theGroupsOfFaces );
/*!
* \brief identify all the elements around a geom shape, get the faces delimiting the hole
GEOM::GEOM_Object_ptr theShape,
const char* groupName,
const SMESH::double_array& theNodesCoords,
- SMESH::array_of_long_array_out GroupsOfNodes)
- throw (SALOME::SALOME_Exception);
+ SMESH::array_of_long_array_out GroupsOfNodes);
/*!
* \brief Generated skin mesh (containing 2D cells) from 3D mesh
* The created 2D mesh elements based on nodes of free faces of boundary volumes
* \return TRUE if operation has been completed successfully, FALSE otherwise
*/
- CORBA::Boolean Make2DMeshFrom3D()
- throw (SALOME::SALOME_Exception);
+ CORBA::Boolean Make2DMeshFrom3D();
SMESH::SMESH_Mesh_ptr MakeBoundaryMesh(SMESH::SMESH_IDSource_ptr elements,
SMESH::Bnd_Dimension dimension,
const char* meshName,
CORBA::Boolean toCopyElements,
CORBA::Boolean toCopyMissingBondary,
- SMESH::SMESH_Group_out group)
- throw (SALOME::SALOME_Exception);
+ SMESH::SMESH_Group_out group);
CORBA::Long MakeBoundaryElements(SMESH::Bnd_Dimension dimension,
const char* groupName,
CORBA::Boolean toCopyAll,
const SMESH::ListOfIDSources& groups,
SMESH::SMESH_Mesh_out mesh,
- SMESH::SMESH_Group_out group)
- throw (SALOME::SALOME_Exception);
+ SMESH::SMESH_Group_out group);
/*!
* \brief Create a polyline consisting of 1D mesh elements each lying on a 2D element of
* be added.
*/
void MakePolyLine(SMESH::ListOfPolySegments& segments,
- const char* groupName)
- throw (SALOME::SALOME_Exception);
+ const char* groupName);
/*!
* \brief Create a slot of given width around given 1D elements lying on a triangle mesh.
* \return Edges located at the slot boundary
*/
SMESH::ListOfEdges* MakeSlot(SMESH::SMESH_GroupBase_ptr segments,
- CORBA::Double width)
- throw (SALOME::SALOME_Exception);
+ CORBA::Double width);
private: //!< private methods
/*!
* \brief Return groups by their IDs
*/
- SMESH::ListOfGroups* getGroups(const std::list<int>* groupIDs)
- throw (SALOME::SALOME_Exception);
+ SMESH::ListOfGroups* getGroups(const std::list<int>* groupIDs);
SMESH::ListOfGroups* mirror(TIDSortedElemSet & IDsOfElements,
const SMESH::AxisStruct & Axis,
SMESH::SMESH_MeshEditor::MirrorType MirrorType,
CORBA::Boolean Copy,
bool MakeGroups,
- ::SMESH_Mesh* TargetMesh=0)
- throw (SALOME::SALOME_Exception);
+ ::SMESH_Mesh* TargetMesh=0);
SMESH::ListOfGroups* translate(TIDSortedElemSet & IDsOfElements,
const SMESH::DirStruct & Vector,
CORBA::Boolean Copy,
bool MakeGroups,
- ::SMESH_Mesh* TargetMesh=0)
- throw (SALOME::SALOME_Exception);
+ ::SMESH_Mesh* TargetMesh=0);
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_Mesh* TargetMesh=0);
SMESH::ListOfGroups* scale(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::PointStruct& thePoint,
const SMESH::double_array& theScaleFact,
CORBA::Boolean theCopy,
bool theMakeGroups,
- ::SMESH_Mesh* theTargetMesh=0)
- throw (SALOME::SALOME_Exception);
+ ::SMESH_Mesh* theTargetMesh=0);
void convertToQuadratic(CORBA::Boolean theForce3d,
CORBA::Boolean theToBiQuad,
- SMESH::SMESH_IDSource_ptr theObject = SMESH::SMESH_IDSource::_nil())
- throw (SALOME::SALOME_Exception);
+ SMESH::SMESH_IDSource_ptr theObject = SMESH::SMESH_IDSource::_nil());
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);
+
+ const int prevNbMeshEnt = NbNodes() + NbElements();
+
if ( _preMeshInfo )
_preMeshInfo->ForgetOrLoad();
- const int prevNbMeshEnt = _impl->NbNodes() + _impl->GetMeshDS()->NbElements();
-
std::string error;
SMESH_Hypothesis::Hypothesis_Status status = addHypothesis( aSubShape, anHyp, &error );
anErrorText = error.c_str();
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;
namespace // functions making checks according to SMESH::NB_COMMON_NODES_ENUM
{
- bool isAllNodesCommon(int nbChecked, int nbCommon, int nbNodes, int nbCorners,
+ bool isAllNodesCommon(int nbChecked, int nbCommon, int nbNodes, int /*nbCorners*/,
bool & toStopChecking )
{
toStopChecking = ( nbCommon < nbChecked );
return nbCommon == nbNodes;
}
- bool isMainNodesCommon(int nbChecked, int nbCommon, int nbNodes, int nbCorners,
+ bool isMainNodesCommon(int nbChecked, int nbCommon, int /*nbNodes*/, int nbCorners,
bool & toStopChecking )
{
toStopChecking = ( nbCommon < nbChecked || nbChecked >= nbCorners );
return nbCommon == nbCorners;
}
- bool isAtLeastOneNodeCommon(int nbChecked, int nbCommon, int nbNodes, int nbCorners,
- bool & toStopChecking )
+ bool isAtLeastOneNodeCommon(int /*nbChecked*/, int nbCommon, int /*nbNodes*/, int /*nbCorners*/,
+ bool & /*toStopChecking*/ )
{
return nbCommon > 0;
}
- bool isMajorityOfNodesCommon(int nbChecked, int nbCommon, int nbNodes, int nbCorners,
- bool & toStopChecking )
+ bool isMajorityOfNodesCommon(int /*nbChecked*/, int nbCommon, int nbNodes, int /*nbCorners*/,
+ bool & /*toStopChecking*/ )
{
return nbCommon >= (nbNodes+1) / 2;
}
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;
// register CORBA object for persistence
int nextId = _gen_i->RegisterObject( subMesh );
if(MYDEBUG) { MESSAGE( "Add submesh to map with id = "<< nextId); }
- else { nextId = 0; } // avoid "unused variable" warning
+ else { (void)nextId; } // avoid "unused variable" warning
// to track changes of GEOM groups
if ( subMeshId > 0 )
//================================================================================
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);
// register CORBA object for persistence
int nextId = _gen_i->RegisterObject( groupVar );
if(MYDEBUG) { MESSAGE( "Add group to map with id = "<< nextId); }
- else { nextId = 0; } // avoid "unused variable" warning in release mode
+ else { (void)nextId; } // avoid "unused variable" warning in release mode
// publishing the groups in the study
GEOM::GEOM_Object_var shapeVar = _gen_i->ShapeToGeomObject( shape );
TopTools_MapIteratorOfMapOfShape anItr( theToCheck );
for (; !isShared && anItr.More(); anItr.Next() )
{
- const TopoDS_Shape aSubSh = anItr.Key();
+ const TopoDS_Shape& aSubSh = anItr.Key();
// check for case when concurrent dimensions are same
isShared = theToFind.Contains( aSubSh );
// check for sub-shape with concurrent dimension
// --- CORBA
- void SetShape( GEOM::GEOM_Object_ptr theShapeObject )
- throw (SALOME::SALOME_Exception);
+ void SetShape( GEOM::GEOM_Object_ptr theShapeObject );
- CORBA::Boolean HasShapeToMesh()
- throw (SALOME::SALOME_Exception);
+ CORBA::Boolean HasShapeToMesh();
- GEOM::GEOM_Object_ptr GetShapeToMesh()
- throw (SALOME::SALOME_Exception);
+ GEOM::GEOM_Object_ptr GetShapeToMesh();
- virtual void ReplaceShape(GEOM::GEOM_Object_ptr theNewGeom)
- throw (SALOME::SALOME_Exception);
+ virtual void ReplaceShape(GEOM::GEOM_Object_ptr theNewGeom);
- CORBA::Boolean IsLoaded()
- throw (SALOME::SALOME_Exception);
+ CORBA::Boolean IsLoaded();
- void Load()
- throw (SALOME::SALOME_Exception);
+ void Load();
- void Clear()
- throw (SALOME::SALOME_Exception);
+ void Clear();
- void ClearSubMesh(CORBA::Long ShapeID)
- throw (SALOME::SALOME_Exception);
+ void ClearSubMesh(CORBA::Long ShapeID);
SMESH::Hypothesis_Status AddHypothesis(GEOM::GEOM_Object_ptr aSubShape,
SMESH::SMESH_Hypothesis_ptr anHyp,
- CORBA::String_out anErrorText)
- throw (SALOME::SALOME_Exception);
+ CORBA::String_out anErrorText);
SMESH::Hypothesis_Status RemoveHypothesis(GEOM::GEOM_Object_ptr aSubShape,
- SMESH::SMESH_Hypothesis_ptr anHyp)
- throw (SALOME::SALOME_Exception);
+ SMESH::SMESH_Hypothesis_ptr anHyp);
- SMESH::ListOfHypothesis* GetHypothesisList(GEOM::GEOM_Object_ptr aSubShape)
- throw (SALOME::SALOME_Exception);
+ SMESH::ListOfHypothesis* GetHypothesisList(GEOM::GEOM_Object_ptr aSubShape);
- SMESH::submesh_array* GetSubMeshes()
- throw (SALOME::SALOME_Exception);
+ SMESH::submesh_array* GetSubMeshes();
- SMESH::SMESH_subMesh_ptr GetSubMesh(GEOM::GEOM_Object_ptr aSubShape, const char* theName)
- throw (SALOME::SALOME_Exception);
+ SMESH::SMESH_subMesh_ptr GetSubMesh(GEOM::GEOM_Object_ptr aSubShape, const char* theName);
- void RemoveSubMesh( SMESH::SMESH_subMesh_ptr theSubMesh )
- throw (SALOME::SALOME_Exception);
+ void RemoveSubMesh( SMESH::SMESH_subMesh_ptr theSubMesh );
- SMESH::SMESH_Group_ptr CreateGroup( SMESH::ElementType theElemType, const char* theName )
- throw (SALOME::SALOME_Exception);
+ SMESH::SMESH_Group_ptr CreateGroup( SMESH::ElementType theElemType, const char* theName );
SMESH::SMESH_GroupOnGeom_ptr CreateGroupFromGEOM(SMESH::ElementType theElemType,
const char* theName,
- GEOM::GEOM_Object_ptr theGeomObj )
- throw (SALOME::SALOME_Exception);
+ GEOM::GEOM_Object_ptr theGeomObj );
SMESH::SMESH_GroupOnFilter_ptr CreateGroupFromFilter(SMESH::ElementType theElemType,
const char* theName,
- SMESH::Filter_ptr theFilter )
- throw (SALOME::SALOME_Exception);
+ SMESH::Filter_ptr theFilter );
- void RemoveGroup( SMESH::SMESH_GroupBase_ptr theGroup )
- throw (SALOME::SALOME_Exception);
+ void RemoveGroup( SMESH::SMESH_GroupBase_ptr theGroup );
- void RemoveGroupWithContents( SMESH::SMESH_GroupBase_ptr theGroup )
- throw (SALOME::SALOME_Exception);
+ void RemoveGroupWithContents( SMESH::SMESH_GroupBase_ptr theGroup );
- SMESH::ListOfGroups* GetGroups()
- throw (SALOME::SALOME_Exception);
+ SMESH::ListOfGroups* GetGroups();
- CORBA::Long NbGroups()
- throw (SALOME::SALOME_Exception);
+ CORBA::Long NbGroups();
SMESH::SMESH_Group_ptr UnionGroups( SMESH::SMESH_GroupBase_ptr theGroup1,
SMESH::SMESH_GroupBase_ptr theGroup2,
- const char* theName )
- throw (SALOME::SALOME_Exception);
+ const char* theName );
SMESH::SMESH_Group_ptr UnionListOfGroups( const SMESH::ListOfGroups& theGroups,
- const char* theName)
- throw (SALOME::SALOME_Exception);
+ const char* theName);
SMESH::SMESH_Group_ptr IntersectGroups( SMESH::SMESH_GroupBase_ptr theGroup1,
SMESH::SMESH_GroupBase_ptr theGroup2,
- const char* theName )
- throw (SALOME::SALOME_Exception);
+ const char* theName );
SMESH::SMESH_Group_ptr IntersectListOfGroups( const SMESH::ListOfGroups& theGroups,
- const char* theName )
- throw (SALOME::SALOME_Exception);
+ const char* theName );
SMESH::SMESH_Group_ptr CutGroups( SMESH::SMESH_GroupBase_ptr theGroup1,
SMESH::SMESH_GroupBase_ptr theGroup2,
- const char* theName )
- throw (SALOME::SALOME_Exception);
+ const char* theName );
SMESH::SMESH_Group_ptr CutListOfGroups( const SMESH::ListOfGroups& theMainGroups,
const SMESH::ListOfGroups& theToolGroups,
- const char* theName )
- throw (SALOME::SALOME_Exception);
+ const char* theName );
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);
+ CORBA::Boolean theUnderlyingOnly );
SMESH::ListOfGroups* FaceGroupsSeparatedByEdges( CORBA::Double theSharpAngle,
CORBA::Boolean theCreateEdges,
- CORBA::Boolean theUseExistingEdges )
- throw (SALOME::SALOME_Exception);
+ CORBA::Boolean theUseExistingEdges );
- SMESH::SMESH_Group_ptr ConvertToStandalone( SMESH::SMESH_GroupBase_ptr theGroupOn )
- throw (SALOME::SALOME_Exception);
+ SMESH::SMESH_Group_ptr ConvertToStandalone( SMESH::SMESH_GroupBase_ptr theGroupOn );
- SMESH::log_array* GetLog(CORBA::Boolean clearAfterGet)
- throw (SALOME::SALOME_Exception);
+ SMESH::log_array* GetLog(CORBA::Boolean clearAfterGet);
- 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 ImportUNVFile( const char* theFileName );
- int ImportSTLFile( const char* theFileName )
- throw (SALOME::SALOME_Exception);
+ int ImportSTLFile( const char* theFileName );
SMESH::ComputeError* ImportGMFFile( const char* theFileName,
- bool theMakeRequiredGroups)
- throw (SALOME::SALOME_Exception);
+ bool theMakeRequiredGroups);
/*!
* 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 ImportMEDFile( const char* theFileName, const char* theMeshName );
SMESH::DriverMED_ReadStatus ImportCGNSFile( const char* theFileName,
const int theMeshIndex,
- std::string& theMeshName)
- throw (SALOME::SALOME_Exception);
+ std::string& theMeshName);
/*!
* Auto color
*/
- void SetAutoColor(CORBA::Boolean theAutoColor)
- throw (SALOME::SALOME_Exception);
+ void SetAutoColor(CORBA::Boolean theAutoColor);
- CORBA::Boolean GetAutoColor()
- throw (SALOME::SALOME_Exception);
+ CORBA::Boolean GetAutoColor();
/*! 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 NbNodes();
- CORBA::Long NbElements()
- throw (SALOME::SALOME_Exception);
+ CORBA::Long NbElements();
- CORBA::Long Nb0DElements()
- throw (SALOME::SALOME_Exception);
+ CORBA::Long Nb0DElements();
- CORBA::Long NbBalls()
- throw (SALOME::SALOME_Exception);
+ CORBA::Long NbBalls();
- CORBA::Long NbEdges()
- throw (SALOME::SALOME_Exception);
+ CORBA::Long NbEdges();
- CORBA::Long NbEdgesOfOrder(SMESH::ElementOrder order)
- throw (SALOME::SALOME_Exception);
+ CORBA::Long NbEdgesOfOrder(SMESH::ElementOrder order);
- CORBA::Long NbFaces()
- throw (SALOME::SALOME_Exception);
+ CORBA::Long NbFaces();
- CORBA::Long NbFacesOfOrder(SMESH::ElementOrder order)
- throw (SALOME::SALOME_Exception);
+ CORBA::Long NbFacesOfOrder(SMESH::ElementOrder order);
- CORBA::Long NbTriangles()
- throw (SALOME::SALOME_Exception);
+ CORBA::Long NbTriangles();
- CORBA::Long NbTrianglesOfOrder(SMESH::ElementOrder order)
- throw (SALOME::SALOME_Exception);
+ CORBA::Long NbTrianglesOfOrder(SMESH::ElementOrder order);
- CORBA::Long NbBiQuadTriangles()
- throw (SALOME::SALOME_Exception);
+ CORBA::Long NbBiQuadTriangles();
- CORBA::Long NbQuadrangles()
- throw (SALOME::SALOME_Exception);
+ CORBA::Long NbQuadrangles();
- CORBA::Long NbQuadranglesOfOrder(SMESH::ElementOrder order)
- throw (SALOME::SALOME_Exception);
+ CORBA::Long NbQuadranglesOfOrder(SMESH::ElementOrder order);
- CORBA::Long NbBiQuadQuadrangles()
- throw (SALOME::SALOME_Exception);
+ CORBA::Long NbBiQuadQuadrangles();
- CORBA::Long NbPolygons()
- throw (SALOME::SALOME_Exception);
+ CORBA::Long NbPolygons();
- CORBA::Long NbPolygonsOfOrder(SMESH::ElementOrder order = SMESH::ORDER_ANY)
- throw (SALOME::SALOME_Exception);
+ CORBA::Long NbPolygonsOfOrder(SMESH::ElementOrder order = SMESH::ORDER_ANY);
- CORBA::Long NbVolumes()
- throw (SALOME::SALOME_Exception);
+ CORBA::Long NbVolumes();
- CORBA::Long NbVolumesOfOrder(SMESH::ElementOrder order)
- throw (SALOME::SALOME_Exception);
+ CORBA::Long NbVolumesOfOrder(SMESH::ElementOrder order);
- CORBA::Long NbTetras()
- throw (SALOME::SALOME_Exception);
+ CORBA::Long NbTetras();
- CORBA::Long NbTetrasOfOrder(SMESH::ElementOrder order)
- throw (SALOME::SALOME_Exception);
+ CORBA::Long NbTetrasOfOrder(SMESH::ElementOrder order);
- CORBA::Long NbHexas()
- throw (SALOME::SALOME_Exception);
+ CORBA::Long NbHexas();
- CORBA::Long NbHexasOfOrder(SMESH::ElementOrder order)
- throw (SALOME::SALOME_Exception);
+ CORBA::Long NbHexasOfOrder(SMESH::ElementOrder order);
- CORBA::Long NbTriQuadraticHexas()
- throw (SALOME::SALOME_Exception);
+ CORBA::Long NbTriQuadraticHexas();
- CORBA::Long NbPyramids()
- throw (SALOME::SALOME_Exception);
+ CORBA::Long NbPyramids();
- CORBA::Long NbPyramidsOfOrder(SMESH::ElementOrder order)
- throw (SALOME::SALOME_Exception);
+ CORBA::Long NbPyramidsOfOrder(SMESH::ElementOrder order);
- CORBA::Long NbPrisms()
- throw (SALOME::SALOME_Exception);
+ CORBA::Long NbPrisms();
- CORBA::Long NbPrismsOfOrder(SMESH::ElementOrder order)
- throw (SALOME::SALOME_Exception);
+ CORBA::Long NbPrismsOfOrder(SMESH::ElementOrder order);
- CORBA::Long NbHexagonalPrisms()
- throw (SALOME::SALOME_Exception);
+ CORBA::Long NbHexagonalPrisms();
- CORBA::Long NbPolyhedrons()
- throw (SALOME::SALOME_Exception);
+ CORBA::Long NbPolyhedrons();
- CORBA::Long NbSubMesh()
- throw (SALOME::SALOME_Exception);
+ CORBA::Long NbSubMesh();
- SMESH::long_array* GetElementsId()
- throw (SALOME::SALOME_Exception);
+ SMESH::long_array* GetElementsId();
- SMESH::long_array* GetElementsByType( SMESH::ElementType theElemType )
- throw (SALOME::SALOME_Exception);
+ SMESH::long_array* GetElementsByType( SMESH::ElementType theElemType );
- SMESH::long_array* GetNodesId()
- throw (SALOME::SALOME_Exception);
+ SMESH::long_array* GetNodesId();
- SMESH::ElementType GetElementType( CORBA::Long id, bool iselem )
- throw (SALOME::SALOME_Exception);
+ SMESH::ElementType GetElementType( CORBA::Long id, bool iselem );
- SMESH::EntityType GetElementGeomType( CORBA::Long id )
- throw (SALOME::SALOME_Exception);
+ SMESH::EntityType GetElementGeomType( CORBA::Long id );
- SMESH::GeometryType GetElementShape( CORBA::Long id )
- throw (SALOME::SALOME_Exception);
+ SMESH::GeometryType GetElementShape( CORBA::Long id );
/*!
* Returns ID of elements for given submesh
*/
- SMESH::long_array* GetSubMeshElementsId(CORBA::Long ShapeID)
- throw (SALOME::SALOME_Exception);
+ SMESH::long_array* GetSubMeshElementsId(CORBA::Long ShapeID);
/*!
* Returns ID of nodes for given submesh
* If param all==true - returns all nodes, else -
* returns only nodes on shapes.
*/
- SMESH::long_array* GetSubMeshNodesId(CORBA::Long ShapeID, CORBA::Boolean all)
- throw (SALOME::SALOME_Exception);
+ SMESH::long_array* GetSubMeshNodesId(CORBA::Long ShapeID, CORBA::Boolean all);
/*!
* Returns type of elements for given submesh
*/
- SMESH::ElementType GetSubMeshElementType(CORBA::Long ShapeID)
- throw (SALOME::SALOME_Exception);
+ SMESH::ElementType GetSubMeshElementType(CORBA::Long ShapeID);
char* Dump();
// Create groups of elements preventing computation of a sub-shape
SMESH::ListOfGroups* MakeGroupsOfBadInputElements( int theSubShapeID,
- const char* theGroupName)
- throw (SALOME::SALOME_Exception);
+ const char* theGroupName);
// ===================================================
// Internal methods not available through CORBA
const char* varIndexPtr = cmdStr.ToCString() + pos;
if ( '0' <= *varIndexPtr && *varIndexPtr <= '9' )
varIndex = atoi( varIndexPtr );
- if ( 0 <= varIndex && varIndex < vars.size() && !vars[varIndex].empty() )
+ if ( 0 <= (int)varIndex && varIndex < vars.size() && !vars[varIndex].empty() )
{
// replace '$VarIndex$' either by var name of var value
const char var0 = vars[varIndex][0];
*/
//================================================================================
- void meshInfoLoaded( SMESH_Mesh_i* mesh )
+ void meshInfoLoaded( SMESH_Mesh_i* /*mesh*/ )
{
theMeshCounter++;
}
*/
//================================================================================
- void filesNoMoreNeeded(SMESH_Mesh_i* mesh,
+ void filesNoMoreNeeded(SMESH_Mesh_i* /*mesh*/,
std::string medFile,
std::string hdfFile)
{
TPythonDump&
TPythonDump::
- operator<<(SMESH::FilterManager_i* theArg)
+ operator<<(SMESH::FilterManager_i* /*theArg*/)
{
myStream<<"aFilterManager";
return *this;
TPythonDump&
TPythonDump::
- operator<<(SMESH::Measurements_i* theArg)
+ operator<<(SMESH::Measurements_i* /*theArg*/)
{
myStream<<"aMeasurements";
return *this;
}
- TPythonDump& TPythonDump:: operator<<(SMESH_Gen_i* theArg)
+ TPythonDump& TPythonDump:: operator<<(SMESH_Gen_i* /*theArg*/)
{
myStream << SMESHGenName(); return *this;
}
{
#ifdef _DEBUG_
std::cout << "Exception in SMESH_Gen_i::DumpPython(): " << text << std::endl;
+#else
+ (void)text; // todo: unused in release mode
#endif
}
//=============================================================================
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 );
}
int localId );
~SMESH_subMesh_i();
- CORBA::Long GetNumberOfElements()
- throw (SALOME::SALOME_Exception);
+ CORBA::Long GetNumberOfElements();
- CORBA::Long GetNumberOfNodes( CORBA::Boolean all )
- throw (SALOME::SALOME_Exception);
+ CORBA::Long GetNumberOfNodes( CORBA::Boolean all );
- SMESH::long_array* GetElementsId()
- throw (SALOME::SALOME_Exception);
+ SMESH::long_array* GetElementsId();
- SMESH::long_array* GetElementsByType( SMESH::ElementType theElemType )
- throw (SALOME::SALOME_Exception);
+ SMESH::long_array* GetElementsByType( SMESH::ElementType theElemType );
- SMESH::ElementType GetElementType( CORBA::Long id, bool iselem )
- throw (SALOME::SALOME_Exception);
+ SMESH::ElementType GetElementType( CORBA::Long id, bool iselem );
- SMESH::long_array* GetNodesId()
- throw (SALOME::SALOME_Exception);
+ SMESH::long_array* GetNodesId();
- SMESH::SMESH_Mesh_ptr GetFather()
- throw (SALOME::SALOME_Exception);
+ SMESH::SMESH_Mesh_ptr GetFather();
- GEOM::GEOM_Object_ptr GetSubShape()
- throw (SALOME::SALOME_Exception);
+ GEOM::GEOM_Object_ptr GetSubShape();
CORBA::Long GetId();
int localId,
GEOM::GEOM_Object_ptr shape);
- virtual GEOM::GEOM_Object_ptr GetSubShape()
- throw (SALOME::SALOME_Exception);
+ virtual GEOM::GEOM_Object_ptr GetSubShape();
protected:
Returns:
A list of edge groups and a list of corresponding node groups,
- where the group is a list of IDs of edges or elements, like follows
+ where the group is a list of IDs of edges or nodes, like follows
[[[branch_edges_1],[branch_edges_2]], [[branch_nodes_1],[branch_nodes_2]]].
If a group is closed, the first and last nodes of the group are same.
"""
double a[3];
bool isDone[3];
double size = -1., maxLinkLen;
- int jLongest;
+ int jLongest = 0;
//int nbLinks = 0;
for ( int i = 1; i <= myPolyTrias->Upper(); ++i )
//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);
+ double GetLength(const SMESH_Mesh* aMesh, const TopoDS_Shape& anEdge);
/*!
* \brief Computes segment length for an edge of given length
*/
- double GetLength(const SMESH_Mesh* aMesh, const double edgeLength)
- throw(SALOME_Exception);
+ double GetLength(const SMESH_Mesh* aMesh, const double edgeLength);
/*!
* \brief Set Fineness
* The "Initial Number of Elements on the Shortest Edge" (S0)
* is divided by (0.5 + 4.5 x theFineness)
*/
- void SetFineness(double theFineness)
- throw(SALOME_Exception);
+ void SetFineness(double theFineness);
/*!
* \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
*/
bool _hasInternalFaces;
public:
virtual ~Solid() {}
- virtual bool Contains( TGeomID subID ) const { return true; }
- virtual bool ContainsAny( const vector< TGeomID>& subIDs ) const { return true; }
+ virtual bool Contains( TGeomID /*subID*/ ) const { return true; }
+ virtual bool ContainsAny( const vector< TGeomID>& /*subIDs*/ ) const { return true; }
virtual TopAbs_Orientation Orientation( const TopoDS_Shape& s ) const { return s.Orientation(); }
- virtual bool IsOutsideOriented( TGeomID faceID ) const { return true; }
+ virtual bool IsOutsideOriented( TGeomID /*faceID*/ ) const { return true; }
void SetID( TGeomID id ) { _id = id; }
TGeomID ID() const { return _id; }
void SetHasInternalFaces( bool has ) { _hasInternalFaces = has; }
}
#ifdef _DEBUG_
_cellID = cellID;
+#else
+ (void)cellID; // unused in release mode
#endif
}
case 3: // at a corner
{
_Node& node = _hexNodes[ subEntity - SMESH_Block::ID_FirstV ];
- if ( node.Node() > 0 )
+ if ( node.Node() != 0 )
{
if ( node._intPoint )
node._intPoint->Add( _eIntPoints[ iP ]->_faceIDs, _eIntPoints[ iP ]->_node );
continue;
// perform intersection
- E_IntersectPoint* eip, *vip;
+ E_IntersectPoint* eip, *vip = 0; // todo: vip must be explicitly initialized to avoid warning (see below)
for ( int iDirZ = 0; iDirZ < 3; ++iDirZ )
{
GridPlanes& planes = pln[ iDirZ ];
vip = _grid->Add( ip );
if ( isInternal && !sameV )
vip->_faceIDs.push_back( _grid->PseudoIntExtFaceID() );
- if ( !addIntersection( vip, hexes, ijk, d000 ) && !sameV )
+ if ( !addIntersection( vip, hexes, ijk, d000 ) && !sameV ) // todo: vip must be explicitly initialized to avoid warning (see above)
_grid->Remove( vip );
ip._shapeID = edgeID;
}
cout << "BUG: not shared link. IKJ = ( "<< _i << " " << _j << " " << _k << " )" << endl
<< "n1 (" << p1.X() << ", "<< p1.Y() << ", "<< p1.Z() << " )" << endl
<< "n2 (" << p2.X() << ", "<< p2.Y() << ", "<< p2.Z() << " )" << endl;
+#else
+ (void)link; // unused in release mode
#endif
return false;
}
if ( allQuads )
{
// set side nodes as this: bottom, top, top, ...
- int iTop, iBot; // side indices
+ int iTop = 0, iBot = 0; // side indices
for ( int iS = 0; iS < 6; ++iS )
{
if ( vol->_names[ iS ] == SMESH_Block::ID_Fxy0 )
*/
//=============================================================================
-bool StdMeshers_Cartesian_3D::Evaluate(SMESH_Mesh & theMesh,
- const TopoDS_Shape & theShape,
- MapShapeNbElems& theResMap)
+bool StdMeshers_Cartesian_3D::Evaluate(SMESH_Mesh & /*theMesh*/,
+ const TopoDS_Shape & /*theShape*/,
+ MapShapeNbElems& /*theResMap*/)
{
// TODO
// std::vector<int> aResVec(SMDSEntity_Last);
// --------------------------------------------------------------------------------
// unsetting _alwaysComputed flag if "Cartesian_3D" was removed
//
- virtual void ProcessEvent(const int event,
+ virtual void ProcessEvent(const int /*event*/,
const int eventType,
SMESH_subMesh* subMeshOfSolid,
- SMESH_subMeshEventListenerData* data,
- const SMESH_Hypothesis* hyp = 0)
+ SMESH_subMeshEventListenerData* /*data*/,
+ const SMESH_Hypothesis* /*hyp*/ = 0)
{
if ( eventType == SMESH_subMesh::COMPUTE_EVENT )
{
virtual bool Compute(SMESH_Mesh& aMesh, const TopoDS_Shape& aShape);
- virtual bool Evaluate(SMESH_Mesh & aMesh, const TopoDS_Shape & aShape,
- MapShapeNbElems& aResMap);
+ virtual bool Evaluate(SMESH_Mesh & /*aMesh*/, const TopoDS_Shape & /*aShape*/,
+ MapShapeNbElems& /*aResMap*/);
virtual void SetEventListener(SMESH_subMesh* subMesh);
*/
//================================================================================
-bool StdMeshers_CompositeHexa_3D::CheckHypothesis(SMESH_Mesh& aMesh,
- const TopoDS_Shape& aShape,
+bool StdMeshers_CompositeHexa_3D::CheckHypothesis(SMESH_Mesh& /*aMesh*/,
+ const TopoDS_Shape& /*aShape*/,
Hypothesis_Status& aStatus)
{
_blockRenumberHyp = nullptr;
if ( fIt->next()->NbNodes() % 4 > 0 )
return error("Non-quadrangular mesh faces are not allowed on sides of a composite block");
- bool isProxy, isTmpElem;
+ bool isProxy = false, isTmpElem = false;
if ( faceSubMesh && faceSubMesh->NbElements() > 0 )
{
isProxy = dynamic_cast< const SMESH_ProxyMesh::SubMesh* >( faceSubMesh );
n = d1u.Crossed( d1v );
return true;
}
- catch (Standard_Failure) {
+ catch (Standard_Failure&) {
return false;
}
}
virtual bool Evaluate(SMESH_Mesh & aMesh, const TopoDS_Shape & aShape,
MapShapeNbElems& aResMap);
- virtual bool CheckHypothesis(SMESH_Mesh& aMesh,
- const TopoDS_Shape& aShape,
+ virtual bool CheckHypothesis(SMESH_Mesh& /*aMesh*/,
+ const TopoDS_Shape& /*aShape*/,
Hypothesis_Status& aStatus);
private:
//=============================================================================
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;
try {
OCC_CATCH_SIGNALS;
f = pow( 10., f );
- } catch(Standard_Failure) {
+ } catch(Standard_Failure&) {
f = 0.0;
ok = false;
}
OCC_CATCH_SIGNALS;
myExpr = ExprIntrp_GenExp::Create();
myExpr->Process( ( Standard_CString )str );
- } catch(Standard_Failure) {
+ } catch(Standard_Failure&) {
ok = false;
}
try {
OCC_CATCH_SIGNALS;
f = myExpr->Expression()->Evaluate( myVars, myValues );
- } catch(Standard_Failure) {
+ } catch(Standard_Failure&) {
f = 0.0;
ok = false;
}
( *static_cast<math_Function*>( const_cast<FunctionExpr*> (this) ), a, b, 20 );
if( _int.IsDone() )
res = _int.Value();
- } catch(Standard_Failure) {
+ } catch(Standard_Failure&) {
res = 0.0;
MESSAGE( "Exception in integral calculating" );
}
MESSAGE_ADD ( "\tF: "<<myFirst[i]<< " L: "<< myLast[i] );
MESSAGE_END ( "\tnormPar: "<<myNormPar[i]<<endl );
}
+#else
+ (void)msg; // unused in release mode
#endif
}
//=============================================================================
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();
*/
//================================================================================
-bool StdMeshers_FixedPoints1D::SetParametersByDefaults(const TDefaults& dflts,
+bool StdMeshers_FixedPoints1D::SetParametersByDefaults(const TDefaults& /*dflts*/,
const SMESH_Mesh* /*mesh*/)
{
_nbsegs.reserve( 1 );
StdMeshers_FixedPoints1D(int hypId, SMESH_Gen* gen);
virtual ~StdMeshers_FixedPoints1D();
- void SetPoints(const std::vector<double>& listParams)
- throw(SALOME_Exception);
+ void SetPoints(const std::vector<double>& listParams);
- void SetNbSegments(const std::vector<int>& listNbSeg)
- throw(SALOME_Exception);
+ void SetNbSegments(const std::vector<int>& listNbSeg) ;
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;
if ( !toCheckAll && ok ) return true;
}
return toCheckAll;
-};
+}
//=======================================================================
//function : ComputePentahedralMesh
if ( getBox()->IsOut( point ))
return false;
+ bool ok = false;
+ double dist2, param;
+ distance2 = Precision::Infinite();
+
if ( isLeaf() )
{
for ( size_t i = 0; i < _segments.size(); ++i )
if ( !_segments[i].IsOut( point ) &&
- _segments[i].IsOn( point, distance2, u ))
- return true;
+ _segments[i].IsOn( point, dist2, param ) &&
+ dist2 < distance2 )
+ {
+ distance2 = dist2;
+ u = param;
+ ok = true;
+ }
+ return ok;
}
else
{
for (int i = 0; i < 8; i++)
- if (((CurveProjector*) myChildren[i])->IsOnCurve( point, distance2, u ))
- return true;
+ if (((CurveProjector*) myChildren[i])->IsOnCurve( point, dist2, param ) &&
+ dist2 < distance2 )
+ {
+ distance2 = dist2;
+ u = param;
+ ok = true;
+ }
}
- return false;
+ return ok;
}
-
+
//================================================================================
/*!
* \brief Initialize
_pLast = pl;
_curve = curve;
_length2 = pf.SquareDistance( pl );
+ _line.SetLocation( pf );
+ _line.SetDirection( gp_Vec( pf, pl ));
_chord2 = Max( _line. SquareDistance( curve->Value( uf + 0.25 * ( ul - uf ))),
Max( _line.SquareDistance( curve->Value( uf + 0.5 * ( ul - uf ))),
_line.SquareDistance( curve->Value( uf + 0.75 * ( ul - uf )))));
_chord2 = Max( tol, _chord2 );
_chord = Sqrt( _chord2 );
- _line.SetLocation( pf );
- _line.SetDirection( gp_Vec( pf, pl ));
Bnd_Box bb;
BndLib_Add3dCurve::Add( GeomAdaptor_Curve( curve, uf, ul ), tol, bb );
gp_Vec edge( _pFirst, _pLast );
gp_Vec n1p ( _pFirst, point );
u = ( edge * n1p ) / _length2; // param [0,1] on the edge
- if ( u < 0 )
+ if ( u < 0. )
{
if ( _pFirst.SquareDistance( point ) > _chord2 )
return false;
}
- else if ( u > _chord )
+ else if ( u > 1. )
{
if ( _pLast.SquareDistance( point ) > _chord2 )
return false;
case TopAbs_EDGE:
if ( SMESH_Algo::isDegenerated( TopoDS::Edge( sm->GetSubShape() )))
continue;
+ // fall through
case TopAbs_FACE:
_subM.insert( sm );
if ( !sm->IsEmpty() )
//=============================================================================
void StdMeshers_LayerDistribution::SetLayerDistribution(SMESH_Hypothesis* hyp1D)
- throw ( SALOME_Exception )
{
if ( myHyp != hyp1D ) {
if ( myHyp && hyp1D->GetDim() != 1 )
* \brief Sets 1D hypothesis specifying distribution of layers
* \param hyp1D - 1D hypothesis
*/
- void SetLayerDistribution(SMESH_Hypothesis* hyp1D)
- throw ( SALOME_Exception );
+ void SetLayerDistribution(SMESH_Hypothesis* hyp1D);
/*!
* \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_MEFISTO_2D::ComputeScaleOnFace(SMESH_Mesh & aMesh,
+void StdMeshers_MEFISTO_2D::ComputeScaleOnFace(SMESH_Mesh & /*aMesh*/,
const TopoDS_Face & aFace,
double & scalex,
double & scaley)
//=============================================================================
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.; }
*/
//=============================================================================
-ostream & operator << (ostream & save, StdMeshers_NotConformAllowed & hyp)
+ostream & operator << (ostream & save, StdMeshers_NotConformAllowed & /*hyp*/)
{
return save;
}
*/
//=============================================================================
-istream & operator >> (istream & load, StdMeshers_NotConformAllowed & hyp)
+istream & operator >> (istream & load, StdMeshers_NotConformAllowed & /*hyp*/)
{
return load;
}
//=============================================================================
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;
OCC_CATCH_SIGNALS;
val = pow( 10.0, val );
}
- catch(Standard_Failure) {
+ catch(Standard_Failure&) {
throw SALOME_Exception( LOCALIZED( "invalid value"));
return;
}
//================================================================================
const vector<double>& StdMeshers_NumberOfSegments::GetTableFunction() const
- throw(SALOME_Exception)
{
if (_distrType != DT_TabFunc)
throw SALOME_Exception(LOCALIZED("not a table function distribution"));
OCC_CATCH_SIGNALS;
myExpr = ExprIntrp_GenExp::Create();
myExpr->Process( str.ToCString() );
- } catch(Standard_Failure) {
+ } catch(Standard_Failure&) {
parsed_ok = false;
}
//================================================================================
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);
+ void SetNumberOfSegments(int segmentsNumber);
/*!
* \brief Get the number of segments
/*!
* \brief Set distribution type
*/
- void SetDistrType(DistrType typ)
- throw (SALOME_Exception);
+ void SetDistrType(DistrType typ);
/*!
* \brief Get distribution type
* Throws SALOME_Exception if distribution type is not DT_Scale,
* or scaleFactor is not a positive value different from 1
*/
- virtual void SetScaleFactor(double scaleFactor)
- throw (SALOME_Exception);
+ virtual void SetScaleFactor(double scaleFactor);
/*!
* \brief Get scale factor for scale distribution
*
* Throws SALOME_Exception if distribution type is not DT_Scale
*/
- double GetScaleFactor() const
- throw (SALOME_Exception);
+ double GetScaleFactor() const;
/*!
* \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);
+ void SetTableFunction(const std::vector<double>& table);
/*!
* \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);
+ const std::vector<double>& GetTableFunction() const;
/*!
* \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);
+ void SetExpressionFunction( const char* expr);
/*!
* \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);
+ const char* GetExpressionFunction() const;
/*!
* \brief Checks validity of the expression of the function f(t), e.g. "sin(t)".
* \param convMode - 0 for "Exponent mode", 1 for "Cut negative mode"
*/
static std::string CheckExpressionFunction( const std::string& expr,
- const int convMode)
- throw (SALOME_Exception);
+ const int convMode);
/*!
* \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);
+ void SetConversionMode( int conv );
/*!
* \brief Returns conversion mode
*
* Throws SALOME_Exception if distribution type is not functional
*/
- int ConversionMode() const
- throw (SALOME_Exception);
+ int ConversionMode() const;
/*!
* \brief Initialize number of segments by the mesh built on the geometry
while(itf->more()) {
const SMDS_MeshElement* pE0 = itf->next();
aElementType = pE0->GetType();
- if (!aElementType==SMDSAbs_Face) {
+ if (aElementType!=SMDSAbs_Face) {
continue;
}
aNbNodes = pE0->NbNodes();
//purpose :
//=======================================================================
-bool StdMeshers_PolygonPerFace_2D::CheckHypothesis(SMESH_Mesh& theMesh,
- const TopoDS_Shape& theShape,
+bool StdMeshers_PolygonPerFace_2D::CheckHypothesis(SMESH_Mesh& /*theMesh*/,
+ const TopoDS_Shape& /*theShape*/,
SMESH_Hypothesis::Hypothesis_Status& theStatus)
{
theStatus = HYP_OK;
BOTTOM_EDGE = 0, TOP_EDGE, V0_EDGE, V1_EDGE, // edge IDs in face
NB_WALL_FACES = 4 }; //
-namespace {
-
+namespace
+{
+ //=======================================================================
+ /*!
+ * \brief Auxiliary mesh
+ */
+ struct TmpMesh: public SMESH_Mesh
+ {
+ TmpMesh() {
+ _isShapeToMesh = (_id = 0);
+ _myMeshDS = new SMESHDS_Mesh( _id, true );
+ }
+ };
//=======================================================================
/*!
* \brief Quadrangle algorithm
*/
- struct TQuadrangleAlgo : public StdMeshers_Quadrangle_2D
+ class TQuadrangleAlgo : public StdMeshers_Quadrangle_2D
{
+ typedef NCollection_DataMap< TopoDS_Face, FaceQuadStruct::Ptr > TFace2QuadMap;
+ TFace2QuadMap myFace2QuadMap;
+
TQuadrangleAlgo(SMESH_Gen* gen)
: StdMeshers_Quadrangle_2D( gen->GetANewId(), gen)
{
}
- static StdMeshers_Quadrangle_2D* instance( SMESH_Algo* fatherAlgo,
- SMESH_MesherHelper* helper=0)
+ public:
+
+ //================================================================================
+ // Clear data of TQuadrangleAlgo at destruction
+ struct Cleaner
+ {
+ TQuadrangleAlgo* myAlgo;
+
+ Cleaner(TQuadrangleAlgo* algo): myAlgo( algo ){}
+ ~Cleaner() { myAlgo->reset(); }
+ };
+
+ //================================================================================
+ // Return TQuadrangleAlgo singleton
+ static TQuadrangleAlgo* instance( SMESH_Algo* fatherAlgo,
+ SMESH_MesherHelper* helper=0)
{
static TQuadrangleAlgo* algo = new TQuadrangleAlgo( fatherAlgo->GetGen() );
if ( helper &&
return algo;
}
+
+ //================================================================================
+ // Clear collected data
+ void reset()
+ {
+ StdMeshers_Quadrangle_2D::myQuadList.clear();
+ StdMeshers_Quadrangle_2D::myHelper = nullptr;
+ StdMeshers_Quadrangle_2D::myProxyMesh.reset();
+ myFace2QuadMap.Clear();
+ }
+
+ //================================================================================
+ /*!
+ * \brief Return FaceQuadStruct if a given FACE can be meshed by StdMeshers_Quadrangle_2D
+ */
+ FaceQuadStruct::Ptr CheckNbEdges(SMESH_Mesh& theMesh,
+ const TopoDS_Shape& theShape )
+ {
+ const TopoDS_Face& face = TopoDS::Face( theShape );
+ if ( myFace2QuadMap.IsBound( face ))
+ return myFace2QuadMap.Find( face );
+
+ FaceQuadStruct::Ptr & resultQuad = * myFace2QuadMap.Bound( face, FaceQuadStruct::Ptr() );
+
+ FaceQuadStruct::Ptr quad =
+ StdMeshers_Quadrangle_2D::CheckNbEdges( theMesh, face, /*considerMesh=*/false, myHelper );
+ if ( quad )
+ {
+ // check if the quadrangle mesh would be valid
+
+ // check existing 1D mesh
+ // int nbSegments[4], i = 0;
+ // for ( FaceQuadStruct::Side & side : quad->side )
+ // nbSegments[ i++ ] = side.grid->NbSegments();
+ // if ( nbSegments[0] > 0 && nbSegments[2] > 0 && nbSegments[0] != nbSegments[2] ||
+ // nbSegments[1] > 0 && nbSegments[3] > 0 && nbSegments[1] != nbSegments[3] )
+ // return resultQuad;
+
+ int nbEdges = 0;
+ for ( FaceQuadStruct::Side & side : quad->side )
+ nbEdges += side.grid->NbEdges();
+ if ( nbEdges == 4 )
+ return resultQuad = quad;
+
+ TmpMesh mesh;
+ mesh.ShapeToMesh( face );
+ SMESHDS_Mesh* meshDS = mesh.GetMeshDS();
+ SMESH_MesherHelper helper( mesh );
+ helper.SetSubShape( face );
+ helper.SetElementsOnShape( true );
+
+ // create nodes on all VERTEX'es
+ for ( TopExp_Explorer vert( face, TopAbs_VERTEX ); vert.More(); vert.Next() )
+ mesh.GetSubMesh( vert.Current() )->ComputeStateEngine( SMESH_subMesh::COMPUTE );
+
+ FaceQuadStruct::Ptr tmpQuad( new FaceQuadStruct() );
+ tmpQuad->side.resize( 4 );
+
+ // divide quad sides into halves at least
+ const SMDS_MeshNode* node;
+ for ( int iDir = 0; iDir < 2; ++iDir )
+ {
+ StdMeshers_FaceSidePtr sides[2] = { quad->side[iDir], quad->side[iDir+2] };
+ std::map< double, const SMDS_MeshNode* > nodes[2];
+ for ( int iS : { 0, 1 } )
+ {
+ node = SMESH_Algo::VertexNode( sides[iS]->FirstVertex(), meshDS );
+ nodes[iS].insert( std::make_pair( 0, node ));
+ double curLen = 0;
+ for ( int iE = 1; iE < sides[iS]->NbEdges(); ++iE )
+ {
+ curLen += sides[iS]->EdgeLength( iE - 1 );
+ double u = curLen / sides[iS]->Length();
+ node = SMESH_Algo::VertexNode( sides[iS]->FirstVertex( iE ), meshDS );
+ nodes[iS ].insert( std::make_pair( u, node ));
+ nodes[1-iS].insert( std::make_pair( u, nullptr ));
+ }
+ nodes[iS].insert( std::make_pair( 0.5, nullptr ));
+ node = SMESH_Algo::VertexNode( sides[iS]->LastVertex(), meshDS );
+ nodes[iS].insert( std::make_pair( 1, node ));
+ }
+
+ for ( int iS : { 0, 1 } )
+ {
+ UVPtStructVec sideNodes;
+ sideNodes.reserve( nodes[ iS ].size() );
+ for ( auto & u_node : nodes[ iS ])
+ {
+ if ( !u_node.second )
+ {
+ gp_Pnt p = sides[iS]->Value3d( u_node.first );
+ u_node.second = meshDS->AddNode( p.X(), p.Y(), p.Z() );
+ TopoDS_Edge edge;
+ double param = sides[iS]->Parameter( u_node.first, edge );
+ meshDS->SetNodeOnEdge( u_node.second, edge, param );
+ }
+ sideNodes.push_back( u_node.second );
+ sideNodes.back().SetUV( helper.GetNodeUV( face, u_node.second ));
+ }
+ tmpQuad->side[ iS ? iDir+2 : iDir ] = StdMeshers_FaceSide::New( sideNodes, face );
+ }
+ }
+ StdMeshers_Quadrangle_2D::myCheckOri = true;
+ StdMeshers_Quadrangle_2D::myQuadList.clear();
+ StdMeshers_Quadrangle_2D::myQuadList.push_back( tmpQuad );
+ StdMeshers_Quadrangle_2D::myHelper = &helper;
+ if ( StdMeshers_Quadrangle_2D::computeQuadDominant( mesh, face, tmpQuad ) &&
+ StdMeshers_Quadrangle_2D::check())
+ {
+ resultQuad = quad;
+ }
+ StdMeshers_Quadrangle_2D::myQuadList.clear();
+ StdMeshers_Quadrangle_2D::myHelper = nullptr;
+ }
+ return resultQuad;
+ }
};
+
//=======================================================================
/*!
* \brief Algorithm projecting 1D mesh
int removeQuasiQuads(list< SMESH_subMesh* >& notQuadSubMesh,
SMESH_MesherHelper* helper,
- StdMeshers_Quadrangle_2D* quadAlgo)
+ TQuadrangleAlgo* quadAlgo)
{
int nbRemoved = 0;
//SMESHDS_Mesh* mesh = notQuadSubMesh.front()->GetFather()->GetMeshDS();
//================================================================================
int countNbSides( const Prism_3D::TPrismTopo & thePrism,
- vector<int> & nbUnitePerEdge,
+ vector<int> & /*nbUnitePerEdge*/,
vector< double > & edgeLength)
{
int nbEdges = thePrism.myNbEdgesInWires.front(); // nb outer edges
return nbSides;
}
+ //================================================================================
+ /*!
+ * \brief Count EDGEs ignoring degenerated ones
+ */
+ //================================================================================
+
+ int CountEdges( const TopoDS_Face& face )
+ {
+ int nbE = 0;
+ for ( TopExp_Explorer edgeExp( face, TopAbs_EDGE ); edgeExp.More(); edgeExp.Next() )
+ if ( !SMESH_Algo::isDegenerated( TopoDS::Edge( edgeExp.Current() )))
+ ++nbE;
+
+ return nbE;
+ }
+
//================================================================================
/*!
* \brief Set/get wire index to FaceQuadStruct
cout << "mesh.AddNode( " << p[i].X() << ", "<< p[i].Y() << ", "<< p[i].Z() << ") # " << i <<" " ;
SMESH_Block::DumpShapeID( i, cout ) << endl;
}
+#else
+ (void)p; // unused in release mode
#endif
}
+
} // namespace
//=======================================================================
//purpose :
//=======================================================================
-bool StdMeshers_Prism_3D::CheckHypothesis(SMESH_Mesh& aMesh,
- const TopoDS_Shape& aShape,
+bool StdMeshers_Prism_3D::CheckHypothesis(SMESH_Mesh& /*aMesh*/,
+ const TopoDS_Shape& /*aShape*/,
SMESH_Hypothesis::Hypothesis_Status& aStatus)
{
// no hypothesis
SMESH_MesherHelper helper( theMesh );
myHelper = &helper;
myPrevBottomSM = 0;
+ TQuadrangleAlgo::Cleaner quadCleaner( TQuadrangleAlgo::instance( this ));
int nbSolids = helper.Count( theShape, TopAbs_SOLID, /*skipSame=*/false );
if ( nbSolids < 1 )
// look for meshed FACEs ("source" FACEs) that must be prism bottoms
list< TopoDS_Face > meshedFaces, notQuadMeshedFaces, notQuadFaces;
const bool meshHasQuads = ( theMesh.NbQuadrangles() > 0 );
- //StdMeshers_Quadrangle_2D* quadAlgo = TQuadrangleAlgo::instance( this );
for ( int iF = 1; iF <= faceToSolids.Extent(); ++iF )
{
const TopoDS_Face& face = TopoDS::Face( faceToSolids.FindKey( iF ));
}
TopTools_MapOfShape meshedSolids;
+ NCollection_DataMap< TopoDS_Shape, SMESH_subMesh* > meshedFace2AlgoSM;
list< Prism_3D::TPrismTopo > meshedPrism;
list< TopoDS_Face > suspectSourceFaces;
TopTools_ListIteratorOfListOfShape solidIt;
{
prism.Clear();
prism.myBottom = face;
+ if ( meshedFace2AlgoSM.IsBound( face ))
+ prism.myAlgoSM = meshedFace2AlgoSM.Find( face );
if ( !initPrism( prism, solid, selectBottom ) ||
!compute( prism ))
return false;
SMESHDS_SubMesh* smDS = theMesh.GetMeshDS()->MeshElements( prism.myTop );
- if ( !myHelper->IsSameElemGeometry( smDS, SMDSGeom_QUADRANGLE ))
+ if ( !myHelper->IsSameElemGeometry( smDS, SMDSGeom_QUADRANGLE ) ||
+ !myHelper->IsStructured( theMesh.GetSubMesh( prism.myTop )))
{
meshedFaces.push_front( prism.myTop );
+ if ( prism.myAlgoSM && prism.myAlgoSM->GetAlgo() )
+ {
+ meshedFace2AlgoSM.Bind( prism.myTop, prism.myAlgoSM );
+ meshedFace2AlgoSM.Bind( prism.myBottom, prism.myAlgoSM );
+ }
}
else
{
solidList.Remove( solidIt );
continue; // already computed prism
}
- if ( myHelper->IsBlock( solid )) {
- solidIt.Next();
- continue; // too trivial
+ if ( myHelper->IsBlock( solid ))
+ {
+ bool isStructBase = true;
+ if ( prismIt->myAlgoSM )
+ isStructBase = ( myHelper->IsSameElemGeometry( prismIt->myAlgoSM->GetSubMeshDS(),
+ SMDSGeom_QUADRANGLE ) &&
+ myHelper->IsStructured(prismIt->myAlgoSM ));
+ if ( isStructBase )
+ {
+ solidIt.Next();
+ continue; // too trivial
+ }
}
// find a source FACE of the SOLID: it's a FACE sharing a bottom EDGE with wFace
const TopoDS_Edge& wEdge = (*wQuad)->side[ QUAD_TOP_SIDE ].grid->Edge(0);
}
prism.Clear();
prism.myBottom = candidateF;
+ prism.myAlgoSM = prismIt->myAlgoSM;
mySetErrorToSM = false;
if ( !myHelper->IsSubShape( candidateF, prismIt->myShape3D ) &&
myHelper ->IsSubShape( candidateF, solid ) &&
!myHelper->GetMesh()->GetSubMesh( candidateF )->IsMeshComputed() &&
initPrism( prism, solid, /*selectBottom=*/false ) &&
!myHelper->GetMesh()->GetSubMesh( prism.myTop )->IsMeshComputed() &&
- !myHelper->GetMesh()->GetSubMesh( prism.myBottom )->IsMeshComputed() &&
- project2dMesh( sourceF, prism.myBottom ))
+ !myHelper->GetMesh()->GetSubMesh( prism.myBottom )->IsMeshComputed() )
{
- mySetErrorToSM = true;
- if ( !compute( prism ))
- return false;
- SMESHDS_SubMesh* smDS = theMesh.GetMeshDS()->MeshElements( prism.myTop );
- if ( !myHelper->IsSameElemGeometry( smDS, SMDSGeom_QUADRANGLE ))
+ if ( project2dMesh( sourceF, prism.myBottom ))
{
- meshedFaces.push_front( prism.myTop );
- meshedFaces.push_front( prism.myBottom );
- selectBottom = false;
+ mySetErrorToSM = true;
+ if ( !compute( prism ))
+ return false;
+ SMESHDS_SubMesh* smDS = theMesh.GetMeshDS()->MeshElements( prism.myTop );
+ if ( !myHelper->IsSameElemGeometry( smDS, SMDSGeom_QUADRANGLE ))
+ {
+ meshedFaces.push_front( prism.myTop );
+ meshedFaces.push_front( prism.myBottom );
+ selectBottom = false;
+ if ( prism.myAlgoSM && prism.myAlgoSM->GetAlgo() )
+ {
+ meshedFace2AlgoSM.Bind( prism.myTop, prism.myAlgoSM );
+ meshedFace2AlgoSM.Bind( prism.myBottom, prism.myAlgoSM );
+ }
+ }
+ meshedPrism.push_back( prism );
+ meshedSolids.Add( solid );
+ }
+ else
+ {
+ suspectSourceFaces.push_back( prism.myBottom );
+ if ( prism.myAlgoSM && prism.myAlgoSM->GetAlgo() )
+ meshedFace2AlgoSM.Bind( prism.myBottom, prism.myAlgoSM );
}
- meshedPrism.push_back( prism );
- meshedSolids.Add( solid );
}
InitComputeError();
}
allSubMeComputed = smIt->next()->IsMeshComputed();
if ( allSubMeComputed )
{
- faceSM->ComputeStateEngine( SMESH_subMesh::COMPUTE );
+ faceSM->ComputeStateEngine( SMESH_subMesh::COMPUTE_SUBMESH );
if ( !faceSM->IsEmpty() ) {
meshedFaces.push_front( face ); // higher priority
selectBottom = true;
SMESH_Mesh* mesh = myHelper->GetMesh();
- StdMeshers_Quadrangle_2D* quadAlgo = TQuadrangleAlgo::instance( this, myHelper );
+ TQuadrangleAlgo* quadAlgo = TQuadrangleAlgo::instance( this, myHelper );
TopTools_MapOfShape faceMap;
TopTools_IndexedDataMapOfShapeListOfShape edgeToFaces;
{
// find any applicable algorithm assigned to any FACE of the main shape
std::vector< TopoDS_Shape > faces;
- if ( myPrevBottomSM &&
- myPrevBottomSM->GetAlgo()->IsApplicableToShape( thePrism.myBottom, /*all=*/false ))
+ if ( thePrism.myAlgoSM && thePrism.myAlgoSM->GetAlgo() )
+ faces.push_back( thePrism.myAlgoSM->GetSubShape() );
+ if ( myPrevBottomSM && myPrevBottomSM->GetAlgo() )
faces.push_back( myPrevBottomSM->GetSubShape() );
TopExp_Explorer faceIt( mesh->GetShapeToMesh(), TopAbs_FACE );
while ( smIt->more() && subOK )
{
SMESH_subMesh* sub = smIt->next();
- sub->ComputeStateEngine( SMESH_subMesh::COMPUTE );
+ sub->ComputeStateEngine( SMESH_subMesh::COMPUTE_SUBMESH );
subOK = sub->IsMeshComputed();
}
if ( !subOK )
}
try {
OCC_CATCH_SIGNALS;
+
+ Hypothesis_Status status;
+ algo->CheckHypothesis( *mesh, faces[i], status );
algo->InitComputeError();
- algo->Compute( *mesh, botSM->GetSubShape() );
+ if ( algo->Compute( *mesh, botSM->GetSubShape() ))
+ {
+ myPrevBottomSM = thePrism.myAlgoSM = mesh->GetSubMesh( faces[i] );
+ break;
+ }
}
catch (...) {
}
}
}
}
+ else
+ {
+ myPrevBottomSM = thePrism.myAlgoSM = botSM;
+ }
if ( botSM->IsEmpty() )
return error( COMPERR_BAD_INPUT_MESH,
TCom( "No mesher defined to compute the base face #")
<< shapeID( thePrism.myBottom ));
- if ( botSM->GetAlgo() )
- myPrevBottomSM = botSM;
-
return true;
}
SMESHDS_Mesh* meshDS = myHelper->GetMeshDS();
DBGOUT( endl << "COMPUTE Prism " << meshDS->ShapeToIndex( thePrism.myShape3D ));
- TProjction1dAlgo* projector1D = TProjction1dAlgo::instance( this );
- StdMeshers_Quadrangle_2D* quadAlgo = TQuadrangleAlgo::instance( this, myHelper );
+ TProjction1dAlgo* projector1D = TProjction1dAlgo::instance( this );
+ TQuadrangleAlgo* quadAlgo = TQuadrangleAlgo::instance( this, myHelper );
// SMESH_HypoFilter hyp1dFilter( SMESH_HypoFilter::IsAlgo(),/*not=*/true);
// hyp1dFilter.And( SMESH_HypoFilter::HasDim( 1 ));
bool StdMeshers_Prism_3D::project2dMesh(const TopoDS_Face& theSrcFace,
const TopoDS_Face& theTgtFace)
{
+ if ( CountEdges( theSrcFace ) != CountEdges( theTgtFace ))
+ return false;
+
TProjction2dAlgo* projector2D = TProjction2dAlgo::instance( this );
projector2D->myHyp.SetSourceFace( theSrcFace );
bool ok = projector2D->Compute( *myHelper->GetMesh(), theTgtFace );
*/
//================================================================================
-bool StdMeshers_Prism_3D::setFaceAndEdgesXYZ( const int faceID, const gp_XYZ& params, int z )
+bool StdMeshers_Prism_3D::setFaceAndEdgesXYZ( const int faceID, const gp_XYZ& params, int /*z*/ )
{
// find base and top edges of the face
enum { BASE = 0, TOP, LEFT, RIGHT };
myBottomEdges.clear();
myNbEdgesInWires.clear();
myWallQuads.clear();
+ myAlgoSM = nullptr;
}
//================================================================================
<< n << ", " << n+1 << ", "
<< n+nb+2 << ", " << n+nb+1 << "]) " << endl;
}
-
+#else
+ (void)face; // unused in release mode
+ (void)nb; // unused in release mode
#endif
}
column = & ( myParamToColumnMap->rbegin()->second );
else
column = & ( myParamToColumnMap->begin()->second );
- if ( column->size() > 0 )
+ if ( column->size() > 1 )
edge = myHelper.GetSubShapeByNode( (*column)[ 1 ], meshDS );
if ( edge.IsNull() || edge.ShapeType() == TopAbs_VERTEX )
node = column->front();
TVerticalEdgeAdaptor* vSide1 = (TVerticalEdgeAdaptor*) VertiCurve(1);
cout << "Verti side 1: "; vSide1->dumpNodes(nbNodes); cout << endl;
delete hSize0; delete hSize1; delete vSide0; delete vSide1;
+#else
+ (void)nbNodes; // unused in release mode
#endif
}
cout << (*myNodeColumn)[i]->GetID() << " ";
if ( nbNodes < (int) myNodeColumn->size() )
cout << myNodeColumn->back()->GetID();
+#else
+ (void)nbNodes; // unused in release mode
#endif
}
side->GetColumns( u , col, col2 );
if ( n != col->second[ i ] )
cout << col->second[ i ]->GetID();
+#else
+ (void)nbNodes; // unused in release mode
#endif
}
std::list< int > myNbEdgesInWires;
bool myNotQuadOnTop;
+ mutable SMESH_subMesh* myAlgoSM; // sub-mesh with algo which computed myBottom
size_t NbWires() const { return myNbEdgesInWires.size(); }
//=============================================================================
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 );
+ void SetSourceEdge(const TopoDS_Shape& edge);
/*!
* Returns the source edge or a group containing edges
* This parameter is optional
*/
void SetVertexAssociation(const TopoDS_Shape& sourceVertex,
- const TopoDS_Shape& targetVertex)
- throw ( SALOME_Exception );
+ const TopoDS_Shape& targetVertex);
/*!
* 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"));
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_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 );
+ void SetSourceFace(const TopoDS_Shape& face);
/*!
* Returns the source face or a group containing faces
void SetVertexAssociation(const TopoDS_Shape& sourceVertex1,
const TopoDS_Shape& sourceVertex2,
const TopoDS_Shape& targetVertex1,
- const TopoDS_Shape& targetVertex2)
- throw ( SALOME_Exception );
+ const TopoDS_Shape& targetVertex2);
/*!
* 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 );
+ void SetSource3DShape(const TopoDS_Shape& shape);
/*!
* Returns the source shape
void SetVertexAssociation(const TopoDS_Shape& sourceVertex1,
const TopoDS_Shape& sourceVertex2,
const TopoDS_Shape& targetVertex1,
- const TopoDS_Shape& targetVertex2)
- throw ( SALOME_Exception );
+ const TopoDS_Shape& targetVertex2);
/*!
* 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
return max(theMeshDS[0]->ShapeToIndex(S), theMeshDS[1]->ShapeToIndex(S) );
return long(S.TShape().operator->());
}
- void show_shape( TopoDS_Shape v, const char* msg ) // debug
+ void show_shape( TopoDS_Shape v, const char* msg ) // debug // todo: unused in release mode
{
if ( v.IsNull() ) cout << msg << " NULL SHAPE" << endl;
else if (v.ShapeType() == TopAbs_VERTEX) {
else {
cout << msg << " "; TopAbs::Print((v).ShapeType(),cout) <<" "<<shapeIndex((v))<<endl;}
}
- void show_list( const char* msg, const list< TopoDS_Edge >& l ) // debug
+ void show_list( const char* msg, const list< TopoDS_Edge >& l ) // debug // todo: unused in release mode
{
cout << msg << " ";
list< TopoDS_Edge >::const_iterator e = l.begin();
show_shape( TopoDS_Shape(), "avoid warning: show_shape() defined but not used");
show_list( "avoid warning: show_list() defined but not used", list< TopoDS_Edge >() );
}
+#else
+ (void)shape; // unused in release mode
#endif
return false;
}
TopoDS_Edge GetBoundaryEdge(const TopoDS_Shape& edgeContainer,
const SMESH_Mesh& mesh,
std::list< TopoDS_Edge >* allBndEdges = 0 );
-};
+}
#endif
//================================================================================
bool getBoundaryNodes ( SMESH_subMesh* sm,
- const TopoDS_Face& face,
+ const TopoDS_Face& /*face*/,
map< double, const SMDS_MeshNode* > & u2nodes,
set< const SMDS_MeshNode* > & seamNodes)
{
*/
//================================================================================
- bool projectQuads(const TopoDS_Face& tgtFace,
- const TopoDS_Face& srcFace,
- const TSideVector& tgtWires,
- const TSideVector& srcWires,
- const TAssocTool::TShapeShapeMap& shape2ShapeMap,
- TAssocTool::TNodeNodeMap& src2tgtNodes,
- const bool is1DComputed)
+ bool projectQuads(const TopoDS_Face& /*tgtFace*/,
+ const TopoDS_Face& /*srcFace*/,
+ const TSideVector& /*tgtWires*/,
+ const TSideVector& /*srcWires*/,
+ const TAssocTool::TShapeShapeMap& /*shape2ShapeMap*/,
+ TAssocTool::TNodeNodeMap& /*src2tgtNodes*/,
+ const bool /*is1DComputed*/)
{
// SMESH_Mesh * tgtMesh = tgtWires[0]->GetMesh();
// SMESH_Mesh * srcMesh = srcWires[0]->GetMesh();
// mapper changed, no more "mapper puts on a seam edge nodes from 2 edges"
if ( isSeam && ! getBoundaryNodes ( sm, tgtFace, u2nodesOnSeam, seamNodes ))
- ;//RETURN_BAD_RESULT("getBoundaryNodes() failed");
+ {
+ //RETURN_BAD_RESULT("getBoundaryNodes() failed");
+ }
SMDS_NodeIteratorPtr nIt = smDS->GetNodes();
while ( nIt->more() )
clearPropagationChain( subMesh );
}
// return; -- hyp is modified any way
+ // fall through
default:
//case SMESH_subMesh::MODIF_HYP: // hyp modif
// clear mesh in a chain
virtual void ProcessEvent(const int event,
const int eventType,
SMESH_subMesh* faceSubMesh,
- SMESH_subMeshEventListenerData* data,
- const SMESH_Hypothesis* hyp)
+ SMESH_subMeshEventListenerData* /*data*/,
+ const SMESH_Hypothesis* /*hyp*/)
{
if ( eventType == SMESH_subMesh::ALGO_EVENT )
{
//================================================================================
void separateNodes( SMESH_MesherHelper& theHelper,
- const SMESH_MAT2d::MedialAxis& theMA,
+ const SMESH_MAT2d::MedialAxis& /*theMA*/,
TMAPar2NPoints & thePointsOnE,
SinuousFace& theSinuFace,
const vector< bool >& theIsComputedEdge)
const vector<TopoDS_Edge>& theShortEdges,
SMESH_Algo* the1dAlgo,
const bool theHasRadialHyp,
- const bool theIs2nd)
+ const bool /*theIs2nd*/)
{
SMESH_Hypothesis::Hypothesis_Status aStatus;
for ( size_t i = 0; i < theShortEdges.size(); ++i )
* \retval bool - true if parameter values have been successfully defined
*/
//================================================================================
-bool StdMeshers_QuadrangleParams::SetParametersByDefaults(const TDefaults& dflts,
+bool StdMeshers_QuadrangleParams::SetParametersByDefaults(const TDefaults& /*dflts*/,
const SMESH_Mesh* /*mesh*/)
{
return true;
//=============================================================================
/*!
- *
+ * Compute the mesh on the given shape
*/
//=============================================================================
//=============================================================================
/*!
- *
+ * Return FaceQuadStruct where sides ordered CCW, top and left sides
+ * reversed to be co-directed with bottom and right sides
*/
//=============================================================================
*/
//=============================================================================
-void StdMeshers_Quadrangle_2D::splitQuadFace(SMESHDS_Mesh * theMeshDS,
- int theFaceID,
+void StdMeshers_Quadrangle_2D::splitQuadFace(SMESHDS_Mesh * /*theMeshDS*/,
+ int /*theFaceID*/,
const SMDS_MeshNode* theNode1,
const SMDS_MeshNode* theNode2,
const SMDS_MeshNode* theNode3,
if ( !toCheckAll ) return true;
}
return ( toCheckAll && nbFoundSolids != 0);
-};
+}
return &theEdgeMarker;
}
//! Clear edge sumbesh if something happens on face
- void ProcessEvent(const int event,
+ void ProcessEvent(const int /*event*/,
const int eventType,
- SMESH_subMesh* faceSubMesh,
+ SMESH_subMesh* /*faceSubMesh*/,
EventListenerData* edgesHolder,
const SMESH_Hypothesis* /*hyp*/)
{
*/
//================================================================================
- bool isCornerInsideCircle(const StdMeshers_FaceSidePtr& CircSide,
- const StdMeshers_FaceSidePtr& LinSide1,
- const StdMeshers_FaceSidePtr& LinSide2)
+ bool isCornerInsideCircle(const StdMeshers_FaceSidePtr& /*CircSide*/,
+ const StdMeshers_FaceSidePtr& /*LinSide1*/,
+ const StdMeshers_FaceSidePtr& /*LinSide2*/)
{
// if ( CircSide && LinSide1 && LinSide2 )
// {
{
// find the center and a point most distant from it
- double maxDist = 0, normPar;
+ double maxDist = 0, normPar = 0;
gp_XY uv1, uv2;
for ( int i = 0; i < 32; ++i )
{
}
if( toCheckAll && nbFoundFaces != 0 ) return true;
return false;
-};
+}
*/
//=============================================================================
-void StdMeshers_Regular_1D::SubmeshRestored(SMESH_subMesh* subMesh)
+void StdMeshers_Regular_1D::SubmeshRestored(SMESH_subMesh* /*subMesh*/)
{
}
*/
//=============================================================================
-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;
virtual void ProcessEvent(const int event,
const int eventType,
SMESH_subMesh* subMesh,
- SMESH_subMeshEventListenerData* data,
- const SMESH_Hypothesis* hyp)
+ SMESH_subMeshEventListenerData* /*data*/,
+ const SMESH_Hypothesis* /*hyp*/)
{
if (( SMESH_subMesh::COMPUTE_EVENT == eventType ) &&
( SMESH_subMesh::CHECK_COMPUTE_STATE != event &&
Handle(ShapeAnalysis_Surface)& surface,
const TopoDS_Face& F,
SMESH_MesherHelper& helper);
- bool smoothComplexEdge( _SolidData& data,
+ bool smoothComplexEdge( _SolidData& data,
Handle(ShapeAnalysis_Surface)& surface,
const TopoDS_Face& F,
SMESH_MesherHelper& helper);
}
return load;
} // --------------------------------------------------------------------------------
-bool StdMeshers_ViscousLayers::SetParametersByMesh(const SMESH_Mesh* theMesh,
- const TopoDS_Shape& theShape)
+bool StdMeshers_ViscousLayers::SetParametersByMesh(const SMESH_Mesh* /*theMesh*/,
+ const TopoDS_Shape& /*theShape*/)
{
// TODO
return false;
bool _ViscousBuilder::getFaceNormalAtSingularity( const gp_XY& uv,
const TopoDS_Face& face,
- SMESH_MesherHelper& helper,
+ SMESH_MesherHelper& /*helper*/,
gp_Dir& normal )
{
BRepAdaptor_Surface surface( face );
} // loop on data._edgesOnShape
if ( !is1stBlocked )
+ {
dumpFunctionEnd();
+ }
if ( closestFace && le )
{
eos._offsetSurf = new ShapeAnalysis_Surface( surf );
}
- catch ( Standard_Failure )
+ catch ( Standard_Failure& )
{
}
}
<< "_InfStep" << infStep << "_" << smooStep );
for ( ; i < eos._edges.size(); ++i )
{
- if ( eos._edges[i]->Is( _LayerEdge::MARKED ))
+ if ( eos._edges[i]->Is( _LayerEdge::MARKED )) {
dumpMove( eos._edges[i]->_nodes.back() );
+ }
}
dumpFunctionEnd();
}
*/
//================================================================================
-bool _Smoother1D::smoothComplexEdge( _SolidData& data,
+bool _Smoother1D::smoothComplexEdge( _SolidData& /*data*/,
Handle(ShapeAnalysis_Surface)& surface,
const TopoDS_Face& F,
- SMESH_MesherHelper& helper)
+ SMESH_MesherHelper& /*helper*/)
{
if ( _offPoints.empty() )
return false;
*/
//================================================================================
-void _ViscousBuilder::limitMaxLenByCurvature( _SolidData& data, SMESH_MesherHelper& helper )
+void _ViscousBuilder::limitMaxLenByCurvature( _SolidData& data, SMESH_MesherHelper& /*helper*/ )
{
// find intersection of neighbor _LayerEdge's to limit _maxLen
// according to local curvature (IPAL52648)
void _ViscousBuilder::limitMaxLenByCurvature( _LayerEdge* e1,
_LayerEdge* e2,
- _EdgesOnShape& eos1,
- _EdgesOnShape& eos2,
- const bool isSmoothable )
+ _EdgesOnShape& /*eos1*/,
+ _EdgesOnShape& /*eos2*/,
+ const bool /*isSmoothable*/ )
{
if (( e1->_nodes[0]->GetPosition()->GetDim() !=
e2->_nodes[0]->GetPosition()->GetDim() ) &&
bool _ViscousBuilder::updateNormals( _SolidData& data,
SMESH_MesherHelper& helper,
int stepNb,
- double stepSize)
+ double /*stepSize*/)
{
updateNormalsOfC1Vertices( data );
_LayerEdge* edge = e2neIt->first;
_LayerEdge& newEdge = e2neIt->second;
_EdgesOnShape* eos = data.GetShapeEdges( edge );
- if ( edge->Is( _LayerEdge::BLOCKED && newEdge._maxLen > edge->_len ))
+ if ( edge->Is( _LayerEdge::BLOCKED ) && newEdge._maxLen > edge->_len )
continue;
// Check if a new _normal is OK:
//================================================================================
bool _ViscousBuilder::updateNormalsOfSmoothed( _SolidData& data,
- SMESH_MesherHelper& helper,
+ SMESH_MesherHelper& /*helper*/,
const int nbSteps,
const double stepSize )
{
//================================================================================
void _LayerEdge::ChooseSmooFunction( const set< TGeomID >& concaveVertices,
- const TNode2Edge& n2eMap)
+ const TNode2Edge& /*n2eMap*/)
{
if ( _smooFunction ) return;
else
norm += cross;
}
- catch (Standard_Failure) { // if |cross| == 0.
+ catch (Standard_Failure&) { // if |cross| == 0.
}
}
gp_XYZ vec = newPos - pN;
bool _ViscousBuilder::prepareEdgeToShrink( _LayerEdge& edge,
_EdgesOnShape& eos,
SMESH_MesherHelper& helper,
- const SMESHDS_SubMesh* faceSubMesh)
+ const SMESHDS_SubMesh* /*faceSubMesh*/)
{
const SMDS_MeshNode* srcNode = edge._nodes[0];
const SMDS_MeshNode* tgtNode = edge._nodes.back();
*/
//================================================================================
-bool _LayerEdge::SetNewLength2d( Handle(Geom_Surface)& surface,
+bool _LayerEdge::SetNewLength2d( Handle(Geom_Surface)& /*surface*/,
const TopoDS_Face& F,
_EdgesOnShape& eos,
SMESH_MesherHelper& helper )
* \brief Initialize my parameter values by default parameters.
* \retval bool - true if parameter values have been successfully defined
*/
- virtual bool SetParametersByDefaults(const TDefaults& dflts, const SMESH_Mesh* theMesh=0)
+ virtual bool SetParametersByDefaults(const TDefaults& /*dflts*/, const SMESH_Mesh* /*theMesh*/=0)
{ return false; }
static const char* GetHypType() { return "ViscousLayers"; }
// Treat events
void ProcessEvent(const int event,
const int eventType,
- SMESH_subMesh* subMesh,
+ SMESH_subMesh* /*subMesh*/,
EventListenerData* data,
const SMESH_Hypothesis* /*hyp*/)
{
_param_algo_dim = -2; // auxiliary hyp used by 2D algos
}
// --------------------------------------------------------------------------------
-bool StdMeshers_ViscousLayers2D::SetParametersByMesh(const SMESH_Mesh* theMesh,
- const TopoDS_Shape& theShape)
+bool StdMeshers_ViscousLayers2D::SetParametersByMesh(const SMESH_Mesh* /*theMesh*/,
+ const TopoDS_Shape& /*theShape*/)
{
// TODO ???
return false;
* \brief Initialize my parameter values by default parameters.
* \retval bool - true if parameter values have been successfully defined
*/
- virtual bool SetParametersByDefaults(const TDefaults& dflts, const SMESH_Mesh* theMesh=0)
+ virtual bool SetParametersByDefaults(const TDefaults& /*dflts*/, const SMESH_Mesh* /*theMesh*/=0)
{ return false; }
static const char* GetHypType() { return "ViscousLayers2D"; }
//================================================================================
QWidget* LineDelegate::createEditor( QWidget* parent,
- const QStyleOptionViewItem& opt,
+ const QStyleOptionViewItem& /*opt*/,
const QModelIndex& index) const
{
QWidget* w = 0;
try {
OCC_CATCH_SIGNALS;
replot();
- } catch(Standard_Failure) {
+ } catch(Standard_Failure&) {
}
}
OCC_CATCH_SIGNALS;
myExpr = ExprIntrp_GenExp::Create();
myExpr->Process( ( Standard_CString ) str.toLatin1().data() );
- } catch(Standard_Failure) {
+ } catch(Standard_Failure&) {
parsed_ok = false;
}
try {
OCC_CATCH_SIGNALS;
res = myExpr->Expression()->Evaluate( myVars, myValues );
- } catch(Standard_Failure) {
+ } catch(Standard_Failure&) {
ok = false;
res = 0.0;
}
//
if(v < -7) v = -7.0;
v = pow( 10.0, v );
- } catch(Standard_Failure) {
+ } catch(Standard_Failure&) {
v = 0.0;
ok = false;
}
}
QWidget* StdMeshersGUI_FixedPointsParamWdg::LineDelegate::createEditor( QWidget* parent,
- const QStyleOptionViewItem& option,
+ const QStyleOptionViewItem& /*option*/,
const QModelIndex& index ) const
{
QWidget* w = 0;
}
}
-void StdMeshersGUI_LayerDistributionParamWdg::onEdited( int result )
+void StdMeshersGUI_LayerDistributionParamWdg::onEdited( int /*result*/ )
{
if ( myDlg )
{
item->setData( Qt::UserRole, -1 );
}
else
- for ( size_t i = 0; i < myChains.size(); ++i )
+ for ( int i = 0; i < (int)myChains.size(); ++i )
{
QString text = tr( "CHAIN_NUM_NB_EDGES" ).arg( i+1 ).arg( myChains[i].size() );
item = new QListWidgetItem( text, myListWidget );
- item->setData( Qt::UserRole, (int) i );
+ item->setData( Qt::UserRole, i );
}
}
else
std::vector< int > * chain = 0;
if ( QListWidgetItem * item = myListWidget->currentItem() )
{
- size_t i = (size_t) item->data( Qt::UserRole ).toInt();
- if ( 0 <= i && i < myChains.size() )
+ int i = item->data( Qt::UserRole ).toInt();
+ if ( 0 <= i && i < (int)myChains.size() )
chain = & myChains[i];
}
return chain;
*/
QWidget* StdMeshersGUI_QuadrangleParamCreator::
ItemDelegate::createEditor( QWidget* parent,
- const QStyleOptionViewItem& option,
- const QModelIndex& index ) const
+ const QStyleOptionViewItem& /*option*/,
+ const QModelIndex& /*index*/ ) const
{
SMESHGUI_SpinBox* sb = new SMESHGUI_SpinBox( parent );
sb->RangeStepAndValidator( COORD_MIN, COORD_MAX, 10 );
//purpose : is called from buildStdFrame()
//=======================================================================
-QWidget* StdMeshersGUI_StdHypothesisCreator::getCustomWidget( const StdParam & param,
+QWidget* StdMeshersGUI_StdHypothesisCreator::getCustomWidget( const StdParam & /*param*/,
QWidget* parent,
const int index) const
{
*/
//================================================================================
-bool StdMeshersGUI_StdHypothesisCreator::initVariableName(SMESH::SMESH_Hypothesis_var theHyp,
+bool StdMeshersGUI_StdHypothesisCreator::initVariableName(SMESH::SMESH_Hypothesis_var /*theHyp*/,
StdParam & theParams,
const char* theMethod) 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();
CORBA::Boolean IsDimSupported( SMESH::Dimension type );
// Methods for copying mesh definition to other geometry
- virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
- std::vector< int > & subIDArray ) const { return false; }
- virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
- std::vector< int > & subIDArray ) { return true; }
+ virtual bool getObjectsDependOn( std::vector< std::string > & /*entryArray*/,
+ std::vector< int > & /*subIDArray*/ ) const { return false; }
+ virtual bool setObjectsDependOn( std::vector< std::string > & /*entryArray*/,
+ std::vector< int > & /*subIDArray*/ ) { return true; }
};
#endif
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 );
}
//================================================================================
std::string StdMeshers_Arithmetic1D_i::getMethodOfParameter(const int paramIndex,
- int nbVars) const
+ int /*nbVars*/) const
{
return paramIndex == 0 ? "SetStartLength" : "SetEndLength";
}
// 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();
CORBA::Boolean IsDimSupported( SMESH::Dimension type );
// Methods for copying mesh definition to other geometry
- virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
- std::vector< int > & subIDArray ) const { return false; }
- virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
- std::vector< int > & subIDArray ) { return true; }
+ virtual bool getObjectsDependOn( std::vector< std::string > & /*entryArray*/,
+ std::vector< int > & /*subIDArray*/ ) const { return false; }
+ virtual bool setObjectsDependOn( std::vector< std::string > & /*entryArray*/,
+ std::vector< int > & /*subIDArray*/ ) { return true; }
};
#endif
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
CORBA::Double x1,
const SMESH::string_array& spaceFuns,
const SMESH::double_array& points,
- const char* axisName )
- throw (SALOME::SALOME_Exception);
+ const char* axisName );
// Get implementation
::StdMeshers_CartesianParameters3D* GetImpl();
// Methods for copying mesh definition to other geometry
- virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
- std::vector< int > & subIDArray ) const { return false; }
- virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
- std::vector< int > & subIDArray ) { return true; }
+ virtual bool getObjectsDependOn( std::vector< std::string > & /*entryArray*/,
+ std::vector< int > & /*subIDArray*/ ) const { return false; }
+ virtual bool setObjectsDependOn( std::vector< std::string > & /*entryArray*/,
+ std::vector< int > & /*subIDArray*/ ) { return true; }
};
#endif
//=============================================================================
void StdMeshers_Deflection1D_i::SetDeflection( CORBA::Double theValue )
- throw ( SALOME::SALOME_Exception )
{
ASSERT( myBaseImpl );
try {
*/
//================================================================================
-std::string StdMeshers_Deflection1D_i::getMethodOfParameter(const int paramIndex,
+std::string StdMeshers_Deflection1D_i::getMethodOfParameter(const int /*paramIndex*/,
int /*nbVars*/) const
{
return "SetDeflection";
virtual ~StdMeshers_Deflection1D_i();
// Set deflection
- void SetDeflection( CORBA::Double theLength )
- throw ( SALOME::SALOME_Exception );
+ void SetDeflection( CORBA::Double theLength );
// Get deflection
CORBA::Double GetDeflection();
CORBA::Boolean IsDimSupported( SMESH::Dimension type );
// Methods for copying mesh definition to other geometry
- virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
- std::vector< int > & subIDArray ) const { return false; }
- virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
- std::vector< int > & subIDArray ) { return true; }
+ virtual bool getObjectsDependOn( std::vector< std::string > & /*entryArray*/,
+ std::vector< int > & /*subIDArray*/ ) const { return false; }
+ virtual bool setObjectsDependOn( std::vector< std::string > & /*entryArray*/,
+ std::vector< int > & /*subIDArray*/ ) { return true; }
protected:
virtual std::string getMethodOfParameter(const int paramIndex, int nbVars) const;
};
//=============================================================================
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 {
// (additionally it is neecessary to check orientation of edges and
// 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 );
+ void SetPoints(const SMESH::double_array& listParams);
+ void SetNbSegments(const SMESH::long_array& listNbSeg);
// 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();
*/
//=============================================================================
-bool StdMeshers_Hexa_3D_i::IsApplicable( const TopoDS_Shape &S, bool toCheckAll, int algoDim )
+bool StdMeshers_Hexa_3D_i::IsApplicable( const TopoDS_Shape &S, bool toCheckAll, int /*algoDim*/ )
{
return ::StdMeshers_Hexa_3D::IsApplicable( S, toCheckAll );
}
// Methods for copying mesh definition to other geometry
// Return geometry this hypothesis depends on. Return false if there is no geometry parameter
- virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
- std::vector< int > & subIDArray ) const { return 0; }
+ virtual bool getObjectsDependOn( std::vector< std::string > & /*entryArray*/,
+ std::vector< int > & /*subIDArray*/ ) const { return 0; }
// Set new geometry instead of that returned by getObjectsDependOn()
- virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
- std::vector< int > & subIDArray ) { return true; }
+ virtual bool setObjectsDependOn( std::vector< std::string > & /*entryArray*/,
+ std::vector< int > & /*subIDArray*/ ) { return true; }
private:
SMESH::string_array_var _groupEntries;
std::vector< std::string > _groupIDs;
// Methods for copying mesh definition to other geometry
// Return geometry this hypothesis depends on. Return false if there is no geometry parameter
- virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
- std::vector< int > & subIDArray ) const { return 0; }
+ virtual bool getObjectsDependOn( std::vector< std::string > & /*entryArray*/,
+ std::vector< int > & /*subIDArray*/ ) const { return 0; }
// Set new geometry instead of that returned by getObjectsDependOn()
- virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
- std::vector< int > & subIDArray ) { return true; }
+ virtual bool setObjectsDependOn( std::vector< std::string > & /*entryArray*/,
+ std::vector< int > & /*subIDArray*/ ) { return true; }
private:
SMESH::string_array_var _groupEntries;
std::vector< std::string > _groupIDs;
// Methods for copying mesh definition to other geometry
// Return geometry this hypothesis depends on. Return false if there is no geometry parameter
- virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
- std::vector< int > & subIDArray ) const { return 0; }
+ virtual bool getObjectsDependOn( std::vector< std::string > & /*entryArray*/,
+ std::vector< int > & /*subIDArray*/ ) const { return 0; }
// Set new geometry instead of that returned by getObjectsDependOn()
- virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
- std::vector< int > & subIDArray ) { return true; }
+ virtual bool setObjectsDependOn( std::vector< std::string > & /*entryArray*/,
+ std::vector< int > & /*subIDArray*/ ) { return true; }
};
#endif
//=============================================================================
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
// Methods for copying mesh definition to other geometry
// Return geometry this hypothesis depends on. Return false if there is no geometry parameter
- virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
- std::vector< int > & subIDArray ) const { return 0; }
+ virtual bool getObjectsDependOn( std::vector< std::string > & /*entryArray*/,
+ std::vector< int > & /*subIDArray*/ ) const { return 0; }
// Set new geometry instead of that returned by getObjectsDependOn()
- virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
- std::vector< int > & subIDArray ) { return true; }
+ virtual bool setObjectsDependOn( std::vector< std::string > & /*entryArray*/,
+ std::vector< int > & /*subIDArray*/ ) { return true; }
protected:
// restore myMethod2VarParams by parameters stored in an old study
virtual void setOldParameters (const char* theParameters);
//=============================================================================
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();
// Methods for copying mesh definition to other geometry
// Return geometry this hypothesis depends on. Return false if there is no geometry parameter
- virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
- std::vector< int > & subIDArray ) const { return 0; }
+ virtual bool getObjectsDependOn( std::vector< std::string > & /*entryArray*/,
+ std::vector< int > & /*subIDArray*/ ) const { return 0; }
// Set new geometry instead of that returned by getObjectsDependOn()
- virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
- std::vector< int > & subIDArray ) { return true; }
+ virtual bool setObjectsDependOn( std::vector< std::string > & /*entryArray*/,
+ std::vector< int > & /*subIDArray*/ ) { return true; }
};
#endif
*/
//=============================================================================
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 {
virtual ~StdMeshers_LocalLength_i();
// Set length
- void SetLength( CORBA::Double theLength )
- throw ( SALOME::SALOME_Exception );
+ void SetLength( CORBA::Double theLength );
// Set precision
- void SetPrecision( CORBA::Double thePrecision )
- throw ( SALOME::SALOME_Exception );
+ void SetPrecision( CORBA::Double thePrecision );
// Get length
CORBA::Double GetLength();
// Methods for copying mesh definition to other geometry
// Return geometry this hypothesis depends on. Return false if there is no geometry parameter
- virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
- std::vector< int > & subIDArray ) const { return 0; }
+ virtual bool getObjectsDependOn( std::vector< std::string > & /*entryArray*/,
+ std::vector< int > & /*subIDArray*/ ) const { return 0; }
// Set new geometry instead of that returned by getObjectsDependOn()
- virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
- std::vector< int > & subIDArray ) { return true; }
+ virtual bool setObjectsDependOn( std::vector< std::string > & /*entryArray*/,
+ std::vector< int > & /*subIDArray*/ ) { return true; }
protected:
virtual std::string getMethodOfParameter(const int paramIndex, int nbVars) const;
};
//=============================================================================
void StdMeshers_MaxElementArea_i::SetMaxElementArea( CORBA::Double theArea )
- throw ( SALOME::SALOME_Exception )
{
ASSERT( myBaseImpl );
try {
*/
//================================================================================
-std::string StdMeshers_MaxElementArea_i::getMethodOfParameter(const int paramIndex,
+std::string StdMeshers_MaxElementArea_i::getMethodOfParameter(const int /*paramIndex*/,
int /*nbVars*/) const
{
return "SetMaxElementArea";
virtual ~StdMeshers_MaxElementArea_i();
// Set maximum element area
- void SetMaxElementArea( CORBA::Double theArea )
- throw ( SALOME::SALOME_Exception );
+ void SetMaxElementArea( CORBA::Double theArea );
// Get maximum element area
CORBA::Double GetMaxElementArea();
// Methods for copying mesh definition to other geometry
// Return geometry this hypothesis depends on. Return false if there is no geometry parameter
- virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
- std::vector< int > & subIDArray ) const { return 0; }
+ virtual bool getObjectsDependOn( std::vector< std::string > & /*entryArray*/,
+ std::vector< int > & /*subIDArray*/ ) const { return 0; }
// Set new geometry instead of that returned by getObjectsDependOn()
- virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
- std::vector< int > & subIDArray ) { return true; }
+ virtual bool setObjectsDependOn( std::vector< std::string > & /*entryArray*/,
+ std::vector< int > & /*subIDArray*/ ) { return true; }
protected:
virtual std::string getMethodOfParameter(const int paramIndex, int nbVars) const;
//=============================================================================
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();
// Methods for copying mesh definition to other geometry
// Return geometry this hypothesis depends on. Return false if there is no geometry parameter
- virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
- std::vector< int > & subIDArray ) const { return 0; }
+ virtual bool getObjectsDependOn( std::vector< std::string > & /*entryArray*/,
+ std::vector< int > & /*subIDArray*/ ) const { return 0; }
// Set new geometry instead of that returned by getObjectsDependOn()
- virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
- std::vector< int > & subIDArray ) { return true; }
+ virtual bool setObjectsDependOn( std::vector< std::string > & /*entryArray*/,
+ std::vector< int > & /*subIDArray*/ ) { return true; }
protected:
virtual std::string getMethodOfParameter(const int paramIndex, int nbVars) const;
};
*/
//=============================================================================
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 {
virtual ~StdMeshers_MaxLength_i();
// Set length
- void SetLength( CORBA::Double theLength )
- throw ( SALOME::SALOME_Exception );
+ void SetLength( CORBA::Double theLength );
// Set precision
// Sets preestimation flag
- void SetUsePreestimatedLength( CORBA::Boolean toUse)
- throw ( SALOME::SALOME_Exception );
+ void SetUsePreestimatedLength( CORBA::Boolean toUse);
// Get length
CORBA::Double GetLength();
// Methods for copying mesh definition to other geometry
// Return geometry this hypothesis depends on. Return false if there is no geometry parameter
- virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
- std::vector< int > & subIDArray ) const { return 0; }
+ virtual bool getObjectsDependOn( std::vector< std::string > & /*entryArray*/,
+ std::vector< int > & /*subIDArray*/ ) const { return 0; }
// Set new geometry instead of that returned by getObjectsDependOn()
- virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
- std::vector< int > & subIDArray ) { return true; }
+ virtual bool setObjectsDependOn( std::vector< std::string > & /*entryArray*/,
+ std::vector< int > & /*subIDArray*/ ) { return true; }
protected:
virtual std::string getMethodOfParameter(const int paramIndex, int nbVars) const;
};
// Methods for copying mesh definition to other geometry
// Return geometry this hypothesis depends on. Return false if there is no geometry parameter
- virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
- std::vector< int > & subIDArray ) const { return 0; }
+ virtual bool getObjectsDependOn( std::vector< std::string > & /*entryArray*/,
+ std::vector< int > & /*subIDArray*/ ) const { return 0; }
// Set new geometry instead of that returned by getObjectsDependOn()
- virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
- std::vector< int > & subIDArray ) { return true; }
+ virtual bool setObjectsDependOn( std::vector< std::string > & /*entryArray*/,
+ std::vector< int > & /*subIDArray*/ ) { return true; }
protected:
::StdMeshers_NotConformAllowed* _impl;
};
// Methods for copying mesh definition to other geometry
// Return geometry this hypothesis depends on. Return false if there is no geometry parameter
- virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
- std::vector< int > & subIDArray ) const { return 0; }
+ virtual bool getObjectsDependOn( std::vector< std::string > & /*entryArray*/,
+ std::vector< int > & /*subIDArray*/ ) const { return 0; }
// Set new geometry instead of that returned by getObjectsDependOn()
- virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
- std::vector< int > & subIDArray ) { return true; }
+ virtual bool setObjectsDependOn( std::vector< std::string > & /*entryArray*/,
+ std::vector< int > & /*subIDArray*/ ) { return true; }
};
#endif
//=============================================================================
void StdMeshers_NumberOfLayers_i::SetNumberOfLayers(CORBA::Long numberOfLayers)
- throw ( SALOME::SALOME_Exception )
{
ASSERT( myBaseImpl );
try {
virtual ~StdMeshers_NumberOfLayers_i();
// Sets <number of segments> parameter value
- void SetNumberOfLayers(CORBA::Long numberOfLayers)
- throw ( SALOME::SALOME_Exception );
+ void SetNumberOfLayers(CORBA::Long numberOfLayers);
// Returns <number of layers> parameter value
CORBA::Long GetNumberOfLayers();
// Methods for copying mesh definition to other geometry
// Return geometry this hypothesis depends on. Return false if there is no geometry parameter
- virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
- std::vector< int > & subIDArray ) const { return 0; }
+ virtual bool getObjectsDependOn( std::vector< std::string > & /*entryArray*/,
+ std::vector< int > & /*subIDArray*/ ) const { return 0; }
// Set new geometry instead of that returned by getObjectsDependOn()
- virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
- std::vector< int > & subIDArray ) { return true; }
+ virtual bool setObjectsDependOn( std::vector< std::string > & /*entryArray*/,
+ std::vector< int > & /*subIDArray*/ ) { return true; }
protected:
virtual std::string getMethodOfParameter(const int paramIndex, int nbVars) const;
};
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;
virtual ~StdMeshers_NumberOfSegments_i();
// 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 );
+ SMESH::double_array* BuildDistributionExpr( const char*, CORBA::Long, CORBA::Long );
+ SMESH::double_array* BuildDistributionTab( const SMESH::double_array&, CORBA::Long, CORBA::Long );
// Set number of segments
- void SetNumberOfSegments( CORBA::Long theSegmentsNumber )
- throw ( SALOME::SALOME_Exception );
+ void SetNumberOfSegments( CORBA::Long theSegmentsNumber );
// Get number of segments
CORBA::Long GetNumberOfSegments();
// Set distribution type
- void SetDistrType(CORBA::Long typ)
- throw ( SALOME::SALOME_Exception );
+ void SetDistrType(CORBA::Long typ);
// Get distribution type
CORBA::Long GetDistrType();
// Set scalar factor
- void SetScaleFactor( CORBA::Double theScaleFactor )
- throw ( SALOME::SALOME_Exception );
+ void SetScaleFactor( CORBA::Double theScaleFactor );
// Get scalar factor
- CORBA::Double GetScaleFactor()
- throw ( SALOME::SALOME_Exception );
+ CORBA::Double GetScaleFactor();
// Set table function for distribution DT_TabFunc
- void SetTableFunction(const SMESH::double_array& table)
- throw ( SALOME::SALOME_Exception );
+ void SetTableFunction(const SMESH::double_array& table);
// Get table function for distribution DT_TabFunc
- SMESH::double_array* GetTableFunction()
- throw ( SALOME::SALOME_Exception );
+ SMESH::double_array* GetTableFunction();
// Set expression function for distribution DT_ExprFunc
- void SetExpressionFunction(const char* expr)
- throw ( SALOME::SALOME_Exception );
+ void SetExpressionFunction(const char* expr);
// Get expression function for distribution DT_ExprFunc
- char* GetExpressionFunction()
- throw ( SALOME::SALOME_Exception );
+ char* GetExpressionFunction();
// Set the exponent mode on/off
- void SetConversionMode( CORBA::Long conv )
- throw ( SALOME::SALOME_Exception );
+ void SetConversionMode( CORBA::Long conv );
// Returns true if the exponent mode is set
- CORBA::Long ConversionMode()
- throw ( SALOME::SALOME_Exception );
+ CORBA::Long ConversionMode();
// Get implementation
::StdMeshers_NumberOfSegments* GetImpl();
}
//-----------------------------------------------------------------------------
-bool StdMeshers_Prism_3D_i::IsApplicable( const TopoDS_Shape &S, bool toCheckAll, int algoDim )
+bool StdMeshers_Prism_3D_i::IsApplicable( const TopoDS_Shape &S, bool toCheckAll, int /*algoDim*/ )
{
return ::StdMeshers_Prism_3D::IsApplicable( S, toCheckAll );
}
//=============================================================================
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 );
bool
StdMeshers_ProjectionSource1D_i::getObjectsDependOn( std::vector< std::string > & entryArray,
- std::vector< int > & subIDArray ) const
+ std::vector< int > & /*subIDArray*/ ) const
{
for ( int i = 0; i < NB_SHAPES; ++i )
entryArray.push_back( myShapeEntries[ i ]);
bool
StdMeshers_ProjectionSource1D_i::setObjectsDependOn( std::vector< std::string > & entryArray,
- std::vector< int > & subIDArray )
+ std::vector< int > & /*subIDArray*/ )
{
TopoDS_Shape shapes[ NB_SHAPES ];
for ( int i = 0; i < NB_SHAPES; ++i )
/*!
* 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 );
+ void SetSourceEdge(GEOM::GEOM_Object_ptr edge);
/*!
* 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 );
+ void SetSourceMesh(SMESH::SMESH_Mesh_ptr mesh);
/*!
* Return source mesh
* This parameter is optional
*/
void SetVertexAssociation(GEOM::GEOM_Object_ptr sourceVertex,
- GEOM::GEOM_Object_ptr targetVertex)
- throw ( SALOME::SALOME_Exception );
+ GEOM::GEOM_Object_ptr targetVertex);
/*!
* 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 {
bool
StdMeshers_ProjectionSource2D_i::getObjectsDependOn( std::vector< std::string > & entryArray,
- std::vector< int > & subIDArray ) const
+ std::vector< int > & /*subIDArray*/ ) const
{
for ( int i = 0; i < NB_SHAPES; ++i )
entryArray.push_back( myShapeEntries[ i ]);
bool
StdMeshers_ProjectionSource2D_i::setObjectsDependOn( std::vector< std::string > & entryArray,
- std::vector< int > & subIDArray )
+ std::vector< int > & /*subIDArray*/ )
{
TopoDS_Shape shapes[ NB_SHAPES ];
for ( int i = 0; i < NB_SHAPES; ++i )
/*!
* Sets a source <face> to take a mesh pattern from
*/
- void SetSourceFace(GEOM::GEOM_Object_ptr face)
- throw ( SALOME::SALOME_Exception );
+ void SetSourceFace(GEOM::GEOM_Object_ptr face);
/*!
* Returns the source face
/*!
* Sets source <mesh> to take a mesh pattern from
*/
- void SetSourceMesh(SMESH::SMESH_Mesh_ptr mesh)
- throw ( SALOME::SALOME_Exception );
+ void SetSourceMesh(SMESH::SMESH_Mesh_ptr mesh);
/*!
* Return source mesh
void SetVertexAssociation(GEOM::GEOM_Object_ptr sourceVertex1,
GEOM::GEOM_Object_ptr sourceVertex2,
GEOM::GEOM_Object_ptr targetVertex1,
- GEOM::GEOM_Object_ptr targetVertex2)
- throw ( SALOME::SALOME_Exception );
+ GEOM::GEOM_Object_ptr targetVertex2);
/*!
* 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 {
bool
StdMeshers_ProjectionSource3D_i::getObjectsDependOn( std::vector< std::string > & entryArray,
- std::vector< int > & subIDArray ) const
+ std::vector< int > & /*subIDArray*/ ) const
{
for ( int i = 0; i < NB_SHAPES; ++i )
entryArray.push_back( myShapeEntries[ i ]);
bool
StdMeshers_ProjectionSource3D_i::setObjectsDependOn( std::vector< std::string > & entryArray,
- std::vector< int > & subIDArray )
+ std::vector< int > & /*subIDArray*/ )
{
TopoDS_Shape shapes[ NB_SHAPES ];
for ( int i = 0; i < NB_SHAPES; ++i )
/*!
* Sets a source <shape> to take a mesh pattern from
*/
- void SetSource3DShape(GEOM::GEOM_Object_ptr shape)
- throw ( SALOME::SALOME_Exception );
+ void SetSource3DShape(GEOM::GEOM_Object_ptr shape);
/*!
* Returns the source shape
/*!
* Sets source <mesh> to take a mesh pattern from
*/
- void SetSourceMesh(SMESH::SMESH_Mesh_ptr mesh)
- throw ( SALOME::SALOME_Exception );
+ void SetSourceMesh(SMESH::SMESH_Mesh_ptr mesh);
/*!
* Return source mesh
void SetVertexAssociation(GEOM::GEOM_Object_ptr sourceVertex1,
GEOM::GEOM_Object_ptr sourceVertex2,
GEOM::GEOM_Object_ptr targetVertex1,
- GEOM::GEOM_Object_ptr targetVertex2)
- throw ( SALOME::SALOME_Exception );
+ GEOM::GEOM_Object_ptr targetVertex2);
/*!
* Returns the <i>-th source vertex associated with the <i>-th target vertex.
*/
//================================================================================
-bool StdMeshers_Projection_3D_i::IsApplicable( const TopoDS_Shape &S, bool toCheckAll, int algoDim )
+bool StdMeshers_Projection_3D_i::IsApplicable( const TopoDS_Shape &S, bool toCheckAll, int /*algoDim*/ )
{
return ::StdMeshers_Projection_3D::IsApplicable( S, toCheckAll );
}
CORBA::Boolean IsDimSupported( SMESH::Dimension type );
// Methods for copying mesh definition to other geometry
- virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
- std::vector< int > & subIDArray ) const { return false; }
- virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
- std::vector< int > & subIDArray ) { return true; }
+ virtual bool getObjectsDependOn( std::vector< std::string > & /*entryArray*/,
+ std::vector< int > & /*subIDArray*/ ) const { return false; }
+ virtual bool setObjectsDependOn( std::vector< std::string > & /*entryArray*/,
+ std::vector< int > & /*subIDArray*/ ) { return true; }
};
// ======================================================
CORBA::Boolean IsDimSupported( SMESH::Dimension type );
// Methods for copying mesh definition to other geometry
- virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
- std::vector< int > & subIDArray ) const { return false; }
- virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
- std::vector< int > & subIDArray ) { return true; }
+ virtual bool getObjectsDependOn( std::vector< std::string > & /*entryArray*/,
+ std::vector< int > & /*subIDArray*/ ) const { return false; }
+ virtual bool setObjectsDependOn( std::vector< std::string > & /*entryArray*/,
+ std::vector< int > & /*subIDArray*/ ) { return true; }
};
#endif
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);
CORBA::Boolean IsDimSupported( SMESH::Dimension type );
// Methods for copying mesh definition to other geometry
- virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
- std::vector< int > & subIDArray ) const { return false; }
- virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
- std::vector< int > & subIDArray ) { return true; }
+ virtual bool getObjectsDependOn( std::vector< std::string > & /*entryArray*/,
+ std::vector< int > & /*subIDArray*/ ) const { return false; }
+ virtual bool setObjectsDependOn( std::vector< std::string > & /*entryArray*/,
+ std::vector< int > & /*subIDArray*/ ) { return true; }
};
#endif
*/
//=============================================================================
-bool StdMeshers_Quadrangle_2D_i::IsApplicable( const TopoDS_Shape &S, bool toCheckAll, int algoDim )
+bool StdMeshers_Quadrangle_2D_i::IsApplicable( const TopoDS_Shape &S, bool toCheckAll, int /*algoDim*/ )
{
return ::StdMeshers_Quadrangle_2D::IsApplicable( S, toCheckAll );
}
//================================================================================
bool StdMeshers_QuadFromMedialAxis_1D2D_i::IsApplicable( const TopoDS_Shape &S,
- bool toCheckAll, int algoDim )
+ bool toCheckAll, int /*algoDim*/ )
{
return ::StdMeshers_QuadFromMedialAxis_1D2D::IsApplicable( S, toCheckAll );
}
CORBA::Boolean IsDimSupported( SMESH::Dimension type );
// Methods for copying mesh definition to other geometry
- virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
- std::vector< int > & subIDArray ) const { return false; }
- virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
- std::vector< int > & subIDArray ) { return true; }
+ virtual bool getObjectsDependOn( std::vector< std::string > & /*entryArray*/,
+ std::vector< int > & /*subIDArray*/ ) const { return false; }
+ virtual bool setObjectsDependOn( std::vector< std::string > & /*entryArray*/,
+ std::vector< int > & /*subIDArray*/ ) { return true; }
};
#endif
//-----------------------------------------------------------------------------
-bool StdMeshers_RadialQuadrangle_1D2D_i::IsApplicable( const TopoDS_Shape &S, bool toCheckAll, int algoDim )
+bool StdMeshers_RadialQuadrangle_1D2D_i::IsApplicable( const TopoDS_Shape &S, bool toCheckAll, int /*algoDim*/ )
{
return ::StdMeshers_RadialQuadrangle_1D2D::IsApplicable( S, toCheckAll );
}
//=============================================================================
void StdMeshers_SegmentLengthAroundVertex_i::SetLength( CORBA::Double theLength )
- throw ( SALOME::SALOME_Exception )
{
ASSERT( myBaseImpl );
try {
virtual ~StdMeshers_SegmentLengthAroundVertex_i();
// Set length
- void SetLength( CORBA::Double theLength )
- throw ( SALOME::SALOME_Exception );
+ void SetLength( CORBA::Double theLength );
// Get length
CORBA::Double GetLength();
// Methods for copying mesh definition to other geometry
// Return geometry this hypothesis depends on. Return false if there is no geometry parameter
- virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
- std::vector< int > & subIDArray ) const { return 0; }
+ virtual bool getObjectsDependOn( std::vector< std::string > & /*entryArray*/,
+ std::vector< int > & /*subIDArray*/ ) const { return 0; }
// Set new geometry instead of that returned by getObjectsDependOn()
- virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
- std::vector< int > & subIDArray ) { return true; }
+ virtual bool setObjectsDependOn( std::vector< std::string > & /*entryArray*/,
+ std::vector< int > & /*subIDArray*/ ) { return true; }
protected:
virtual std::string getMethodOfParameter(const int paramIndex, int nbVars) const;
};
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 );
+ 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_ViscousLayers2D_i::SetEdges(const ::SMESH::long_array& edgeIDs,
CORBA::Boolean toIgnore)
- throw ( SALOME::SALOME_Exception )
{
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 );
//================================================================================
bool
-StdMeshers_ViscousLayers2D_i::getObjectsDependOn( std::vector< std::string > & entryArray,
+StdMeshers_ViscousLayers2D_i::getObjectsDependOn( std::vector< std::string > & /*entryArray*/,
std::vector< int > & subIDArray ) const
{
const ::StdMeshers_ViscousLayers2D* impl =
//================================================================================
bool
-StdMeshers_ViscousLayers2D_i::setObjectsDependOn( std::vector< std::string > & entryArray,
+StdMeshers_ViscousLayers2D_i::setObjectsDependOn( std::vector< std::string > & /*entryArray*/,
std::vector< int > & subIDArray )
{
std::vector< int > newIDs;
// 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 );
//================================================================================
bool
-StdMeshers_ViscousLayers_i::getObjectsDependOn( std::vector< std::string > & entryArray,
+StdMeshers_ViscousLayers_i::getObjectsDependOn( std::vector< std::string > & /*entryArray*/,
std::vector< int > & subIDArray ) const
{
const ::StdMeshers_ViscousLayers* impl =
//================================================================================
bool
-StdMeshers_ViscousLayers_i::setObjectsDependOn( std::vector< std::string > & entryArray,
+StdMeshers_ViscousLayers_i::setObjectsDependOn( std::vector< std::string > & /*entryArray*/,
std::vector< int > & subIDArray )
{
std::vector< int > newIDs;
// 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 );
class ApplicableToAny
{
public:
- static bool IsApplicable( const TopoDS_Shape &S, bool toCheckAll, int algoDim )
+ static bool IsApplicable( const TopoDS_Shape &S, bool /*toCheckAll*/, int algoDim )
{
return GenericHypothesisCreator_i::IsShapeOfDim( S, algoDim );
}
};
-};
+}
template <class T, class TIsApplicable = SMESH::ApplicableToAny>
class StdHypothesisCreator_i : public HypothesisCreator_i< T >
aCreator = new StdHypothesisCreator_i<StdMeshers_PolygonPerFace_2D_i>;
else if (strcmp(aHypName, "PolyhedronPerSolid_3D") == 0)
aCreator = new StdHypothesisCreator_i<StdMeshers_PolyhedronPerSolid_3D_i>;
- else ;
return aCreator;
}
}
}
-void Maillage::listeMaillesType(TYPE_MAILLE tm)
+void Maillage::listeMaillesType(TYPE_MAILLE /*tm*/)
{
cout << "La fonction \"Restitution des mailles par type\" est obsolète " << endl;
}
void Maillage::acquisitionTYPE_inputMED(TYPE_MAILLE TYPE, int nTYPE, med_idt fid, char maa[MED_NAME_SIZE + 1],
- med_int mdim)
+ med_int /*mdim*/)
{
// int taille, numeromaille, numeroFamille;
return resultat;
}
-int Maillage::NLOCAL(int nglobal, TYPE_MAILLE tm)
+int Maillage::NLOCAL(int nglobal, TYPE_MAILLE /*tm*/)
{
// Attention, les num. globaux commencent à 1, les num. locaux à 0
int nPOI1 = EFFECTIFS_TYPES[POI1];
void eliminationMailles(TYPE_MAILLE typeMaille, std::vector<int> listeMaillesSuppr);
// acquisitionTYPE_inputMED appelée par inputMED
- void
- acquisitionTYPE_inputMED(TYPE_MAILLE TYPE, int nTYPE, med_idt fid, char maa[MED_NAME_SIZE + 1], med_int mdim);
+ void acquisitionTYPE_inputMED(TYPE_MAILLE TYPE, int nTYPE, med_idt fid, char maa[MED_NAME_SIZE + 1], med_int mdim);
// void infoChamps(std::string type, med_entity_type MEM, med_geometry_type MGE, med_idt fid, char *maa,
// char *nomChamp, med_field_type typeChamp, med_int nCompChamp, std::map<std::string, int> REFGAUSS);
std::string MESHCUT::floatEnsight(float x)
{
- char buf[12];
+ char buf[20];
string s;
if (x < 0.0)
sprintf(buf, "%1.5E", x);
LOG("resource["<<i<<"] = "<<aResourceName);
resourceDefinition = _resourcesManager->GetResourceDefinition(aResourceName);
LOG("protocol["<<i<<"] = "<<resourceDefinition->protocol);
+ (void)resourceDefinition; // unused in release mode
}
}
