-// Copyright (C) 2007-2015 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : StdMeshers_CompositeHexa_3D.cxx
// Module : SMESH
// Created : Tue Nov 25 11:04:59 2008
#include "SMDS_Mesh.hxx"
#include "SMDS_MeshNode.hxx"
#include "SMDS_SetIterator.hxx"
+#include "SMESHDS_Mesh.hxx"
+#include "SMESHDS_SubMesh.hxx"
#include "SMESH_Block.hxx"
#include "SMESH_Comment.hxx"
#include "SMESH_ComputeError.hxx"
#include <set>
#include <vector>
+using namespace std;
#ifdef _DEBUG_
// #define DEB_FACES
// #define DEB_GRID
-// #define DUMP_VERT(msg,V) \
-// { TopoDS_Vertex v = V; gp_Pnt p = BRep_Tool::Pnt(v); \
-// cout << msg << "( "<< p.X()<<", "<<p.Y()<<", "<<p.Z()<<" )"<<endl;}
+// #define DUMP_VERT(msg,V) { TopoDS_Vertex v = V; gp_Pnt p = BRep_Tool::Pnt(v); cout << msg << "( "<< p.X()<<", "<<p.Y()<<", "<<p.Z()<<" )"<<endl; }
#endif
#ifndef DUMP_VERT
//================================================================================
/*!
- * \brief Convertor of a pair of integers to a sole index
+ * \brief Converter of a pair of integers to a sole index
*/
struct _Indexer
{
*/
//================================================================================
-StdMeshers_CompositeHexa_3D::StdMeshers_CompositeHexa_3D(int hypId, int studyId, SMESH_Gen* gen)
- :SMESH_3D_Algo(hypId, studyId, gen)
+StdMeshers_CompositeHexa_3D::StdMeshers_CompositeHexa_3D(int hypId, SMESH_Gen* gen)
+ :SMESH_3D_Algo(hypId, gen)
{
_name = "CompositeHexa_3D";
_shapeType = (1 << TopAbs_SHELL) | (1 << TopAbs_SOLID); // 1 bit /shape type
if ( !TopExp::CommonVertex( E1, E2, V )) return false;
const SMDS_MeshNode* n = SMESH_Algo::VertexNode( V, mesh.GetMeshDS() );
- if ( !n ) return false;
+ if ( !n ) return SMESH_Algo::IsContinuous( E1, E2 ); // meshed by "composite segment"
SMESHDS_SubMesh* sm = mesh.GetSubMeshContaining( F )->GetSubMeshDS();
if ( !sm ) return false;
int nbQuads = 0;
SMDS_ElemIteratorPtr fIt = n->GetInverseElementIterator(SMDSAbs_Face);
+ if ( !fIt->more() )
+ return SMESH_Algo::IsContinuous( E1, E2 ); // meshed by "composite segment"
while ( fIt->more() )
{
const SMDS_MeshElement* f = fIt->next();
return nbQuads == 2;
}
+ //================================================================================
+ /*!
+ * \brief Return true if a vertex holds a node and this node is used by some quadrangle
+ */
+ //================================================================================
+
+ // bool isMeshedVertex( TopoDS_Vertex& V,
+ // const SMESH_Mesh& mesh )
+ // {
+ // const SMDS_MeshNode* n = SMESH_Algo::VertexNode( V, mesh.GetMeshDS() );
+ // if ( !n ) return false;
+
+ // SMDS_ElemIteratorPtr fIt = n->GetInverseElementIterator(SMDSAbs_Face);
+ // while ( fIt->more() )
+ // {
+ // const SMDS_MeshElement* f = fIt->next();
+ // if ( f->NbCornerNodes() == 4 )
+ // return true;
+ // }
+ // return false;
+ // }
+
//================================================================================
/*!
* \brief Finds VERTEXes located at block corners
const TopTools_MapOfShape& cornerVV,
TopTools_MapOfShape& internEE)
{
- TopTools_IndexedMapOfShape subEE, subFF;
+ TopTools_IndexedMapOfShape subEE;
TopExp::MapShapes( shape, TopAbs_EDGE, subEE );
- TopExp::MapShapes( shape, TopAbs_FACE, subFF );
+ //TopExp::MapShapes( shape, TopAbs_FACE, subFF );
TopoDS_Vertex VV[2];
- TopTools_MapOfShape subChecked/*, ridgeEE*/;
+ TopTools_MapOfShape subChecked, ridgeEE;
TopTools_MapIteratorOfMapOfShape vIt( cornerVV );
for ( ; vIt.More(); vIt.Next() )
{
TopoDS_Edge ridgeE = TopoDS::Edge( *riE );
while ( !ridgeE.IsNull() )
{
+ if ( !ridgeEE.Add( ridgeE ))
+ break;
TopExp::Vertices( ridgeE, VV[0], VV[1] );
TopoDS_Shape V1 = VV[ V0.IsSame( VV[0] )];
if ( cornerVV.Contains( V1 ) )
} // loop on ridge EDGEs around a corner VERTEX
} // loop on on corner VERTEXes
+ if ( subEE.Extent() > ridgeEE.Extent() + internEE.Extent() ) // PAL23269
+ for ( int i = 1; i < subEE.Extent(); ++i )
+ if ( !ridgeEE.Contains( subEE(i) ))
+ internEE.Add( subEE(i) );
+
return true;
} // getInternalEdges()
} // namespace
if ( !fTop )
return error(COMPERR_BAD_SHAPE);
- // orient bottom egde of faces along axes of the unit box
+ // orient bottom edge of faces along axes of the unit box
fBottom->ReverseEdges();
fBack ->ReverseEdges();
fLeft ->ReverseEdges();
* \brief Computes hexahedral mesh on a box with composite sides
* \param aMesh - mesh to compute
* \param aShape - shape to mesh
- * \retval bool - succes sign
+ * \retval bool - success sign
*/
//================================================================================
nbSeg1 += Max( nbElems[ SMDSEntity_Edge ], nbElems[ SMDSEntity_Quad_Edge ]);
}
- // Get an 1D size of a box side ortogonal to lessComplexSide
+ // Get an 1D size of a box side orthogonal to lessComplexSide
int nbSeg2 = 0;
_QuadFaceGrid* ortoSide =
lessComplexSide->FindAdjacentForSide( Q_LEFT, boxFaceContainer, B_UNDEFINED );
nbSeg2 += Max( nbElems[ SMDSEntity_Edge ], nbElems[ SMDSEntity_Quad_Edge ]);
}
- // Get an 2D size of a box side ortogonal to lessComplexSide
+ // Get an 2D size of a box side orthogonal to lessComplexSide
int nbFaces = 0, nbQuadFace = 0;
list< TopoDS_Face > sideFaces;
if ( ortoSide->IsComplex() )
while ( !edges.empty()) {
sideEdges.clear();
sideEdges.splice( sideEdges.end(), edges, edges.begin());// edges.front()->sideEdges.back()
+ if ( SMESH_Algo::isDegenerated( sideEdges.back() ))
+ continue;
while ( !edges.empty() ) {
- if ( SMESH_Algo::IsContinuous( sideEdges.back(), edges.front() )) {
- sideEdges.splice( sideEdges.end(), edges, edges.begin());
- }
- else if ( SMESH_Algo::IsContinuous( sideEdges.front(), edges.back() )) {
- sideEdges.splice( sideEdges.begin(), edges, --edges.end());
- }
- else if ( isContinuousMesh( sideEdges.back(), edges.front(), f, mesh )) {
+ if ( isContinuousMesh( sideEdges.back(), edges.front(), f, mesh )) {
sideEdges.splice( sideEdges.end(), edges, edges.begin());
}
else if ( isContinuousMesh( sideEdges.front(), edges.back(), f, mesh )) {
{
const _FaceSide& otherSide = other.GetSide( i );
int iMyCommon;
- if ( mySides.Contain( otherSide, &iMyCommon ) )
+ if ( mySides.Contain( otherSide, &iMyCommon ))
{
if ( internalEdges.Contains( otherSide.Edge( 0 )))
{
DUMP_VERT("Cont 2", mySides.GetSide(iMyCommon)->LastVertex());
DUMP_VERT("Cont 3", otherSide.FirstVertex());
DUMP_VERT("Cont 4", otherSide.LastVertex());
- if ( myChildren.empty() ) {
+
+ if ( myChildren.empty() )
+ {
myChildren.push_back( *this );
myFace.Nullify();
}
+ else // find iMyCommon in myChildren
+ {
+ for ( TChildIterator children = GetChildren(); children.more(); ) {
+ const _QuadFaceGrid& child = children.next();
+ if ( child.mySides.Contain( otherSide, &iMyCommon ))
+ break;
+ }
+ }
// orient new children equally
- int otherBottomIndex = ( 4 + i - iMyCommon + 2 ) % 4;
+ int otherBottomIndex = SMESH_MesherHelper::WrapIndex( i - iMyCommon + 2, 4 );
if ( other.IsComplex() )
for ( TChildIterator children = other.GetChildren(); children.more(); ) {
myChildren.push_back( children.next() );
if ( other.IsComplex() )
for ( TChildIterator children = other.GetChildren(); children.more(); )
{
- const _QuadFaceGrid& child = children.next();
+ const _QuadFaceGrid& child = children.next();
for ( int i = 0; i < 4; ++i )
mySides.AppendSide( child.GetSide(i) );
}
{
if ( childFace->SetBottomSide( bottom, &myBottomIndex ))
{
- TChildren::iterator orientedCild = childFace;
+ TChildren::iterator orientedChild = childFace;
for ( childFace = myChildren.begin(); childFace != childEnd; ++childFace ) {
- if ( childFace != orientedCild )
+ if ( childFace != orientedChild )
childFace->SetBottomSide( childFace->GetSide( myBottomIndex ));
}
if ( sideIndex )
*/
//================================================================================
-void _QuadFaceGrid::ReverseEdges(/*int e1, int e2*/)
+void _QuadFaceGrid::ReverseEdges()
{
myReverse = !myReverse;
if ( myChildren.empty() )
{
-// mySides.GetSide( e1 )->Reverse();
-// mySides.GetSide( e2 )->Reverse();
DumpVertices();
}
else
DumpVertices();
TChildren::iterator child = myChildren.begin(), childEnd = myChildren.end();
for ( ; child != childEnd; ++child )
- child->ReverseEdges( /*e1, e2*/ );
+ child->ReverseEdges();
}
}
myGrid.resize( myIndexer.size() );
- // strore nodes bound to the bottom edge
+ // store nodes bound to the bottom edge
mySides.GetSide( Q_BOTTOM )->StoreNodes( mesh, myGrid, myReverse );
// store the rest nodes row by row
TIDSortedElemSet emptySet, avoidSet;
const SMDS_MeshElement* firstQuad = 0; // most left face above the last row of found nodes
- int nbFoundNodes = myIndexer._xSize;
+ size_t nbFoundNodes = myIndexer._xSize;
while ( nbFoundNodes != myGrid.size() )
{
// first and last nodes of the last filled row of nodes
for ( ; edge != eEnd; ++edge ) {
myChildren.push_back( _FaceSide( *edge ));
myNbChildren++;
-// myVertices.insert( myChildren.back().myVertices.begin(),
-// myChildren.back().myVertices.end() );
myVertices.Add( myChildren.back().FirstVertex() );
myVertices.Add( myChildren.back().LastVertex() );
myChildren.back().SetID( Q_CHILD ); // not to splice them
//=======================================================================
//function : GetSide
-//purpose :
+//purpose :
//=======================================================================
_FaceSide* _FaceSide::GetSide(const int i)
nodes);
if ( !ok ) return false;
+ // skip nodes on VERTEXes not included in faces
+ if ( !nodes.begin()->second->GetInverseElementIterator(SMDSAbs_Face)->more() )
+ nodes.erase( nodes.begin() );
+ if ( !nodes.empty() &&
+ !nodes.rbegin()->second->GetInverseElementIterator(SMDSAbs_Face)->more() )
+ nodes.erase( --nodes.end() );
+
bool forward = ( edge->Orientation() == TopAbs_FORWARD );
if ( reverse ) forward = !forward;
if ( forward )
