ForkMaster/smesh
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/smesh.git synced 2025-03-14 14:01:34 +05:00
Code Issues Packages Projects Releases Wiki Activity

fight warnings, c++17. Fix minor warnings. Buils SMESH finished

Browse Source
This commit is contained in:
SALOME 2020-08-27 16:24:57 +03:00
parent 44c1e310f0
commit f83eeba172
88 changed files with 215 additions and 215 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/Controls/SMESH_Controls.cxx
View File

@ -2045,7 +2045,7 @@ double Deflection2D::GetBadRate( double Value, int /*nbNodes*/ ) const
*/
//================================================================================
double MultiConnection::GetValue( const TSequenceOfXYZ& P )
double MultiConnection::GetValue( const TSequenceOfXYZ& /*P*/ )
{
return 0;
}
@ -2072,7 +2072,7 @@ SMDSAbs_ElementType MultiConnection::GetType() const
*/
//================================================================================
double MultiConnection2D::GetValue( const TSequenceOfXYZ& P )
double MultiConnection2D::GetValue( const TSequenceOfXYZ& /*P*/ )
{
return 0;
}
@ -4263,7 +4263,7 @@ private:
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 );

2
src/Controls/SMESH_ControlsDef.hxx
View File

@ -129,7 +129,7 @@ namespace SMESH{
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,

2
src/DriverUNV/UNV164_Structure.hxx
View File

@ -88,7 +88,7 @@ namespace UNV164
MESHDRIVERUNV_EXPORT void
Write(std::ofstream& out_stream );
};
}
#endif

2
src/DriverUNV/UNV2411_Structure.hxx
View File

@ -49,7 +49,7 @@ namespace UNV2411{
MESHDRIVERUNV_EXPORT void
Write(std::ofstream& out_stream, const TDataSet& theDataSet);
};
}
#endif

2
src/DriverUNV/UNV2412_Structure.hxx
View File

@ -65,7 +65,7 @@ namespace UNV2412{
MESHDRIVERUNV_EXPORT bool
IsVolume(int theFeDescriptorId);
};
}
#endif

2
src/DriverUNV/UNV2417_Structure.hxx
View File

@ -46,7 +46,7 @@ namespace UNV2417{
void ReadGroup(const std::string& myGroupLabel, std::ifstream& in_stream, TDataSet& theDataSet);
void Write(std::ofstream& out_stream, const TDataSet& theDataSet);
};
}
#endif

2
src/DriverUNV/UNV2420_Structure.hxx
View File

@ -113,7 +113,7 @@ namespace UNV2420
const std::string& part_name); // can store a mesh name
// const TDataSet& theDataSet);
};
}
#endif

2
src/DriverUNV/UNV_Utilities.hxx
View File

@ -141,7 +141,7 @@ namespace UNV {
resLine.resize( resLine.size()-1 );
return resLine;
}
};
}
#ifndef MESSAGE

2
src/MEDWrapper/MED_Algorithm.cxx
View File

