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; }
*/
struct CellsAroundLink
{
+ int _iDir;
int _dInd[4][3];
size_t _nbCells[3];
int _i,_j,_k;
Grid* _grid;
CellsAroundLink( Grid* grid, int iDir ):
+ _iDir( iDir ),
_dInd{ {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0} },
_nbCells{ grid->_coords[0].size() - 1,
grid->_coords[1].size() - 1,
_j = j - _dInd[iL][1];
_k = k - _dInd[iL][2];
}
- bool GetCell( int iL, int& i, int& j, int& k, int& cellIndex )
+ bool GetCell( int iL, int& i, int& j, int& k, int& cellIndex, int& linkIndex )
{
i = _i + _dInd[iL][0];
j = _j + _dInd[iL][1];
k < 0 || k >= (int)_nbCells[2] )
return false;
cellIndex = _grid->CellIndex( i,j,k );
+ linkIndex = iL + _iDir * 4;
return true;
}
};
{
struct _Split // data of a link split
{
- int _linkID; // hex link ID
+ int _linkID; // hex link ID
_Node* _nodes[2];
int _iCheckIteration; // iteration where split is tried as Hexahedron split
_Link* _checkedSplit; // split set to hex links
- bool _isUsed; // used in a volume
+ bool _isUsed; // used in a volume
_Split( _Link & split, int iLink ):
_linkID( iLink ), _nodes{ split._nodes[0], split._nodes[1] },
const E_IntersectPoint* EdgeIntPnt() const
{ return static_cast< const E_IntersectPoint* >( _intPoint ); }
_ptr Ptr() const { return Node() ? (_ptr) Node() : (_ptr) EdgeIntPnt(); }
+ bool operator==(const _nodeDef& other ) const { return Ptr() == other.Ptr(); }
};
vector< _nodeDef > _nodes;
{ _nodes.swap( other._nodes ); _quantities.swap( other._quantities ); other._volume = 0;
_names.swap( other._names ); }
+ size_t size() const { return 1 + ( _next ? _next->size() : 0 ); }
+ _volumeDef* at(int index)
+ { return index == 0 ? this : ( _next ? _next->at(index-1) : _next ); }
+
void Set( _Node** nodes, int nb )
{ _nodes.assign( nodes, nodes + nb ); }
bool IsEmpty() const { return (( _nodes.empty() ) &&
( !_next || _next->IsEmpty() )); }
+ bool IsPolyhedron() const { return ( !_quantities.empty() ||
+ ( _next && !_next->_quantities.empty() )); }
struct _linkDef: public std::pair<_ptr,_ptr> // to join polygons in removeExcessSideDivision()
void getVolumes( vector< const SMDS_MeshElement* > & volumes );
void getBoundaryElems( vector< const SMDS_MeshElement* > & boundaryVolumes );
void removeExcessSideDivision(const vector< Hexahedron* >& allHexa);
+ void removeExcessNodes(vector< Hexahedron* >& allHexa);
+ void preventVolumesOverlapping();
TGeomID getAnyFace() const;
void cutByExtendedInternal( std::vector< Hexahedron* >& hexes,
const TColStd_MapOfInteger& intEdgeIDs );
}
#ifdef _DEBUG_
_cellID = cellID;
+#else
+ (void)cellID; // unused in release mode
#endif
}
{
_i = i; _j = j; _k = k;
+ bool isCompute = solid;
if ( !solid )
solid = _grid->GetSolid();
_intNodes.clear();
_vIntNodes.clear();
+ if ( !isCompute )
+ return;
+
if ( _nbFaceIntNodes + _eIntPoints.size() > 0 &&
_nbFaceIntNodes + _eIntPoints.size() + _nbCornerNodes > 3)
{
case 3: // at a corner
{
_Node& node = _hexNodes[ subEntity - SMESH_Block::ID_FirstV ];
- if ( node.Node() > 0 )
+ if ( node.Node() )
{
if ( node._intPoint )
node._intPoint->Add( _eIntPoints[ iP ]->_faceIDs, _eIntPoints[ iP ]->_node );
} // loop on _eIntPoints
}
- else if ( 3 < _nbCornerNodes && _nbCornerNodes < 8 ) // _nbFaceIntNodes == 0
+ else if (( 3 < _nbCornerNodes && _nbCornerNodes < 8 ) || // _nbFaceIntNodes == 0
+ ( !_grid->_geometry.IsOneSolid() ))
{
_Link split;
// create sub-links (_splits) of whole links
for ( int iN = 0; iN < 8; ++iN )
_hexNodes[iN]._usedInFace = 0;
+ if ( intFlag & IS_CUT_BY_INTERNAL_FACE && !_grid->_toAddEdges ) // Issue #19913
+ preventVolumesOverlapping();
+
// Create polygons from quadrangles
// --------------------------------
vector<_Node*> chainNodes;
_Face* coplanarPolyg;
- bool hasEdgeIntersections = !_eIntPoints.empty();
+ const bool hasEdgeIntersections = !_eIntPoints.empty();
+ const bool toCheckSideDivision = isImplementEdges() || intFlag & IS_CUT_BY_INTERNAL_FACE;
for ( int iF = 0; iF < 6; ++iF ) // loop on 6 sides of a hexahedron
{
n1 = split.FirstNode();
if ( n1 == n2 &&
n1->_intPoint &&
- (( n1->_intPoint->_faceIDs.size() > 1 && isImplementEdges() ) ||
+ (( n1->_intPoint->_faceIDs.size() > 1 && toCheckSideDivision ) ||
( n1->_isInternalFlags )))
{
// n1 is at intersection with EDGE
int nbIntHex = 0;
// set intersection nodes from GridLine's to links of allHexa
- int i,j,k, cellIndex;
+ int i,j,k, cellIndex, iLink;
for ( int iDir = 0; iDir < 3; ++iDir )
{
// loop on GridLine's parallel to iDir
fourCells.Init( lineInd.I(), lineInd.J(), lineInd.K() );
for ( int iL = 0; iL < 4; ++iL ) // loop on 4 cells sharing a link
{
- if ( !fourCells.GetCell( iL, i,j,k, cellIndex ))
+ if ( !fourCells.GetCell( iL, i,j,k, cellIndex, iLink ))
continue;
Hexahedron *& hex = allHexa[ cellIndex ];
if ( !hex)
hex = new Hexahedron( *this, i, j, k, cellIndex );
++nbIntHex;
}
- const int iLink = iL + iDir * 4;
hex->_hexLinks[iLink]._fIntPoints.push_back( &(*ip) );
hex->_nbFaceIntNodes += bool( ip->_node );
}
if ( hex ) // split hexahedron
{
intHexa.push_back( hex );
- if ( hex->_nbFaceIntNodes > 0 || hex->_eIntPoints.size() > 0 )
+ if ( hex->_nbFaceIntNodes > 0 ||
+ hex->_eIntPoints.size() > 0 ||
+ hex->getSolids( solidIDs ) > 1 )
continue; // treat intersected hex later in parallel
this->init( hex->_i, hex->_j, hex->_k );
}
hex->computeElements();
#endif
+ // simplify polyhedrons
+ if ( _grid->IsToRemoveExcessEntities() )
+ {
+ for ( size_t i = 0; i < intHexa.size(); ++i )
+ if ( Hexahedron * hex = intHexa[ i ] )
+ hex->removeExcessSideDivision( allHexa );
+
+ for ( size_t i = 0; i < intHexa.size(); ++i )
+ if ( Hexahedron * hex = intHexa[ i ] )
+ hex->removeExcessNodes( allHexa );
+ }
+
// add volumes
for ( size_t i = 0; i < intHexa.size(); ++i )
if ( Hexahedron * hex = intHexa[ i ] )
- {
- hex->removeExcessSideDivision( allHexa );
nbAdded += hex->addVolumes( helper );
- }
// fill boundaryVolumes with volumes neighboring too small skipped volumes
if ( _grid->_toCreateFaces )
continue;
// perform intersection
- E_IntersectPoint* eip, *vip;
+ E_IntersectPoint* eip, *vip = 0;
for ( int iDirZ = 0; iDirZ < 3; ++iDirZ )
{
GridPlanes& planes = pln[ iDirZ ];
int i,j,k, cellIndex;
for ( int iC = 0; iC < 4; ++iC ) // loop on 4 cells sharing the link
{
- if ( !fourCells.GetCell( iC, i,j,k, cellIndex ))
+ if ( !fourCells.GetCell( iC, i,j,k, cellIndex, iLink ))
continue;
Hexahedron * h = hexes[ cellIndex ];
if ( !h )
h = hexes[ cellIndex ] = new Hexahedron( *this, i, j, k, cellIndex );
- const int iL = iC + iDir * 4;
- h->_hexLinks[iL]._fIntPoints.push_back( ip );
+ h->_hexLinks[iLink]._fIntPoints.push_back( ip );
h->_nbFaceIntNodes++;
//isCut = true;
}
{
curIntPnt._paramOnLine = coords[ ijk[ iDir ]] - coords[0] + _grid->_tol;
const GridLine& line = _grid->_lines[ iDir ][ lineIndex[ iL ]];
- multiset< F_IntersectPoint >::const_iterator ip =
- line._intPoints.upper_bound( curIntPnt );
- --ip;
- firstIntPnt = &(*ip);
+ if ( !line._intPoints.empty() )
+ {
+ multiset< F_IntersectPoint >::const_iterator ip =
+ line._intPoints.upper_bound( curIntPnt );
+ --ip;
+ firstIntPnt = &(*ip);
+ }
}
else if ( !link._fIntPoints.empty() )
{
cout << "BUG: not shared link. IKJ = ( "<< _i << " " << _j << " " << _k << " )" << endl
<< "n1 (" << p1.X() << ", "<< p1.Y() << ", "<< p1.Z() << " )" << endl
<< "n2 (" << p2.X() << ", "<< p2.Y() << ", "<< p2.Z() << " )" << endl;
+#else
+ (void)link; // unused in release mode
#endif
return false;
}
void Hexahedron::removeExcessSideDivision(const vector< Hexahedron* >& allHexa)
{
- if ( !_grid->IsToRemoveExcessEntities() || _volumeDefs.IsEmpty() )
- return;
- if (( _volumeDefs._quantities.empty() ) &&
- ( !_volumeDefs._next || _volumeDefs._next->_quantities.empty() ))
+ if ( ! _volumeDefs.IsPolyhedron() )
return; // not a polyhedron
// look for a divided side adjacent to a small hexahedron
std::set< TLinkDef > linkSet;
for ( size_t iLoop = 0; iLoop < loops.size(); ++iLoop )
{
- bool joined = false;
TLinkDef* beg = 0;
for ( TLinkDef* l = loops[ iLoop ]; l != beg; l = l->_next ) // walk around the iLoop
{
if ( equal->_loopIndex == l->_loopIndex )
continue; // error?
+ loopsJoined = true;
+
+ for ( size_t i = iLoop - 1; i < loops.size(); --i )
+ if ( loops[ i ] && loops[ i ]->_loopIndex == equal->_loopIndex )
+ loops[ i ] = 0;
+
// exclude l and equal and join two loops
if ( l->_prev != equal )
l->_prev->setNext( equal->_next );
if ( equal->_prev != l )
equal->_prev->setNext( l->_next );
- joined = true;
if ( volDef->_quantities[ l->_loopIndex ] > 0 )
volDef->_quantities[ l->_loopIndex ] *= -1;
if ( volDef->_quantities[ equal->_loopIndex ] > 0 )
}
beg = loops[ iLoop ];
}
- if ( joined )
- {
- loops[ iLoop ] = 0;
- loopsJoined = true;
- }
}
// update volDef
if ( loopsJoined )
{
// set unchanged polygons
- std::vector< int > newQuantities; newQuantities.reserve( volDef->_quantities.size() );
- std::vector< _volumeDef::_nodeDef > newNodes; newNodes.reserve( volDef->_nodes.size() );
- vector< SMESH_Block::TShapeID > newNames; newNames.reserve( volDef->_names.size() );
+ std::vector< int > newQuantities;
+ std::vector< _volumeDef::_nodeDef > newNodes;
+ vector< SMESH_Block::TShapeID > newNames;
+ newQuantities.reserve( volDef->_quantities.size() );
+ newNodes.reserve ( volDef->_nodes.size() );
+ newNames.reserve ( volDef->_names.size() );
for ( size_t i = 0, iLoop = 0; iLoop < volDef->_quantities.size(); ++iLoop )
{
if ( volDef->_quantities[ iLoop ] < 0 )
newNodes.insert( newNodes.end(),
volDef->_nodes.begin() + i,
volDef->_nodes.begin() + i + newQuantities.back() );
- newNames.push_back( volDef->_names[ iLoop ]);
+ newNames.push_back( volDef->_names[ iLoop ]);
i += volDef->_quantities[ iLoop ];
}
newNodes.push_back( l->_node1 );
beg = loops[ iLoop ];
}
- newNames.push_back( _hexQuads[ iF ]._name );
+ newNames.push_back( _hexQuads[ iF ]._name );
}
volDef->_quantities.swap( newQuantities );
volDef->_nodes.swap( newNodes );
return;
} // removeExcessSideDivision()
+
+ //================================================================================
+ /*!
+ * \brief Remove nodes splitting Cartesian cell edges in the case if a node
+ * is used in every cells only by two polygons sharing the edge
+ * Issue #19887.
+ */
+ //================================================================================
+
+ void Hexahedron::removeExcessNodes(vector< Hexahedron* >& allHexa)
+ {
+ if ( ! _volumeDefs.IsPolyhedron() )
+ return; // not a polyhedron
+
+ typedef vector< _volumeDef::_nodeDef >::iterator TNodeIt;
+ vector< int > nodesInPoly[ 4 ]; // node index in _volumeDefs._nodes
+ vector< int > volDefInd [ 4 ]; // index of a _volumeDefs
+ Hexahedron* hexa [ 4 ];
+ int i,j,k, cellIndex, iLink = 0, iCellLink;
+ for ( int iDir = 0; iDir < 3; ++iDir )
+ {
+ CellsAroundLink fourCells( _grid, iDir );
+ for ( int iL = 0; iL < 4; ++iL, ++iLink ) // 4 links in a direction
+ {
+ _Link& link = _hexLinks[ iLink ];
+ fourCells.Init( _i, _j, _k, iLink );
+
+ for ( size_t iP = 0; iP < link._fIntPoints.size(); ++iP ) // loop on nodes on the link
+ {
+ bool nodeRemoved = true;
+ _volumeDef::_nodeDef node; node._intPoint = link._fIntPoints[iP];
+
+ for ( size_t i = 0, nb = _volumeDefs.size(); i < nb && nodeRemoved; ++i )
+ if ( _volumeDef* vol = _volumeDefs.at( i ))
+ nodeRemoved =
+ ( std::find( vol->_nodes.begin(), vol->_nodes.end(), node ) == vol->_nodes.end() );
+ if ( nodeRemoved )
+ continue; // node already removed
+
+ // check if a node encounters zero or two times in 4 cells sharing iLink
+ // if so, the node can be removed from the cells
+ bool nodeIsOnEdge = true;
+ int nbPolyhedraWithNode = 0;
+ for ( int iC = 0; iC < 4; ++iC ) // loop on 4 cells sharing a link
+ {
+ nodesInPoly[ iC ].clear();
+ volDefInd [ iC ].clear();
+ hexa [ iC ] = 0;
+ if ( !fourCells.GetCell( iC, i,j,k, cellIndex, iCellLink ))
+ continue;
+ hexa[ iC ] = allHexa[ cellIndex ];
+ if ( !hexa[ iC ])
+ continue;
+ for ( size_t i = 0, nb = hexa[ iC ]->_volumeDefs.size(); i < nb; ++i )
+ if ( _volumeDef* vol = hexa[ iC ]->_volumeDefs.at( i ))
+ {
+ for ( TNodeIt nIt = vol->_nodes.begin(); nIt != vol->_nodes.end(); ++nIt )
+ {
+ nIt = std::find( nIt, vol->_nodes.end(), node );
+ if ( nIt != vol->_nodes.end() )
+ {
+ nodesInPoly[ iC ].push_back( std::distance( vol->_nodes.begin(), nIt ));
+ volDefInd [ iC ].push_back( i );
+ }
+ else
+ break;
+ }
+ nbPolyhedraWithNode += ( !nodesInPoly[ iC ].empty() );
+ }
+ if ( nodesInPoly[ iC ].size() != 0 &&
+ nodesInPoly[ iC ].size() != 2 )
+ {
+ nodeIsOnEdge = false;
+ break;
+ }
+ } // loop on 4 cells
+
+ // remove nodes from polyhedra
+ if ( nbPolyhedraWithNode > 0 && nodeIsOnEdge )
+ {
+ for ( int iC = 0; iC < 4; ++iC ) // loop on 4 cells sharing the link
+ {
+ if ( nodesInPoly[ iC ].empty() )
+ continue;
+ for ( int i = volDefInd[ iC ].size() - 1; i >= 0; --i )
+ {
+ _volumeDef* vol = hexa[ iC ]->_volumeDefs.at( volDefInd[ iC ][ i ]);
+ int nIndex = nodesInPoly[ iC ][ i ];
+ // decrement _quantities
+ for ( size_t iQ = 0; iQ < vol->_quantities.size(); ++iQ )
+ if ( nIndex < vol->_quantities[ iQ ])
+ {
+ vol->_quantities[ iQ ]--;
+ break;
+ }
+ else
+ {
+ nIndex -= vol->_quantities[ iQ ];
+ }
+ vol->_nodes.erase( vol->_nodes.begin() + nodesInPoly[ iC ][ i ]);
+
+ if ( i == 0 &&
+ vol->_nodes.size() == 6 * 4 &&
+ vol->_quantities.size() == 6 ) // polyhedron becomes hexahedron?
+ {
+ bool allQuads = true;
+ for ( size_t iQ = 0; iQ < vol->_quantities.size() && allQuads; ++iQ )
+ allQuads = ( vol->_quantities[ iQ ] == 4 );
+ if ( allQuads )
+ {
+ // set side nodes as this: bottom, top, top, ...
+ int iTop = 0, iBot = 0; // side indices
+ for ( int iS = 0; iS < 6; ++iS )
+ {
+ if ( vol->_names[ iS ] == SMESH_Block::ID_Fxy0 )
+ iBot = iS;
+ if ( vol->_names[ iS ] == SMESH_Block::ID_Fxy1 )
+ iTop = iS;
+ }
+ if ( iBot != 0 )
+ {
+ if ( iTop == 0 )
+ {
+ std::copy( vol->_nodes.begin(),
+ vol->_nodes.begin() + 4,
+ vol->_nodes.begin() + 4 );
+ iTop = 1;
+ }
+ std::copy( vol->_nodes.begin() + 4 * iBot,
+ vol->_nodes.begin() + 4 * ( iBot + 1),
+ vol->_nodes.begin() );
+ }
+ if ( iTop != 1 )
+ std::copy( vol->_nodes.begin() + 4 * iTop,
+ vol->_nodes.begin() + 4 * ( iTop + 1),
+ vol->_nodes.begin() + 4 );
+
+ std::copy( vol->_nodes.begin() + 4,
+ vol->_nodes.begin() + 8,
+ vol->_nodes.begin() + 8 );
+ // set up top facet nodes by comparing their uvw with bottom nodes
+ E_IntersectPoint ip[8];
+ for ( int iN = 0; iN < 8; ++iN )
+ {
+ SMESH_NodeXYZ p = vol->_nodes[ iN ].Node();
+ _grid->ComputeUVW( p, ip[ iN ]._uvw );
+ }
+ const double tol2 = _grid->_tol * _grid->_tol;
+ for ( int iN = 0; iN < 4; ++iN )
+ {
+ gp_Pnt2d pBot( ip[ iN ]._uvw[0], ip[ iN ]._uvw[1] );
+ for ( int iT = 4; iT < 8; ++iT )
+ {
+ gp_Pnt2d pTop( ip[ iT ]._uvw[0], ip[ iT ]._uvw[1] );
+ if ( pBot.SquareDistance( pTop ) < tol2 )
+ {
+ // vol->_nodes[ iN + 4 ]._node = ip[ iT ]._node;
+ // vol->_nodes[ iN + 4 ]._intPoint = 0;
+ vol->_nodes[ iN + 4 ] = vol->_nodes[ iT + 4 ];
+ break;
+ }
+ }
+ }
+ vol->_nodes.resize( 8 );
+ vol->_quantities.clear();
+ //vol->_names.clear();
+ }
+ }
+ } // loop on _volumeDefs
+ } // loop on 4 cell abound a link
+ } // if ( nodeIsOnEdge )
+ } // loop on intersection points of a link
+ } // loop on 4 links of a direction
+ } // loop on 3 directions
+
+ return;
+
+ } // removeExcessNodes()
+
+ //================================================================================
+ /*!
+ * \brief [Issue #19913] Modify _hexLinks._splits to prevent creating overlapping volumes
+ */
+ //================================================================================
+
+ void Hexahedron::preventVolumesOverlapping()
+ {
+ // Cut off a quadrangle corner if two links sharing the corner
+ // are shared by same two solids, in this case each of solids gets
+ // a triangle for it-self.
+ std::vector< TGeomID > soIDs[4];
+ for ( int iF = 0; iF < 6; ++iF ) // loop on 6 sides of a hexahedron
+ {
+ _Face& quad = _hexQuads[ iF ] ;
+
+ int iFOpposite = iF + ( iF % 2 ? -1 : 1 );
+ _Face& quadOpp = _hexQuads[ iFOpposite ] ;
+
+ int nbSides = 0, nbSidesOpp = 0;
+ for ( int iE = 0; iE < 4; ++iE ) // loop on 4 sides of a quadrangle
+ {
+ nbSides += ( quad._links [ iE ].NbResultLinks() > 0 );
+ nbSidesOpp += ( quadOpp._links[ iE ].NbResultLinks() > 0 );
+ }
+ if ( nbSides < 4 || nbSidesOpp != 2 )
+ continue;
+
+ for ( int iE = 0; iE < 4; ++iE )
+ {
+ soIDs[ iE ].clear();
+ _Node* n = quad._links[ iE ].FirstNode();
+ if ( n->_intPoint && n->_intPoint->_faceIDs.size() )
+ soIDs[ iE ] = _grid->GetSolidIDs( n->_intPoint->_faceIDs[0] );
+ }
+ if ((( soIDs[0].size() >= 2 ) +
+ ( soIDs[1].size() >= 2 ) +
+ ( soIDs[2].size() >= 2 ) +
+ ( soIDs[3].size() >= 2 ) ) < 3 )
+ continue;
+
+ bool done = false;
+ for ( int i = 0; i < 4; ++i )
+ {
+ int i1 = _grid->_helper->WrapIndex( i + 1, 4 );
+ int i2 = _grid->_helper->WrapIndex( i + 2, 4 );
+ int i3 = _grid->_helper->WrapIndex( i + 3, 4 );
+ if ( soIDs[i1].size() == 2 && soIDs[i ] != soIDs[i1] &&
+ soIDs[i2].size() == 2 && soIDs[i1] == soIDs[i2] &&
+ soIDs[i3].size() == 2 && soIDs[i2] == soIDs[i3] )
+ {
+ quad._links[ i1 ]._link->_splits.clear();
+ quad._links[ i2 ]._link->_splits.clear();
+ done = true;
+ break;
+ }
+ }
+ if ( done )
+ break;
+ }
+ return;
+ } // preventVolumesOverlapping()
+
//================================================================================
/*!
* \brief Set to _hexLinks a next portion of splits located on one side of INTERNAL FACEs
*/
//=============================================================================
-bool StdMeshers_Cartesian_3D::Evaluate(SMESH_Mesh & theMesh,
- const TopoDS_Shape & theShape,
- MapShapeNbElems& theResMap)
+bool StdMeshers_Cartesian_3D::Evaluate(SMESH_Mesh & /*theMesh*/,
+ const TopoDS_Shape & /*theShape*/,
+ MapShapeNbElems& /*theResMap*/)
{
// TODO
// std::vector<int> aResVec(SMDSEntity_Last);
// --------------------------------------------------------------------------------
// unsetting _alwaysComputed flag if "Cartesian_3D" was removed
//
- virtual void ProcessEvent(const int event,
+ virtual void ProcessEvent(const int /*event*/,
const int eventType,
SMESH_subMesh* subMeshOfSolid,
- SMESH_subMeshEventListenerData* data,
- const SMESH_Hypothesis* hyp = 0)
+ SMESH_subMeshEventListenerData* /*data*/,
+ const SMESH_Hypothesis* /*hyp*/ = 0)
{
if ( eventType == SMESH_subMesh::COMPUTE_EVENT )
{
