public:
TSequenceOfXYZ();
- explicit TSequenceOfXYZ(size_type n);
+ explicit TSequenceOfXYZ(size_type n);
TSequenceOfXYZ(size_type n, const gp_XYZ& t);
//! Get set of TElemInfo by its geometrical type and corresponding MED ENTITY
MEDWRAPPER_EXPORT
TEntity2TGeom2ElemInfo
- GetEntity2TGeom2ElemInfo(const PWrapper& /*theWrapper*/,
+ GetEntity2TGeom2ElemInfo(const PWrapper& theWrapper,
const PMeshInfo& theMeshInfo,
const MED::TEntityInfo& theEntityInfo);
*/
//================================================================================
-int SMDS_Mesh::CheckMemory(const bool doNotRaise)
+int SMDS_Mesh::CheckMemory(const bool doNotRaise)
{
return -1;
#if !defined WIN32 && !defined __APPLE__
}
return -1;
}
-bool SMDS_MeshVolume::ChangeNodes(const SMDS_MeshNode* /*nodes[]*/, const int /*nbNodes*/)
+bool SMDS_MeshVolume::ChangeNodes(const SMDS_MeshNode* /*nodes*/[], const int /*nbNodes*/)
{
return false;
}
virtual int NbFaces() const;
virtual int NbEdges() const;
virtual int GetNodeIndex( const SMDS_MeshNode* node ) const;
- virtual bool ChangeNodes(const SMDS_MeshNode* /*nodes[]*/, const int /*nbNodes*/);
+ virtual bool ChangeNodes(const SMDS_MeshNode* nodes[], const int nbNodes);
virtual bool IsMediumNode(const SMDS_MeshNode* node) const;
virtual int NbCornerNodes() const;
int CellIdToDownId(int vtkCellId);
void setCellIdToDownId(int vtkCellId, int downId);
void CleanDownwardConnectivity();
- void BuildDownwardConnectivity(bool /*withEdges*/);
+ void BuildDownwardConnectivity(bool withEdges);
int GetNeighbors(int* neighborsVtkIds, int* downIds, unsigned char* downTypes, int vtkId, bool getSkin=false);
int GetParentVolumes(int* volVtkIds, int vtkId);
int GetParentVolumes(int* volVtkIds, int downId, unsigned char downType);
protected:
SMDS_UnstructuredGrid();
~SMDS_UnstructuredGrid();
- void copyNodes(vtkPoints *newPoints, std::vector<int>& /*idNodesOldToNew*/, int& alreadyCopied, int start, int end);
+ void copyNodes(vtkPoints *newPoints, std::vector<int>& idNodesOldToNew, int& alreadyCopied, int start, int end);
void copyBloc(vtkUnsignedCharArray *newTypes,
const std::vector<int>& idCellsOldToNew,
const std::vector<int>& idNodesOldToNew,
* else, returns OK if at least one shape is OK
* \retval bool - \c true by default
*/
- virtual bool IsApplicableToShape(const TopoDS_Shape & /*shape*/, bool /*toCheckAll*/) const;
+ virtual bool IsApplicableToShape(const TopoDS_Shape & shape, bool toCheckAll) const;
/*!
* \brief Sets _computeCanceled to true. It's usage depends on
* else, returns OK if at least one shape is OK
* \retval bool - \c true by default
*/
- virtual bool IsApplicableToShape(const TopoDS_Shape & shape, bool /*toCheckAll*/) const;
+ virtual bool IsApplicableToShape(const TopoDS_Shape & shape, bool toCheckAll) const;
};
class SMESH_EXPORT SMESH_2D_Algo: public SMESH_Algo
* else, returns OK if at least one shape is OK
* \retval bool - \c true by default
*/
- virtual bool IsApplicableToShape(const TopoDS_Shape & shape, bool /*toCheckAll*/) const;
+ virtual bool IsApplicableToShape(const TopoDS_Shape & shape, bool toCheckAll) const;
/*!
* \brief Method in which an algorithm generating a structured mesh
* fixes positions of in-face nodes after there movement
* else, returns OK if at least one shape is OK
* \retval bool - \c true by default
*/
- virtual bool IsApplicableToShape(const TopoDS_Shape & shape, bool /*toCheckAll*/) const;
+ virtual bool IsApplicableToShape(const TopoDS_Shape & shape, bool toCheckAll) const;
};
#endif
SMESH_Gen();
~SMESH_Gen();
- SMESH_Mesh* CreateMesh(bool theIsEmbeddedMode)
- ;
+ SMESH_Mesh* CreateMesh(bool theIsEmbeddedMode);
enum ComputeFlags
{
const ::MeshDimension aDim=::MeshDim_3D,
TSetOfInt* aShapesId=0);
- void PrepareCompute(::SMESH_Mesh & /*aMesh*/,
- const TopoDS_Shape & /*aShape*/);
- void CancelCompute(::SMESH_Mesh & /*aMesh*/,
- const TopoDS_Shape & /*aShape*/);
+ void PrepareCompute(::SMESH_Mesh & aMesh,
+ const TopoDS_Shape & aShape);
+ void CancelCompute(::SMESH_Mesh & aMesh,
+ const TopoDS_Shape & aShape);
const SMESH_subMesh* GetCurrentSubMesh() const;
SMESH_Hypothesis::Hypothesis_Status
SMESH_Mesh::AddHypothesis(const TopoDS_Shape & aSubShape,
int anHypId,
- std::string* anError )
+ 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)
+ 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
-
{
return _myMeshDS->GetHypothesis(aSubShape);
}
*/
//=============================================================================
-const std::list<SMESHDS_Command*> & SMESH_Mesh::GetLog()
+const std::list<SMESHDS_Command*> & SMESH_Mesh::GetLog()
{
Unexpect aCatch(SalomeException);
return _myMeshDS->GetScript()->GetCommands();
*
*/
//=============================================================================
-void SMESH_Mesh::ClearLog()
+void SMESH_Mesh::ClearLog()
{
Unexpect aCatch(SalomeException);
_myMeshDS->GetScript()->Clear();
//=============================================================================
SMESH_subMesh * SMESH_Mesh::GetSubMesh(const TopoDS_Shape & aSubShape)
-
{
int index = _myMeshDS->ShapeToIndex(aSubShape);
if ( !index && aSubShape.IsNull() )
//=============================================================================
SMESH_subMesh *SMESH_Mesh::GetSubMeshContaining(const TopoDS_Shape & aSubShape) const
-
{
int index = _myMeshDS->ShapeToIndex(aSubShape);
return GetSubMeshContaining( index );
//=============================================================================
SMESH_subMesh *SMESH_Mesh::GetSubMeshContaining(const int aShapeID) const
-
{
SMESH_subMesh *aSubMesh = _subMeshHolder->Get( aShapeID );
-
return aSubMesh;
}
std::list<SMESH_subMesh*>
SMESH_Mesh::GetGroupSubMeshesContaining(const TopoDS_Shape & aSubShape) const
-
{
std::list<SMESH_subMesh*> found;
* Auto color functionality
*/
//=============================================================================
-void SMESH_Mesh::SetAutoColor(bool theAutoColor)
+void SMESH_Mesh::SetAutoColor(bool theAutoColor)
{
Unexpect aCatch(SalomeException);
_isAutoColor = theAutoColor;
}
-bool SMESH_Mesh::GetAutoColor()
+bool SMESH_Mesh::GetAutoColor()
{
Unexpect aCatch(SalomeException);
return _isAutoColor;
bool theAddODOnVertices,
double theZTolerance,
bool theAllElemsToGroup)
-
{
MESSAGE("MED_VERSION:"<< theVersion);
SMESH_TRY;
void SMESH_Mesh::ExportSAUV(const char *file,
const char* theMeshName,
bool theAutoGroups)
-
{
std::string medfilename(file);
medfilename += ".med";
//================================================================================
void SMESH_Mesh::ExportDAT(const char * file,
- const SMESHDS_Mesh* meshPart)
+ const SMESHDS_Mesh* meshPart)
{
Unexpect aCatch(SalomeException);
DriverDAT_W_SMDS_Mesh myWriter;
//================================================================================
void SMESH_Mesh::ExportUNV(const char * file,
- const SMESHDS_Mesh* meshPart)
+ 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)
+ const SMESHDS_Mesh* meshPart)
{
Unexpect aCatch(SalomeException);
DriverSTL_W_SMDS_Mesh myWriter;
*/
//================================================================================
-int SMESH_Mesh::NbNodes() const
+int SMESH_Mesh::NbNodes() const
{
Unexpect aCatch(SalomeException);
return _myMeshDS->NbNodes();
*/
//================================================================================
-int SMESH_Mesh::Nb0DElements() const
+int SMESH_Mesh::Nb0DElements() const
{
Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().Nb0DElements();
*/
//================================================================================
-int SMESH_Mesh::NbEdges(SMDSAbs_ElementOrder order) const
+int SMESH_Mesh::NbEdges(SMDSAbs_ElementOrder order) const
{
Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbEdges(order);
*/
//================================================================================
-int SMESH_Mesh::NbFaces(SMDSAbs_ElementOrder order) const
+int SMESH_Mesh::NbFaces(SMDSAbs_ElementOrder order) const
{
Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbFaces(order);
*/
//================================================================================
-int SMESH_Mesh::NbTriangles(SMDSAbs_ElementOrder order) const
+int SMESH_Mesh::NbTriangles(SMDSAbs_ElementOrder order) const
{
Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbTriangles(order);
*/
//================================================================================
-int SMESH_Mesh::NbBiQuadTriangles() const
+int SMESH_Mesh::NbBiQuadTriangles() const
{
Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbBiQuadTriangles();
*/
//================================================================================
-int SMESH_Mesh::NbQuadrangles(SMDSAbs_ElementOrder order) const
+int SMESH_Mesh::NbQuadrangles(SMDSAbs_ElementOrder order) const
{
Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbQuadrangles(order);
*/
//================================================================================
-int SMESH_Mesh::NbBiQuadQuadrangles() const
+int SMESH_Mesh::NbBiQuadQuadrangles() const
{
Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbBiQuadQuadrangles();
*/
//================================================================================
-int SMESH_Mesh::NbPolygons(SMDSAbs_ElementOrder order) const
+int SMESH_Mesh::NbPolygons(SMDSAbs_ElementOrder order) const
{
Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbPolygons(order);
*/
//================================================================================
-int SMESH_Mesh::NbVolumes(SMDSAbs_ElementOrder order) const
+int SMESH_Mesh::NbVolumes(SMDSAbs_ElementOrder order) const
{
Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbVolumes(order);
*/
//================================================================================
-int SMESH_Mesh::NbTetras(SMDSAbs_ElementOrder order) const
+int SMESH_Mesh::NbTetras(SMDSAbs_ElementOrder order) const
{
Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbTetras(order);
*/
//================================================================================
-int SMESH_Mesh::NbHexas(SMDSAbs_ElementOrder order) const
+int SMESH_Mesh::NbHexas(SMDSAbs_ElementOrder order) const
{
Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbHexas(order);
*/
//================================================================================
-int SMESH_Mesh::NbTriQuadraticHexas() const
+int SMESH_Mesh::NbTriQuadraticHexas() const
{
Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbTriQuadHexas();
*/
//================================================================================
-int SMESH_Mesh::NbPyramids(SMDSAbs_ElementOrder order) const
+int SMESH_Mesh::NbPyramids(SMDSAbs_ElementOrder order) const
{
Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbPyramids(order);
*/
//================================================================================
-int SMESH_Mesh::NbPrisms(SMDSAbs_ElementOrder order) const
+int SMESH_Mesh::NbPrisms(SMDSAbs_ElementOrder order) const
{
Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbPrisms(order);
}
-int SMESH_Mesh::NbQuadPrisms() const
+int SMESH_Mesh::NbQuadPrisms() const
{
Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbQuadPrisms();
}
-int SMESH_Mesh::NbBiQuadPrisms() const
+int SMESH_Mesh::NbBiQuadPrisms() const
{
Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbBiQuadPrisms();
*/
//================================================================================
-int SMESH_Mesh::NbHexagonalPrisms() const
+int SMESH_Mesh::NbHexagonalPrisms() const
{
Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbHexPrisms();
*/
//================================================================================
-int SMESH_Mesh::NbPolyhedrons() const
+int SMESH_Mesh::NbPolyhedrons() const
{
Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbPolyhedrons();
*/
//================================================================================
-int SMESH_Mesh::NbBalls() const
+int SMESH_Mesh::NbBalls() const
{
Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbBalls();
*/
//================================================================================
-int SMESH_Mesh::NbSubMesh() const
+int SMESH_Mesh::NbSubMesh() const
{
Unexpect aCatch(SalomeException);
return _myMeshDS->NbSubMesh();
*/
//================================================================================
-SMESH_Group* SMESH_Mesh::AddGroup (SMESHDS_GroupBase* groupDS)
+SMESH_Group* SMESH_Mesh::AddGroup (SMESHDS_GroupBase* groupDS)
{
if ( !groupDS )
throw SALOME_Exception(LOCALIZED ("SMESH_Mesh::AddGroup(): NULL SMESHDS_GroupBase"));
bool theMakeRequiredGroups = true );
SMESH_Hypothesis::Hypothesis_Status
- AddHypothesis(const TopoDS_Shape & aSubShape, int anHypId, std::string* error=0)
- ;
+ AddHypothesis(const TopoDS_Shape & aSubShape, int anHypId, std::string* error=0);
SMESH_Hypothesis::Hypothesis_Status
- RemoveHypothesis(const TopoDS_Shape & aSubShape, int anHypId)
- ;
+ RemoveHypothesis(const TopoDS_Shape & aSubShape, int anHypId);
const std::list <const SMESHDS_Hypothesis * >&
- GetHypothesisList(const TopoDS_Shape & aSubShape) const
- ;
+ 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() ;
+ const std::list<SMESHDS_Command*> & GetLog();
- void ClearLog() ;
+ void ClearLog();
int GetId() const { return _id; }
SMESH_Gen *GetGen() { return _gen; }
- SMESH_subMesh *GetSubMesh(const TopoDS_Shape & aSubShape)
- ;
+ SMESH_subMesh *GetSubMesh(const TopoDS_Shape & aSubShape);
- SMESH_subMesh *GetSubMeshContaining(const TopoDS_Shape & aSubShape) const
- ;
+ SMESH_subMesh *GetSubMeshContaining(const TopoDS_Shape & aSubShape) const;
- SMESH_subMesh *GetSubMeshContaining(const int aShapeID) const
- ;
+ 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
- ;
+ 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) ;
+ void SetAutoColor(bool theAutoColor);
- bool GetAutoColor() ;
+ 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)
- ;
+ bool theAllElemsToGroup = false);
void ExportDAT(const char * file,
- const SMESHDS_Mesh* meshPart = 0) ;
+ const SMESHDS_Mesh* meshPart = 0);
void ExportUNV(const char * file,
- const SMESHDS_Mesh* meshPart = 0) ;
+ const SMESHDS_Mesh* meshPart = 0);
void ExportSTL(const char * file,
const bool isascii,
const char * name = 0,
- const SMESHDS_Mesh* meshPart = 0) ;
+ 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) ;
+ bool theAutoGroups = true);
double GetComputeProgress() const;
- int NbNodes() const ;
- int Nb0DElements() const ;
- int NbBalls() const ;
+ int NbNodes() const;
+ int Nb0DElements() const;
+ int NbBalls() const;
- int NbEdges(SMDSAbs_ElementOrder order = ORDER_ANY) const ;
+ int NbEdges(SMDSAbs_ElementOrder order = ORDER_ANY) const;
- 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 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 ;
- 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 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 ;
+ 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) ;
+ SMESH_Group* AddGroup (SMESHDS_GroupBase* groupDS);
typedef boost::shared_ptr< SMDS_Iterator<SMESH_Group*> > GroupIteratorPtr;
GroupIteratorPtr GetGroups() const;
const SMDS_MeshNode* srcNode,
std::list<const SMDS_MeshNode*> & newNodes,
const bool makeMediumNodes);
- int makeNodesByNormal1D( SMESHDS_Mesh* /*mesh*/,
- const SMDS_MeshNode* /*srcNode*/,
- std::list<const SMDS_MeshNode*> & /*newNodes*/,
- const bool /*makeMediumNodes*/);
+ int makeNodesByNormal1D( SMESHDS_Mesh* mesh,
+ const SMDS_MeshNode* srcNode,
+ std::list<const SMDS_MeshNode*> & newNodes,
+ const bool makeMediumNodes);
int makeNodesAlongTrack( SMESHDS_Mesh* mesh,
const SMDS_MeshNode* srcNode,
std::list<const SMDS_MeshNode*> & newNodes,
*/
int removeQuadElem( SMESHDS_SubMesh * theSm,
SMDS_ElemIteratorPtr theItr,
- const int /*theShapeID*/);
+ const int theShapeID);
/*!
* \brief Create groups of elements made during transformation
* \param nodeGens - nodes making corresponding myLastCreatedNodes
* \brief Return a shape containing all sub-shapes of the MainShape that can be
* meshed at once along with _subShape
*/
- TopoDS_Shape getCollection(SMESH_Gen * /*theGen*/,
+ TopoDS_Shape getCollection(SMESH_Gen * theGen,
SMESH_Algo* theAlgo,
bool & theSubComputed,
bool & theSubFailed,
static void ProcessEvents( vtkObject* theObject,
unsigned long theEvent,
void* theClientData,
- void* /*theCallData*/ );
+ void* theCallData );
private:
void OnEditDelete();
private slots:
- void onItemCheck(QTreeWidgetItem * item, int /*column*/);
+ void onItemCheck(QTreeWidgetItem * item, int column);
private:
aNF = aFilterMgr->CreateMultiConnection2D();
else if (myComboBoxFunctor->currentText() == tr("MIN_DIAG_ELEMENTS"))
aNF = aFilterMgr->CreateMaxElementLength2D();
- //else;
return aNF._retn();
}
void SetCommandBefore( Handle(_pyCommand) theCmd, Handle(_pyCommand) theBeforeCmd );
Handle(_pyCommand)& GetLastCommand();
std::list< Handle(_pyCommand) >& GetCommands() { return myCommands; }
- void PlaceSubmeshAfterItsCreation( Handle(_pyCommand) /*theCmdUsingSubmesh*/ ) const;
+ void PlaceSubmeshAfterItsCreation( Handle(_pyCommand) theCmdUsingSubmesh ) const;
_pyID GenerateNewID( const _pyID& theID );
bool AddObject( Handle(_pyObject)& theObj );
virtual Handle(_pyMesh) GetMesh() { return myMesh; }
virtual void Free() { myCreator.Nullify(); myMesh.Nullify(); }
void SetCreator( const Handle(_pyObject)& theCreator ) { myCreator = theCreator; }
- static bool CanBeArgOfMethod(const _AString& /*theMethodName*/);
+ static bool CanBeArgOfMethod(const _AString& theMethodName);
DEFINE_STANDARD_RTTIEXT(_pySubMesh,_pyObject)
};
// 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;
+ virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
+ std::vector< int > & subIDArray ) const;
// Set new geometry instead of that returned by getObjectsDependOn()
- virtual bool setObjectsDependOn( std::vector< std::string > & /*entryArray*/,
- std::vector< int > & /*subIDArray*/ );
+ virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
+ std::vector< int > & subIDArray );
};
#endif
void SetElementType( ElementType theType );
void SetPoint( CORBA::Double x, CORBA::Double y, CORBA::Double z );
- void SetVertex( GEOM::GEOM_Object_ptr vertex )
- ;
- void SetNode ( CORBA::Long nodeID )
- ;
+ void SetVertex( GEOM::GEOM_Object_ptr vertex );
+ void SetNode ( CORBA::Long nodeID );
void SetThreshold ( const char* threshold,
- SMESH::ConnectedElements::ThresholdType type )
- ;
+ SMESH::ConnectedElements::ThresholdType type );
char* GetThreshold ( SMESH::ConnectedElements::ThresholdType& type );
private:
GenericHypothesisCreator_i* SMESH_Gen_i::getHypothesisCreator(const char* theHypName,
const char* theLibName,
std::string& thePlatformLibName)
-
{
std::string aPlatformLibName;
/* It's Need to translate lib name for WIN32 or X platform */
//=============================================================================
SMESH::SMESH_Mesh_ptr SMESH_Gen_i::createMesh()
-
{
Unexpect aCatch(SALOME_SalomeException);
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::createMesh" );
SMESH::SMESH_Hypothesis_ptr SMESH_Gen_i::CreateHypothesis( const char* theHypName,
const char* theLibName )
-
{
Unexpect aCatch(SALOME_SalomeException);
// Create hypothesis/algorithm
const char* theLibName,
CORBA::Double theAverageLength,
CORBA::Boolean theQuadDominated)
-
{
SMESH::HypInitParams initParams = { ::SMESH_Hypothesis::BY_AVERAGE_LENGTH,
theAverageLength, theQuadDominated };
SMESH::SMESH_Mesh_ptr theMesh,
GEOM::GEOM_Object_ptr theGeom,
const SMESH::HypInitParams& theParams)
-
{
Unexpect aCatch(SALOME_SalomeException);
//=============================================================================
void SMESH_Gen_i::SetBoundaryBoxSegmentation( CORBA::Long theNbSegments )
-
{
if ( theNbSegments > 0 )
myGen.SetBoundaryBoxSegmentation( int( theNbSegments ));
//=============================================================================
void SMESH_Gen_i::SetDefaultNbSegments(CORBA::Long theNbSegments)
-
{
if ( theNbSegments > 0 )
myGen.SetDefaultNbSegments( int(theNbSegments) );
//=============================================================================
SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateMesh( GEOM::GEOM_Object_ptr theShapeObject )
-
{
Unexpect aCatch(SALOME_SalomeException);
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::CreateMesh" );
//=============================================================================
SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateEmptyMesh()
-
{
Unexpect aCatch(SALOME_SalomeException);
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::CreateMesh" );
*/
//================================================================================
- void checkFileReadable( const char* theFileName )
+ void checkFileReadable( const char* theFileName )
{
SMESH_File f ( theFileName );
if ( !f )
//=============================================================================
SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateMeshesFromUNV( const char* theFileName )
-
{
Unexpect aCatch(SALOME_SalomeException);
SMESH::mesh_array* SMESH_Gen_i::CreateMeshesFromMED( const char* theFileName,
SMESH::DriverMED_ReadStatus& theStatus)
-
{
Unexpect aCatch(SALOME_SalomeException);
checkFileReadable( theFileName );
SMESH::mesh_array* SMESH_Gen_i::CreateMeshesFromSAUV( const char* theFileName,
SMESH::DriverMED_ReadStatus& theStatus)
-
{
Unexpect aCatch(SALOME_SalomeException);
checkFileReadable( theFileName );
//=============================================================================
SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateMeshesFromSTL( const char* theFileName )
-
{
Unexpect aCatch(SALOME_SalomeException);
checkFileReadable( theFileName );
SMESH::mesh_array* SMESH_Gen_i::CreateMeshesFromCGNS( const char* theFileName,
SMESH::DriverMED_ReadStatus& theStatus)
-
{
Unexpect aCatch(SALOME_SalomeException);
checkFileReadable( theFileName );
SMESH_Gen_i::CreateMeshesFromGMF( const char* theFileName,
CORBA::Boolean theMakeRequiredGroups,
SMESH::ComputeError_out theError)
-
{
Unexpect aCatch(SALOME_SalomeException);
checkFileReadable( theFileName );
CORBA::Boolean SMESH_Gen_i::IsReadyToCompute( SMESH::SMESH_Mesh_ptr theMesh,
GEOM::GEOM_Object_ptr theShapeObject )
-
{
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 )
-
{
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 )
-
{
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 )
-
{
Unexpect aCatch(SALOME_SalomeException);
SMESH::algo_error_array* SMESH_Gen_i::GetAlgoState( SMESH::SMESH_Mesh_ptr theMesh,
GEOM::GEOM_Object_ptr theSubObject )
-
{
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 )
-
{
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 )
-
{
//MEMOSTAT;
Unexpect aCatch(SALOME_SalomeException);
GEOM::GEOM_Object_ptr theShapeObject,
SMESH::Dimension theDimension,
SMESH::long_array& theShapesId)
-
{
Unexpect aCatch(SALOME_SalomeException);
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::Precompute" );
SMESH::long_array* SMESH_Gen_i::Evaluate(SMESH::SMESH_Mesh_ptr theMesh,
GEOM::GEOM_Object_ptr theShapeObject)
// SMESH::long_array& theNbElems)
-
{
Unexpect aCatch(SALOME_SalomeException);
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::Evaluate" );
SMESH_Gen_i::GetGeometryByMeshElement( SMESH::SMESH_Mesh_ptr theMesh,
CORBA::Long theElementID,
const char* theGeomName)
-
{
Unexpect aCatch(SALOME_SalomeException);
GEOM::GEOM_Object_ptr
SMESH_Gen_i::FindGeometryByMeshElement( SMESH::SMESH_Mesh_ptr theMesh,
CORBA::Long theElementID)
-
{
Unexpect aCatch(SALOME_SalomeException);
if ( CORBA::is_nil( theMesh ) )
CORBA::Boolean theMergeNodesAndElements,
CORBA::Double theMergeTolerance,
SMESH::SMESH_Mesh_ptr theMeshToAppendTo)
-
{
return ConcatenateCommon(theMeshesArray,
theUniteIdenticalGroups,
CORBA::Boolean theMergeNodesAndElements,
CORBA::Double theMergeTolerance,
SMESH::SMESH_Mesh_ptr theMeshToAppendTo)
-
{
return ConcatenateCommon(theMeshesArray,
theUniteIdenticalGroups,
CORBA::Double theMergeTolerance,
CORBA::Boolean theCommonGroups,
SMESH::SMESH_Mesh_ptr theMeshToAppendTo)
-
{
std::unique_ptr< TPythonDump > pPythonDump( new TPythonDump );
TPythonDump& pythonDump = *pPythonDump; // prevent dump of called methods
const char* meshName,
CORBA::Boolean toCopyGroups,
CORBA::Boolean toKeepIDs)
-
{
Unexpect aCatch(SALOME_SalomeException);
SMESH::submesh_array_out theNewSubmeshes,
SMESH::ListOfHypothesis_out theNewHypotheses,
SMESH::string_array_out theInvalidEntries)
-
{
if ( CORBA::is_nil( theSourceMesh ) ||
CORBA::is_nil( theNewGeometry ))
// Create hypothesis/algorithm of given type
SMESH::SMESH_Hypothesis_ptr CreateHypothesis (const char* theHypType,
- const char* theLibName)
- ;
+ const char* theLibName);
SMESH::SMESH_Hypothesis_ptr CreateHypothesisByAverageLength( const char* theHypType,
const char* theLibName,
CORBA::Double theAverageLength,
- CORBA::Boolean theQuadDominated)
- ;
+ 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)
- ;
+ 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 ) ;
+ void SetBoundaryBoxSegmentation( CORBA::Long theNbSegments );
/*!
* \brief Sets default number of segments per edge
*/
- void SetDefaultNbSegments(CORBA::Long theNbSegments) ;
+ 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 )
- ;
+ SMESH::SMESH_Mesh_ptr CreateMesh( GEOM::GEOM_Object_ptr theShapeObject );
// Create empty mesh
- SMESH::SMESH_Mesh_ptr CreateEmptyMesh()
- ;
+ SMESH::SMESH_Mesh_ptr CreateEmptyMesh();
// Create a mesh and import data from an UNV file
- SMESH::SMESH_Mesh_ptr CreateMeshesFromUNV( const char* theFileName )
- ;
+ 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 )
- ;
+ SMESH::DriverMED_ReadStatus& theStatus );
// Create mesh(es) and import data from MED file
SMESH::mesh_array* CreateMeshesFromSAUV( const char* theFileName,
- SMESH::DriverMED_ReadStatus& theStatus )
- ;
+ SMESH::DriverMED_ReadStatus& theStatus );
// Create a mesh and import data from a STL file
- SMESH::SMESH_Mesh_ptr CreateMeshesFromSTL( const char* theFileName )
- ;
+ 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 )
- ;
+ 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)
- ;
+ 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)
- ;
+ 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)
- ;
+ SMESH::string_array_out invalidEntries);
// Compute mesh on a shape
CORBA::Boolean Compute( SMESH::SMESH_Mesh_ptr theMesh,
- GEOM::GEOM_Object_ptr theShapeObject )
- ;
+ 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 )
- ;
+ 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)
- ;
+ 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 )
- ;
+ 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 )
- ;
+ SMESH::long_array& theShapesId );
// Returns errors of hypotheses definition
SMESH::algo_error_array* GetAlgoState( SMESH::SMESH_Mesh_ptr theMesh,
- GEOM::GEOM_Object_ptr theSubObject )
- ;
+ GEOM::GEOM_Object_ptr theSubObject );
// Return mesh elements preventing computation of a subshape
SMESH::MeshPreviewStruct* GetBadInputElements( SMESH::SMESH_Mesh_ptr theMesh,
- CORBA::Short theSubShapeID )
- ;
+ 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)
- ;
+ const char* theGroupName);
// Get sub-shapes unique ID's list
SMESH::long_array* GetSubShapesId( GEOM::GEOM_Object_ptr theMainShapeObject,
- const SMESH::object_array& theListOfSubShape )
- ;
+ 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)
- ;
+ 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)
- ;
+ 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)
- ;
+ 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)
- ;
+ 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)
- ;
+ 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 )
- ;
+ 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; }
// Get hypothesis creator
GenericHypothesisCreator_i* getHypothesisCreator( const char* theHypName,
const char* theLibName,
- std::string& thePlatformLibName)
- ;
+ 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()
- ;
+ SMESH::SMESH_Mesh_ptr createMesh();
// Check mesh icon
bool isGeomModifIcon( SMESH::SMESH_Mesh_ptr mesh );
static SMESH_PredicatePtr GetPredicate( SMESH::Filter_ptr );
// CORBA interface implementation
- void SetFilter(SMESH::Filter_ptr theFilter) ;
+ void SetFilter(SMESH::Filter_ptr theFilter);
SMESH::Filter_ptr GetFilter();
virtual CORBA::Boolean IsUpToDate();
virtual SMESH::long_array* GetListOfID();
virtual bool IsMeshInfoCorrect();
// method of SMESH::NotifyerAndWaiter to update self when myFilter changes
- virtual void OnBaseObjModified(NotifyerAndWaiter* /*filter*/, bool);
+ virtual void OnBaseObjModified(NotifyerAndWaiter* filter, bool);
private:
SMESH::Filter_var myFilter;
//================================================================================
SMESH::MeshPreviewStruct* SMESH_MeshEditor_i::GetPreviewData()
-
{
SMESH_TRY;
const bool hasBadElems = ( getEditor().GetError() && getEditor().GetError()->HasBadElems() );
//================================================================================
SMESH::long_array* SMESH_MeshEditor_i::GetLastCreatedNodes()
-
{
SMESH_TRY;
SMESH::long_array_var myLastCreatedNodes = new SMESH::long_array();
//================================================================================
SMESH::long_array* SMESH_MeshEditor_i::GetLastCreatedElems()
-
{
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()
+void SMESH_MeshEditor_i::ClearLastCreated()
{
SMESH_TRY;
getEditor().ClearLastCreated();
//=======================================================================
SMESH::ComputeError* SMESH_MeshEditor_i::GetLastError()
-
{
SMESH_TRY;
SMESH::ComputeError_var errOut = new SMESH::ComputeError;
CORBA::Boolean
SMESH_MeshEditor_i::RemoveElements(const SMESH::long_array & IDsOfElements)
-
{
SMESH_TRY;
initData();
//=============================================================================
CORBA::Boolean SMESH_MeshEditor_i::RemoveNodes(const SMESH::long_array & IDsOfNodes)
-
{
SMESH_TRY;
initData();
//=============================================================================
CORBA::Long SMESH_MeshEditor_i::RemoveOrphanNodes()
-
{
SMESH_TRY;
initData();
//=============================================================================
CORBA::Long SMESH_MeshEditor_i::AddNode(CORBA::Double x,CORBA::Double y, CORBA::Double z)
-
{
SMESH_TRY;
initData();
CORBA::Long SMESH_MeshEditor_i::Add0DElement(CORBA::Long IDOfNode,
CORBA::Boolean DuplicateElements)
-
{
SMESH_TRY;
initData();
//=============================================================================
CORBA::Long SMESH_MeshEditor_i::AddBall(CORBA::Long IDOfNode, CORBA::Double diameter)
-
{
SMESH_TRY;
initData();
//=============================================================================
CORBA::Long SMESH_MeshEditor_i::AddEdge(const SMESH::long_array & IDsOfNodes)
-
{
SMESH_TRY;
initData();
//=============================================================================
CORBA::Long SMESH_MeshEditor_i::AddFace(const SMESH::long_array & IDsOfNodes)
-
{
SMESH_TRY;
initData();
//=============================================================================
CORBA::Long SMESH_MeshEditor_i::AddPolygonalFace (const SMESH::long_array & IDsOfNodes)
-
{
SMESH_TRY;
initData();
//=============================================================================
CORBA::Long SMESH_MeshEditor_i::AddQuadPolygonalFace (const SMESH::long_array & IDsOfNodes)
-
{
SMESH_TRY;
initData();
//=============================================================================
CORBA::Long SMESH_MeshEditor_i::AddVolume(const SMESH::long_array & IDsOfNodes)
-
{
SMESH_TRY;
initData();
//=============================================================================
CORBA::Long SMESH_MeshEditor_i::AddPolyhedralVolume (const SMESH::long_array & IDsOfNodes,
const SMESH::long_array & Quantities)
-
{
SMESH_TRY;
initData();
//=============================================================================
CORBA::Long SMESH_MeshEditor_i::AddPolyhedralVolumeByFaces (const SMESH::long_array & IdsOfFaces)
-
{
SMESH_TRY;
initData();
SMESH_MeshEditor_i::Create0DElementsOnAllNodes(SMESH::SMESH_IDSource_ptr theObject,
const char* theGroupName,
CORBA::Boolean theDuplicateElements)
-
{
SMESH_TRY;
initData();
//=============================================================================
void SMESH_MeshEditor_i::SetNodeOnVertex(CORBA::Long NodeID, CORBA::Long VertexID)
-
{
SMESH_TRY;
void SMESH_MeshEditor_i::SetNodeOnEdge(CORBA::Long NodeID, CORBA::Long EdgeID,
CORBA::Double paramOnEdge)
-
{
SMESH_TRY;
void SMESH_MeshEditor_i::SetNodeOnFace(CORBA::Long NodeID, CORBA::Long FaceID,
CORBA::Double u, CORBA::Double v)
-
{
SMESH_TRY;
SMESHDS_Mesh * mesh = getMeshDS();
//=============================================================================
void SMESH_MeshEditor_i::SetNodeInVolume(CORBA::Long NodeID, CORBA::Long SolidID)
-
{
SMESH_TRY;
SMESHDS_Mesh * mesh = getMeshDS();
void SMESH_MeshEditor_i::SetMeshElementOnShape(CORBA::Long ElementID,
CORBA::Long ShapeID)
-
{
SMESH_TRY;
SMESHDS_Mesh * mesh = getMeshDS();
CORBA::Boolean SMESH_MeshEditor_i::InverseDiag(CORBA::Long NodeID1,
CORBA::Long NodeID2)
-
{
SMESH_TRY;
initData();
CORBA::Boolean SMESH_MeshEditor_i::DeleteDiag(CORBA::Long NodeID1,
CORBA::Long NodeID2)
-
{
SMESH_TRY;
initData();
//=============================================================================
CORBA::Boolean SMESH_MeshEditor_i::Reorient(const SMESH::long_array & IDsOfElements)
-
{
SMESH_TRY;
initData();
//=============================================================================
CORBA::Boolean SMESH_MeshEditor_i::ReorientObject(SMESH::SMESH_IDSource_ptr theObject)
-
{
SMESH_TRY;
initData();
const SMESH::DirStruct& theDirection,
CORBA::Long theFace,
const SMESH::PointStruct& thePoint)
-
{
SMESH_TRY;
initData(/*deleteSearchers=*/false);
CORBA::Long SMESH_MeshEditor_i::Reorient2DBy3D(const SMESH::ListOfIDSources& faceGroups,
SMESH::SMESH_IDSource_ptr volumeGroup,
CORBA::Boolean outsideNormal)
-
{
SMESH_TRY;
initData();
CORBA::Boolean SMESH_MeshEditor_i::TriToQuad (const SMESH::long_array & IDsOfElements,
SMESH::NumericalFunctor_ptr Criterion,
CORBA::Double MaxAngle)
-
{
SMESH_TRY;
initData();
CORBA::Boolean SMESH_MeshEditor_i::TriToQuadObject (SMESH::SMESH_IDSource_ptr theObject,
SMESH::NumericalFunctor_ptr Criterion,
CORBA::Double MaxAngle)
-
{
SMESH_TRY;
initData();
CORBA::Boolean SMESH_MeshEditor_i::QuadToTri (const SMESH::long_array & IDsOfElements,
SMESH::NumericalFunctor_ptr Criterion)
-
{
SMESH_TRY;
initData();
CORBA::Boolean SMESH_MeshEditor_i::QuadToTriObject (SMESH::SMESH_IDSource_ptr theObject,
SMESH::NumericalFunctor_ptr Criterion)
-
{
SMESH_TRY;
initData();
//================================================================================
void SMESH_MeshEditor_i::QuadTo4Tri (SMESH::SMESH_IDSource_ptr theObject)
-
{
SMESH_TRY;
initData();
CORBA::Boolean SMESH_MeshEditor_i::SplitQuad (const SMESH::long_array & IDsOfElements,
CORBA::Boolean Diag13)
-
{
SMESH_TRY;
initData();
CORBA::Boolean SMESH_MeshEditor_i::SplitQuadObject (SMESH::SMESH_IDSource_ptr theObject,
CORBA::Boolean Diag13)
-
{
SMESH_TRY;
initData();
CORBA::Long SMESH_MeshEditor_i::BestSplit (CORBA::Long IDOfQuad,
SMESH::NumericalFunctor_ptr Criterion)
-
{
SMESH_TRY;
initData();
void SMESH_MeshEditor_i::SplitVolumesIntoTetra (SMESH::SMESH_IDSource_ptr elems,
CORBA::Short methodFlags)
-
{
SMESH_TRY;
initData();
const SMESH::DirStruct& facetToSplitNormal,
CORBA::Short methodFlags,
CORBA::Boolean allDomains)
-
{
SMESH_TRY;
initData();
//================================================================================
void SMESH_MeshEditor_i::SplitBiQuadraticIntoLinear(const SMESH::ListOfIDSources& theElems)
-
{
SMESH_TRY;
initData();
CORBA::Long MaxNbOfIterations,
CORBA::Double MaxAspectRatio,
SMESH::SMESH_MeshEditor::Smooth_Method Method)
-
{
return smooth( IDsOfElements, IDsOfFixedNodes, MaxNbOfIterations,
MaxAspectRatio, Method, false );
CORBA::Long MaxNbOfIterations,
CORBA::Double MaxAspectRatio,
SMESH::SMESH_MeshEditor::Smooth_Method Method)
-
{
return smooth( IDsOfElements, IDsOfFixedNodes, MaxNbOfIterations,
MaxAspectRatio, Method, true );
CORBA::Long MaxNbOfIterations,
CORBA::Double MaxAspectRatio,
SMESH::SMESH_MeshEditor::Smooth_Method Method)
-
{
return smoothObject (theObject, IDsOfFixedNodes, MaxNbOfIterations,
MaxAspectRatio, Method, false);
CORBA::Long MaxNbOfIterations,
CORBA::Double MaxAspectRatio,
SMESH::SMESH_MeshEditor::Smooth_Method Method)
-
{
return smoothObject (theObject, IDsOfFixedNodes, MaxNbOfIterations,
MaxAspectRatio, Method, true);
CORBA::Double MaxAspectRatio,
SMESH::SMESH_MeshEditor::Smooth_Method Method,
bool IsParametric)
-
{
SMESH_TRY;
initData();
CORBA::Double MaxAspectRatio,
SMESH::SMESH_MeshEditor::Smooth_Method Method,
bool IsParametric)
-
{
SMESH_TRY;
initData();
//=============================================================================
void SMESH_MeshEditor_i::RenumberNodes()
-
{
SMESH_TRY;
// Update Python script
//=============================================================================
void SMESH_MeshEditor_i::RenumberElements()
-
{
SMESH_TRY;
// Update Python script
//=======================================================================
SMESH::ListOfGroups* SMESH_MeshEditor_i::getGroups(const std::list<int>* groupIDs)
-
{
SMESH_TRY;
if ( !groupIDs )
CORBA::Long theNbOfSteps,
CORBA::Double theTolerance,
const bool theMakeGroups)
-
{
SMESH_TRY;
initData();
const SMESH::double_array & theBasePoint,
const SMESH::double_array & theAngles,
CORBA::Boolean theAnglesVariation)
-
{
SMESH_TRY;
initData();
CORBA::Boolean useInputElemsOnly,
CORBA::Boolean makeGroups,
CORBA::Short dim)
-
{
SMESH_TRY;
initData();
CORBA::Long theExtrFlags,
CORBA::Double theSewTolerance,
CORBA::Boolean theMakeGroups)
-
{
SMESH_TRY;
initData();
const SMESH::double_array & theScaleFactors,
CORBA::Boolean theScalesVariation,
SMESH::SMESH_MeshEditor::Extrusion_Error& theError)
-
{
SMESH_TRY;
initData();
CORBA::Boolean theCopy,
bool theMakeGroups,
::SMESH_Mesh* theTargetMesh)
-
{
SMESH_TRY;
initData();
const SMESH::AxisStruct & theAxis,
SMESH::SMESH_MeshEditor::MirrorType theMirrorType,
CORBA::Boolean theCopy)
-
{
if ( !myIsPreviewMode ) {
TPythonDump() << this << ".Mirror( "
const SMESH::AxisStruct & theAxis,
SMESH::SMESH_MeshEditor::MirrorType theMirrorType,
CORBA::Boolean theCopy)
-
{
if ( !myIsPreviewMode ) {
TPythonDump() << this << ".MirrorObject( "
SMESH_MeshEditor_i::MirrorMakeGroups(const SMESH::long_array& theIDsOfElements,
const SMESH::AxisStruct& theMirror,
SMESH::SMESH_MeshEditor::MirrorType theMirrorType)
-
{
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)
-
{
TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
SMESH::SMESH_MeshEditor::MirrorType theMirrorType,
CORBA::Boolean theCopyGroups,
const char* theMeshName)
-
{
SMESH_Mesh_i* mesh_i;
SMESH::SMESH_Mesh_var mesh;
SMESH::SMESH_MeshEditor::MirrorType theMirrorType,
CORBA::Boolean theCopyGroups,
const char* theMeshName)
-
{
SMESH_Mesh_i* mesh_i;
SMESH::SMESH_Mesh_var mesh;
CORBA::Boolean theCopy,
bool theMakeGroups,
::SMESH_Mesh* theTargetMesh)
-
{
SMESH_TRY;
initData();
void SMESH_MeshEditor_i::Translate(const SMESH::long_array & theIDsOfElements,
const SMESH::DirStruct & theVector,
CORBA::Boolean theCopy)
-
{
if (!myIsPreviewMode) {
TPythonDump() << this << ".Translate( "
void SMESH_MeshEditor_i::TranslateObject(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::DirStruct & theVector,
CORBA::Boolean theCopy)
-
{
if (!myIsPreviewMode) {
TPythonDump() << this << ".TranslateObject( "
SMESH::ListOfGroups*
SMESH_MeshEditor_i::TranslateMakeGroups(const SMESH::long_array& theIDsOfElements,
const SMESH::DirStruct& theVector)
-
{
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)
-
{
TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
const SMESH::DirStruct& theVector,
CORBA::Boolean theCopyGroups,
const char* theMeshName)
-
{
SMESH_Mesh_i* mesh_i;
SMESH::SMESH_Mesh_var mesh;
const SMESH::DirStruct& theVector,
CORBA::Boolean theCopyGroups,
const char* theMeshName)
-
{
SMESH_TRY;
SMESH_Mesh_i* mesh_i;
CORBA::Boolean theCopy,
bool theMakeGroups,
::SMESH_Mesh* theTargetMesh)
-
{
SMESH_TRY;
initData();
const SMESH::AxisStruct & theAxis,
CORBA::Double theAngle,
CORBA::Boolean theCopy)
-
{
if (!myIsPreviewMode) {
TPythonDump() << this << ".Rotate( "
const SMESH::AxisStruct & theAxis,
CORBA::Double theAngle,
CORBA::Boolean theCopy)
-
{
if ( !myIsPreviewMode ) {
TPythonDump() << this << ".RotateObject( "
SMESH_MeshEditor_i::RotateMakeGroups(const SMESH::long_array& theIDsOfElements,
const SMESH::AxisStruct& theAxis,
CORBA::Double theAngle)
-
{
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)
-
{
TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
CORBA::Double theAngleInRadians,
CORBA::Boolean theCopyGroups,
const char* theMeshName)
-
{
SMESH_TRY;
SMESH::SMESH_Mesh_var mesh;
CORBA::Double theAngleInRadians,
CORBA::Boolean theCopyGroups,
const char* theMeshName)
-
{
SMESH_TRY;
SMESH::SMESH_Mesh_var mesh;
CORBA::Boolean theCopy,
bool theMakeGroups,
::SMESH_Mesh* theTargetMesh)
-
{
SMESH_TRY;
initData();
SMESH_MeshEditor_i::ScaleMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::PointStruct& thePoint,
const SMESH::double_array& theScaleFact)
-
{
TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
const SMESH::double_array& theScaleFact,
CORBA::Boolean theCopyGroups,
const char* theMeshName)
-
{
SMESH_Mesh_i* mesh_i;
SMESH::SMESH_Mesh_var mesh;
CORBA::Boolean theCopyElements,
const char* theMeshName,
SMESH::ListOfGroups_out theGroups)
-
{
SMESH_TRY;
initData();
FindCoincidentNodes (CORBA::Double Tolerance,
SMESH::array_of_long_array_out GroupsOfNodes,
CORBA::Boolean SeparateCornersAndMedium)
-
{
SMESH_TRY;
initData();
CORBA::Double Tolerance,
SMESH::array_of_long_array_out GroupsOfNodes,
CORBA::Boolean SeparateCornersAndMedium)
-
{
SMESH_TRY;
initData();
SMESH::array_of_long_array_out theGroupsOfNodes,
const SMESH::ListOfIDSources& theExceptSubMeshOrGroups,
CORBA::Boolean theSeparateCornersAndMedium)
-
{
SMESH_TRY;
initData();
void SMESH_MeshEditor_i::MergeNodes (const SMESH::array_of_long_array& GroupsOfNodes,
const SMESH::ListOfIDSources& NodesToKeep,
CORBA::Boolean AvoidMakingHoles)
-
{
SMESH_TRY;
initData();
void SMESH_MeshEditor_i::FindEqualElements(const SMESH::ListOfIDSources& theObjects,
const SMESH::ListOfIDSources& theExceptObjects,
SMESH::array_of_long_array_out theGroupsOfElementsID)
-
{
SMESH_TRY;
initData();
void SMESH_MeshEditor_i::MergeElements(const SMESH::array_of_long_array& theGroupsOfElementsID,
const SMESH::ListOfIDSources& theElementsToKeep)
-
{
SMESH_TRY;
initData();
//=======================================================================
void SMESH_MeshEditor_i::MergeEqualElements()
-
{
SMESH_TRY;
initData();
CORBA::Double x,
CORBA::Double y,
CORBA::Double z)
-
{
SMESH_TRY;
initData(/*deleteSearchers=*/false);
CORBA::Long SMESH_MeshEditor_i::FindNodeClosestTo(CORBA::Double x,
CORBA::Double y,
CORBA::Double z)
-
{
SMESH_TRY;
theSearchersDeleter.Set( myMesh ); // remove theNodeSearcher if mesh is other
CORBA::Double y,
CORBA::Double z,
CORBA::Long theNodeID)
-
{
SMESH_TRY;
// We keep theNodeSearcher until any mesh modification:
CORBA::Double y,
CORBA::Double z,
SMESH::ElementType type)
-
{
SMESH_TRY;
SMESH::long_array_var res = new SMESH::long_array;
CORBA::Double y,
CORBA::Double z,
SMESH::ElementType type)
-
{
SMESH_TRY;
SMESH::long_array_var res = new SMESH::long_array;
SMESH::ElementType type,
SMESH::SMESH_IDSource_ptr meshObject,
SMESH::double_array_out projecton)
-
{
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)
-
{
SMESH_TRY;
theSearchersDeleter.Set( myMesh );
//=======================================================================
CORBA::Boolean SMESH_MeshEditor_i::IsManifold()
-
{
bool isManifold = true;
//=======================================================================
CORBA::Boolean SMESH_MeshEditor_i::IsCoherentOrientation2D()
-
{
bool isGoodOri = true;
SMESH_MeshEditor_i::Get1DBranches( SMESH::SMESH_IDSource_ptr theEdges,
CORBA::Long theStartNode,
SMESH::array_of_long_array_out theNodeGroups )
-
{
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)
-
{
SMESH::ListOfEdges_var resultEdges = new SMESH::ListOfEdges;
SMESH_TRY;
//=======================================================================
SMESH::ListOfFreeBorders* SMESH_MeshEditor_i::FindFreeBorders(CORBA::Boolean closedOnly)
-
{
SMESH::ListOfFreeBorders_var resBorders = new SMESH::ListOfFreeBorders;
SMESH_TRY;
SMESH::SMESH_Group_ptr
SMESH_MeshEditor_i::FillHole(const SMESH::FreeBorder& theHole,
const char* theGroupName)
-
{
initData();
SewCoincidentFreeBorders(const SMESH::CoincidentFreeBorders& freeBorders,
CORBA::Boolean createPolygons,
CORBA::Boolean createPolyhedra)
-
{
CORBA::Short nbSewed = 0;
CORBA::Long LastNodeID2,
CORBA::Boolean CreatePolygons,
CORBA::Boolean CreatePolyedrs)
-
{
SMESH_TRY;
initData();
CORBA::Long LastNodeID1,
CORBA::Long FirstNodeID2,
CORBA::Long SecondNodeID2)
-
{
SMESH_TRY;
initData();
CORBA::Long LastNodeIDOnSide,
CORBA::Boolean CreatePolygons,
CORBA::Boolean CreatePolyedrs)
-
{
SMESH_TRY;
initData();
CORBA::Long NodeID1OfSide2ToMerge,
CORBA::Long NodeID2OfSide1ToMerge,
CORBA::Long NodeID2OfSide2ToMerge)
-
{
SMESH_TRY;
initData();
CORBA::Boolean SMESH_MeshEditor_i::ChangeElemNodes(CORBA::Long ide,
const SMESH::long_array& newIDs)
-
{
SMESH_TRY;
initData();
void SMESH_MeshEditor_i::convertToQuadratic(CORBA::Boolean theForce3d,
CORBA::Boolean theToBiQuad,
SMESH::SMESH_IDSource_ptr theObject)
-
{
SMESH_TRY;
initData();
//=======================================================================
CORBA::Boolean SMESH_MeshEditor_i::ConvertFromQuadratic()
-
{
SMESH_TRY;
initData();
//=======================================================================
void SMESH_MeshEditor_i::ConvertToQuadratic(CORBA::Boolean theForce3d)
-
{
convertToQuadratic( theForce3d, false );
TPythonDump() << this << ".ConvertToQuadratic("<<theForce3d<<")";
void SMESH_MeshEditor_i::ConvertToQuadraticObject(CORBA::Boolean theForce3d,
SMESH::SMESH_IDSource_ptr theObject)
-
{
convertToQuadratic( theForce3d, false, theObject );
TPythonDump() << this << ".ConvertToQuadraticObject("<<theForce3d<<", "<<theObject<<")";
void SMESH_MeshEditor_i::ConvertToBiQuadratic(CORBA::Boolean theForce3d,
SMESH::SMESH_IDSource_ptr theObject)
-
{
convertToQuadratic( theForce3d, true, theObject );
TPythonDump() << this << ".ConvertToBiQuadratic("<<theForce3d<<", "<<theObject<<")";
//================================================================================
void SMESH_MeshEditor_i::ConvertFromQuadraticObject(SMESH::SMESH_IDSource_ptr theObject)
-
{
SMESH_TRY;
initData();
SMESH::SMESH_Group_ptr
SMESH_MeshEditor_i::DoubleElements(SMESH::SMESH_IDSource_ptr theElements,
const char* theGroupName)
-
{
SMESH::SMESH_Group_var newGroup;
CORBA::Boolean SMESH_MeshEditor_i::DoubleNodes( const SMESH::long_array& theNodes,
const SMESH::long_array& theModifiedElems )
-
{
SMESH_TRY;
initData();
CORBA::Boolean SMESH_MeshEditor_i::DoubleNode( CORBA::Long theNodeId,
const SMESH::long_array& theModifiedElems )
-
{
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 )
-
{
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 )
-
{
SMESH_TRY;
SMESH::SMESH_Group_var aNewGroup;
CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeGroups(const SMESH::ListOfGroups& theNodes,
const SMESH::ListOfGroups& theModifiedElems )
-
{
SMESH_TRY;
initData();
SMESH::SMESH_Group_ptr
SMESH_MeshEditor_i::DoubleNodeGroupsNew( const SMESH::ListOfGroups& theNodes,
const SMESH::ListOfGroups& theModifiedElems )
-
{
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 )
-
{
SMESH_TRY;
initData();
CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeElemInRegion ( const SMESH::long_array& theElems,
const SMESH::long_array& theNodesNot,
GEOM::GEOM_Object_ptr theShape )
-
{
SMESH_TRY;
initData();
SMESH_MeshEditor_i::DoubleNodeElemGroup(SMESH::SMESH_GroupBase_ptr theElems,
SMESH::SMESH_GroupBase_ptr theNodesNot,
SMESH::SMESH_GroupBase_ptr theAffectedElems)
-
{
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)
-
{
TPythonDump pyDump;
SMESH::ListOfGroups_var twoGroups = DoubleNodeElemGroup2New( theElems,
SMESH::SMESH_GroupBase_ptr theAffectedElems,
CORBA::Boolean theElemGroupNeeded,
CORBA::Boolean theNodeGroupNeeded)
-
{
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 )
-
{
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)
-
{
SMESH_TRY;
initData();
SMESH_MeshEditor_i::DoubleNodeElemGroupsNew(const SMESH::ListOfGroups& theElems,
const SMESH::ListOfGroups& theNodesNot,
const SMESH::ListOfGroups& theAffectedElems)
-
{
TPythonDump pyDump;
SMESH::ListOfGroups_var twoGroups = DoubleNodeElemGroups2New( theElems,
const SMESH::ListOfGroups& theAffectedElems,
CORBA::Boolean theElemGroupNeeded,
CORBA::Boolean theNodeGroupNeeded)
-
{
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 )
-
{
SMESH_TRY;
initData();
SMESH_MeshEditor_i::AffectedElemGroupsInRegion( const SMESH::ListOfGroups& theElems,
const SMESH::ListOfGroups& theNodesNot,
GEOM::GEOM_Object_ptr theShape )
-
{
SMESH_TRY;
SMESH::ListOfGroups_var aListOfGroups = new SMESH::ListOfGroups();
//================================================================================
CORBA::Boolean SMESH_MeshEditor_i::Make2DMeshFrom3D()
-
{
SMESH_TRY;
initData();
SMESH_MeshEditor_i::DoubleNodesOnGroupBoundaries( const SMESH::ListOfGroups& theDomains,
CORBA::Boolean createJointElems,
CORBA::Boolean onAllBoundaries )
-
{
bool isOK = false;
CORBA::Boolean
SMESH_MeshEditor_i::CreateFlatElementsOnFacesGroups( const SMESH::ListOfGroups& theGroupsOfFaces )
-
{
SMESH_TRY;
initData();
const char* groupName,
const SMESH::double_array& theNodesCoords,
SMESH::array_of_long_array_out GroupsOfNodes)
-
{
SMESH_TRY;
CORBA::Boolean toCopyElements,
CORBA::Boolean toCopyExistingBondary,
SMESH::SMESH_Group_out group)
-
{
SMESH_TRY;
initData();
const SMESH::ListOfIDSources& groups,
SMESH::SMESH_Mesh_out mesh,
SMESH::SMESH_Group_out group)
-
{
SMESH_TRY;
initData();
void SMESH_MeshEditor_i::MakePolyLine(SMESH::ListOfPolySegments& theSegments,
const char* theGroupName)
-
{
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)
-
{
if ( CORBA::is_nil( theSegments ) ||
theSegments->GetType() != SMESH::EDGE )
/*!
* Return data of mesh edition preview
*/
- SMESH::MeshPreviewStruct* GetPreviewData() ;
+ 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() ;
+ 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() ;
+ SMESH::long_array* GetLastCreatedElems();
/*!
* \brief Clears sequences of last created elements and nodes
*/
- void ClearLastCreated() ;
+ void ClearLastCreated();
/*!
* \brief Returns description of an error/warning occurred during the last operation
*/
- SMESH::ComputeError* GetLastError() ;
+ 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)
- ;
- CORBA::Boolean RemoveNodes (const SMESH::long_array & IDsOfNodes)
- ;
- CORBA::Long RemoveOrphanNodes()
- ;
+ 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)
- ;
- 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 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)
- ;
- CORBA::Long AddPolyhedralVolumeByFaces(const SMESH::long_array & IdsOfFaces)
- ;
+ 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)
- ;
+ 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)
- ;
+ 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)
- ;
+ 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)
- ;
+ 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)
- ;
+ 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)
- ;
+ void SetMeshElementOnShape(CORBA::Long ElementID, CORBA::Long ShapeID);
CORBA::Boolean MoveNode(CORBA::Long NodeID,
- 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)
- ;
+ 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) ;
+ 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)
- ;
+ CORBA::Boolean outsideNormal);
// Split/Join
CORBA::Boolean TriToQuad (const SMESH::long_array & IDsOfElements,
SMESH::NumericalFunctor_ptr Criterion,
- CORBA::Double MaxAngle)
- ;
+ CORBA::Double MaxAngle);
CORBA::Boolean TriToQuadObject (SMESH::SMESH_IDSource_ptr theObject,
SMESH::NumericalFunctor_ptr Criterion,
- CORBA::Double MaxAngle)
- ;
+ CORBA::Double MaxAngle);
CORBA::Boolean QuadToTri (const SMESH::long_array & IDsOfElements,
- SMESH::NumericalFunctor_ptr Criterion)
- ;
+ SMESH::NumericalFunctor_ptr Criterion);
CORBA::Boolean QuadToTriObject (SMESH::SMESH_IDSource_ptr theObject,
- SMESH::NumericalFunctor_ptr Criterion)
- ;
- void QuadTo4Tri (SMESH::SMESH_IDSource_ptr theObject)
- ;
+ SMESH::NumericalFunctor_ptr Criterion);
+ void QuadTo4Tri (SMESH::SMESH_IDSource_ptr theObject);
CORBA::Boolean SplitQuad (const SMESH::long_array & IDsOfElements,
- CORBA::Boolean Diag13)
- ;
+ CORBA::Boolean Diag13);
CORBA::Boolean SplitQuadObject (SMESH::SMESH_IDSource_ptr theObject,
- CORBA::Boolean Diag13)
- ;
+ CORBA::Boolean Diag13);
CORBA::Long BestSplit (CORBA::Long IDOfQuad,
- SMESH::NumericalFunctor_ptr Criterion)
- ;
+ SMESH::NumericalFunctor_ptr Criterion);
void SplitVolumesIntoTetra(SMESH::SMESH_IDSource_ptr elems,
- CORBA::Short methodFlags)
- ;
+ CORBA::Short methodFlags);
void SplitHexahedraIntoPrisms(SMESH::SMESH_IDSource_ptr elems,
const SMESH::PointStruct & startHexPoint,
const SMESH::DirStruct& facetToSplitNormal,
CORBA::Short methodFlags,
- CORBA::Boolean allDomains)
- ;
- void SplitBiQuadraticIntoLinear(const SMESH::ListOfIDSources& elems)
- ;
+ 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)
- ;
+ 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)
- ;
+ 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)
- ;
+ 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)
- ;
+ 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)
- ;
+ 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)
- ;
-
- CORBA::Boolean ConvertFromQuadratic()
- ;
- void ConvertFromQuadraticObject(SMESH::SMESH_IDSource_ptr theObject)
- ;
- void ConvertToQuadratic(CORBA::Boolean Force3d)
- ;
+ 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)
- ;
+ SMESH::SMESH_IDSource_ptr theObject);
void ConvertToBiQuadratic(CORBA::Boolean theForce3d,
- SMESH::SMESH_IDSource_ptr theObject)
- ;
+ SMESH::SMESH_IDSource_ptr theObject);
- void RenumberNodes() ;
- void RenumberElements() ;
+ 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)
- ;
+ 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)
- ;
+ 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)
- ;
+ 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)
- ;
+ 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)
- ;
+ 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)
- ;
+ CORBA::Boolean Copy);
void MirrorObject(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::AxisStruct & Axis,
SMESH::SMESH_MeshEditor::MirrorType MirrorType,
- CORBA::Boolean Copy)
- ;
+ CORBA::Boolean Copy);
void Translate(const SMESH::long_array & IDsOfElements,
const SMESH::DirStruct & Vector,
- CORBA::Boolean Copy)
- ;
+ CORBA::Boolean Copy);
void TranslateObject(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::DirStruct & Vector,
- CORBA::Boolean Copy)
- ;
+ CORBA::Boolean Copy);
void Rotate(const SMESH::long_array & IDsOfElements,
const SMESH::AxisStruct & Axis,
CORBA::Double Angle,
- CORBA::Boolean Copy)
- ;
+ CORBA::Boolean Copy);
void RotateObject(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::AxisStruct & Axis,
CORBA::Double Angle,
- CORBA::Boolean Copy)
- ;
+ CORBA::Boolean Copy);
SMESH::ListOfGroups* MirrorMakeGroups(const SMESH::long_array& IDsOfElements,
const SMESH::AxisStruct& Mirror,
- SMESH::SMESH_MeshEditor::MirrorType MirrorType)
- ;
+ SMESH::SMESH_MeshEditor::MirrorType MirrorType);
SMESH::ListOfGroups* MirrorObjectMakeGroups(SMESH::SMESH_IDSource_ptr Object,
const SMESH::AxisStruct& Mirror,
- SMESH::SMESH_MeshEditor::MirrorType MirrorType)
- ;
+ SMESH::SMESH_MeshEditor::MirrorType MirrorType);
SMESH::ListOfGroups* TranslateMakeGroups(const SMESH::long_array& IDsOfElements,
- const SMESH::DirStruct& Vector)
- ;
+ const SMESH::DirStruct& Vector);
SMESH::ListOfGroups* TranslateObjectMakeGroups(SMESH::SMESH_IDSource_ptr Object,
- const SMESH::DirStruct& Vector)
- ;
+ const SMESH::DirStruct& Vector);
SMESH::ListOfGroups* RotateMakeGroups(const SMESH::long_array& IDsOfElements,
const SMESH::AxisStruct& Axis,
- CORBA::Double AngleInRadians)
- ;
+ CORBA::Double AngleInRadians);
SMESH::ListOfGroups* RotateObjectMakeGroups(SMESH::SMESH_IDSource_ptr Object,
const SMESH::AxisStruct& Axis,
- CORBA::Double AngleInRadians)
- ;
+ 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)
- ;
+ 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)
- ;
+ const char* MeshName);
SMESH::SMESH_Mesh_ptr TranslateMakeMesh(const SMESH::long_array& IDsOfElements,
const SMESH::DirStruct& Vector,
CORBA::Boolean CopyGroups,
- const char* MeshName)
- ;
+ const char* MeshName);
SMESH::SMESH_Mesh_ptr TranslateObjectMakeMesh(SMESH::SMESH_IDSource_ptr Object,
const SMESH::DirStruct& Vector,
CORBA::Boolean CopyGroups,
- const char* MeshName)
- ;
+ 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)
- ;
+ 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)
- ;
+ const char* MeshName);
void Scale(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::PointStruct& thePoint,
const SMESH::double_array& theScaleFact,
- CORBA::Boolean theCopy)
- ;
+ CORBA::Boolean theCopy);
SMESH::ListOfGroups* ScaleMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::PointStruct& thePoint,
- const SMESH::double_array& theScaleFact)
- ;
+ 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)
- ;
+ 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)
- ;
+ SMESH::ListOfGroups_out Groups);
void FindCoincidentNodes (CORBA::Double Tolerance,
SMESH::array_of_long_array_out GroupsOfNodes,
- CORBA::Boolean SeparateCornersAndMedium)
- ;
+ CORBA::Boolean SeparateCornersAndMedium);
void FindCoincidentNodesOnPart(SMESH::SMESH_IDSource_ptr Object,
CORBA::Double Tolerance,
SMESH::array_of_long_array_out GroupsOfNodes,
- CORBA::Boolean SeparateCornersAndMedium)
- ;
+ 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)
- ;
+ CORBA::Boolean SeparateCornersAndMedium);
void MergeNodes (const SMESH::array_of_long_array& GroupsOfNodes,
const SMESH::ListOfIDSources& NodesToKeep,
- CORBA::Boolean AvoidMakingHoles )
- ;
+ CORBA::Boolean AvoidMakingHoles );
void FindEqualElements(const SMESH::ListOfIDSources& Objects,
const SMESH::ListOfIDSources& ExceptSubMeshOrGroups,
- SMESH::array_of_long_array_out GroupsOfElementsID)
- ;
+ SMESH::array_of_long_array_out GroupsOfElementsID);
void MergeElements(const SMESH::array_of_long_array& GroupsOfElementsID,
- const SMESH::ListOfIDSources& ElementsToKeep)
- ;
- void MergeEqualElements()
- ;
+ const SMESH::ListOfIDSources& ElementsToKeep);
+ void MergeEqualElements();
CORBA::Long MoveClosestNodeToPoint(CORBA::Double x,
CORBA::Double y,
CORBA::Double z,
- CORBA::Long nodeID)
- ;
+ 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)
- ;
+ 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)
- ;
+ 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)
- ;
+ 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)
- ;
+ 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)
- ;
+ CORBA::Short GetPointState(CORBA::Double x, CORBA::Double y, CORBA::Double z);
/*!
* Check if a 2D mesh is manifold
*/
- CORBA::Boolean IsManifold()
- ;
+ CORBA::Boolean IsManifold();
/*!
* Check if orientation of 2D elements is coherent
*/
- CORBA::Boolean IsCoherentOrientation2D()
- ;
+ 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)
- ;
+ 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)
- ;
+ SMESH::ListOfEdges* FindSharpEdges(CORBA::Double angle, CORBA::Boolean addExisting);
/*!
* Returns all or only closed FreeBorder's.
*/
- SMESH::ListOfFreeBorders* FindFreeBorders(CORBA::Boolean closedOnly)
- ;
+ 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)
- ;
+ const char* groupName);
SMESH::CoincidentFreeBorders* FindCoincidentFreeBorders(CORBA::Double tolerance);
CORBA::Short SewCoincidentFreeBorders(const SMESH::CoincidentFreeBorders& freeBorders,
CORBA::Boolean createPolygons,
- CORBA::Boolean createPolyedrs)
- ;
+ CORBA::Boolean createPolyedrs);
SMESH::SMESH_MeshEditor::Sew_Error
SewFreeBorders(CORBA::Long FirstNodeID1,
CORBA::Long SecondNodeID2,
CORBA::Long LastNodeID2,
CORBA::Boolean CreatePolygons,
- CORBA::Boolean CreatePolyedrs) ;
+ CORBA::Boolean CreatePolyedrs);
SMESH::SMESH_MeshEditor::Sew_Error
SewConformFreeBorders(CORBA::Long FirstNodeID1,
CORBA::Long SecondNodeID1,
CORBA::Long LastNodeID1,
CORBA::Long FirstNodeID2,
- CORBA::Long SecondNodeID2) ;
+ 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) ;
+ 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) ;
+ 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)
- ;
+ CORBA::Boolean ChangeElemNodes(CORBA::Long ide, const SMESH::long_array& newIDs);
SMESH::SMESH_Group_ptr DoubleElements(SMESH::SMESH_IDSource_ptr theElements,
- const char* theGroupName)
- ;
+ const char* theGroupName);
CORBA::Boolean DoubleNodes( const SMESH::long_array& theNodes,
- const SMESH::long_array& theModifiedElems )
- ;
+ const SMESH::long_array& theModifiedElems );
CORBA::Boolean DoubleNode( CORBA::Long theNodeId,
- const SMESH::long_array& theModifiedElems )
- ;
+ const SMESH::long_array& theModifiedElems );
CORBA::Boolean DoubleNodeGroup( SMESH::SMESH_GroupBase_ptr theNodes,
- SMESH::SMESH_GroupBase_ptr theModifiedElems )
- ;
+ 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 )
- ;
+ SMESH::SMESH_GroupBase_ptr theModifiedElems );
CORBA::Boolean DoubleNodeGroups( const SMESH::ListOfGroups& theNodes,
- const SMESH::ListOfGroups& theModifiedElems )
- ;
+ const SMESH::ListOfGroups& theModifiedElems );
SMESH::SMESH_Group_ptr DoubleNodeGroupsNew( const SMESH::ListOfGroups& theNodes,
- const SMESH::ListOfGroups& theModifiedElems )
- ;
+ 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 )
- ;
+ 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 )
- ;
+ 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 )
- ;
+ 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 )
- ;
+ 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)
- ;
+ 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 )
- ;
+ 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 )
- ;
+ 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 )
- ;
+ 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)
- ;
+ 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 )
- ;
+ 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 )
- ;
+ 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 )
- ;
+ 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 )
- ;
+ 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)
- ;
+ 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()
- ;
+ 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)
- ;
+ 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)
- ;
+ 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)
- ;
+ 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)
- ;
+ CORBA::Double width);
private: //!< private methods
/*!
* \brief Return groups by their IDs
*/
- SMESH::ListOfGroups* getGroups(const std::list<int>* groupIDs)
- ;
+ 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)
- ;
+ ::SMESH_Mesh* TargetMesh=0);
SMESH::ListOfGroups* translate(TIDSortedElemSet & IDsOfElements,
const SMESH::DirStruct & Vector,
CORBA::Boolean Copy,
bool MakeGroups,
- ::SMESH_Mesh* TargetMesh=0)
- ;
+ ::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)
- ;
+ ::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)
- ;
+ ::SMESH_Mesh* theTargetMesh=0);
void convertToQuadratic(CORBA::Boolean theForce3d,
CORBA::Boolean theToBiQuad,
- SMESH::SMESH_IDSource_ptr theObject = SMESH::SMESH_IDSource::_nil())
- ;
+ 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 )
-
{
Unexpect aCatch(SALOME_SalomeException);
try {
//================================================================================
CORBA::Boolean SMESH_Mesh_i::HasShapeToMesh()
-
{
Unexpect aCatch(SALOME_SalomeException);
bool res = false;
//================================================================================
GEOM::GEOM_Object_ptr SMESH_Mesh_i::GetShapeToMesh()
-
{
Unexpect aCatch(SALOME_SalomeException);
GEOM::GEOM_Object_var aShapeObj;
*/
//================================================================================
-CORBA::Boolean SMESH_Mesh_i::IsLoaded()
+CORBA::Boolean SMESH_Mesh_i::IsLoaded()
{
Unexpect aCatch(SALOME_SalomeException);
return !_preMeshInfo;
*/
//================================================================================
-void SMESH_Mesh_i::Load()
+void SMESH_Mesh_i::Load()
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
*/
//================================================================================
-void SMESH_Mesh_i::Clear()
+void SMESH_Mesh_i::Clear()
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
//================================================================================
void SMESH_Mesh_i::ClearSubMesh(CORBA::Long ShapeID)
-
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
SMESH::DriverMED_ReadStatus SMESH_Mesh_i::ImportCGNSFile( const char* theFileName,
const int theMeshIndex,
std::string& theMeshName )
-
{
Unexpect aCatch(SALOME_SalomeException);
int status;
//=============================================================================
int SMESH_Mesh_i::ImportUNVFile( const char* theFileName )
-
{
SMESH_TRY;
//=============================================================================
int SMESH_Mesh_i::ImportSTLFile( const char* theFileName )
-
{
SMESH_TRY;
SMESH::ComputeError* SMESH_Mesh_i::ImportGMFFile( const char* theFileName,
bool theMakeRequiredGroups )
-
{
SMESH_ComputeErrorPtr error;
SMESH_Mesh_i::AddHypothesis(GEOM::GEOM_Object_ptr aSubShape,
SMESH::SMESH_Hypothesis_ptr anHyp,
CORBA::String_out anErrorText)
-
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
SMESH::Hypothesis_Status SMESH_Mesh_i::RemoveHypothesis(GEOM::GEOM_Object_ptr aSubShape,
SMESH::SMESH_Hypothesis_ptr anHyp)
-
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
SMESH::ListOfHypothesis *
SMESH_Mesh_i::GetHypothesisList(GEOM::GEOM_Object_ptr aSubShape)
-
{
Unexpect aCatch(SALOME_SalomeException);
if (MYDEBUG) MESSAGE("GetHypothesisList");
*/
//================================================================================
-SMESH::submesh_array* SMESH_Mesh_i::GetSubMeshes()
+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 )
-
{
Unexpect aCatch(SALOME_SalomeException);
if (CORBA::is_nil(aSubShape))
//================================================================================
void SMESH_Mesh_i::RemoveSubMesh( SMESH::SMESH_subMesh_ptr theSubMesh )
-
{
SMESH_TRY;
SMESH::SMESH_Group_ptr SMESH_Mesh_i::CreateGroup( SMESH::ElementType theElemType,
const char* theName )
-
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
SMESH_Mesh_i::CreateGroupFromGEOM (SMESH::ElementType theElemType,
const char* theName,
GEOM::GEOM_Object_ptr theGeomObj)
-
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
SMESH_Mesh_i::CreateGroupFromFilter(SMESH::ElementType theElemType,
const char* theName,
SMESH::Filter_ptr theFilter )
-
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
//================================================================================
void SMESH_Mesh_i::RemoveGroup( SMESH::SMESH_GroupBase_ptr theGroup )
-
{
if ( theGroup->_is_nil() )
return;
//=============================================================================
void SMESH_Mesh_i::RemoveGroupWithContents( SMESH::SMESH_GroupBase_ptr theGroup )
-
{
SMESH_TRY;
if ( _preMeshInfo )
*/
//================================================================================
-SMESH::ListOfGroups * SMESH_Mesh_i::GetGroups()
+SMESH::ListOfGroups * SMESH_Mesh_i::GetGroups()
{
Unexpect aCatch(SALOME_SalomeException);
if (MYDEBUG) MESSAGE("GetGroups");
*/
//=============================================================================
-CORBA::Long SMESH_Mesh_i::NbGroups()
+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 )
-
{
SMESH::SMESH_Group_var aResGrp;
SMESH::SMESH_Group_ptr SMESH_Mesh_i::UnionListOfGroups(const SMESH::ListOfGroups& theGroups,
const char* theName )
-
{
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 )
-
{
SMESH::SMESH_Group_var aResGrp;
SMESH::SMESH_Group_ptr
SMESH_Mesh_i::IntersectListOfGroups(const SMESH::ListOfGroups& theGroups,
const char* theName )
-
{
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 )
-
{
SMESH::SMESH_Group_var aResGrp;
SMESH_Mesh_i::CutListOfGroups(const SMESH::ListOfGroups& theMainGroups,
const SMESH::ListOfGroups& theToolGroups,
const char* theName )
-
{
SMESH::SMESH_Group_var aResGrp;
const char* theName,
SMESH::NB_COMMON_NODES_ENUM theNbCommonNodes,
CORBA::Boolean theUnderlyingOnly)
-
{
SMESH::SMESH_Group_var aResGrp;
SMESH_Mesh_i::FaceGroupsSeparatedByEdges( CORBA::Double theSharpAngle,
CORBA::Boolean theCreateEdges,
CORBA::Boolean theUseExistingEdges )
-
{
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)
-
{
// check if geometry changed
bool geomChanged = true;
//=============================================================================
SMESH::SMESH_Group_ptr SMESH_Mesh_i::ConvertToStandalone( SMESH::SMESH_GroupBase_ptr theGroup )
-
{
SMESH::SMESH_Group_var aGroup;
//================================================================================
SMESH::log_array * SMESH_Mesh_i::GetLog(CORBA::Boolean clearAfterGet)
-
{
SMESH::log_array_var aLog;
*/
//================================================================================
-void SMESH_Mesh_i::ClearLog()
+void SMESH_Mesh_i::ClearLog()
{
SMESH_TRY;
_impl->ClearLog();
//=============================================================================
SMESH::SMESH_MeshEditor_ptr SMESH_Mesh_i::GetMeshEditor()
-
{
SMESH::SMESH_MeshEditor_var aMeshEdVar;
//=============================================================================
SMESH::SMESH_MeshEditor_ptr SMESH_Mesh_i::GetMeshEditPreviewer()
-
{
SMESH::SMESH_MeshEditor_var aMeshEdVar;
*/
//================================================================================
-CORBA::Boolean SMESH_Mesh_i::HasModificationsToDiscard()
+CORBA::Boolean SMESH_Mesh_i::HasModificationsToDiscard()
{
Unexpect aCatch(SALOME_SalomeException);
return _impl->HasModificationsToDiscard();
*/
//=============================================================================
-void SMESH_Mesh_i::SetAutoColor(CORBA::Boolean theAutoColor)
+void SMESH_Mesh_i::SetAutoColor(CORBA::Boolean theAutoColor)
{
Unexpect aCatch(SALOME_SalomeException);
_impl->SetAutoColor(theAutoColor);
*/
//=============================================================================
-CORBA::Boolean SMESH_Mesh_i::GetAutoColor()
+CORBA::Boolean SMESH_Mesh_i::GetAutoColor()
{
Unexpect aCatch(SALOME_SalomeException);
return _impl->GetAutoColor();
CORBA::Long version,
CORBA::Boolean overwrite,
CORBA::Boolean autoDimension)
-
{
//MESSAGE("MED minor version: "<< minor);
SMESH_TRY;
void SMESH_Mesh_i::ExportSAUV (const char* file,
CORBA::Boolean auto_groups)
-
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
//================================================================================
void SMESH_Mesh_i::ExportDAT (const char *file)
-
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
//================================================================================
void SMESH_Mesh_i::ExportUNV (const char *file)
-
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
//================================================================================
void SMESH_Mesh_i::ExportSTL (const char *file, const bool isascii)
-
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
const GEOM::ListOfFields& fields,
const char* geomAssocFields,
CORBA::Double ZTolerance)
-
{
MESSAGE("MED version: "<< version);
SMESH_TRY;
void SMESH_Mesh_i::ExportPartToDAT(::SMESH::SMESH_IDSource_ptr meshPart,
const char* file)
-
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
void SMESH_Mesh_i::ExportPartToUNV(::SMESH::SMESH_IDSource_ptr meshPart,
const char* file)
-
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
void SMESH_Mesh_i::ExportPartToSTL(::SMESH::SMESH_IDSource_ptr meshPart,
const char* file,
::CORBA::Boolean isascii)
-
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
const char* file,
CORBA::Boolean overwrite,
CORBA::Boolean groupElemsByType)
-
{
#ifdef WITH_CGNS
Unexpect aCatch(SALOME_SalomeException);
void SMESH_Mesh_i::ExportGMF(::SMESH::SMESH_IDSource_ptr meshPart,
const char* file,
bool withRequiredGroups)
-
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
*/
//================================================================================
-CORBA::Long SMESH_Mesh_i::NbBalls()
+CORBA::Long SMESH_Mesh_i::NbBalls()
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
//================================================================================
CORBA::Long SMESH_Mesh_i::NbEdgesOfOrder(SMESH::ElementOrder order)
-
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
return _impl->NbBiQuadQuadrangles();
}
-CORBA::Long SMESH_Mesh_i::NbPolygons()
+CORBA::Long SMESH_Mesh_i::NbPolygons()
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
return _impl->NbPolygons();
}
-CORBA::Long SMESH_Mesh_i::NbPolygonsOfOrder(SMESH::ElementOrder order)
+CORBA::Long SMESH_Mesh_i::NbPolygonsOfOrder(SMESH::ElementOrder order)
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
}
CORBA::Long SMESH_Mesh_i::NbFacesOfOrder(SMESH::ElementOrder order)
-
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
}
CORBA::Long SMESH_Mesh_i::NbTrianglesOfOrder(SMESH::ElementOrder order)
-
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
}
CORBA::Long SMESH_Mesh_i::NbQuadranglesOfOrder(SMESH::ElementOrder order)
-
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
}
CORBA::Long SMESH_Mesh_i::NbVolumesOfOrder(SMESH::ElementOrder order)
-
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
}
CORBA::Long SMESH_Mesh_i::NbTetrasOfOrder(SMESH::ElementOrder order)
-
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
}
CORBA::Long SMESH_Mesh_i::NbHexasOfOrder(SMESH::ElementOrder order)
-
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
}
CORBA::Long SMESH_Mesh_i::NbPyramidsOfOrder(SMESH::ElementOrder order)
-
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
}
CORBA::Long SMESH_Mesh_i::NbPrismsOfOrder(SMESH::ElementOrder order)
-
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
//=============================================================================
SMESH::long_array* SMESH_Mesh_i::GetElementsId()
-
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
//=============================================================================
SMESH::long_array* SMESH_Mesh_i::GetElementsByType( SMESH::ElementType theElemType )
-
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
//=============================================================================
SMESH::long_array* SMESH_Mesh_i::GetNodesId()
-
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
//=============================================================================
SMESH::ElementType SMESH_Mesh_i::GetElementType( const CORBA::Long id, const bool iselem )
-
{
SMESH::ElementType type = SMESH::ALL;
SMESH_TRY;
//=============================================================================
SMESH::EntityType SMESH_Mesh_i::GetElementGeomType( const CORBA::Long id )
-
{
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
//=============================================================================
SMESH::GeometryType SMESH_Mesh_i::GetElementShape( const CORBA::Long id )
-
{
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
//=============================================================================
SMESH::long_array* SMESH_Mesh_i::GetSubMeshElementsId(const CORBA::Long ShapeID)
-
{
SMESH::long_array_var aResult = new SMESH::long_array();
SMESH::long_array* SMESH_Mesh_i::GetSubMeshNodesId(const CORBA::Long ShapeID,
CORBA::Boolean all)
-
{
SMESH::long_array_var aResult = new SMESH::long_array();
//=============================================================================
SMESH::ElementType SMESH_Mesh_i::GetSubMeshElementType(const CORBA::Long ShapeID)
-
{
SMESH::ElementType type = SMESH::ALL;
SMESH::ListOfGroups*
SMESH_Mesh_i::MakeGroupsOfBadInputElements( int theSubShapeID,
const char* theGroupName )
-
{
Unexpect aCatch(SALOME_SalomeException);
// --- CORBA
- void SetShape( GEOM::GEOM_Object_ptr theShapeObject )
- ;
+ void SetShape( GEOM::GEOM_Object_ptr theShapeObject );
- CORBA::Boolean HasShapeToMesh()
- ;
+ CORBA::Boolean HasShapeToMesh();
- GEOM::GEOM_Object_ptr GetShapeToMesh()
- ;
+ GEOM::GEOM_Object_ptr GetShapeToMesh();
- virtual void ReplaceShape(GEOM::GEOM_Object_ptr theNewGeom)
- ;
+ virtual void ReplaceShape(GEOM::GEOM_Object_ptr theNewGeom);
- CORBA::Boolean IsLoaded()
- ;
+ CORBA::Boolean IsLoaded();
- void Load()
- ;
+ void Load();
- void Clear()
- ;
+ void Clear();
- void ClearSubMesh(CORBA::Long ShapeID)
- ;
+ void ClearSubMesh(CORBA::Long ShapeID);
SMESH::Hypothesis_Status AddHypothesis(GEOM::GEOM_Object_ptr aSubShape,
SMESH::SMESH_Hypothesis_ptr anHyp,
- CORBA::String_out anErrorText)
- ;
+ CORBA::String_out anErrorText);
SMESH::Hypothesis_Status RemoveHypothesis(GEOM::GEOM_Object_ptr aSubShape,
- SMESH::SMESH_Hypothesis_ptr anHyp)
- ;
+ SMESH::SMESH_Hypothesis_ptr anHyp);
- SMESH::ListOfHypothesis* GetHypothesisList(GEOM::GEOM_Object_ptr aSubShape)
- ;
+ SMESH::ListOfHypothesis* GetHypothesisList(GEOM::GEOM_Object_ptr aSubShape);
- SMESH::submesh_array* GetSubMeshes()
- ;
+ SMESH::submesh_array* GetSubMeshes();
- SMESH::SMESH_subMesh_ptr GetSubMesh(GEOM::GEOM_Object_ptr aSubShape, const char* theName)
- ;
+ SMESH::SMESH_subMesh_ptr GetSubMesh(GEOM::GEOM_Object_ptr aSubShape, const char* theName);
- void RemoveSubMesh( SMESH::SMESH_subMesh_ptr theSubMesh )
- ;
+ void RemoveSubMesh( SMESH::SMESH_subMesh_ptr theSubMesh );
- SMESH::SMESH_Group_ptr CreateGroup( SMESH::ElementType theElemType, const char* theName )
- ;
+ 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 )
- ;
+ GEOM::GEOM_Object_ptr theGeomObj );
SMESH::SMESH_GroupOnFilter_ptr CreateGroupFromFilter(SMESH::ElementType theElemType,
const char* theName,
- SMESH::Filter_ptr theFilter )
- ;
+ SMESH::Filter_ptr theFilter );
- void RemoveGroup( SMESH::SMESH_GroupBase_ptr theGroup )
- ;
+ void RemoveGroup( SMESH::SMESH_GroupBase_ptr theGroup );
- void RemoveGroupWithContents( SMESH::SMESH_GroupBase_ptr theGroup )
- ;
+ void RemoveGroupWithContents( SMESH::SMESH_GroupBase_ptr theGroup );
- SMESH::ListOfGroups* GetGroups()
- ;
+ SMESH::ListOfGroups* GetGroups();
- CORBA::Long NbGroups()
- ;
+ CORBA::Long NbGroups();
SMESH::SMESH_Group_ptr UnionGroups( SMESH::SMESH_GroupBase_ptr theGroup1,
SMESH::SMESH_GroupBase_ptr theGroup2,
- const char* theName )
- ;
+ const char* theName );
SMESH::SMESH_Group_ptr UnionListOfGroups( const SMESH::ListOfGroups& theGroups,
- const char* theName)
- ;
+ const char* theName);
SMESH::SMESH_Group_ptr IntersectGroups( SMESH::SMESH_GroupBase_ptr theGroup1,
SMESH::SMESH_GroupBase_ptr theGroup2,
- const char* theName )
- ;
+ const char* theName );
SMESH::SMESH_Group_ptr IntersectListOfGroups( const SMESH::ListOfGroups& theGroups,
- const char* theName )
- ;
+ const char* theName );
SMESH::SMESH_Group_ptr CutGroups( SMESH::SMESH_GroupBase_ptr theGroup1,
SMESH::SMESH_GroupBase_ptr theGroup2,
- const char* theName )
- ;
+ const char* theName );
SMESH::SMESH_Group_ptr CutListOfGroups( const SMESH::ListOfGroups& theMainGroups,
const SMESH::ListOfGroups& theToolGroups,
- const char* theName )
- ;
+ 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 )
- ;
+ CORBA::Boolean theUnderlyingOnly );
SMESH::ListOfGroups* FaceGroupsSeparatedByEdges( CORBA::Double theSharpAngle,
CORBA::Boolean theCreateEdges,
- CORBA::Boolean theUseExistingEdges )
- ;
+ CORBA::Boolean theUseExistingEdges );
- SMESH::SMESH_Group_ptr ConvertToStandalone( SMESH::SMESH_GroupBase_ptr theGroupOn )
- ;
+ SMESH::SMESH_Group_ptr ConvertToStandalone( SMESH::SMESH_GroupBase_ptr theGroupOn );
- SMESH::log_array* GetLog(CORBA::Boolean clearAfterGet)
- ;
+ SMESH::log_array* GetLog(CORBA::Boolean clearAfterGet);
- SMESH::SMESH_MeshEditor_ptr GetMeshEditor() ;
+ SMESH::SMESH_MeshEditor_ptr GetMeshEditor();
- SMESH::SMESH_MeshEditor_ptr GetMeshEditPreviewer() ;
+ SMESH::SMESH_MeshEditor_ptr GetMeshEditPreviewer();
- CORBA::Boolean HasModificationsToDiscard() ;
+ CORBA::Boolean HasModificationsToDiscard();
- void ClearLog() ;
+ void ClearLog();
- CORBA::Long GetId() ;
+ CORBA::Long GetId();
// --- C++ interface
SMESH_Gen_i* GetGen() { return _gen_i; }
- int ImportUNVFile( const char* theFileName )
- ;
+ int ImportUNVFile( const char* theFileName );
- int ImportSTLFile( const char* theFileName )
- ;
+ int ImportSTLFile( const char* theFileName );
SMESH::ComputeError* ImportGMFFile( const char* theFileName,
- bool theMakeRequiredGroups)
- ;
+ bool theMakeRequiredGroups);
/*!
* consult DriverMED_R_SMESHDS_Mesh::ReadStatus for returned value
*/
- SMESH::DriverMED_ReadStatus ImportMEDFile( const char* theFileName, const char* theMeshName )
- ;
+ SMESH::DriverMED_ReadStatus ImportMEDFile( const char* theFileName, const char* theMeshName );
SMESH::DriverMED_ReadStatus ImportCGNSFile( const char* theFileName,
const int theMeshIndex,
- std::string& theMeshName)
- ;
+ std::string& theMeshName);
/*!
* Auto color
*/
- void SetAutoColor(CORBA::Boolean theAutoColor)
- ;
+ void SetAutoColor(CORBA::Boolean theAutoColor);
- CORBA::Boolean GetAutoColor()
- ;
+ 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) ;
+ CORBA::Boolean autoDimension = true);
- void ExportSAUV( const char* file, CORBA::Boolean auto_groups ) ;
+ void ExportSAUV( const char* file, CORBA::Boolean auto_groups );
- void ExportDAT( const char* file ) ;
- void ExportUNV( const char* file ) ;
- void ExportSTL( const char* file, bool isascii ) ;
+ 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) ;
+ CORBA::Boolean groupElemsByType);
void ExportGMF(SMESH::SMESH_IDSource_ptr meshPart,
const char* file,
- CORBA::Boolean withRequiredGroups) ;
+ 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) ;
+ CORBA::Double ZTolerance);
void ExportPartToDAT(SMESH::SMESH_IDSource_ptr meshPart,
- const char* file) ;
+ const char* file);
void ExportPartToUNV(SMESH::SMESH_IDSource_ptr meshPart,
- const char* file) ;
+ const char* file);
void ExportPartToSTL(SMESH::SMESH_IDSource_ptr meshPart,
const char* file,
- CORBA::Boolean isascii) ;
+ CORBA::Boolean isascii);
CORBA::Double GetComputeProgress();
- CORBA::Long NbNodes()
- ;
+ CORBA::Long NbNodes();
- CORBA::Long NbElements()
- ;
+ CORBA::Long NbElements();
- CORBA::Long Nb0DElements()
- ;
+ CORBA::Long Nb0DElements();
- CORBA::Long NbBalls()
- ;
+ CORBA::Long NbBalls();
- CORBA::Long NbEdges()
- ;
+ CORBA::Long NbEdges();
- CORBA::Long NbEdgesOfOrder(SMESH::ElementOrder order)
- ;
+ CORBA::Long NbEdgesOfOrder(SMESH::ElementOrder order);
- CORBA::Long NbFaces()
- ;
+ CORBA::Long NbFaces();
- CORBA::Long NbFacesOfOrder(SMESH::ElementOrder order)
- ;
+ CORBA::Long NbFacesOfOrder(SMESH::ElementOrder order);
- CORBA::Long NbTriangles()
- ;
+ CORBA::Long NbTriangles();
- CORBA::Long NbTrianglesOfOrder(SMESH::ElementOrder order)
- ;
+ CORBA::Long NbTrianglesOfOrder(SMESH::ElementOrder order);
- CORBA::Long NbBiQuadTriangles()
- ;
+ CORBA::Long NbBiQuadTriangles();
- CORBA::Long NbQuadrangles()
- ;
+ CORBA::Long NbQuadrangles();
- CORBA::Long NbQuadranglesOfOrder(SMESH::ElementOrder order)
- ;
+ CORBA::Long NbQuadranglesOfOrder(SMESH::ElementOrder order);
- CORBA::Long NbBiQuadQuadrangles()
- ;
+ CORBA::Long NbBiQuadQuadrangles();
- CORBA::Long NbPolygons()
- ;
+ CORBA::Long NbPolygons();
- CORBA::Long NbPolygonsOfOrder(SMESH::ElementOrder order = SMESH::ORDER_ANY)
- ;
+ CORBA::Long NbPolygonsOfOrder(SMESH::ElementOrder order = SMESH::ORDER_ANY);
- CORBA::Long NbVolumes()
- ;
+ CORBA::Long NbVolumes();
- CORBA::Long NbVolumesOfOrder(SMESH::ElementOrder order)
- ;
+ CORBA::Long NbVolumesOfOrder(SMESH::ElementOrder order);
- CORBA::Long NbTetras()
- ;
+ CORBA::Long NbTetras();
- CORBA::Long NbTetrasOfOrder(SMESH::ElementOrder order)
- ;
+ CORBA::Long NbTetrasOfOrder(SMESH::ElementOrder order);
- CORBA::Long NbHexas()
- ;
+ CORBA::Long NbHexas();
- CORBA::Long NbHexasOfOrder(SMESH::ElementOrder order)
- ;
+ CORBA::Long NbHexasOfOrder(SMESH::ElementOrder order);
- CORBA::Long NbTriQuadraticHexas()
- ;
+ CORBA::Long NbTriQuadraticHexas();
- CORBA::Long NbPyramids()
- ;
+ CORBA::Long NbPyramids();
- CORBA::Long NbPyramidsOfOrder(SMESH::ElementOrder order)
- ;
+ CORBA::Long NbPyramidsOfOrder(SMESH::ElementOrder order);
- CORBA::Long NbPrisms()
- ;
+ CORBA::Long NbPrisms();
- CORBA::Long NbPrismsOfOrder(SMESH::ElementOrder order)
- ;
+ CORBA::Long NbPrismsOfOrder(SMESH::ElementOrder order);
- CORBA::Long NbHexagonalPrisms()
- ;
+ CORBA::Long NbHexagonalPrisms();
- CORBA::Long NbPolyhedrons()
- ;
+ CORBA::Long NbPolyhedrons();
- CORBA::Long NbSubMesh()
- ;
+ CORBA::Long NbSubMesh();
- SMESH::long_array* GetElementsId()
- ;
+ SMESH::long_array* GetElementsId();
- SMESH::long_array* GetElementsByType( SMESH::ElementType theElemType )
- ;
+ SMESH::long_array* GetElementsByType( SMESH::ElementType theElemType );
- SMESH::long_array* GetNodesId()
- ;
+ SMESH::long_array* GetNodesId();
- SMESH::ElementType GetElementType( CORBA::Long id, bool iselem )
- ;
+ SMESH::ElementType GetElementType( CORBA::Long id, bool iselem );
- SMESH::EntityType GetElementGeomType( CORBA::Long id )
- ;
+ SMESH::EntityType GetElementGeomType( CORBA::Long id );
- SMESH::GeometryType GetElementShape( CORBA::Long id )
- ;
+ SMESH::GeometryType GetElementShape( CORBA::Long id );
/*!
* Returns ID of elements for given submesh
*/
- SMESH::long_array* GetSubMeshElementsId(CORBA::Long ShapeID)
- ;
+ 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)
- ;
+ SMESH::long_array* GetSubMeshNodesId(CORBA::Long ShapeID, CORBA::Boolean all);
/*!
* Returns type of elements for given submesh
*/
- SMESH::ElementType GetSubMeshElementType(CORBA::Long ShapeID)
- ;
+ 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)
- ;
+ const char* theGroupName);
// ===================================================
// Internal methods not available through CORBA
//=============================================================================
CORBA::Long SMESH_subMesh_i::GetNumberOfElements()
-
{
Unexpect aCatch(SALOME_SalomeException);
//=============================================================================
CORBA::Long SMESH_subMesh_i::GetNumberOfNodes(CORBA::Boolean all)
-
{
Unexpect aCatch(SALOME_SalomeException);
//=============================================================================
SMESH::long_array* SMESH_subMesh_i::GetElementsId()
-
{
Unexpect aCatch(SALOME_SalomeException);
//=============================================================================
SMESH::long_array* SMESH_subMesh_i::GetElementsByType( SMESH::ElementType theElemType )
-
{
Unexpect aCatch(SALOME_SalomeException);
//=============================================================================
SMESH::long_array* SMESH_subMesh_i::GetNodesId()
-
{
Unexpect aCatch(SALOME_SalomeException);
//=============================================================================
SMESH::SMESH_Mesh_ptr SMESH_subMesh_i::GetFather()
-
{
Unexpect aCatch(SALOME_SalomeException);
return _mesh_i->_this();
//=======================================================================
GEOM::GEOM_Object_ptr SMESH_subMesh_i::GetSubShape()
-
{
Unexpect aCatch(SALOME_SalomeException);
GEOM::GEOM_Object_var aShapeObj;
*/
//=============================================================================
SMESH::ElementType SMESH_subMesh_i::GetElementType( const CORBA::Long id, const bool iselem )
-
{
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
//=======================================================================
GEOM::GEOM_Object_ptr SMESH_Invalid_subMesh_i::GetSubShape()
-
{
return GEOM::GEOM_Object::_duplicate( _geom );
}
int localId );
~SMESH_subMesh_i();
- CORBA::Long GetNumberOfElements()
- ;
+ CORBA::Long GetNumberOfElements();
- CORBA::Long GetNumberOfNodes( CORBA::Boolean all )
- ;
+ CORBA::Long GetNumberOfNodes( CORBA::Boolean all );
- SMESH::long_array* GetElementsId()
- ;
+ SMESH::long_array* GetElementsId();
- SMESH::long_array* GetElementsByType( SMESH::ElementType theElemType )
- ;
+ SMESH::long_array* GetElementsByType( SMESH::ElementType theElemType );
- SMESH::ElementType GetElementType( CORBA::Long id, bool iselem )
- ;
+ SMESH::ElementType GetElementType( CORBA::Long id, bool iselem );
- SMESH::long_array* GetNodesId()
- ;
+ SMESH::long_array* GetNodesId();
- SMESH::SMESH_Mesh_ptr GetFather()
- ;
+ SMESH::SMESH_Mesh_ptr GetFather();
- GEOM::GEOM_Object_ptr GetSubShape()
- ;
+ GEOM::GEOM_Object_ptr GetSubShape();
CORBA::Long GetId();
int localId,
GEOM::GEOM_Object_ptr shape);
- virtual GEOM::GEOM_Object_ptr GetSubShape()
- ;
+ virtual GEOM::GEOM_Object_ptr GetSubShape();
protected:
/*!
* Sets minimal allowed segment length
*/
- void SetMinSize( double minSegLen ) ;
+ void SetMinSize( double minSegLen );
double GetMinSize() const { return myMinSize; }
/*!
* Sets maximal allowed segment length
*/
- void SetMaxSize( double maxSegLen ) ;
+ 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) ;
+ void SetDeflection(double value);
double GetDeflection() const { return myDeflection; }
virtual std::ostream & SaveTo(std::ostream & save);
StdMeshers_Arithmetic1D(int hypId, SMESH_Gen* gen);
virtual ~StdMeshers_Arithmetic1D();
- void SetLength(double length, bool isStartLength) ;
+ void SetLength(double length, bool isStartLength);
double GetLength(bool isStartLength) const;
const double theFineConst = 4.5;
void StdMeshers_AutomaticLength::SetFineness(double theFineness)
-
{
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)
-
{
if ( !theMesh ) throw SALOME_Exception(LOCALIZED("NULL Mesh"));
double StdMeshers_AutomaticLength::GetLength(const SMESH_Mesh* theMesh,
const TopoDS_Shape& anEdge)
-
{
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)
- ;
+ 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)
- ;
+ 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)
- ;
+ void SetFineness(double theFineness);
/*!
* \brief Return mesh Fineness
void checkGridSpacing(std::vector<std::string>& spaceFunctions,
std::vector<double>& internalPoints,
const std::string& axis)
-
{
if ( spaceFunctions.empty() )
throw SALOME_Exception(SMESH_Comment("Empty space function for ") << axis );
//=======================================================================
void StdMeshers_CartesianParameters3D::SetGrid(std::vector<double>& coords, int axis)
-
{
checkAxis( axis );
void StdMeshers_CartesianParameters3D::SetGridSpacing(std::vector<string>& xSpaceFuns,
std::vector<double>& xInternalPoints,
const int axis)
-
{
checkAxis( axis );
//=======================================================================
void StdMeshers_CartesianParameters3D::SetSizeThreshold(const double threshold)
-
{
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
-
{
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
-
{
checkAxis(axis);
return !_spaceFunctions[axis].empty();
vector<double>& coords,
const string& axis,
const double* xForced )
-
{
checkGridSpacing( theSpaceFuns, thePoints, axis );
std::vector<double>& yNodes,
std::vector<double>& zNodes,
const Bnd_Box& bndBox) const
-
{
double x0,y0,z0, x1,y1,z1;
if ( IsGridBySpacing(0) || IsGridBySpacing(1) || IsGridBySpacing(2))
//=======================================================================
void StdMeshers_CartesianParameters3D::SetAxisDirs(const double* the9DirComps)
-
{
gp_Vec x( the9DirComps[0],
the9DirComps[1],
//=======================================================================
void StdMeshers_CartesianParameters3D::GetGrid(std::vector<double>& coords, int axis) const
-
{
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) ;
+ 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 ;
+ 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) ;
+ const int axis);
void GetGridSpacing(std::vector<std::string>& spaceFunctions,
std::vector<double>& internalPoints,
- const int axis) const ;
+ const int axis) const;
- bool IsGridBySpacing(const int axis) const ;
+ 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) ;
+ 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 ;
+ const Bnd_Box& bndBox) const;
/*!
* \brief Set custom direction of axes
*/
- void SetAxisDirs(const double* the9DirComps) ;
+ 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) ;
+ void SetSizeThreshold(const double threshold);
/*!
* \brief Return size threshold
*/
StdMeshers_Deflection1D(int hypId, SMESH_Gen * gen);
virtual ~ StdMeshers_Deflection1D();
- void SetDeflection(double value) ;
+ void SetDeflection(double value);
double GetDeflection() const;
//=============================================================================
void StdMeshers_FixedPoints1D::SetPoints(const std::vector<double>& listParams)
-
{
_params = listParams;
NotifySubMeshesHypothesisModification();
//=============================================================================
void StdMeshers_FixedPoints1D::SetNbSegments(const std::vector<int>& listNbSeg)
-
{
_nbsegs = listNbSeg;
NotifySubMeshesHypothesisModification();
StdMeshers_FixedPoints1D(int hypId, SMESH_Gen* gen);
virtual ~StdMeshers_FixedPoints1D();
- void SetPoints(const std::vector<double>& listParams)
- ;
+ void SetPoints(const std::vector<double>& listParams);
- void SetNbSegments(const std::vector<int>& listNbSeg)
- ;
+ void SetNbSegments(const std::vector<int>& listNbSeg) ;
const std::vector<double>& GetPoints() const { return _params; }
public:
StdMeshers_Geometric1D(int hypId, SMESH_Gen* gen);
- void SetStartLength(double length) ;
- void SetCommonRatio(double factor) ;
+ void SetStartLength(double length);
+ void SetCommonRatio(double factor);
double GetStartLength() const;
double GetCommonRatio() const;
* \brief Sets 1D hypothesis specifying distribution of layers
* \param hyp1D - 1D hypothesis
*/
- void SetLayerDistribution(SMESH_Hypothesis* hyp1D)
- ;
+ void SetLayerDistribution(SMESH_Hypothesis* hyp1D);
/*!
* \brief Returns 1D hypothesis specifying distribution of layers
*/
//=============================================================================
-void StdMeshers_LocalLength::SetLength(double length)
+void StdMeshers_LocalLength::SetLength(double length)
{
double oldLength = _length;
if (length <= 0)
*
*/
//=============================================================================
-void StdMeshers_LocalLength::SetPrecision (double thePrecision)
+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) ;
- void SetPrecision(double precision) ;
+ void SetLength(double length);
+ void SetPrecision(double precision);
double GetLength() const;
double GetPrecision() const;
std::vector< const SMDS_MeshNode*>& mefistoToDS,
double scalex, double scaley);
- void ComputeScaleOnFace(SMESH_Mesh& /*aMesh*/,
+ void ComputeScaleOnFace(SMESH_Mesh& aMesh,
const TopoDS_Face& aFace,
double& scalex,
double& scaley);
StdMeshers_MaxLength(int hypId, SMESH_Gen * gen);
virtual ~ StdMeshers_MaxLength();
- void SetLength(double length) ;
+ void SetLength(double length);
double GetLength() const;
bool HavePreestimatedLength() const { return _preestimated > 0.; }
virtual std::ostream & SaveTo(std::ostream & save);
virtual std::istream & LoadFrom(std::istream & load);
- friend std::ostream & operator << (std::ostream & save, StdMeshers_NotConformAllowed & /*hyp*/);
- friend std::istream & operator >> (std::istream & load, StdMeshers_NotConformAllowed & /*hyp*/);
+ friend std::ostream & operator << (std::ostream & save, StdMeshers_NotConformAllowed & hyp);
+ friend std::istream & operator >> (std::istream & load, StdMeshers_NotConformAllowed & hyp);
/*!
* \brief Initialize my parameter values by the mesh built on the geometry
virtual ~StdMeshers_NumberOfLayers();
// Sets <number of segments> parameter value
- void SetNumberOfLayers(int numberOfLayers) ;
+ 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 )
-
{
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 )
-
{
if( !buildDistribution( tab, conv, 0.0, 1.0, nbSeg, _distr, 1E-4 ) )
_distr.resize( 0 );
//=============================================================================
void StdMeshers_NumberOfSegments::SetNumberOfSegments(int segmentsNumber)
-
{
int oldNumberOfSegments = _numberOfSegments;
if (segmentsNumber <= 0)
//================================================================================
void StdMeshers_NumberOfSegments::SetDistrType(DistrType typ)
-
{
if (typ < DT_Regular || typ > DT_ExprFunc)
throw SALOME_Exception(LOCALIZED("distribution type is out of range"));
//================================================================================
void StdMeshers_NumberOfSegments::SetScaleFactor(double scaleFactor)
-
{
if (scaleFactor < PRECISION)
throw SALOME_Exception(LOCALIZED("scale factor must be positive"));
//================================================================================
double StdMeshers_NumberOfSegments::GetScaleFactor() const
-
{
if (_distrType != DT_Scale)
throw SALOME_Exception(LOCALIZED("not a scale distribution"));
//================================================================================
void StdMeshers_NumberOfSegments::SetTableFunction(const vector<double>& table)
-
{
if (_distrType != DT_TabFunc)
_distrType = DT_TabFunc;
//================================================================================
const vector<double>& StdMeshers_NumberOfSegments::GetTableFunction() const
-
{
if (_distrType != DT_TabFunc)
throw SALOME_Exception(LOCALIZED("not a table function distribution"));
//================================================================================
void StdMeshers_NumberOfSegments::SetExpressionFunction(const char* expr)
-
{
if (_distrType != DT_ExprFunc)
_distrType = DT_ExprFunc;
std::string
StdMeshers_NumberOfSegments::CheckExpressionFunction( const std::string& expr,
const int convMode)
-
{
// remove white spaces
TCollection_AsciiString str((Standard_CString)expr.c_str());
//================================================================================
const char* StdMeshers_NumberOfSegments::GetExpressionFunction() const
-
{
if (_distrType != DT_ExprFunc)
throw SALOME_Exception(LOCALIZED("not an expression function distribution"));
//================================================================================
void StdMeshers_NumberOfSegments::SetConversionMode( int conv )
-
{
// if (_distrType != DT_TabFunc && _distrType != DT_ExprFunc)
// throw SALOME_Exception(LOCALIZED("not a functional distribution"));
//================================================================================
int StdMeshers_NumberOfSegments::ConversionMode() const
-
{
// 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 ) ;
- const std::vector<double>& BuildDistributionTab( const std::vector<double>&, int, int ) ;
+ 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)
- ;
+ void SetNumberOfSegments(int segmentsNumber);
/*!
* \brief Get the number of segments
/*!
* \brief Set distribution type
*/
- void SetDistrType(DistrType typ)
- ;
+ 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)
- ;
+ 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
- ;
+ 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)
- ;
+ 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
- ;
+ 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)
- ;
+ 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
- ;
+ 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)
- ;
+ 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 )
- ;
+ void SetConversionMode( int conv );
/*!
* \brief Returns conversion mode
*
* Throws SALOME_Exception if distribution type is not functional
*/
- int ConversionMode() const
- ;
+ int ConversionMode() const;
/*!
* \brief Initialize number of segments by the mesh built on the geometry
public:
StdMeshers_PolygonPerFace_2D(int hypId, SMESH_Gen* gen);
- virtual bool CheckHypothesis(SMESH_Mesh& /*aMesh*/,
- const TopoDS_Shape& /*aShape*/,
+ virtual bool CheckHypothesis(SMESH_Mesh& aMesh,
+ const TopoDS_Shape& aShape,
SMESH_Hypothesis::Hypothesis_Status& aStatus);
virtual bool Compute(SMESH_Mesh& aMesh, const TopoDS_Shape& aShape);
StdMeshers_Prism_3D(int hypId, SMESH_Gen* gen);
virtual ~StdMeshers_Prism_3D();
- virtual bool CheckHypothesis(SMESH_Mesh& /*aMesh*/,
- const TopoDS_Shape& /*aShape*/,
+ virtual bool CheckHypothesis(SMESH_Mesh& aMesh,
+ const TopoDS_Shape& aShape,
SMESH_Hypothesis::Hypothesis_Status& aStatus);
virtual bool Compute(SMESH_Mesh& aMesh, const TopoDS_Shape& aShape);
/*!
* Sets source <edge> to take a mesh pattern from
*/
- void SetSourceEdge(const TopoDS_Shape& edge)
- ;
+ 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)
- ;
+ const TopoDS_Shape& targetVertex);
/*!
* Returns the vertex associated with the target vertex.
void StdMeshers_ProjectionSource2D::SetVertexAssociation(const TopoDS_Shape& sourceVertex1,
const TopoDS_Shape& sourceVertex2,
const TopoDS_Shape& targetVertex1,
- const TopoDS_Shape& targetVertex2)
+ const TopoDS_Shape& targetVertex2)
{
if ( sourceVertex1.IsNull() != targetVertex1.IsNull() ||
sourceVertex2.IsNull() != targetVertex2.IsNull() )
/*!
* Sets a source <face> to take a mesh pattern from
*/
- void SetSourceFace(const TopoDS_Shape& face)
- ;
+ 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)
- ;
+ 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 ;
+ 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 ;
+ TopoDS_Vertex GetTargetVertex(int i) const;
/*!
* \brief Test if vertex association defined
/*!
* Sets a source <shape> to take a mesh pattern from
*/
- void SetSource3DShape(const TopoDS_Shape& shape)
- ;
+ 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)
- ;
+ 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 ;
+ 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 ;
+ TopoDS_Vertex GetTargetVertex(int i) const;
/*!
* \brief Test if vertex association defined
bool setNormalizedGrid(FaceQuadStruct::Ptr quad);
- void splitQuadFace(SMESHDS_Mesh * /*theMeshDS*/,
- const int /*theFaceID*/,
+ void splitQuadFace(SMESHDS_Mesh * theMeshDS,
+ const int theFaceID,
const SMDS_MeshNode* theNode1,
const SMDS_MeshNode* theNode2,
const SMDS_MeshNode* theNode3,
StdMeshers_SegmentLengthAroundVertex(int hypId, SMESH_Gen * gen);
virtual ~ StdMeshers_SegmentLengthAroundVertex();
- void SetLength(double length) ;
+ void SetLength(double length);
double GetLength() const;
StdMeshers_StartEndLength(int hypId, SMESH_Gen * gen);
virtual ~ StdMeshers_StartEndLength();
- void SetLength(double length, bool isStartLength) ;
+ void SetLength(double length, bool isStartLength);
double GetLength(bool isStartLength) const;
std::string DumpFlags() const; // debug
void SetNewLength( double len, _EdgesOnShape& eos, SMESH_MesherHelper& helper );
- bool SetNewLength2d( Handle(Geom_Surface)& /*surface*/,
+ bool SetNewLength2d( Handle(Geom_Surface)& surface,
const TopoDS_Face& F,
_EdgesOnShape& eos,
SMESH_MesherHelper& helper );
void Block( _SolidData& data );
void InvalidateStep( size_t curStep, const _EdgesOnShape& eos, bool restoreLength=false );
void ChooseSmooFunction(const set< TGeomID >& concaveVertices,
- const TNode2Edge& /*n2eMap*/);
+ const TNode2Edge& n2eMap);
void SmoothPos( const vector< double >& segLen, const double tol );
int GetSmoothedPos( const double tol );
int Smooth(const int step, const bool isConcaveFace, bool findBest);
bool shiftInside=false);
bool getFaceNormalAtSingularity(const gp_XY& uv,
const TopoDS_Face& face,
- SMESH_MesherHelper& /*helper*/,
+ SMESH_MesherHelper& helper,
gp_Dir& normal );
gp_XYZ getWeigthedNormal( const _LayerEdge* edge );
gp_XYZ getNormalByOffset( _LayerEdge* edge,
SMESH_MesherHelper& helper );
void limitMaxLenByCurvature( _SolidData& data, SMESH_MesherHelper& helper );
void limitMaxLenByCurvature( _LayerEdge* e1, _LayerEdge* e2,
- _EdgesOnShape& /*eos1*/, _EdgesOnShape& /*eos2*/,
- const bool /*isSmoothable*/ );
- bool updateNormals( _SolidData& data, SMESH_MesherHelper& helper, int stepNb, double /*stepSize*/ );
+ _EdgesOnShape& eos1, _EdgesOnShape& eos2,
+ const bool isSmoothable );
+ bool updateNormals( _SolidData& data, SMESH_MesherHelper& helper, int stepNb, double stepSize );
bool updateNormalsOfConvexFaces( _SolidData& data,
SMESH_MesherHelper& helper,
int stepNb );
void updateNormalsOfC1Vertices( _SolidData& data );
bool updateNormalsOfSmoothed( _SolidData& data,
- SMESH_MesherHelper& /*helper*/,
+ SMESH_MesherHelper& helper,
const int nbSteps,
const double stepSize );
bool isNewNormalOk( _SolidData& data,
bool shrink(_SolidData& data);
bool prepareEdgeToShrink( _LayerEdge& edge, _EdgesOnShape& eos,
SMESH_MesherHelper& helper,
- const SMESHDS_SubMesh* /*faceSubMesh*/ );
+ const SMESHDS_SubMesh* faceSubMesh );
void restoreNoShrink( _LayerEdge& edge ) const;
void fixBadFaces(const TopoDS_Face& F,
SMESH_MesherHelper& helper,
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*/);
+ SMESH_MesherHelper& helper);
gp_XYZ getNormalNormal( const gp_XYZ & normal,
const gp_XYZ& edgeDir);
_LayerEdge* getLEdgeOnV( bool is2nd )
* \param theShape - the geometry of interest
* \retval bool - true if parameter values have been successfully defined
*/
- virtual bool SetParametersByMesh(const SMESH_Mesh* /*theMesh*/, const TopoDS_Shape& /*theShape*/);
+ virtual bool SetParametersByMesh(const SMESH_Mesh* theMesh, const TopoDS_Shape& theShape);
/*!
* \brief Initialize my parameter values by default parameters.
*
* Just return false as this hypothesis does not have parameters values
*/
- virtual bool SetParametersByMesh(const SMESH_Mesh* /*theMesh*/, const TopoDS_Shape& /*theShape*/);
+ virtual bool SetParametersByMesh(const SMESH_Mesh* theMesh, const TopoDS_Shape& theShape);
/*!
* \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"; }
virtual void onReject();
virtual void valueChanged( QWidget* );
- bool initVariableName(SMESH::SMESH_Hypothesis_var /*theHyp*/, StdParam& theParams, const char* theMethod) const;
+ bool initVariableName(SMESH::SMESH_Hypothesis_var theHyp, StdParam& theParams, const char* theMethod) const;
QWidget* makeReverseEdgesWdg( SMESH::long_array_var edgeIDs,
CORBA::String_var shapeEntry) const;
void removeOldGroup(const char* oldName,
std::vector< int > & subIDArray );
protected:
- virtual std::string getMethodOfParameter(const int paramIndex, int /*nbVars*/) const;
+ virtual std::string getMethodOfParameter(const int paramIndex, int nbVars) const;
};
#endif
* it's size is \athreshold times less than the size of the initial hexahedron.
* threshold must be > 1.0
*/
- void SetSizeThreshold(CORBA::Double threshold) ;
+ 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) ;
- SMESH::double_array* GetGrid(CORBA::Short axis) ;
+ 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) ;
+ CORBA::Short axis);
void GetGridSpacing(SMESH::string_array_out xSpaceFunctions,
SMESH::double_array_out xInternalPoints,
- CORBA::Short axis) ;
+ CORBA::Short axis);
/*!
* Set custom direction of axes
*/
void SetAxesDirs(const SMESH::DirStruct& x,
const SMESH::DirStruct& y,
- const SMESH::DirStruct& z) ;
+ 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) ;
+ 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 )
- ;
+ const char* axisName );
// Get implementation
::StdMeshers_CartesianParameters3D* GetImpl();
virtual ~StdMeshers_Deflection1D_i();
// Set deflection
- void SetDeflection( CORBA::Double theLength )
- ;
+ void SetDeflection( CORBA::Double theLength );
// Get deflection
CORBA::Double GetDeflection();
// (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)
- ;
- void SetNbSegments(const SMESH::long_array& listNbSeg)
- ;
+ void SetPoints(const SMESH::double_array& listParams);
+ void SetNbSegments(const SMESH::long_array& listNbSeg);
// Returns list of point's parameters
SMESH::double_array* GetPoints();
StdMeshers_Geometric1D_i( PortableServer::POA_ptr thePOA,
::SMESH_Gen* theGenImpl );
- void SetStartLength(CORBA::Double length) ;
- void SetCommonRatio(CORBA::Double factor) ;
+ void SetStartLength(CORBA::Double length);
+ void SetCommonRatio(CORBA::Double factor);
CORBA::Double GetStartLength();
CORBA::Double GetCommonRatio();
virtual ~StdMeshers_LocalLength_i();
// Set length
- void SetLength( CORBA::Double theLength )
- ;
+ void SetLength( CORBA::Double theLength );
// Set precision
- void SetPrecision( CORBA::Double thePrecision )
- ;
+ void SetPrecision( CORBA::Double thePrecision );
// Get length
CORBA::Double GetLength();
virtual ~StdMeshers_MaxElementArea_i();
// Set maximum element area
- void SetMaxElementArea( CORBA::Double theArea )
- ;
+ void SetMaxElementArea( CORBA::Double theArea );
// Get maximum element area
CORBA::Double GetMaxElementArea();
virtual ~StdMeshers_MaxLength_i();
// Set length
- void SetLength( CORBA::Double theLength )
- ;
+ void SetLength( CORBA::Double theLength );
// Set precision
// Sets preestimation flag
- void SetUsePreestimatedLength( CORBA::Boolean toUse)
- ;
+ void SetUsePreestimatedLength( CORBA::Boolean toUse);
// Get length
CORBA::Double GetLength();
virtual ~StdMeshers_NumberOfLayers_i();
// Sets <number of segments> parameter value
- void SetNumberOfLayers(CORBA::Long numberOfLayers)
- ;
+ void SetNumberOfLayers(CORBA::Long numberOfLayers);
// Returns <number of layers> parameter value
CORBA::Long GetNumberOfLayers();
SMESH::double_array* StdMeshers_NumberOfSegments_i::BuildDistributionExpr( const char* func,
CORBA::Long nbSeg,
CORBA::Long conv )
-
{
ASSERT( myBaseImpl );
try
StdMeshers_NumberOfSegments_i::BuildDistributionTab( const SMESH::double_array& func,
CORBA::Long nbSeg,
CORBA::Long conv )
-
{
ASSERT( myBaseImpl );
//=============================================================================
void StdMeshers_NumberOfSegments_i::SetNumberOfSegments( CORBA::Long theSegmentsNumber )
-
{
ASSERT( myBaseImpl );
try {
//=============================================================================
void StdMeshers_NumberOfSegments_i::SetDistrType(CORBA::Long typ)
-
{
ASSERT( myBaseImpl );
try {
//=============================================================================
void StdMeshers_NumberOfSegments_i::SetScaleFactor( CORBA::Double theScaleFactor )
-
{
ASSERT( myBaseImpl );
try {
//=============================================================================
CORBA::Double StdMeshers_NumberOfSegments_i::GetScaleFactor()
-
{
ASSERT( myBaseImpl );
double scale;
//=============================================================================
void StdMeshers_NumberOfSegments_i::SetTableFunction(const SMESH::double_array& table)
-
{
ASSERT( myBaseImpl );
std::vector<double> tbl( table.length() );
//=============================================================================
SMESH::double_array* StdMeshers_NumberOfSegments_i::GetTableFunction()
-
{
ASSERT( myBaseImpl );
const std::vector<double>* tbl;
//=============================================================================
void StdMeshers_NumberOfSegments_i::SetExpressionFunction(const char* expr)
-
{
ASSERT( myBaseImpl );
try {
//=============================================================================
char* StdMeshers_NumberOfSegments_i::GetExpressionFunction()
-
{
ASSERT( myBaseImpl );
const char* expr;
//=============================================================================
void StdMeshers_NumberOfSegments_i::SetConversionMode(CORBA::Long conv )
-
{
ASSERT( myBaseImpl );
try {
//=============================================================================
CORBA::Long StdMeshers_NumberOfSegments_i::ConversionMode()
-
{
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 )
- ;
- SMESH::double_array* BuildDistributionTab( const SMESH::double_array&, CORBA::Long, CORBA::Long )
- ;
+ 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 )
- ;
+ void SetNumberOfSegments( CORBA::Long theSegmentsNumber );
// Get number of segments
CORBA::Long GetNumberOfSegments();
// Set distribution type
- void SetDistrType(CORBA::Long typ)
- ;
+ void SetDistrType(CORBA::Long typ);
// Get distribution type
CORBA::Long GetDistrType();
// Set scalar factor
- void SetScaleFactor( CORBA::Double theScaleFactor )
- ;
+ void SetScaleFactor( CORBA::Double theScaleFactor );
// Get scalar factor
- CORBA::Double GetScaleFactor()
- ;
+ CORBA::Double GetScaleFactor();
// Set table function for distribution DT_TabFunc
- void SetTableFunction(const SMESH::double_array& table)
- ;
+ void SetTableFunction(const SMESH::double_array& table);
// Get table function for distribution DT_TabFunc
- SMESH::double_array* GetTableFunction()
- ;
+ SMESH::double_array* GetTableFunction();
// Set expression function for distribution DT_ExprFunc
- void SetExpressionFunction(const char* expr)
- ;
+ void SetExpressionFunction(const char* expr);
// Get expression function for distribution DT_ExprFunc
- char* GetExpressionFunction()
- ;
+ char* GetExpressionFunction();
// Set the exponent mode on/off
- void SetConversionMode( CORBA::Long conv )
- ;
+ void SetConversionMode( CORBA::Long conv );
// Returns true if the exponent mode is set
- CORBA::Long ConversionMode()
- ;
+ CORBA::Long ConversionMode();
// Get implementation
::StdMeshers_NumberOfSegments* GetImpl();
::StdMeshers_RadialPrism_3D* GetImpl();
// Return true if the algorithm is applicable to a shape
- static bool IsApplicable(const TopoDS_Shape &S, bool toCheckAll, int /*dim*/);
+ static bool IsApplicable(const TopoDS_Shape &S, bool toCheckAll, int dim);
};
//=============================================================================
void StdMeshers_ProjectionSource1D_i::SetSourceEdge(GEOM::GEOM_Object_ptr edge)
-
{
ASSERT( myBaseImpl );
try {
void StdMeshers_ProjectionSource1D_i::SetVertexAssociation(GEOM::GEOM_Object_ptr sourceVertex,
GEOM::GEOM_Object_ptr targetVertex)
-
{
ASSERT( myBaseImpl );
try {
//=============================================================================
void StdMeshers_ProjectionSource1D_i::SetSourceMesh(SMESH::SMESH_Mesh_ptr theMesh)
-
{
ASSERT( myBaseImpl );
/*!
* Sets source <edge> or a group containing edges to take a mesh pattern from
*/
- void SetSourceEdge(GEOM::GEOM_Object_ptr edge)
- ;
+ 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)
- ;
+ 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)
- ;
+ GEOM::GEOM_Object_ptr targetVertex);
/*!
* Returns the vertex associated with the target vertex.
// 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;
+ std::vector< int > & subIDArray ) const;
// Set new geometry instead of that returned by getObjectsDependOn()
virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
- std::vector< int > & /*subIDArray*/ );
+ std::vector< int > & subIDArray );
private:
// keep entries because the same shape can be published several times with
// different names and in this case a correct name can't be restored by a TopoDS_Shape
//=============================================================================
void StdMeshers_ProjectionSource2D_i::SetSourceFace(GEOM::GEOM_Object_ptr face)
-
{
ASSERT( myBaseImpl );
try {
//=============================================================================
void StdMeshers_ProjectionSource2D_i::SetSourceMesh(SMESH::SMESH_Mesh_ptr theMesh)
-
{
ASSERT( myBaseImpl );
GEOM::GEOM_Object_ptr sourceVertex2,
GEOM::GEOM_Object_ptr targetVertex1,
GEOM::GEOM_Object_ptr targetVertex2)
-
{
ASSERT( myBaseImpl );
try {
/*!
* Sets a source <face> to take a mesh pattern from
*/
- void SetSourceFace(GEOM::GEOM_Object_ptr face)
- ;
+ 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)
- ;
+ 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)
- ;
+ GEOM::GEOM_Object_ptr targetVertex2);
/*!
* Returns the <i>-th source vertex associated with the <i>-th target vertex.
// 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;
+ std::vector< int > & subIDArray ) const;
// Set new geometry instead of that returned by getObjectsDependOn()
virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
- std::vector< int > & /*subIDArray*/ );
+ std::vector< int > & subIDArray );
private:
// keep entries because the same shape can be published several times with
// different names and in this case a correct name can't be restored by a TopoDS_Shape
//=============================================================================
void StdMeshers_ProjectionSource3D_i::SetSource3DShape(GEOM::GEOM_Object_ptr shape)
-
{
ASSERT( myBaseImpl );
try {
//=============================================================================
void StdMeshers_ProjectionSource3D_i::SetSourceMesh(SMESH::SMESH_Mesh_ptr theMesh)
-
{
ASSERT( myBaseImpl );
GEOM::GEOM_Object_ptr sourceVertex2,
GEOM::GEOM_Object_ptr targetVertex1,
GEOM::GEOM_Object_ptr targetVertex2)
-
{
ASSERT( myBaseImpl );
try {
/*!
* Sets a source <shape> to take a mesh pattern from
*/
- void SetSource3DShape(GEOM::GEOM_Object_ptr shape)
- ;
+ 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)
- ;
+ 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)
- ;
+ GEOM::GEOM_Object_ptr targetVertex2);
/*!
* Returns the <i>-th source vertex associated with the <i>-th target vertex.
// 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;
+ std::vector< int > & subIDArray ) const;
// Set new geometry instead of that returned by getObjectsDependOn()
virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
- std::vector< int > & /*subIDArray*/ );
+ std::vector< int > & subIDArray );
private:
// keep entries because the same shape can be published several times with
::StdMeshers_Projection_3D* GetImpl();
// Return true if the algorithm is applicable to a shape
- static bool IsApplicable(const TopoDS_Shape &S, bool toCheckAll, int /*dim*/);
+ static bool IsApplicable(const TopoDS_Shape &S, bool toCheckAll, int dim);
};
// ======================================================
virtual ~StdMeshers_SegmentLengthAroundVertex_i();
// Set length
- void SetLength( CORBA::Double theLength )
- ;
+ void SetLength( CORBA::Double theLength );
// Get length
CORBA::Double GetLength();
// Set length
// * OBSOLETE *. Avoid such a way of interface design
- void SetLength( CORBA::Double theLength, CORBA::Boolean theIsStart )
- ;
+ void SetLength( CORBA::Double theLength, CORBA::Boolean theIsStart );
// Sets <start segment length> parameter value
- void SetStartLength( CORBA::Double length) ;
+ void SetStartLength( CORBA::Double length);
// Sets <end segment length> parameter value
- void SetEndLength( CORBA::Double length) ;
+ 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)
+ CORBA::Boolean toIgnore)
{
vector<int> ids( edgeIDs.length() );
for ( unsigned i = 0; i < ids.size(); ++i )
//================================================================================
void StdMeshers_ViscousLayers2D_i::SetIgnoreEdges(const ::SMESH::long_array& edgeIDs)
-
{
SMESH::TPythonDump pyDump;
this->SetEdges( edgeIDs, true );
//================================================================================
void StdMeshers_ViscousLayers2D_i::SetTotalThickness(::CORBA::Double thickness)
-
{
if ( thickness < 1e-100 )
THROW_SALOME_CORBA_EXCEPTION( "Invalid thickness", SALOME::BAD_PARAM );
//================================================================================
void StdMeshers_ViscousLayers2D_i::SetNumberLayers(::CORBA::Short nb)
-
{
if ( nb < 1 )
THROW_SALOME_CORBA_EXCEPTION( "Invalid number of layers", SALOME::BAD_PARAM );
//================================================================================
void StdMeshers_ViscousLayers2D_i::SetStretchFactor(::CORBA::Double factor)
-
{
if ( factor < 1 )
THROW_SALOME_CORBA_EXCEPTION( "Invalid stretch factor, it must be >= 1.0", SALOME::BAD_PARAM );
// Destructor
virtual ~StdMeshers_ViscousLayers2D_i();
- void SetIgnoreEdges(const SMESH::long_array& edgeIDs) ;
+ void SetIgnoreEdges(const SMESH::long_array& edgeIDs);
SMESH::long_array* GetIgnoreEdges();
void SetEdges(const SMESH::long_array& edgeIDs,
SMESH::long_array* GetEdges();
CORBA::Boolean GetIsToIgnoreEdges();
- void SetTotalThickness(::CORBA::Double thickness) ;
+ void SetTotalThickness(::CORBA::Double thickness);
::CORBA::Double GetTotalThickness();
- void SetNumberLayers(::CORBA::Short nb) ;
+ void SetNumberLayers(::CORBA::Short nb);
::CORBA::Short GetNumberLayers();
- void SetStretchFactor(::CORBA::Double factor) ;
+ void SetStretchFactor(::CORBA::Double factor);
::CORBA::Double GetStretchFactor();
void SetGroupName(const char* name);
// 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*/,
+ virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) const;
// Set new geometry instead of that returned by getObjectsDependOn()
- virtual bool setObjectsDependOn( std::vector< std::string > & /*entryArray*/,
+ virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray );
};
void StdMeshers_ViscousLayers_i::SetFaces(const ::SMESH::long_array& faceIDs,
CORBA::Boolean toIgnore)
-
{
vector<int> ids( faceIDs.length() );
for ( unsigned i = 0; i < ids.size(); ++i )
//================================================================================
void StdMeshers_ViscousLayers_i::SetIgnoreFaces(const ::SMESH::long_array& faceIDs)
-
{
vector<int> ids( faceIDs.length() );
for ( unsigned i = 0; i < ids.size(); ++i )
//================================================================================
void StdMeshers_ViscousLayers_i::SetTotalThickness(::CORBA::Double thickness)
-
{
if ( thickness < 1e-100 )
THROW_SALOME_CORBA_EXCEPTION( "Invalid thickness", SALOME::BAD_PARAM );
//================================================================================
void StdMeshers_ViscousLayers_i::SetNumberLayers(::CORBA::Short nb)
-
{
if ( nb < 1 )
THROW_SALOME_CORBA_EXCEPTION( "Invalid number of layers", SALOME::BAD_PARAM );
//================================================================================
void StdMeshers_ViscousLayers_i::SetStretchFactor(::CORBA::Double factor)
-
{
if ( factor < 1 )
THROW_SALOME_CORBA_EXCEPTION( "Invalid stretch factor, it must be >= 1.0", SALOME::BAD_PARAM );
// Destructor
virtual ~StdMeshers_ViscousLayers_i();
- void SetIgnoreFaces(const ::SMESH::long_array& faceIDs) ;
+ void SetIgnoreFaces(const ::SMESH::long_array& faceIDs);
SMESH::long_array* GetIgnoreFaces();
void SetFaces(const SMESH::long_array& faceIDs,
- CORBA::Boolean toIgnore) ;
+ CORBA::Boolean toIgnore);
SMESH::long_array* GetFaces();
CORBA::Boolean GetIsToIgnoreFaces();
- void SetTotalThickness(::CORBA::Double thickness) ;
+ void SetTotalThickness(::CORBA::Double thickness);
::CORBA::Double GetTotalThickness();
- void SetNumberLayers(::CORBA::Short nb) ;
+ void SetNumberLayers(::CORBA::Short nb);
::CORBA::Short GetNumberLayers();
- void SetStretchFactor(::CORBA::Double factor) ;
+ void SetStretchFactor(::CORBA::Double factor);
::CORBA::Double GetStretchFactor();
void SetMethod( ::StdMeshers::VLExtrusionMethod how );
// 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*/,
+ virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) const;
// Set new geometry instead of that returned by getObjectsDependOn()
- virtual bool setObjectsDependOn( std::vector< std::string > & /*entryArray*/,
+ virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray );
protected:
virtual std::string getMethodOfParameter(const int paramIndex, int nbVars) const;
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 creationGMtype(TYPE_MAILLE tm, std::string nomGMtype);
void afficheMailles(TYPE_MAILLE tm);
- void listeMaillesType(TYPE_MAILLE /*tm*/);
+ void listeMaillesType(TYPE_MAILLE tm);
void listeMaillesTousTypes();
void listeMaillesParGM();
void listeMaillesGM(std::string nomGM);
// std::string vrmlType(TYPE_MAILLE tm, char *renduAretes, char *renduFaces, float transparence);
// void Maillage::creationGMtype(TYPE_MAILLE tm, std::vector<int> CON_TYPE);
int NGLOBAL(TYPE_MAILLE typeMaille, int nlocal);
- int NLOCAL(int nglobal, TYPE_MAILLE /*tm*/);
+ int NLOCAL(int nglobal, TYPE_MAILLE tm);
TYPE_MAILLE TYPE(int nglobal);
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);