@ -178,7 +178,7 @@ namespace MED
//---------------------------------------------------------------
TEntity2FamilySet
GetEntity2FamilySet(const PWrapper& theWrapper,
GetEntity2FamilySet(const PWrapper& /*theWrapper*/,
const TEntity2TGeom2ElemInfo& theEntity2TGeom2ElemInfo,
const TFamilyInfoSet& theFamilyInfoSet)
{

2
src/MEDWrapper/MED_Algorithm.hxx
View File

@ -53,7 +53,7 @@ namespace MED
//! 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);

2
src/MEFISTO2/aptrte.cxx
View File

@ -760,7 +760,7 @@ void
#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 )
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

2
src/OBJECT/SMESH_Actor.h
View File

@ -56,7 +56,7 @@ class SMESHOBJECT_EXPORT SMESH_Actor: public SALOME_Actor
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,

2
src/OBJECT/SMESH_ActorDef.h
View File

@ -83,7 +83,7 @@ class SMESH_ActorDef : public SMESH_Actor
friend class SMESH_Actor;
public:
vtkTypeMacro(SMESH_ActorDef,SMESH_Actor);
vtkTypeMacro(SMESH_ActorDef,SMESH_Actor)
virtual void Delete();

2
src/OBJECT/SMESH_CellLabelActor.cxx
View File

@ -44,7 +44,7 @@
#include <vtkUnstructuredGrid.h>
#include <vtkCellData.h>
vtkStandardNewMacro(SMESH_CellLabelActor);
vtkStandardNewMacro(SMESH_CellLabelActor)
/*!
Constructor.

2
src/OBJECT/SMESH_CellLabelActor.h
View File

@ -49,7 +49,7 @@ public:
void* theCallData);
vtkTypeMacro(SMESH_CellLabelActor, SMESH_DeviceActor);
vtkTypeMacro(SMESH_CellLabelActor, SMESH_DeviceActor)
virtual void SetCellsLabeled(bool theIsCellsLabeled);

2
src/OBJECT/SMESH_DeviceActor.cxx
View File

@ -77,7 +77,7 @@ static int MYDEBUG = 0;
using namespace std;
vtkStandardNewMacro(SMESH_DeviceActor);
vtkStandardNewMacro(SMESH_DeviceActor)
SMESH_DeviceActor

2
src/OBJECT/SMESH_DeviceActor.h
View File

@ -61,7 +61,7 @@ class SMESHOBJECT_EXPORT SMESH_DeviceActor: public vtkLODActor{
friend class SMESH_ActorDef;
public:
vtkTypeMacro(SMESH_DeviceActor,vtkLODActor);
vtkTypeMacro(SMESH_DeviceActor,vtkLODActor)
static SMESH_DeviceActor* New();
void SetStoreClippingMapping(bool theStoreMapping);

2
src/OBJECT/SMESH_ExtractGeometry.cxx
View File

@ -48,7 +48,7 @@ using namespace std;
#endif
vtkStandardNewMacro(SMESH_ExtractGeometry);
vtkStandardNewMacro(SMESH_ExtractGeometry)
SMESH_ExtractGeometry::SMESH_ExtractGeometry()

2
src/OBJECT/SMESH_ExtractGeometry.h
View File

@ -32,7 +32,7 @@
class SMESHOBJECT_EXPORT SMESH_ExtractGeometry : public vtkExtractGeometry{
public:
vtkTypeMacro(SMESH_ExtractGeometry,vtkExtractGeometry);
vtkTypeMacro(SMESH_ExtractGeometry,vtkExtractGeometry)
static SMESH_ExtractGeometry *New();

4
src/OBJECT/SMESH_FaceOrientationFilter.cxx
View File

@ -42,7 +42,7 @@
#define PI 3.14159265359
vtkStandardNewMacro(SMESH_FaceOrientationFilter);
vtkStandardNewMacro(SMESH_FaceOrientationFilter)
/*!
* \class SMESH_FaceOrientationFilter
@ -237,7 +237,7 @@ void GetFaceParams( vtkCell* theFace, double theNormal[3], double& theSize )
* Execute method. Output calculation.
*/
int SMESH_FaceOrientationFilter::RequestData(
vtkInformation *request,
vtkInformation * /*request*/,
vtkInformationVector **inputVector,
vtkInformationVector *outputVector)
{

2
src/OBJECT/SMESH_FaceOrientationFilter.h
View File

@ -33,7 +33,7 @@ class VTKViewer_CellCenters;
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();

2
src/OBJECT/SMESH_NodeLabelActor.cxx
View File

@ -39,7 +39,7 @@
#include <vtkRenderer.h>
#include <vtkUnstructuredGrid.h>
vtkStandardNewMacro(SMESH_NodeLabelActor);
vtkStandardNewMacro(SMESH_NodeLabelActor)
/*!
Constructor.

2
src/OBJECT/SMESH_NodeLabelActor.h
View File

@ -46,7 +46,7 @@ public:
void* theCallData);
vtkTypeMacro(SMESH_NodeLabelActor, SMESH_DeviceActor);
vtkTypeMacro(SMESH_NodeLabelActor, SMESH_DeviceActor)
virtual void SetPointsLabeled(bool theIsPointsLabeled);

2
src/OBJECT/SMESH_SVTKActor.cxx
View File

@ -43,7 +43,7 @@
#include <Utils_SALOME_Exception.hxx>
vtkStandardNewMacro(SMESH_SVTKActor);
vtkStandardNewMacro(SMESH_SVTKActor)
/*!
Constructor

2
src/OBJECT/SMESH_SVTKActor.h
View File

@ -41,7 +41,7 @@ class SMESHOBJECT_EXPORT SMESH_SVTKActor : public SVTK_Actor {
public:
static SMESH_SVTKActor* New();
vtkTypeMacro(SMESH_SVTKActor, SVTK_Actor);
vtkTypeMacro(SMESH_SVTKActor, SVTK_Actor)
void SetBallScale(double theSize);
void SetBallSize(float theSize);

2
src/OBJECT/SMESH_ScalarBarActor.cxx
View File

@ -41,7 +41,7 @@
#define SHRINK_COEF 0.08;
vtkStandardNewMacro(SMESH_ScalarBarActor);
vtkStandardNewMacro(SMESH_ScalarBarActor)
vtkCxxSetObjectMacro(SMESH_ScalarBarActor,LookupTable,vtkScalarsToColors);
vtkCxxSetObjectMacro(SMESH_ScalarBarActor,LabelTextProperty,vtkTextProperty);

2
src/OBJECT/SMESH_ScalarBarActor.h
View File

@ -91,7 +91,7 @@ class SMESHOBJECT_EXPORT SMESH_ScalarBarActor: public vtkActor2D {
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

2
src/SMDS/SMDS_MeshGroup.hxx
View File

@ -41,7 +41,7 @@ class SMDS_EXPORT SMDS_MeshGroup: public SMDS_MeshObject, SMDS_ElementHolder
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(); }

2
src/SMDS/SMDS_PolygonalFaceOfNodes.hxx
View File

@ -40,7 +40,7 @@ class SMDS_EXPORT SMDS_PolygonalFaceOfNodes : public SMDS_CellOfNodes
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;

4
src/SMDS/SMDS_UnstructuredGrid.cxx
View File

@ -336,7 +336,7 @@ void SMDS_UnstructuredGrid::compactGrid(std::vector<int>& idNodesOldToNew, int n
}
void SMDS_UnstructuredGrid::copyNodes(vtkPoints * newPoints,
std::vector<int>& idNodesOldToNew,
std::vector<int>& /*idNodesOldToNew*/,
int& alreadyCopied,
int start,
int end)
@ -410,7 +410,7 @@ void SMDS_UnstructuredGrid::CleanDownwardConnectivity()
* 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

4
src/SMDS/SMDS_UnstructuredGrid.hxx
View File

@ -85,7 +85,7 @@ public:
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);
@ -115,7 +115,7 @@ public:
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,

2
src/SMDS/SMDS_VolumeTool.cxx
View File

@ -1328,7 +1328,7 @@ int SMDS_VolumeTool::GetOppFaceIndex( int faceIndex ) const
case 15:
if ( faceIndex == 0 || faceIndex == 1 )
ind = 1 - faceIndex;
break;
break;
case 8:
case 12:
if ( faceIndex <= 1 ) // top or bottom

8
src/SMESH/SMESH_Algo.cxx
View File

@ -858,7 +858,7 @@ bool SMESH_Algo::Compute(SMESH_Mesh & /*aMesh*/, SMESH_MesherHelper* /*aHelper*/
//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;
}
@ -1261,7 +1261,7 @@ bool SMESH_2D_Algo::FixInternalNodes(const SMESH_ProxyMesh& mesh,
//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() );
}
@ -1271,7 +1271,7 @@ bool SMESH_1D_Algo::IsApplicableToShape(const TopoDS_Shape & shape, bool toCheck
//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() );
}
@ -1281,7 +1281,7 @@ bool SMESH_2D_Algo::IsApplicableToShape(const TopoDS_Shape & shape, bool toCheck
//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() );
}

8
src/SMESH/SMESH_Algo.hxx
View File

@ -173,7 +173,7 @@ class SMESH_EXPORT SMESH_Algo : public SMESH_Hypothesis
* 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
@ -480,7 +480,7 @@ public:
* 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
@ -494,7 +494,7 @@ public:
* 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
@ -515,7 +515,7 @@ public:
* 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

8
src/SMESH/SMESH_Gen.cxx
View File

@ -415,8 +415,8 @@ bool SMESH_Gen::Compute(SMESH_Mesh & aMesh,
* 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();
@ -427,8 +427,8 @@ void SMESH_Gen::PrepareCompute(SMESH_Mesh & aMesh,
* 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() )

8
src/SMESH/SMESH_Gen.hxx
View File

@ -91,10 +91,10 @@ public:
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;

2
src/SMESH/SMESH_HypoFilter.hxx
View File

@ -107,7 +107,7 @@ class SMESH_EXPORT SMESH_HypoFilter: public SMESH_HypoPredicate
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 )
{

10
src/SMESH/SMESH_MeshEditor.cxx
View File

@ -5652,10 +5652,10 @@ makeNodesByNormal2D( SMESHDS_Mesh* mesh,
//=======================================================================
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;
@ -9202,7 +9202,7 @@ void SMESH_MeshEditor::ConvertToQuadratic(const bool theForce3d,
int SMESH_MeshEditor::removeQuadElem(SMESHDS_SubMesh * theSm,
SMDS_ElemIteratorPtr theItr,
const int theShapeID)
const int /*theShapeID*/)
{
int nbElem = 0;
SMESHDS_Mesh* meshDS = GetMeshDS();

10
src/SMESH/SMESH_MeshEditor.hxx
View File

@ -395,10 +395,10 @@ public:
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,
@ -747,7 +747,7 @@ public:
*/
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

2
src/SMESH/SMESH_subMesh.cxx
View File

@ -2106,7 +2106,7 @@ void SMESH_subMesh::removeSubMeshElementsAndNodes()
// 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,

2
src/SMESH/SMESH_subMesh.hxx
View File

@ -294,7 +294,7 @@ protected:
* \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,

4
src/SMESH/SMESH_subMeshEventListener.hxx
View File

@ -55,8 +55,8 @@ class SMESH_EXPORT SMESH_subMeshEventListener
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

8
src/SMESHGUI/SMESHGUI.cxx
View File

@ -3961,7 +3961,7 @@ bool SMESHGUI::OnGUIEvent( int theCommandID )
*
*/
//=============================================================================
bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
bool SMESHGUI::OnMousePress( QMouseEvent * /*pe*/, SUIT_ViewWindow * /*wnd*/ )
{
return false;
}
@ -3971,7 +3971,7 @@ bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
*
*/
//=============================================================================
bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
bool SMESHGUI::OnMouseMove( QMouseEvent * /*pe*/, SUIT_ViewWindow * /*wnd*/ )
{
return true;
}
@ -3981,7 +3981,7 @@ bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
*
*/
//=============================================================================
bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
bool SMESHGUI::OnKeyPress( QKeyEvent * /*pe*/, SUIT_ViewWindow * /*wnd*/ )
{
return true;
}
@ -5270,7 +5270,7 @@ void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
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 ) {

2
src/SMESHGUI/SMESHGUI.h
View File

@ -202,7 +202,7 @@ protected:
static void ProcessEvents( vtkObject* theObject,
unsigned long theEvent,
void* theClientData,
void* theCallData );
void* /*theCallData*/ );
private:
void OnEditDelete();

4
src/SMESHGUI/SMESHGUI_ClippingDlg.h
View File

@ -81,7 +81,7 @@ namespace SMESH
public:
static OrientedPlane *New();
static OrientedPlane *New(SVTK_ViewWindow* theViewWindow);
vtkTypeMacro (OrientedPlane, vtkPlane);
vtkTypeMacro (OrientedPlane, vtkPlane)
QPointer<SVTK_ViewWindow> myViewWindow;
SMESH::Orientation myRelativeOrientation;
@ -135,7 +135,7 @@ namespace SMESH
typedef std::vector<TPlane> TPlaneVector;
typedef std::vector<TPlaneData> TPlaneDataVector;
};
}
//=================================================================================
// class : SMESHGUI_ClippingDlg

4
src/SMESHGUI/SMESHGUI_GroupDlg.cxx
View File

@ -767,7 +767,7 @@ void SMESHGUI_GroupDlg::updateButtons()
// function : onNameChanged()
// purpose :
//=================================================================================
void SMESHGUI_GroupDlg::onNameChanged (const QString& text)
void SMESHGUI_GroupDlg::onNameChanged (const QString& /*text*/)
{
myOldName = myName->text();
updateButtons();
@ -814,7 +814,7 @@ void SMESHGUI_GroupDlg::onGrpTypeChanged (int id)
// function : onColorChanged()
// purpose : Color button management
//=================================================================================
void SMESHGUI_GroupDlg::onColorChanged(QColor theColor)
void SMESHGUI_GroupDlg::onColorChanged(QColor /*theColor*/)
{
updateButtons();
}

6
src/SMESHGUI/SMESHGUI_MeshInfo.cxx
View File

@ -2175,8 +2175,8 @@ void SMESHGUI_TreeElemInfo::information( const QList<uint>& ids )
\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
@ -2284,7 +2284,7 @@ void SMESHGUI_TreeElemInfo::contextMenuEvent( QContextMenuEvent* e )
}
}
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();

