*/
//================================================================================
-double MultiConnection::GetValue( const TSequenceOfXYZ& P )
+double MultiConnection::GetValue( const TSequenceOfXYZ& /*P*/ )
{
return 0;
}
*/
//================================================================================
-double MultiConnection2D::GetValue( const TSequenceOfXYZ& P )
+double MultiConnection2D::GetValue( const TSequenceOfXYZ& /*P*/ )
{
return 0;
}
bool isOutOfFace (const gp_Pnt& p);
bool isOutOfEdge (const gp_Pnt& p);
bool isOutOfVertex(const gp_Pnt& p);
- bool isOutOfNone (const gp_Pnt& p) { return true; }
+ bool isOutOfNone (const gp_Pnt& /*p*/) { return true; }
bool isBox (const TopoDS_Shape& s);
TopoDS_Shape prepareSolid( const TopoDS_Shape& theSolid );
NumericalFunctor();
virtual void SetMesh( const SMDS_Mesh* theMesh );
virtual double GetValue( long theElementId );
- virtual double GetValue(const TSequenceOfXYZ& thePoints) { return -1.0;};
+ virtual double GetValue(const TSequenceOfXYZ& /*thePoints*/) { return -1.0;};
void GetHistogram(int nbIntervals,
std::vector<int>& nbEvents,
std::vector<double>& funValues,
MESHDRIVERUNV_EXPORT void
Write(std::ofstream& out_stream );
-};
+}
#endif
MESHDRIVERUNV_EXPORT void
Write(std::ofstream& out_stream, const TDataSet& theDataSet);
-};
+}
#endif
MESHDRIVERUNV_EXPORT bool
IsVolume(int theFeDescriptorId);
-};
+}
#endif
void ReadGroup(const std::string& myGroupLabel, std::ifstream& in_stream, TDataSet& theDataSet);
void Write(std::ofstream& out_stream, const TDataSet& theDataSet);
-};
+}
#endif
const std::string& part_name); // can store a mesh name
// const TDataSet& theDataSet);
-};
+}
#endif
resLine.resize( resLine.size()-1 );
return resLine;
}
-};
+}
#ifndef MESSAGE
//---------------------------------------------------------------
TEntity2FamilySet
- GetEntity2FamilySet(const PWrapper& theWrapper,
+ GetEntity2FamilySet(const PWrapper& /*theWrapper*/,
const TEntity2TGeom2ElemInfo& theEntity2TGeom2ElemInfo,
const TFamilyInfoSet& theFamilyInfoSet)
{
//! 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);
#endif
#endif
qualitetrte( R3 *mnpxyd,
- Z & mosoar, Z & mxsoar, Z *mnsoar,
+ Z & mosoar, Z & /*mxsoar*/, Z *mnsoar,
Z & moartr, Z & mxartr, Z *mnartr,
Z & nbtria, R & quamoy, R & quamin )
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
static SMESH_Actor* New() { return NULL;}
public:
- vtkTypeMacro(SMESH_Actor,SALOME_Actor);
+ vtkTypeMacro(SMESH_Actor,SALOME_Actor)
static SMESH_Actor* New(TVisualObjPtr theVisualObj,
const char* theEntry,
const char* theName,
friend class SMESH_Actor;
public:
- vtkTypeMacro(SMESH_ActorDef,SMESH_Actor);
+ vtkTypeMacro(SMESH_ActorDef,SMESH_Actor)
virtual void Delete();
#include <vtkUnstructuredGrid.h>
#include <vtkCellData.h>
-vtkStandardNewMacro(SMESH_CellLabelActor);
+vtkStandardNewMacro(SMESH_CellLabelActor)
/*!
Constructor.
void* theCallData);
- vtkTypeMacro(SMESH_CellLabelActor, SMESH_DeviceActor);
+ vtkTypeMacro(SMESH_CellLabelActor, SMESH_DeviceActor)
virtual void SetCellsLabeled(bool theIsCellsLabeled);
using namespace std;
-vtkStandardNewMacro(SMESH_DeviceActor);
+vtkStandardNewMacro(SMESH_DeviceActor)
SMESH_DeviceActor
friend class SMESH_ActorDef;
public:
- vtkTypeMacro(SMESH_DeviceActor,vtkLODActor);
+ vtkTypeMacro(SMESH_DeviceActor,vtkLODActor)
static SMESH_DeviceActor* New();
void SetStoreClippingMapping(bool theStoreMapping);
#endif
-vtkStandardNewMacro(SMESH_ExtractGeometry);
+vtkStandardNewMacro(SMESH_ExtractGeometry)
SMESH_ExtractGeometry::SMESH_ExtractGeometry()
class SMESHOBJECT_EXPORT SMESH_ExtractGeometry : public vtkExtractGeometry{
public:
- vtkTypeMacro(SMESH_ExtractGeometry,vtkExtractGeometry);
+ vtkTypeMacro(SMESH_ExtractGeometry,vtkExtractGeometry)
static SMESH_ExtractGeometry *New();
#define PI 3.14159265359
-vtkStandardNewMacro(SMESH_FaceOrientationFilter);
+vtkStandardNewMacro(SMESH_FaceOrientationFilter)
/*!
* \class SMESH_FaceOrientationFilter
* Execute method. Output calculation.
*/
int SMESH_FaceOrientationFilter::RequestData(
- vtkInformation *request,
+ vtkInformation * /*request*/,
vtkInformationVector **inputVector,
vtkInformationVector *outputVector)
{
class SMESHOBJECT_EXPORT SMESH_FaceOrientationFilter : public vtkPolyDataAlgorithm
{
public:
- vtkTypeMacro( SMESH_FaceOrientationFilter, vtkPolyDataAlgorithm );
+ vtkTypeMacro( SMESH_FaceOrientationFilter, vtkPolyDataAlgorithm )
/*!Create a new SMESH_FaceOrientationFilter.*/
static SMESH_FaceOrientationFilter *New();
#include <vtkRenderer.h>
#include <vtkUnstructuredGrid.h>
-vtkStandardNewMacro(SMESH_NodeLabelActor);
+vtkStandardNewMacro(SMESH_NodeLabelActor)
/*!
Constructor.
void* theCallData);
- vtkTypeMacro(SMESH_NodeLabelActor, SMESH_DeviceActor);
+ vtkTypeMacro(SMESH_NodeLabelActor, SMESH_DeviceActor)
virtual void SetPointsLabeled(bool theIsPointsLabeled);
#include <Utils_SALOME_Exception.hxx>
-vtkStandardNewMacro(SMESH_SVTKActor);
+vtkStandardNewMacro(SMESH_SVTKActor)
/*!
Constructor
public:
static SMESH_SVTKActor* New();
- vtkTypeMacro(SMESH_SVTKActor, SVTK_Actor);
+ vtkTypeMacro(SMESH_SVTKActor, SVTK_Actor)
void SetBallScale(double theSize);
void SetBallSize(float theSize);
#define SHRINK_COEF 0.08;
-vtkStandardNewMacro(SMESH_ScalarBarActor);
+vtkStandardNewMacro(SMESH_ScalarBarActor)
vtkCxxSetObjectMacro(SMESH_ScalarBarActor,LookupTable,vtkScalarsToColors);
vtkCxxSetObjectMacro(SMESH_ScalarBarActor,LabelTextProperty,vtkTextProperty);
public:
void PrintSelf(ostream& os, vtkIndent indent);
- vtkTypeMacro(SMESH_ScalarBarActor,vtkActor2D);
+ vtkTypeMacro(SMESH_ScalarBarActor,vtkActor2D)
// Description:
// Instantiate object with 64 maximum colors; 5 labels; %%-#6.3g label
void SetType (const SMDSAbs_ElementType theType);
void Clear();
- void Reserve(size_t nbElems) {}
+ void Reserve(size_t /*nbElems*/) {}
bool Add(const SMDS_MeshElement * theElem);
bool Remove(const SMDS_MeshElement * theElem);
bool IsEmpty() const { return myElements.empty(); }
virtual SMDSAbs_GeometryType GetGeomType() const { return SMDSGeom_POLYGON; }
virtual bool IsPoly() const { return true; }
virtual bool IsQuadratic() const { return false; }
- virtual bool IsMediumNode(const SMDS_MeshNode* node) const { return false; }
+ virtual bool IsMediumNode(const SMDS_MeshNode* /*node*/) const { return false; }
virtual int NbCornerNodes() const { return NbNodes(); }
virtual int NbNodes() const;
}
void SMDS_UnstructuredGrid::copyNodes(vtkPoints * newPoints,
- std::vector<int>& idNodesOldToNew,
+ std::vector<int>& /*idNodesOldToNew*/,
int& alreadyCopied,
int start,
int end)
* Downward connectivity is no more valid if vtkUnstructuredGrid is modified.
*
*/
-void SMDS_UnstructuredGrid::BuildDownwardConnectivity(bool withEdges)
+void SMDS_UnstructuredGrid::BuildDownwardConnectivity(bool /*withEdges*/)
{
MESSAGE("SMDS_UnstructuredGrid::BuildDownwardConnectivity");CHRONO(2);
// TODO calcul partiel sans edges
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,
case 15:
if ( faceIndex == 0 || faceIndex == 1 )
ind = 1 - faceIndex;
- break;
+ break;
case 8:
case 12:
if ( faceIndex <= 1 ) // top or bottom
//purpose : Return true if the algorithm can mesh a given shape
//=======================================================================
-bool SMESH_Algo::IsApplicableToShape(const TopoDS_Shape & shape, bool toCheckAll) const
+bool SMESH_Algo::IsApplicableToShape(const TopoDS_Shape & /*shape*/, bool /*toCheckAll*/) const
{
return true;
}
//purpose : Return true if the algorithm can mesh a given shape
//=======================================================================
-bool SMESH_1D_Algo::IsApplicableToShape(const TopoDS_Shape & shape, bool toCheckAll) const
+bool SMESH_1D_Algo::IsApplicableToShape(const TopoDS_Shape & shape, bool /*toCheckAll*/) const
{
return ( !shape.IsNull() && TopExp_Explorer( shape, TopAbs_EDGE ).More() );
}
//purpose : Return true if the algorithm can mesh a given shape
//=======================================================================
-bool SMESH_2D_Algo::IsApplicableToShape(const TopoDS_Shape & shape, bool toCheckAll) const
+bool SMESH_2D_Algo::IsApplicableToShape(const TopoDS_Shape & shape, bool /*toCheckAll*/) const
{
return ( !shape.IsNull() && TopExp_Explorer( shape, TopAbs_FACE ).More() );
}
//purpose : Return true if the algorithm can mesh a given shape
//=======================================================================
-bool SMESH_3D_Algo::IsApplicableToShape(const TopoDS_Shape & shape, bool toCheckAll) const
+bool SMESH_3D_Algo::IsApplicableToShape(const TopoDS_Shape & shape, bool /*toCheckAll*/) const
{
return ( !shape.IsNull() && TopExp_Explorer( shape, TopAbs_SOLID ).More() );
}
* 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
* Prepare Compute a mesh
*/
//=============================================================================
-void SMESH_Gen::PrepareCompute(SMESH_Mesh & aMesh,
- const TopoDS_Shape & aShape)
+void SMESH_Gen::PrepareCompute(SMESH_Mesh & /*aMesh*/,
+ const TopoDS_Shape & /*aShape*/)
{
_compute_canceled = false;
resetCurrentSubMesh();
* Cancel Compute a mesh
*/
//=============================================================================
-void SMESH_Gen::CancelCompute(SMESH_Mesh & aMesh,
- const TopoDS_Shape & aShape)
+void SMESH_Gen::CancelCompute(SMESH_Mesh & /*aMesh*/,
+ const TopoDS_Shape & /*aShape*/)
{
_compute_canceled = true;
if ( const SMESH_subMesh* sm = GetCurrentSubMesh() )
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;
enum Logical { AND, AND_NOT, OR, OR_NOT };
enum Comparison { EQUAL, NOT_EQUAL, MORE, LESS };
- SMESH_HypoFilter(const SMESH_HypoFilter& other){}
+ SMESH_HypoFilter(const SMESH_HypoFilter& /*other*/){}
void add( Logical bool_op, SMESH_HypoPredicate* pred )
{
//=======================================================================
int SMESH_MeshEditor::ExtrusParam::
-makeNodesByNormal1D( SMESHDS_Mesh* mesh,
- const SMDS_MeshNode* srcNode,
- std::list<const SMDS_MeshNode*> & newNodes,
- const bool makeMediumNodes)
+makeNodesByNormal1D( SMESHDS_Mesh* /*mesh*/,
+ const SMDS_MeshNode* /*srcNode*/,
+ std::list<const SMDS_MeshNode*> & /*newNodes*/,
+ const bool /*makeMediumNodes*/)
{
throw SALOME_Exception("Extrusion 1D by Normal not implemented");
return 0;
int SMESH_MeshEditor::removeQuadElem(SMESHDS_SubMesh * theSm,
SMDS_ElemIteratorPtr theItr,
- const int theShapeID)
+ const int /*theShapeID*/)
{
int nbElem = 0;
SMESHDS_Mesh* meshDS = GetMeshDS();
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
// meshed at once along with _subShape
//=======================================================================
-TopoDS_Shape SMESH_subMesh::getCollection(SMESH_Gen * theGen,
+TopoDS_Shape SMESH_subMesh::getCollection(SMESH_Gen * /*theGen*/,
SMESH_Algo* theAlgo,
bool & theSubComputed,
bool & theSubFailed,
* \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,
virtual ~SMESH_subMeshEventListener() {}
bool IsDeletable() const { return myIsDeletable; }
const char* GetName() const { return myName; }
- virtual void BeforeDelete(SMESH_subMesh* subMesh,
- SMESH_subMeshEventListenerData* data)
+ virtual void BeforeDelete(SMESH_subMesh* /*subMesh*/,
+ SMESH_subMeshEventListenerData* /*data*/)
{}
/*!
* \brief Do something on a certain event
*
*/
//=============================================================================
-bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
+bool SMESHGUI::OnMousePress( QMouseEvent * /*pe*/, SUIT_ViewWindow * /*wnd*/ )
{
return false;
}
*
*/
//=============================================================================
-bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
+bool SMESHGUI::OnMouseMove( QMouseEvent * /*pe*/, SUIT_ViewWindow * /*wnd*/ )
{
return true;
}
*
*/
//=============================================================================
-bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
+bool SMESHGUI::OnKeyPress( QKeyEvent * /*pe*/, SUIT_ViewWindow * /*wnd*/ )
{
return true;
}
void SMESHGUI::ProcessEvents( vtkObject* theObject,
unsigned long theEvent,
void* theClientData,
- void* theCallData )
+ void* /*theCallData*/ )
{
if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
if( theObject && (int) theEvent == SMESH::DeleteActorEvent ) {
static void ProcessEvents( vtkObject* theObject,
unsigned long theEvent,
void* theClientData,
- void* theCallData );
+ void* /*theCallData*/ );
private:
void OnEditDelete();
public:
static OrientedPlane *New();
static OrientedPlane *New(SVTK_ViewWindow* theViewWindow);
- vtkTypeMacro (OrientedPlane, vtkPlane);
+ vtkTypeMacro (OrientedPlane, vtkPlane)
QPointer<SVTK_ViewWindow> myViewWindow;
SMESH::Orientation myRelativeOrientation;
typedef std::vector<TPlane> TPlaneVector;
typedef std::vector<TPlaneData> TPlaneDataVector;
-};
+}
//=================================================================================
// class : SMESHGUI_ClippingDlg
// function : onNameChanged()
// purpose :
//=================================================================================
-void SMESHGUI_GroupDlg::onNameChanged (const QString& text)
+void SMESHGUI_GroupDlg::onNameChanged (const QString& /*text*/)
{
myOldName = myName->text();
updateButtons();
// function : onColorChanged()
// purpose : Color button management
//=================================================================================
-void SMESHGUI_GroupDlg::onColorChanged(QColor theColor)
+void SMESHGUI_GroupDlg::onColorChanged(QColor /*theColor*/)
{
updateButtons();
}
\param nbNodes number of unique nodes in element
\param parentItem parent item of tree
*/
-void SMESHGUI_TreeElemInfo::nodeInfo( const SMDS_MeshNode* node, int index,
- int nbNodes, QTreeWidgetItem* parentItem )
+void SMESHGUI_TreeElemInfo::nodeInfo( const SMDS_MeshNode* /*node*/, int /*index*/,
+ int /*nbNodes*/, QTreeWidgetItem* /*parentItem*/ )
{
// int precision = SMESHGUI::resourceMgr()->integerValue( "SMESH", "length_precision", 6 );
// // node number and ID
}
}
-void SMESHGUI_TreeElemInfo::itemDoubleClicked( QTreeWidgetItem* theItem, int theColumn )
+void SMESHGUI_TreeElemInfo::itemDoubleClicked( QTreeWidgetItem* theItem, int /*theColumn*/ )
{
if ( theItem ) {
int type = theItem->data( 1, TypeRole ).toInt();
// function : ValueChangedInSpinBox()
// purpose :
//=================================================================================
-void SMESHGUI_NodesDlg::ValueChangedInSpinBox( double newValue )
+void SMESHGUI_NodesDlg::ValueChangedInSpinBox( double /*newValue*/ )
{
if ( !myMesh->_is_nil() ) {
double vx = SpinBox_X->GetValue();
SMESHGUI_EXPORT
void UpdateActorsAfterUpdateStudy();
-};
+}
#endif // SMESHGUI_VTKUTILS_H
*/
//================================================================================
-void _pyGen::PlaceSubmeshAfterItsCreation( Handle(_pyCommand) theCmdUsingSubmesh ) const
+void _pyGen::PlaceSubmeshAfterItsCreation( Handle(_pyCommand) /*theCmdUsingSubmesh*/ ) const
{
// map< _pyID, Handle(_pyObject) >::const_iterator id_obj = myObjects.begin();
// for ( ; id_obj != myObjects.end(); ++id_obj )
*/
//================================================================================
-bool _pySubMesh::CanBeArgOfMethod(const _AString& theMethodName)
+bool _pySubMesh::CanBeArgOfMethod(const _AString& /*theMethodName*/)
{
return false;
// names of all methods where a sub-mesh can be used as argument
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 bool Addition2Creation( const Handle(_pyCommand)& theAdditionCmd,
const _pyID& theMesh);
virtual const char* AccessorMethod() const { return "GetAlgorithm()"; }
- virtual bool IsWrappable(const _pyID& theMesh) { return !myIsWrapped; }
+ virtual bool IsWrappable(const _pyID& /*theMesh*/) { return !myIsWrapped; }
DEFINE_STANDARD_RTTIEXT(_pyAlgorithm,_pyHypothesis)
};
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)
};
*/
//================================================================================
-bool SMESH_Algo_i::getObjectsDependOn( std::vector< std::string > & entryArray,
- std::vector< int > & subIDArray ) const
+bool SMESH_Algo_i::getObjectsDependOn( std::vector< std::string > & /*entryArray*/,
+ std::vector< int > & /*subIDArray*/ ) const
{
return false;
}
*/
//================================================================================
-bool SMESH_Algo_i::setObjectsDependOn( std::vector< std::string > & entryArray,
- std::vector< int > & subIDArray )
+bool SMESH_Algo_i::setObjectsDependOn( std::vector< std::string > & /*entryArray*/,
+ std::vector< int > & /*subIDArray*/ )
{
return true;
}
// 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
{
Controls::PredicatePtr control( new Controls::BadOrientedVolume() );
myFunctorPtr = myPredicatePtr = control;
-};
+}
FunctorType BadOrientedVolume_i::GetFunctorType()
{
{
Controls::PredicatePtr control( new Controls::BareBorderVolume() );
myFunctorPtr = myPredicatePtr = control;
-};
+}
FunctorType BareBorderVolume_i::GetFunctorType()
{
{
Controls::PredicatePtr control( new Controls::BareBorderFace() );
myFunctorPtr = myPredicatePtr = control;
-};
+}
FunctorType BareBorderFace_i::GetFunctorType()
{
{
Controls::PredicatePtr control( new Controls::OverConstrainedVolume() );
myFunctorPtr = myPredicatePtr = control;
-};
+}
FunctorType OverConstrainedVolume_i::GetFunctorType()
{
{
Controls::PredicatePtr control( new Controls::OverConstrainedFace() );
myFunctorPtr = myPredicatePtr = control;
-};
+}
FunctorType OverConstrainedFace_i::GetFunctorType()
{
*/
struct NotifyerAndWaiter
{
- virtual void OnBaseObjModified(NotifyerAndWaiter* obj, bool removed) {};
+ virtual void OnBaseObjModified(NotifyerAndWaiter* /*obj*/, bool /*removed*/) {};
// specific reaction on modification of a base object
void Modified( bool removed=false, NotifyerAndWaiter* who = 0);
*/
//================================================================================
-void SMESH_GroupOnFilter_i::OnBaseObjModified(NotifyerAndWaiter* filter, bool /*removed*/)
+void SMESH_GroupOnFilter_i::OnBaseObjModified(NotifyerAndWaiter* /*filter*/, bool /*removed*/)
{
if ( myPreMeshInfo )
myPreMeshInfo->FullLoadFromFile();
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;
: SALOME::GenericObj_i( thePOA )
{
myBaseImpl = 0;
-};
+}
//=============================================================================
/*!
//MESSAGE( "SMESH_Hypothesis_i::~SMESH_Hypothesis_i" );
if ( myBaseImpl )
delete myBaseImpl;
-};
+}
//=============================================================================
/*!
char* SMESH_Hypothesis_i::GetName()
{
return CORBA::string_dup( myBaseImpl->GetName() );
-};
+}
//=============================================================================
/*!
char* SMESH_Hypothesis_i::GetLibName()
{
return CORBA::string_dup( myBaseImpl->GetLibName() );
-};
+}
//=============================================================================
/*!
void SMESH_Hypothesis_i::SetLibName(const char* theLibName)
{
myBaseImpl->SetLibName( theLibName );
-};
+}
//=============================================================================
/*!
// method used to convert variable parameters stored in an old study
// into myMethod2VarParams. It should return a method name for an index of
// variable parameters. Index is countered from zero
- virtual std::string getMethodOfParameter(const int paramIndex, int nbVars) const { return ""; }
+ virtual std::string getMethodOfParameter(const int /*paramIndex*/, int /*nbVars*/) const { return ""; }
// method intended to remove explicit treatment of Netgen hypotheses from SMESH_NoteBook
- virtual int getParamIndex(const TCollection_AsciiString& method, int nbVars) const { return -1; }
+ virtual int getParamIndex(const TCollection_AsciiString& /*method*/, int /*nbVars*/) const { return -1; }
};
// ======================================================
virtual std::string GetModuleName() = 0;
// Check if an algorithm is applicable to a shape
- virtual bool IsApplicable( const TopoDS_Shape &S, bool toCheckAll, int algoDim )
+ virtual bool IsApplicable( const TopoDS_Shape &S, bool /*toCheckAll*/, int algoDim )
{
return IsShapeOfDim( S, algoDim );
}
namespace // functions making checks according to SMESH::NB_COMMON_NODES_ENUM
{
- bool isAllNodesCommon(int nbChecked, int nbCommon, int nbNodes, int nbCorners,
+ bool isAllNodesCommon(int nbChecked, int nbCommon, int nbNodes, int /*nbCorners*/,
bool & toStopChecking )
{
toStopChecking = ( nbCommon < nbChecked );
return nbCommon == nbNodes;
}
- bool isMainNodesCommon(int nbChecked, int nbCommon, int nbNodes, int nbCorners,
+ bool isMainNodesCommon(int nbChecked, int nbCommon, int /*nbNodes*/, int nbCorners,
bool & toStopChecking )
{
toStopChecking = ( nbCommon < nbChecked || nbChecked >= nbCorners );
return nbCommon == nbCorners;
}
- bool isAtLeastOneNodeCommon(int nbChecked, int nbCommon, int nbNodes, int nbCorners,
- bool & toStopChecking )
+ bool isAtLeastOneNodeCommon(int /*nbChecked*/, int nbCommon, int /*nbNodes*/, int /*nbCorners*/,
+ bool & /*toStopChecking*/ )
{
return nbCommon > 0;
}
- bool isMajorityOfNodesCommon(int nbChecked, int nbCommon, int nbNodes, int nbCorners,
- bool & toStopChecking )
+ bool isMajorityOfNodesCommon(int /*nbChecked*/, int nbCommon, int nbNodes, int /*nbCorners*/,
+ bool & /*toStopChecking*/ )
{
return nbCommon >= (nbNodes+1) / 2;
}
*/
//================================================================================
- void meshInfoLoaded( SMESH_Mesh_i* mesh )
+ void meshInfoLoaded( SMESH_Mesh_i* /*mesh*/ )
{
theMeshCounter++;
}
*/
//================================================================================
- void filesNoMoreNeeded(SMESH_Mesh_i* mesh,
+ void filesNoMoreNeeded(SMESH_Mesh_i* /*mesh*/,
std::string medFile,
std::string hdfFile)
{
bool _hasInternalFaces;
public:
virtual ~Solid() {}
- virtual bool Contains( TGeomID subID ) const { return true; }
- virtual bool ContainsAny( const vector< TGeomID>& subIDs ) const { return true; }
+ virtual bool Contains( TGeomID /*subID*/ ) const { return true; }
+ virtual bool ContainsAny( const vector< TGeomID>& /*subIDs*/ ) const { return true; }
virtual TopAbs_Orientation Orientation( const TopoDS_Shape& s ) const { return s.Orientation(); }
- virtual bool IsOutsideOriented( TGeomID faceID ) const { return true; }
+ virtual bool IsOutsideOriented( TGeomID /*faceID*/ ) const { return true; }
void SetID( TGeomID id ) { _id = id; }
TGeomID ID() const { return _id; }
void SetHasInternalFaces( bool has ) { _hasInternalFaces = has; }
*/
//=============================================================================
-bool StdMeshers_Cartesian_3D::Evaluate(SMESH_Mesh & theMesh,
- const TopoDS_Shape & theShape,
- MapShapeNbElems& theResMap)
+bool StdMeshers_Cartesian_3D::Evaluate(SMESH_Mesh & /*theMesh*/,
+ const TopoDS_Shape & /*theShape*/,
+ MapShapeNbElems& /*theResMap*/)
{
// TODO
// std::vector<int> aResVec(SMDSEntity_Last);
// --------------------------------------------------------------------------------
// unsetting _alwaysComputed flag if "Cartesian_3D" was removed
//
- virtual void ProcessEvent(const int event,
+ virtual void ProcessEvent(const int /*event*/,
const int eventType,
SMESH_subMesh* subMeshOfSolid,
- SMESH_subMeshEventListenerData* data,
+ SMESH_subMeshEventListenerData* /*data*/,
const SMESH_Hypothesis* hyp = 0)
{
if ( eventType == SMESH_subMesh::COMPUTE_EVENT )
virtual bool Compute(SMESH_Mesh& aMesh, const TopoDS_Shape& aShape);
- virtual bool Evaluate(SMESH_Mesh & aMesh, const TopoDS_Shape & aShape,
- MapShapeNbElems& aResMap);
+ virtual bool Evaluate(SMESH_Mesh & /*aMesh*/, const TopoDS_Shape & /*aShape*/,
+ MapShapeNbElems& /*aResMap*/);
virtual void SetEventListener(SMESH_subMesh* subMesh);
*/
//================================================================================
-bool StdMeshers_CompositeHexa_3D::CheckHypothesis(SMESH_Mesh& aMesh,
- const TopoDS_Shape& aShape,
+bool StdMeshers_CompositeHexa_3D::CheckHypothesis(SMESH_Mesh& /*aMesh*/,
+ const TopoDS_Shape& /*aShape*/,
Hypothesis_Status& aStatus)
{
aStatus = HYP_OK;
virtual bool Evaluate(SMESH_Mesh & aMesh, const TopoDS_Shape & aShape,
MapShapeNbElems& aResMap);
- virtual bool CheckHypothesis(SMESH_Mesh& aMesh,
- const TopoDS_Shape& aShape,
+ virtual bool CheckHypothesis(SMESH_Mesh& /*aMesh*/,
+ const TopoDS_Shape& /*aShape*/,
Hypothesis_Status& aStatus);
private:
if ( !toCheckAll && ok ) return true;
}
return toCheckAll;
-};
+}
//=======================================================================
//function : ComputePentahedralMesh
*/
//=============================================================================
-void StdMeshers_MEFISTO_2D::ComputeScaleOnFace(SMESH_Mesh & aMesh,
+void StdMeshers_MEFISTO_2D::ComputeScaleOnFace(SMESH_Mesh & /*aMesh*/,
const TopoDS_Face & aFace,
double & scalex,
double & scaley)
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);
*/
//=============================================================================
-ostream & operator << (ostream & save, StdMeshers_NotConformAllowed & hyp)
+ostream & operator << (ostream & save, StdMeshers_NotConformAllowed & /*hyp*/)
{
return save;
}
*/
//=============================================================================
-istream & operator >> (istream & load, StdMeshers_NotConformAllowed & hyp)
+istream & operator >> (istream & load, StdMeshers_NotConformAllowed & /*hyp*/)
{
return load;
}
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
//purpose :
//=======================================================================
-bool StdMeshers_PolygonPerFace_2D::CheckHypothesis(SMESH_Mesh& theMesh,
- const TopoDS_Shape& theShape,
+bool StdMeshers_PolygonPerFace_2D::CheckHypothesis(SMESH_Mesh& /*theMesh*/,
+ const TopoDS_Shape& /*theShape*/,
SMESH_Hypothesis::Hypothesis_Status& theStatus)
{
theStatus = HYP_OK;
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);
//================================================================================
int countNbSides( const Prism_3D::TPrismTopo & thePrism,
- vector<int> & nbUnitePerEdge,
+ vector<int> & /*nbUnitePerEdge*/,
vector< double > & edgeLength)
{
int nbEdges = thePrism.myNbEdgesInWires.front(); // nb outer edges
//purpose :
//=======================================================================
-bool StdMeshers_Prism_3D::CheckHypothesis(SMESH_Mesh& aMesh,
- const TopoDS_Shape& aShape,
+bool StdMeshers_Prism_3D::CheckHypothesis(SMESH_Mesh& /*aMesh*/,
+ const TopoDS_Shape& /*aShape*/,
SMESH_Hypothesis::Hypothesis_Status& aStatus)
{
// no hypothesis
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);
TopoDS_Edge GetBoundaryEdge(const TopoDS_Shape& edgeContainer,
const SMESH_Mesh& mesh,
std::list< TopoDS_Edge >* allBndEdges = 0 );
-};
+}
#endif
//================================================================================
bool getBoundaryNodes ( SMESH_subMesh* sm,
- const TopoDS_Face& face,
+ const TopoDS_Face& /*face*/,
map< double, const SMDS_MeshNode* > & u2nodes,
set< const SMDS_MeshNode* > & seamNodes)
{
*/
//================================================================================
- bool projectQuads(const TopoDS_Face& tgtFace,
- const TopoDS_Face& srcFace,
- const TSideVector& tgtWires,
- const TSideVector& srcWires,
- const TAssocTool::TShapeShapeMap& shape2ShapeMap,
- TAssocTool::TNodeNodeMap& src2tgtNodes,
- const bool is1DComputed)
+ bool projectQuads(const TopoDS_Face& /*tgtFace*/,
+ const TopoDS_Face& /*srcFace*/,
+ const TSideVector& /*tgtWires*/,
+ const TSideVector& /*srcWires*/,
+ const TAssocTool::TShapeShapeMap& /*shape2ShapeMap*/,
+ TAssocTool::TNodeNodeMap& /*src2tgtNodes*/,
+ const bool /*is1DComputed*/)
{
// SMESH_Mesh * tgtMesh = tgtWires[0]->GetMesh();
// SMESH_Mesh * srcMesh = srcWires[0]->GetMesh();
virtual void ProcessEvent(const int event,
const int eventType,
SMESH_subMesh* faceSubMesh,
- SMESH_subMeshEventListenerData* data,
- const SMESH_Hypothesis* hyp)
+ SMESH_subMeshEventListenerData* /*data*/,
+ const SMESH_Hypothesis* /*hyp*/)
{
if ( eventType == SMESH_subMesh::ALGO_EVENT )
{
//================================================================================
void separateNodes( SMESH_MesherHelper& theHelper,
- const SMESH_MAT2d::MedialAxis& theMA,
+ const SMESH_MAT2d::MedialAxis& /*theMA*/,
TMAPar2NPoints & thePointsOnE,
SinuousFace& theSinuFace,
const vector< bool >& theIsComputedEdge)
const vector<TopoDS_Edge>& theShortEdges,
SMESH_Algo* the1dAlgo,
const bool theHasRadialHyp,
- const bool theIs2nd)
+ const bool /*theIs2nd*/)
{
SMESH_Hypothesis::Hypothesis_Status aStatus;
for ( size_t i = 0; i < theShortEdges.size(); ++i )
*/
//=============================================================================
-void StdMeshers_Quadrangle_2D::splitQuadFace(SMESHDS_Mesh * theMeshDS,
- int theFaceID,
+void StdMeshers_Quadrangle_2D::splitQuadFace(SMESHDS_Mesh * /*theMeshDS*/,
+ int /*theFaceID*/,
const SMDS_MeshNode* theNode1,
const SMDS_MeshNode* theNode2,
const SMDS_MeshNode* theNode3,
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,
if ( !toCheckAll ) return true;
}
return ( toCheckAll && nbFoundSolids != 0);
-};
+}
return &theEdgeMarker;
}
//! Clear edge sumbesh if something happens on face
- void ProcessEvent(const int event,
+ void ProcessEvent(const int /*event*/,
const int eventType,
- SMESH_subMesh* faceSubMesh,
+ SMESH_subMesh* /*faceSubMesh*/,
EventListenerData* edgesHolder,
const SMESH_Hypothesis* /*hyp*/)
{
*/
//================================================================================
- bool isCornerInsideCircle(const StdMeshers_FaceSidePtr& CircSide,
- const StdMeshers_FaceSidePtr& LinSide1,
- const StdMeshers_FaceSidePtr& LinSide2)
+ bool isCornerInsideCircle(const StdMeshers_FaceSidePtr& /*CircSide*/,
+ const StdMeshers_FaceSidePtr& /*LinSide1*/,
+ const StdMeshers_FaceSidePtr& /*LinSide2*/)
{
// if ( CircSide && LinSide1 && LinSide2 )
// {
}
if( toCheckAll && nbFoundFaces != 0 ) return true;
return false;
-};
+}
virtual void ProcessEvent(const int event,
const int eventType,
SMESH_subMesh* subMesh,
- SMESH_subMeshEventListenerData* data,
- const SMESH_Hypothesis* hyp)
+ SMESH_subMeshEventListenerData* /*data*/,
+ const SMESH_Hypothesis* /*hyp*/)
{
if (( SMESH_subMesh::COMPUTE_EVENT == eventType ) &&
( SMESH_subMesh::CHECK_COMPUTE_STATE != event &&
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 )
}
return load;
} // --------------------------------------------------------------------------------
-bool StdMeshers_ViscousLayers::SetParametersByMesh(const SMESH_Mesh* theMesh,
- const TopoDS_Shape& theShape)
+bool StdMeshers_ViscousLayers::SetParametersByMesh(const SMESH_Mesh* /*theMesh*/,
+ const TopoDS_Shape& /*theShape*/)
{
// TODO
return false;
bool _ViscousBuilder::getFaceNormalAtSingularity( const gp_XY& uv,
const TopoDS_Face& face,
- SMESH_MesherHelper& helper,
+ SMESH_MesherHelper& /*helper*/,
gp_Dir& normal )
{
BRepAdaptor_Surface surface( face );
*/
//================================================================================
-bool _Smoother1D::smoothComplexEdge( _SolidData& data,
+bool _Smoother1D::smoothComplexEdge( _SolidData& /*data*/,
Handle(ShapeAnalysis_Surface)& surface,
const TopoDS_Face& F,
- SMESH_MesherHelper& helper)
+ SMESH_MesherHelper& /*helper*/)
{
if ( _offPoints.empty() )
return false;
*/
//================================================================================
-void _ViscousBuilder::limitMaxLenByCurvature( _SolidData& data, SMESH_MesherHelper& helper )
+void _ViscousBuilder::limitMaxLenByCurvature( _SolidData& data, SMESH_MesherHelper& /*helper*/ )
{
// find intersection of neighbor _LayerEdge's to limit _maxLen
// according to local curvature (IPAL52648)
void _ViscousBuilder::limitMaxLenByCurvature( _LayerEdge* e1,
_LayerEdge* e2,
- _EdgesOnShape& eos1,
- _EdgesOnShape& eos2,
- const bool isSmoothable )
+ _EdgesOnShape& /*eos1*/,
+ _EdgesOnShape& /*eos2*/,
+ const bool /*isSmoothable*/ )
{
if (( e1->_nodes[0]->GetPosition()->GetDim() !=
e2->_nodes[0]->GetPosition()->GetDim() ) &&
bool _ViscousBuilder::updateNormals( _SolidData& data,
SMESH_MesherHelper& helper,
int stepNb,
- double stepSize)
+ double /*stepSize*/)
{
updateNormalsOfC1Vertices( data );
//================================================================================
bool _ViscousBuilder::updateNormalsOfSmoothed( _SolidData& data,
- SMESH_MesherHelper& helper,
+ SMESH_MesherHelper& /*helper*/,
const int nbSteps,
const double stepSize )
{
//================================================================================
void _LayerEdge::ChooseSmooFunction( const set< TGeomID >& concaveVertices,
- const TNode2Edge& n2eMap)
+ const TNode2Edge& /*n2eMap*/)
{
if ( _smooFunction ) return;
bool _ViscousBuilder::prepareEdgeToShrink( _LayerEdge& edge,
_EdgesOnShape& eos,
SMESH_MesherHelper& helper,
- const SMESHDS_SubMesh* faceSubMesh)
+ const SMESHDS_SubMesh* /*faceSubMesh*/)
{
const SMDS_MeshNode* srcNode = edge._nodes[0];
const SMDS_MeshNode* tgtNode = edge._nodes.back();
*/
//================================================================================
-bool _LayerEdge::SetNewLength2d( Handle(Geom_Surface)& surface,
+bool _LayerEdge::SetNewLength2d( Handle(Geom_Surface)& /*surface*/,
const TopoDS_Face& F,
_EdgesOnShape& eos,
SMESH_MesherHelper& helper )
* \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.
* \retval bool - true if parameter values have been successfully defined
*/
- virtual bool SetParametersByDefaults(const TDefaults& dflts, const SMESH_Mesh* theMesh=0)
+ virtual bool SetParametersByDefaults(const TDefaults& /*dflts*/, const SMESH_Mesh* theMesh=0)
{ return false; }
static const char* GetHypType() { return "ViscousLayers"; }
_param_algo_dim = -2; // auxiliary hyp used by 2D algos
}
// --------------------------------------------------------------------------------
-bool StdMeshers_ViscousLayers2D::SetParametersByMesh(const SMESH_Mesh* theMesh,
- const TopoDS_Shape& theShape)
+bool StdMeshers_ViscousLayers2D::SetParametersByMesh(const SMESH_Mesh* /*theMesh*/,
+ const TopoDS_Shape& /*theShape*/)
{
// TODO ???
return false;
*
* 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"; }
CORBA::Boolean IsDimSupported( SMESH::Dimension type );
// Methods for copying mesh definition to other geometry
- virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
- std::vector< int > & subIDArray ) const { return false; }
- virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
- std::vector< int > & subIDArray ) { return true; }
+ virtual bool getObjectsDependOn( std::vector< std::string > & /*entryArray*/,
+ std::vector< int > & /*subIDArray*/ ) const { return false; }
+ virtual bool setObjectsDependOn( std::vector< std::string > & /*entryArray*/,
+ std::vector< int > & /*subIDArray*/ ) { return true; }
};
#endif
}
}
-void Maillage::listeMaillesType(TYPE_MAILLE tm)
+void Maillage::listeMaillesType(TYPE_MAILLE /*tm*/)
{
cout << "La fonction \"Restitution des mailles par type\" est obsolète " << endl;
}
void Maillage::acquisitionTYPE_inputMED(TYPE_MAILLE TYPE, int nTYPE, med_idt fid, char maa[MED_NAME_SIZE + 1],
- med_int mdim)
+ med_int /*mdim*/)
{
// int taille, numeromaille, numeroFamille;
return resultat;
}
-int Maillage::NLOCAL(int nglobal, TYPE_MAILLE tm)
+int Maillage::NLOCAL(int nglobal, TYPE_MAILLE /*tm*/)
{
// Attention, les num. globaux commencent à 1, les num. locaux à 0
int nPOI1 = EFFECTIFS_TYPES[POI1];
void 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);
+ 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);