2
src/SMESHGUI/SMESHGUI_NodesDlg.cxx
View File

@ -395,7 +395,7 @@ void SMESHGUI_NodesDlg::Init()
// function : ValueChangedInSpinBox()
// purpose :
//=================================================================================
void SMESHGUI_NodesDlg::ValueChangedInSpinBox( double newValue )
void SMESHGUI_NodesDlg::ValueChangedInSpinBox( double /*newValue*/ )
{
if ( !myMesh->_is_nil() ) {
double vx = SpinBox_X->GetValue();

2
src/SMESHGUI/SMESHGUI_VTKUtils.h
View File

@ -222,6 +222,6 @@ SMESHGUI_EXPORT
SMESHGUI_EXPORT
void UpdateActorsAfterUpdateStudy();
};
}
#endif // SMESHGUI_VTKUTILS_H

4
src/SMESH_I/SMESH_2smeshpy.cxx
View File

@ -1230,7 +1230,7 @@ void _pyGen::Flush()
*/
//================================================================================
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 )
@ -4482,7 +4482,7 @@ _pySubMesh::_pySubMesh(const Handle(_pyCommand)& theCreationCmd, bool toKeepAgrC
*/
//================================================================================
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

6
src/SMESH_I/SMESH_2smeshpy.hxx
View File

@ -260,7 +260,7 @@ public:
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 );
@ -490,7 +490,7 @@ public:
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)
};
@ -600,7 +600,7 @@ public:
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)
};

8
src/SMESH_I/SMESH_Algo_i.cxx
View File

@ -88,8 +88,8 @@ SMESH::ListOfHypothesisName* SMESH_Algo_i::GetCompatibleHypothesis()
*/
//================================================================================
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;
}
@ -100,8 +100,8 @@ bool SMESH_Algo_i::getObjectsDependOn( std::vector< std::string > & entryArray,
*/
//================================================================================
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;
}

8
src/SMESH_I/SMESH_Algo_i.hxx
View File

@ -56,12 +56,12 @@ public:
// 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

10
src/SMESH_I/SMESH_Filter_i.cxx
View File

@ -718,7 +718,7 @@ BadOrientedVolume_i::BadOrientedVolume_i()
{
Controls::PredicatePtr control( new Controls::BadOrientedVolume() );
myFunctorPtr = myPredicatePtr = control;
};
}
FunctorType BadOrientedVolume_i::GetFunctorType()
{
@ -733,7 +733,7 @@ BareBorderVolume_i::BareBorderVolume_i()
{
Controls::PredicatePtr control( new Controls::BareBorderVolume() );
myFunctorPtr = myPredicatePtr = control;
};
}
FunctorType BareBorderVolume_i::GetFunctorType()
{
@ -748,7 +748,7 @@ BareBorderFace_i::BareBorderFace_i()
{
Controls::PredicatePtr control( new Controls::BareBorderFace() );
myFunctorPtr = myPredicatePtr = control;
};
}
FunctorType BareBorderFace_i::GetFunctorType()
{
@ -763,7 +763,7 @@ OverConstrainedVolume_i::OverConstrainedVolume_i()
{
Controls::PredicatePtr control( new Controls::OverConstrainedVolume() );
myFunctorPtr = myPredicatePtr = control;
};
}
FunctorType OverConstrainedVolume_i::GetFunctorType()
{
@ -778,7 +778,7 @@ OverConstrainedFace_i::OverConstrainedFace_i()
{
Controls::PredicatePtr control( new Controls::OverConstrainedFace() );
myFunctorPtr = myPredicatePtr = control;
};
}
FunctorType OverConstrainedFace_i::GetFunctorType()
{

2
src/SMESH_I/SMESH_Filter_i.hxx
View File

@ -55,7 +55,7 @@ namespace SMESH
*/
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);

2
src/SMESH_I/SMESH_Group_i.cxx
View File

@ -1071,7 +1071,7 @@ SMESH_GroupOnFilter_i::~SMESH_GroupOnFilter_i()
*/
//================================================================================
void SMESH_GroupOnFilter_i::OnBaseObjModified(NotifyerAndWaiter* filter, bool /*removed*/)
void SMESH_GroupOnFilter_i::OnBaseObjModified(NotifyerAndWaiter* /*filter*/, bool /*removed*/)
{
if ( myPreMeshInfo )
myPreMeshInfo->FullLoadFromFile();

2
src/SMESH_I/SMESH_Group_i.hxx
View File

@ -206,7 +206,7 @@ class SMESH_I_EXPORT SMESH_GroupOnFilter_i:
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;

10
src/SMESH_I/SMESH_Hypothesis_i.cxx
View File

@ -50,7 +50,7 @@ SMESH_Hypothesis_i::SMESH_Hypothesis_i( PortableServer::POA_ptr thePOA )
: SALOME::GenericObj_i( thePOA )
{
myBaseImpl = 0;
};
}
//=============================================================================
/*!
@ -65,7 +65,7 @@ SMESH_Hypothesis_i::~SMESH_Hypothesis_i()
//MESSAGE( "SMESH_Hypothesis_i::~SMESH_Hypothesis_i" );
if ( myBaseImpl )
delete myBaseImpl;
};
}
//=============================================================================
/*!
@ -78,7 +78,7 @@ SMESH_Hypothesis_i::~SMESH_Hypothesis_i()
char* SMESH_Hypothesis_i::GetName()
{
return CORBA::string_dup( myBaseImpl->GetName() );
};
}
//=============================================================================
/*!
@ -91,7 +91,7 @@ char* SMESH_Hypothesis_i::GetName()
char* SMESH_Hypothesis_i::GetLibName()
{
return CORBA::string_dup( myBaseImpl->GetLibName() );
};
}
//=============================================================================
/*!
@ -104,7 +104,7 @@ char* SMESH_Hypothesis_i::GetLibName()
void SMESH_Hypothesis_i::SetLibName(const char* theLibName)
{
myBaseImpl->SetLibName( theLibName );
};
}
//=============================================================================
/*!

6
src/SMESH_I/SMESH_Hypothesis_i.hxx
View File

@ -131,10 +131,10 @@ public:
// 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; }
};
// ======================================================
@ -152,7 +152,7 @@ public:
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 );
}

12
src/SMESH_I/SMESH_Mesh_i.cxx
View File

@ -1692,25 +1692,25 @@ SMESH_Mesh_i::CutListOfGroups(const SMESH::ListOfGroups& theMainGroups,
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;
}

4
src/SMESH_I/SMESH_PreMeshInfo.cxx
View File

@ -72,7 +72,7 @@ namespace
*/
//================================================================================
void meshInfoLoaded( SMESH_Mesh_i* mesh )
void meshInfoLoaded( SMESH_Mesh_i* /*mesh*/ )
{
theMeshCounter++;
}
@ -82,7 +82,7 @@ namespace
*/
//================================================================================
void filesNoMoreNeeded(SMESH_Mesh_i* mesh,
void filesNoMoreNeeded(SMESH_Mesh_i* /*mesh*/,
std::string medFile,
std::string hdfFile)
{

16
src/StdMeshers/StdMeshers_Cartesian_3D.cxx
View File

@ -191,10 +191,10 @@ namespace
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; }
@ -5830,9 +5830,9 @@ bool StdMeshers_Cartesian_3D::Compute(SMESH_Mesh & theMesh,
*/
//=============================================================================
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);
@ -5886,10 +5886,10 @@ namespace
// --------------------------------------------------------------------------------
// 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 )

4
src/StdMeshers/StdMeshers_Cartesian_3D.hxx
View File

@ -51,8 +51,8 @@ public:
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);

4
src/StdMeshers/StdMeshers_CompositeHexa_3D.cxx
View File

@ -283,8 +283,8 @@ StdMeshers_CompositeHexa_3D::StdMeshers_CompositeHexa_3D(int hypId, SMESH_Gen* g
*/
//================================================================================
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;

4
src/StdMeshers/StdMeshers_CompositeHexa_3D.hxx
View File

@ -52,8 +52,8 @@ public:
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:

2
src/StdMeshers/StdMeshers_Hexa_3D.cxx
View File

@ -869,7 +869,7 @@ bool StdMeshers_Hexa_3D::IsApplicable( const TopoDS_Shape & aShape, bool toCheck
if ( !toCheckAll && ok ) return true;
}
return toCheckAll;
};
}
//=======================================================================
//function : ComputePentahedralMesh

2
src/StdMeshers/StdMeshers_MEFISTO_2D.cxx
View File

@ -677,7 +677,7 @@ bool StdMeshers_MEFISTO_2D::LoadPoints(TWireVector & wires,
*/
//=============================================================================
void StdMeshers_MEFISTO_2D::ComputeScaleOnFace(SMESH_Mesh & aMesh,
void StdMeshers_MEFISTO_2D::ComputeScaleOnFace(SMESH_Mesh & /*aMesh*/,
const TopoDS_Face & aFace,
double & scalex,
double & scaley)

2
src/StdMeshers/StdMeshers_MEFISTO_2D.hxx
View File

@ -68,7 +68,7 @@ public:
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);

4
src/StdMeshers/StdMeshers_NotConformAllowed.cxx
View File

@ -81,7 +81,7 @@ istream & StdMeshers_NotConformAllowed::LoadFrom(istream & load)
*/
//=============================================================================
ostream & operator << (ostream & save, StdMeshers_NotConformAllowed & hyp)
ostream & operator << (ostream & save, StdMeshers_NotConformAllowed & /*hyp*/)
{
return save;
}
@ -92,7 +92,7 @@ ostream & operator << (ostream & save, StdMeshers_NotConformAllowed & hyp)
*/
//=============================================================================
istream & operator >> (istream & load, StdMeshers_NotConformAllowed & hyp)
istream & operator >> (istream & load, StdMeshers_NotConformAllowed & /*hyp*/)
{
return load;
}

4
src/StdMeshers/StdMeshers_NotConformAllowed.hxx
View File

@ -42,8 +42,8 @@ public:
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

4
src/StdMeshers/StdMeshers_PolygonPerFace_2D.cxx
View File

@ -60,8 +60,8 @@ StdMeshers_PolygonPerFace_2D::StdMeshers_PolygonPerFace_2D(int hypId,
//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;

4
src/StdMeshers/StdMeshers_PolygonPerFace_2D.hxx
View File

@ -34,8 +34,8 @@ class STDMESHERS_EXPORT StdMeshers_PolygonPerFace_2D: public SMESH_2D_Algo
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);

6
src/StdMeshers/StdMeshers_Prism_3D.cxx
View File

@ -450,7 +450,7 @@ namespace {
//================================================================================
int countNbSides( const Prism_3D::TPrismTopo & thePrism,
vector<int> & nbUnitePerEdge,
vector<int> & /*nbUnitePerEdge*/,
vector< double > & edgeLength)
{
int nbEdges = thePrism.myNbEdgesInWires.front(); // nb outer edges
@ -598,8 +598,8 @@ StdMeshers_Prism_3D::~StdMeshers_Prism_3D()
//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

4
src/StdMeshers/StdMeshers_Prism_3D.hxx
View File

@ -482,8 +482,8 @@ public:
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);

2
src/StdMeshers/StdMeshers_ProjectionUtils.hxx
View File

@ -336,6 +336,6 @@ namespace StdMeshers_ProjectionUtils
TopoDS_Edge GetBoundaryEdge(const TopoDS_Shape& edgeContainer,
const SMESH_Mesh& mesh,
std::list< TopoDS_Edge >* allBndEdges = 0 );
};
}
#endif

16
src/StdMeshers/StdMeshers_Projection_2D.cxx
View File

@ -278,7 +278,7 @@ namespace {
//================================================================================
bool getBoundaryNodes ( SMESH_subMesh* sm,
const TopoDS_Face& face,
const TopoDS_Face& /*face*/,
map< double, const SMDS_MeshNode* > & u2nodes,
set< const SMDS_MeshNode* > & seamNodes)
{
@ -975,13 +975,13 @@ namespace {
*/
//================================================================================
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();

8
src/StdMeshers/StdMeshers_QuadFromMedialAxis_1D2D.cxx
View File

@ -260,8 +260,8 @@ namespace
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 )
{
@ -1248,7 +1248,7 @@ namespace
//================================================================================
void separateNodes( SMESH_MesherHelper& theHelper,
const SMESH_MAT2d::MedialAxis& theMA,
const SMESH_MAT2d::MedialAxis& /*theMA*/,
TMAPar2NPoints & thePointsOnE,
SinuousFace& theSinuFace,
const vector< bool >& theIsComputedEdge)
@ -1932,7 +1932,7 @@ namespace
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 )

4
src/StdMeshers/StdMeshers_Quadrangle_2D.cxx
View File

@ -3208,8 +3208,8 @@ bool StdMeshers_Quadrangle_2D::evaluateQuadPref(SMESH_Mesh & aMesh,
*/
//=============================================================================
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,

4
src/StdMeshers/StdMeshers_Quadrangle_2D.hxx
View File

@ -174,8 +174,8 @@ class STDMESHERS_EXPORT StdMeshers_Quadrangle_2D: public SMESH_2D_Algo
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,

2
src/StdMeshers/StdMeshers_RadialPrism_3D.cxx
View File

@ -636,4 +636,4 @@ bool StdMeshers_RadialPrism_3D::IsApplicable( const TopoDS_Shape & aShape, bool
if ( !toCheckAll ) return true;
}
return ( toCheckAll && nbFoundSolids != 0);
};
}

12
src/StdMeshers/StdMeshers_RadialQuadrangle_1D2D.cxx
View File

@ -164,9 +164,9 @@ namespace
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*/)
{
@ -402,9 +402,9 @@ namespace
*/
//================================================================================
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 )
// {
@ -1279,4 +1279,4 @@ bool StdMeshers_RadialQuadrangle_1D2D::IsApplicable( const TopoDS_Shape & aShape
}
if( toCheckAll && nbFoundFaces != 0 ) return true;
return false;
};
}

52
src/StdMeshers/StdMeshers_ViscousLayers.cxx
View File

@ -206,8 +206,8 @@ namespace VISCOUS_3D
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 &&
@ -440,7 +440,7 @@ namespace VISCOUS_3D
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 );
@ -451,7 +451,7 @@ namespace VISCOUS_3D
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);
@ -937,7 +937,7 @@ namespace VISCOUS_3D
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,
@ -975,15 +975,15 @@ namespace VISCOUS_3D
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,
@ -993,7 +993,7 @@ namespace VISCOUS_3D
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,
@ -1091,10 +1091,10 @@ namespace VISCOUS_3D
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 )
@ -1376,8 +1376,8 @@ std::istream & StdMeshers_ViscousLayers::LoadFrom(std::istream & load)
}
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;
@ -3953,7 +3953,7 @@ gp_XYZ _ViscousBuilder::getFaceNormal(const SMDS_MeshNode* node,
bool _ViscousBuilder::getFaceNormalAtSingularity( const gp_XY& uv,
const TopoDS_Face& face,
SMESH_MesherHelper& helper,
SMESH_MesherHelper& /*helper*/,
gp_Dir& normal )
{
BRepAdaptor_Surface surface( face );
@ -6086,10 +6086,10 @@ bool _Smoother1D::smoothAnalyticEdge( _SolidData& data,
*/
//================================================================================
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;
@ -6746,7 +6746,7 @@ void _SolidData::AddShapesToSmooth( const set< _EdgesOnShape* >& eosToSmooth,
*/
//================================================================================
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)
@ -6798,9 +6798,9 @@ void _ViscousBuilder::limitMaxLenByCurvature( _SolidData& data, SMESH_MesherHelp
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() ) &&
@ -7119,7 +7119,7 @@ void _ViscousBuilder::findEdgesToUpdateNormalNearConvexFace( _ConvexFace &
bool _ViscousBuilder::updateNormals( _SolidData& data,
SMESH_MesherHelper& helper,
int stepNb,
double stepSize)
double /*stepSize*/)
{
updateNormalsOfC1Vertices( data );
@ -7459,7 +7459,7 @@ bool _ViscousBuilder::isNewNormalOk( _SolidData& data,
//================================================================================
bool _ViscousBuilder::updateNormalsOfSmoothed( _SolidData& data,
SMESH_MesherHelper& helper,
SMESH_MesherHelper& /*helper*/,
const int nbSteps,
const double stepSize )
{
@ -8917,7 +8917,7 @@ int _LayerEdge::Smooth(const int step, const bool isConcaveFace, bool findBest )
//================================================================================
void _LayerEdge::ChooseSmooFunction( const set< TGeomID >& concaveVertices,
const TNode2Edge& n2eMap)
const TNode2Edge& /*n2eMap*/)
{
if ( _smooFunction ) return;
@ -11512,7 +11512,7 @@ bool _ViscousBuilder::shrink(_SolidData& theData)
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();
@ -11801,7 +11801,7 @@ void _ViscousBuilder::fixBadFaces(const TopoDS_Face& F,
*/
//================================================================================
bool _LayerEdge::SetNewLength2d( Handle(Geom_Surface)& surface,
bool _LayerEdge::SetNewLength2d( Handle(Geom_Surface)& /*surface*/,
const TopoDS_Face& F,
_EdgesOnShape& eos,
SMESH_MesherHelper& helper )

4
src/StdMeshers/StdMeshers_ViscousLayers.hxx
View File

@ -106,13 +106,13 @@ public:
* \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"; }

4
src/StdMeshers/StdMeshers_ViscousLayers2D.cxx
View File

@ -509,8 +509,8 @@ StdMeshers_ViscousLayers2D::StdMeshers_ViscousLayers2D(int hypId, SMESH_Gen* gen
_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;

4
src/StdMeshers/StdMeshers_ViscousLayers2D.hxx
View File

@ -62,13 +62,13 @@ public:
*
* 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"; }

8
src/StdMeshers_I/StdMeshers_Adaptive1D_i.hxx
View File

@ -85,10 +85,10 @@ class STDMESHERS_I_EXPORT StdMeshers_Adaptive1D_i:
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

6
src/Tools/MeshCut/MeshCut_Maillage.cxx
View File

@ -78,7 +78,7 @@ void Maillage::afficheMailles(TYPE_MAILLE tm)
}
}
void Maillage::listeMaillesType(TYPE_MAILLE tm)
void Maillage::listeMaillesType(TYPE_MAILLE /*tm*/)
{
cout << "La fonction \"Restitution des mailles par type\" est obsolète " << endl;
@ -854,7 +854,7 @@ void Maillage::inputMED(std::string fichierMED)
}
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;
@ -1595,7 +1595,7 @@ TYPE_MAILLE Maillage::TYPE(int nglobal)
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];

6
src/Tools/MeshCut/MeshCut_Maillage.hxx
View File

@ -95,7 +95,7 @@ namespace MESHCUT
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);
@ -120,13 +120,13 @@ namespace MESHCUT
// 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);