PyObject* FemMeshPy::getGroupElements(PyObject *args)
{
int id;
if (!PyArg_ParseTuple(args, "i", &id))
return 0;
std::set<int> ids;
SMDS_ElemIteratorPtr aElemIter = getFemMeshPtr()->getSMesh()->GetGroup(id)->GetGroupDS()->GetElements();
while (aElemIter->more()) {
const SMDS_MeshElement* aElement = aElemIter->next();
ids.insert(aElement->GetID());
}
Py::Tuple tuple(ids.size());
int index = 0;
for (std::set<int>::iterator it = ids.begin(); it != ids.end(); ++it) {
#if PY_MAJOR_VERSION >= 3
tuple.setItem(index++, Py::Long(*it));
#else
tuple.setItem(index++, Py::Int(*it));
#endif
}
return Py::new_reference_to(tuple);
}
int SMESHDS_GroupBase::Extent() const
{
SMDS_ElemIteratorPtr it = GetElements();
int nb = 0;
if ( it )
for ( ; it->more(); it->next() )
nb++;
return nb;
}
_MyEdgeIterator(const SMDS_QuadraticFaceOfNodes* face):myIndex(0) {
myElems.reserve( face->NbNodes() );
SMDS_ElemIteratorPtr nIt = face->interlacedNodesElemIterator();
const SMDS_MeshNode* n0 = face->GetNodeWrap( -1 );
while ( nIt->more() ) {
const SMDS_MeshNode* n1 = static_cast<const SMDS_MeshNode*>( nIt->next() );
const SMDS_MeshElement* edge = SMDS_Mesh::FindEdge( n0, n1 );
if ( edge )
myElems.push_back( edge );
n0 = n1;
}
}
bool SMESH_Algo::GetSortedNodesOnEdge(const SMESHDS_Mesh* theMesh,
const TopoDS_Edge& theEdge,
const bool ignoreMediumNodes,
map< double, const SMDS_MeshNode* > & theNodes)
{
theNodes.clear();
if ( !theMesh || theEdge.IsNull() )
return false;
SMESHDS_SubMesh * eSubMesh = theMesh->MeshElements( theEdge );
if ( !eSubMesh || !eSubMesh->GetElements()->more() )
return false; // edge is not meshed
int nbNodes = 0;
set < double > paramSet;
if ( eSubMesh )
{
// loop on nodes of an edge: sort them by param on edge
SMDS_NodeIteratorPtr nIt = eSubMesh->GetNodes();
while ( nIt->more() )
{
const SMDS_MeshNode* node = nIt->next();
if ( ignoreMediumNodes ) {
SMDS_ElemIteratorPtr elemIt = node->GetInverseElementIterator();
if ( elemIt->more() && elemIt->next()->IsMediumNode( node ))
continue;
}
const SMDS_PositionPtr& pos = node->GetPosition();
if ( pos->GetTypeOfPosition() != SMDS_TOP_EDGE )
return false;
const SMDS_EdgePosition* epos =
static_cast<const SMDS_EdgePosition*>(node->GetPosition().get());
theNodes.insert( make_pair( epos->GetUParameter(), node ));
++nbNodes;
}
}
// add vertex nodes
TopoDS_Vertex v1, v2;
TopExp::Vertices(theEdge, v1, v2);
const SMDS_MeshNode* n1 = VertexNode( v1, (SMESHDS_Mesh*) theMesh );
const SMDS_MeshNode* n2 = VertexNode( v2, (SMESHDS_Mesh*) theMesh );
Standard_Real f, l;
BRep_Tool::Range(theEdge, f, l);
if ( v1.Orientation() != TopAbs_FORWARD )
std::swap( f, l );
if ( n1 && ++nbNodes )
theNodes.insert( make_pair( f, n1 ));
if ( n2 && ++nbNodes )
theNodes.insert( make_pair( l, n2 ));
return theNodes.size() == nbNodes;
}
const SMDS_MeshElement* next()
{
if ( myType == SMDSAbs_Node && (myNodeIt!=NULL) )
return myNodeIt->next();
const SMDS_MeshElement* res = myElem;
myElem = 0;
while ( (myElemIt!=NULL) && myElemIt->more() ) {
myElem = myElemIt->next();
if ( myElem && myElem->GetType() == myType )
break;
else
myElem = 0;
}
}
bool NETGENPlugin_Mesher::fillNgMesh(netgen::OCCGeometry& occgeom,
netgen::Mesh& ngMesh,
vector<SMDS_MeshNode*>& nodeVec,
const list< SMESH_subMesh* > & meshedSM)
{
TNode2IdMap nodeNgIdMap;
TopTools_MapOfShape visitedShapes;
SMESH_MesherHelper helper (*_mesh);
int faceID = occgeom.fmap.Extent();
_faceDescriptors.clear();
list< SMESH_subMesh* >::const_iterator smIt, smEnd = meshedSM.end();
for ( smIt = meshedSM.begin(); smIt != smEnd; ++smIt )
{
SMESH_subMesh* sm = *smIt;
if ( !visitedShapes.Add( sm->GetSubShape() ))
continue;
SMESHDS_SubMesh * smDS = sm->GetSubMeshDS();
switch ( sm->GetSubShape().ShapeType() )
{
case TopAbs_EDGE: { // EDGE
// ----------------------
const TopoDS_Edge& geomEdge = TopoDS::Edge( sm->GetSubShape() );
// Add ng segments for each not meshed face the edge bounds
TopTools_MapOfShape visitedAncestors;
const TopTools_ListOfShape& ancestors = _mesh->GetAncestors( geomEdge );
TopTools_ListIteratorOfListOfShape ancestorIt ( ancestors );
for ( ; ancestorIt.More(); ancestorIt.Next() )
{
const TopoDS_Shape & ans = ancestorIt.Value();
if ( ans.ShapeType() != TopAbs_FACE || !visitedAncestors.Add( ans ))
continue;
const TopoDS_Face& face = TopoDS::Face( ans );
int faceID = occgeom.fmap.FindIndex( face );
if ( faceID < 1 )
continue; // meshed face
// find out orientation of geomEdge within face
bool isForwad = false;
for ( TopExp_Explorer exp( face, TopAbs_EDGE ); exp.More(); exp.Next() ) {
if ( geomEdge.IsSame( exp.Current() )) {
isForwad = ( exp.Current().Orientation() == geomEdge.Orientation() );
break;
}
}
bool isQuad = smDS->GetElements()->next()->IsQuadratic();
// get all nodes from geomEdge
StdMeshers_FaceSide fSide( face, geomEdge, _mesh, isForwad, isQuad );
const vector<UVPtStruct>& points = fSide.GetUVPtStruct();
int i, nbSeg = fSide.NbSegments();
double otherSeamParam = 0;
helper.SetSubShape( face );
bool isSeam = helper.IsRealSeam( geomEdge );
if ( isSeam )
otherSeamParam =
helper.GetOtherParam( helper.GetPeriodicIndex() == 1 ? points[0].u : points[0].v );
// add segments
int prevNgId = ngNodeId( points[0].node, ngMesh, nodeNgIdMap );
for ( i = 0; i < nbSeg; ++i )
{
const UVPtStruct& p1 = points[ i ];
const UVPtStruct& p2 = points[ i+1 ];
netgen::Segment seg;
// ng node ids
seg.p1 = prevNgId;
seg.p2 = prevNgId = ngNodeId( p2.node, ngMesh, nodeNgIdMap );
// node param on curve
seg.epgeominfo[ 0 ].dist = p1.param;
seg.epgeominfo[ 1 ].dist = p2.param;
// uv on face
seg.epgeominfo[ 0 ].u = p1.u;
seg.epgeominfo[ 0 ].v = p1.v;
seg.epgeominfo[ 1 ].u = p2.u;
seg.epgeominfo[ 1 ].v = p2.v;
//seg.epgeominfo[ iEnd ].edgenr = edgeID; // = geom.emap.FindIndex(edge);
seg.si = faceID; // = geom.fmap.FindIndex (face);
seg.edgenr = ngMesh.GetNSeg() + 1; // segment id
ngMesh.AddSegment (seg);
if ( isSeam )
{
if ( helper.GetPeriodicIndex() == 1 ) {
seg.epgeominfo[ 0 ].u = otherSeamParam;
seg.epgeominfo[ 1 ].u = otherSeamParam;
swap (seg.epgeominfo[0].v, seg.epgeominfo[1].v);
} else {
seg.epgeominfo[ 0 ].v = otherSeamParam;
seg.epgeominfo[ 1 ].v = otherSeamParam;
swap (seg.epgeominfo[0].u, seg.epgeominfo[1].u);
}
swap (seg.p1, seg.p2);
swap (seg.epgeominfo[0].dist, seg.epgeominfo[1].dist);
seg.edgenr = ngMesh.GetNSeg() + 1; // segment id
ngMesh.AddSegment (seg);
}
}
} // loop on geomEdge ancestors
break;
} // case TopAbs_EDGE
case TopAbs_FACE: { // FACE
// ----------------------
const TopoDS_Face& geomFace = TopoDS::Face( sm->GetSubShape() );
helper.SetSubShape( geomFace );
// Find solids the geomFace bounds
int solidID1 = 0, solidID2 = 0;
const TopTools_ListOfShape& ancestors = _mesh->GetAncestors( geomFace );
TopTools_ListIteratorOfListOfShape ancestorIt ( ancestors );
for ( ; ancestorIt.More(); ancestorIt.Next() )
{
const TopoDS_Shape & solid = ancestorIt.Value();
if ( solid.ShapeType() == TopAbs_SOLID ) {
int id = occgeom.somap.FindIndex ( solid );
if ( solidID1 && id != solidID1 ) solidID2 = id;
else solidID1 = id;
}
}
faceID++;
_faceDescriptors[ faceID ].first = solidID1;
_faceDescriptors[ faceID ].second = solidID2;
// Orient the face correctly in solidID1 (issue 0020206)
bool reverse = false;
if ( solidID1 ) {
TopoDS_Shape solid = occgeom.somap( solidID1 );
for ( TopExp_Explorer f( solid, TopAbs_FACE ); f.More(); f.Next() ) {
if ( geomFace.IsSame( f.Current() )) {
reverse = SMESH_Algo::IsReversedSubMesh( TopoDS::Face( f.Current()), helper.GetMeshDS() );
break;
}
}
}
// Add surface elements
SMDS_ElemIteratorPtr faces = smDS->GetElements();
while ( faces->more() ) {
const SMDS_MeshElement* f = faces->next();
if ( f->NbNodes() % 3 != 0 ) { // not triangle
for ( ancestorIt.Initialize(ancestors); ancestorIt.More(); ancestorIt.Next() )
if ( ancestorIt.Value().ShapeType() == TopAbs_SOLID ) {
sm = _mesh->GetSubMesh( ancestorIt.Value() );
break;
}
SMESH_ComputeErrorPtr& smError = sm->GetComputeError();
smError.reset( new SMESH_ComputeError(COMPERR_BAD_INPUT_MESH,"Not triangle submesh"));
smError->myBadElements.push_back( f );
return false;
}
netgen::Element2d tri(3);
tri.SetIndex ( faceID );
for ( int i = 0; i < 3; ++i ) {
const SMDS_MeshNode* node = f->GetNode( i ), * inFaceNode=0;
if ( helper.IsSeamShape( node->GetPosition()->GetShapeId() ))
if ( helper.IsSeamShape( f->GetNodeWrap( i+1 )->GetPosition()->GetShapeId() ))
inFaceNode = f->GetNodeWrap( i-1 );
else
inFaceNode = f->GetNodeWrap( i+1 );
gp_XY uv = helper.GetNodeUV( geomFace, node, inFaceNode );
if ( reverse ) {
tri.GeomInfoPi(3-i).u = uv.X();
tri.GeomInfoPi(3-i).v = uv.Y();
tri.PNum (3-i) = ngNodeId( node, ngMesh, nodeNgIdMap );
} else {
tri.GeomInfoPi(i+1).u = uv.X();
tri.GeomInfoPi(i+1).v = uv.Y();
tri.PNum (i+1) = ngNodeId( node, ngMesh, nodeNgIdMap );
}
}
ngMesh.AddSurfaceElement (tri);
}
break;
} //
case TopAbs_VERTEX: { // VERTEX
// --------------------------
SMDS_NodeIteratorPtr nodeIt = smDS->GetNodes();
if ( nodeIt->more() )
ngNodeId( nodeIt->next(), ngMesh, nodeNgIdMap );
break;
}
default:;
} // switch
} // loop on submeshes
// fill nodeVec
nodeVec.resize( ngMesh.GetNP() + 1 );
TNode2IdMap::iterator node_NgId, nodeNgIdEnd = nodeNgIdMap.end();
for ( node_NgId = nodeNgIdMap.begin(); node_NgId != nodeNgIdEnd; ++node_NgId)
nodeVec[ node_NgId->second ] = (SMDS_MeshNode*) node_NgId->first;
return true;
}
bool NETGENPlugin_NETGEN_3D::Compute(SMESH_Mesh& aMesh,
SMESH_MesherHelper* aHelper)
{
MESSAGE("NETGENPlugin_NETGEN_3D::Compute with maxElmentsize = " << _maxElementVolume);
const int invalid_ID = -1;
bool _quadraticMesh = false;
typedef map< const SMDS_MeshNode*, int, TIDCompare > TNodeToIDMap;
TNodeToIDMap nodeToNetgenID;
list< const SMDS_MeshElement* > triangles;
SMESHDS_Mesh* MeshDS = aHelper->GetMeshDS();
SMESH_MesherHelper::MType MeshType = aHelper->IsQuadraticMesh();
if(MeshType == SMESH_MesherHelper::COMP)
return error( COMPERR_BAD_INPUT_MESH,
SMESH_Comment("Mesh with linear and quadratic elements given."));
else if (MeshType == SMESH_MesherHelper::QUADRATIC)
_quadraticMesh = true;
StdMeshers_QuadToTriaAdaptor Adaptor;
Adaptor.Compute(aMesh);
SMDS_FaceIteratorPtr fIt = MeshDS->facesIterator();
TIDSortedElemSet sortedFaces; // 0020279: control the "random" use when using mesh algorithms
while( fIt->more()) sortedFaces.insert( fIt->next() );
TIDSortedElemSet::iterator itFace = sortedFaces.begin(), fEnd = sortedFaces.end();
for ( ; itFace != fEnd; ++itFace ) {
// check element
const SMDS_MeshElement* elem = *itFace;
if ( !elem )
return error( COMPERR_BAD_INPUT_MESH, "Null element encounters");
bool isTraingle = ( elem->NbNodes()==3 || (_quadraticMesh && elem->NbNodes()==6 ));
if ( !isTraingle ) {
//return error( COMPERR_BAD_INPUT_MESH,
// SMESH_Comment("Not triangle element ")<<elem->GetID());
// using adaptor
const list<const SMDS_FaceOfNodes*>* faces = Adaptor.GetTriangles(elem);
if(faces==0) {
return error( COMPERR_BAD_INPUT_MESH,
SMESH_Comment("Not triangles in adaptor for element ")<<elem->GetID());
}
list<const SMDS_FaceOfNodes*>::const_iterator itf = faces->begin();
for(; itf!=faces->end(); itf++ ) {
triangles.push_back( (*itf) );
// put triange's nodes to nodeToNetgenID map
SMDS_ElemIteratorPtr triangleNodesIt = (*itf)->nodesIterator();
while ( triangleNodesIt->more() ) {
const SMDS_MeshNode * node =
static_cast<const SMDS_MeshNode *>(triangleNodesIt->next());
if(aHelper->IsMedium(node))
continue;
nodeToNetgenID.insert( make_pair( node, invalid_ID ));
}
}
}
else {
// keep a triangle
triangles.push_back( elem );
// put elem nodes to nodeToNetgenID map
SMDS_ElemIteratorPtr triangleNodesIt = elem->nodesIterator();
while ( triangleNodesIt->more() ) {
const SMDS_MeshNode * node =
static_cast<const SMDS_MeshNode *>(triangleNodesIt->next());
if(aHelper->IsMedium(node))
continue;
nodeToNetgenID.insert( make_pair( node, invalid_ID ));
}
}
}
// ---------------------------------
// Feed the Netgen with surface mesh
// ---------------------------------
int Netgen_NbOfNodes = 0;
int Netgen_param2ndOrder = 0;
double Netgen_paramFine = 1.;
double Netgen_paramSize = pow( 72, 1/6. ) * pow( _maxElementVolume, 1/3. );
double Netgen_point[3];
int Netgen_triangle[3];
int Netgen_tetrahedron[4];
Ng_Init();
Ng_Mesh * Netgen_mesh = Ng_NewMesh();
// set nodes and remember thier netgen IDs
TNodeToIDMap::iterator n_id = nodeToNetgenID.begin();
for ( ; n_id != nodeToNetgenID.end(); ++n_id )
{
const SMDS_MeshNode* node = n_id->first;
Netgen_point [ 0 ] = node->X();
Netgen_point [ 1 ] = node->Y();
Netgen_point [ 2 ] = node->Z();
Ng_AddPoint(Netgen_mesh, Netgen_point);
n_id->second = ++Netgen_NbOfNodes; // set netgen ID
}
// set triangles
list< const SMDS_MeshElement* >::iterator tria = triangles.begin();
for ( ; tria != triangles.end(); ++tria)
{
int i = 0;
SMDS_ElemIteratorPtr triangleNodesIt = (*tria)->nodesIterator();
while ( triangleNodesIt->more() ) {
const SMDS_MeshNode * node =
static_cast<const SMDS_MeshNode *>(triangleNodesIt->next());
if(aHelper->IsMedium(node))
continue;
Netgen_triangle[ i ] = nodeToNetgenID[ node ];
++i;
}
Ng_AddSurfaceElement(Netgen_mesh, NG_TRIG, Netgen_triangle);
}
// -------------------------
// Generate the volume mesh
// -------------------------
Ng_Meshing_Parameters Netgen_param;
Netgen_param.secondorder = Netgen_param2ndOrder;
Netgen_param.fineness = Netgen_paramFine;
Netgen_param.maxh = Netgen_paramSize;
Ng_Result status;
try {
#if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
OCC_CATCH_SIGNALS;
#endif
status = Ng_GenerateVolumeMesh(Netgen_mesh, &Netgen_param);
}
catch (Standard_Failure& exc) {
error(COMPERR_OCC_EXCEPTION, exc.GetMessageString());
status = NG_VOLUME_FAILURE;
}
catch (...) {
error("Bad mesh input!!!");
status = NG_VOLUME_FAILURE;
}
if ( GetComputeError()->IsOK() ) {
error( status, "Bad mesh input!!!");
}
int Netgen_NbOfNodesNew = Ng_GetNP(Netgen_mesh);
int Netgen_NbOfTetra = Ng_GetNE(Netgen_mesh);
MESSAGE("End of Volume Mesh Generation. status=" << status <<
", nb new nodes: " << Netgen_NbOfNodesNew - Netgen_NbOfNodes <<
", nb tetra: " << Netgen_NbOfTetra);
// -------------------------------------------------------------------
// Feed back the SMESHDS with the generated Nodes and Volume Elements
// -------------------------------------------------------------------
bool isOK = ( Netgen_NbOfTetra > 0 );// get whatever built
if ( isOK )
{
// vector of nodes in which node index == netgen ID
vector< const SMDS_MeshNode* > nodeVec ( Netgen_NbOfNodesNew + 1 );
// insert old nodes into nodeVec
for ( n_id = nodeToNetgenID.begin(); n_id != nodeToNetgenID.end(); ++n_id ) {
nodeVec.at( n_id->second ) = n_id->first;
}
// create and insert new nodes into nodeVec
int nodeIndex = Netgen_NbOfNodes + 1;
for ( ; nodeIndex <= Netgen_NbOfNodesNew; ++nodeIndex )
{
Ng_GetPoint( Netgen_mesh, nodeIndex, Netgen_point );
SMDS_MeshNode * node = aHelper->AddNode(Netgen_point[0],
Netgen_point[1],
Netgen_point[2]);
nodeVec.at(nodeIndex) = node;
}
// create tetrahedrons
for ( int elemIndex = 1; elemIndex <= Netgen_NbOfTetra; ++elemIndex )
{
Ng_GetVolumeElement(Netgen_mesh, elemIndex, Netgen_tetrahedron);
aHelper->AddVolume (nodeVec.at( Netgen_tetrahedron[0] ),
nodeVec.at( Netgen_tetrahedron[1] ),
nodeVec.at( Netgen_tetrahedron[2] ),
nodeVec.at( Netgen_tetrahedron[3] ));
}
}
Ng_DeleteMesh(Netgen_mesh);
Ng_Exit();
NETGENPlugin_Mesher::RemoveTmpFiles();
return (status == NG_OK);
}
bool NETGENPlugin_NETGEN_3D::Compute(SMESH_Mesh& aMesh,
const TopoDS_Shape& aShape)
{
MESSAGE("NETGENPlugin_NETGEN_3D::Compute with maxElmentsize = " << _maxElementVolume);
SMESHDS_Mesh* meshDS = aMesh.GetMeshDS();
const int invalid_ID = -1;
SMESH::Controls::Area areaControl;
SMESH::Controls::TSequenceOfXYZ nodesCoords;
// -------------------------------------------------------------------
// get triangles on aShell and make a map of nodes to Netgen node IDs
// -------------------------------------------------------------------
SMESH_MesherHelper helper(aMesh);
SMESH_MesherHelper* myTool = &helper;
bool _quadraticMesh = myTool->IsQuadraticSubMesh(aShape);
typedef map< const SMDS_MeshNode*, int, TIDCompare > TNodeToIDMap;
TNodeToIDMap nodeToNetgenID;
list< const SMDS_MeshElement* > triangles;
list< bool > isReversed; // orientation of triangles
TopAbs_ShapeEnum mainType = aMesh.GetShapeToMesh().ShapeType();
bool checkReverse = ( mainType == TopAbs_COMPOUND || mainType == TopAbs_COMPSOLID );
// for the degeneraged edge: ignore all but one node on it;
// map storing ids of degen edges and vertices and their netgen id:
map< int, int* > degenShapeIdToPtrNgId;
map< int, int* >::iterator shId_ngId;
list< int > degenNgIds;
StdMeshers_QuadToTriaAdaptor Adaptor;
Adaptor.Compute(aMesh,aShape);
for (TopExp_Explorer exp(aShape,TopAbs_FACE); exp.More(); exp.Next())
{
const TopoDS_Shape& aShapeFace = exp.Current();
const SMESHDS_SubMesh * aSubMeshDSFace = meshDS->MeshElements( aShapeFace );
if ( aSubMeshDSFace )
{
bool isRev = false;
if ( checkReverse && helper.NbAncestors(aShapeFace, aMesh, aShape.ShapeType()) > 1 )
// IsReversedSubMesh() can work wrong on strongly curved faces,
// so we use it as less as possible
isRev = SMESH_Algo::IsReversedSubMesh( TopoDS::Face(aShapeFace), meshDS );
SMDS_ElemIteratorPtr iteratorElem = aSubMeshDSFace->GetElements();
while ( iteratorElem->more() ) // loop on elements on a face
{
// check element
const SMDS_MeshElement* elem = iteratorElem->next();
if ( !elem )
return error( COMPERR_BAD_INPUT_MESH, "Null element encounters");
bool isTraingle = ( elem->NbNodes()==3 || (_quadraticMesh && elem->NbNodes()==6 ));
if ( !isTraingle ) {
//return error( COMPERR_BAD_INPUT_MESH,
// SMESH_Comment("Not triangle element ")<<elem->GetID());
// using adaptor
const list<const SMDS_FaceOfNodes*>* faces = Adaptor.GetTriangles(elem);
if(faces==0) {
return error( COMPERR_BAD_INPUT_MESH,
SMESH_Comment("Not triangles in adaptor for element ")<<elem->GetID());
}
list<const SMDS_FaceOfNodes*>::const_iterator itf = faces->begin();
for(; itf!=faces->end(); itf++ ) {
triangles.push_back( (*itf) );
isReversed.push_back( isRev );
// put triange's nodes to nodeToNetgenID map
SMDS_ElemIteratorPtr triangleNodesIt = (*itf)->nodesIterator();
while ( triangleNodesIt->more() ) {
const SMDS_MeshNode * node =
static_cast<const SMDS_MeshNode *>(triangleNodesIt->next());
if(myTool->IsMedium(node))
continue;
nodeToNetgenID.insert( make_pair( node, invalid_ID ));
}
}
}
else {
// keep a triangle
triangles.push_back( elem );
isReversed.push_back( isRev );
// put elem nodes to nodeToNetgenID map
SMDS_ElemIteratorPtr triangleNodesIt = elem->nodesIterator();
while ( triangleNodesIt->more() ) {
const SMDS_MeshNode * node =
static_cast<const SMDS_MeshNode *>(triangleNodesIt->next());
if(myTool->IsMedium(node))
continue;
nodeToNetgenID.insert( make_pair( node, invalid_ID ));
}
}
#ifdef _DEBUG_
// check if a trainge is degenerated
areaControl.GetPoints( elem, nodesCoords );
double area = areaControl.GetValue( nodesCoords );
if ( area <= DBL_MIN ) {
MESSAGE( "Warning: Degenerated " << elem );
}
#endif
}
// look for degeneraged edges and vetices
for (TopExp_Explorer expE(aShapeFace,TopAbs_EDGE); expE.More(); expE.Next())
{
TopoDS_Edge aShapeEdge = TopoDS::Edge( expE.Current() );
if ( BRep_Tool::Degenerated( aShapeEdge ))
{
degenNgIds.push_back( invalid_ID );
int* ptrIdOnEdge = & degenNgIds.back();
// remember edge id
int edgeID = meshDS->ShapeToIndex( aShapeEdge );
degenShapeIdToPtrNgId.insert( make_pair( edgeID, ptrIdOnEdge ));
// remember vertex id
int vertexID = meshDS->ShapeToIndex( TopExp::FirstVertex( aShapeEdge ));
degenShapeIdToPtrNgId.insert( make_pair( vertexID, ptrIdOnEdge ));
}
}
}
}
// ---------------------------------
// Feed the Netgen with surface mesh
// ---------------------------------
int Netgen_NbOfNodes = 0;
int Netgen_param2ndOrder = 0;
double Netgen_paramFine = 1.;
double Netgen_paramSize = pow( 72, 1/6. ) * pow( _maxElementVolume, 1/3. );
double Netgen_point[3];
int Netgen_triangle[3];
int Netgen_tetrahedron[4];
Ng_Init();
Ng_Mesh * Netgen_mesh = Ng_NewMesh();
// set nodes and remember thier netgen IDs
bool isDegen = false, hasDegen = !degenShapeIdToPtrNgId.empty();
TNodeToIDMap::iterator n_id = nodeToNetgenID.begin();
for ( ; n_id != nodeToNetgenID.end(); ++n_id )
{
const SMDS_MeshNode* node = n_id->first;
// ignore nodes on degenerated edge
if ( hasDegen ) {
int shapeId = node->GetPosition()->GetShapeId();
shId_ngId = degenShapeIdToPtrNgId.find( shapeId );
isDegen = ( shId_ngId != degenShapeIdToPtrNgId.end() );
if ( isDegen && *(shId_ngId->second) != invalid_ID ) {
n_id->second = *(shId_ngId->second);
continue;
}
}
Netgen_point [ 0 ] = node->X();
Netgen_point [ 1 ] = node->Y();
Netgen_point [ 2 ] = node->Z();
Ng_AddPoint(Netgen_mesh, Netgen_point);
n_id->second = ++Netgen_NbOfNodes; // set netgen ID
if ( isDegen ) // all nodes on a degen edge get one netgen ID
*(shId_ngId->second) = n_id->second;
}
// set triangles
list< const SMDS_MeshElement* >::iterator tria = triangles.begin();
list< bool >::iterator reverse = isReversed.begin();
for ( ; tria != triangles.end(); ++tria, ++reverse )
{
int i = 0;
SMDS_ElemIteratorPtr triangleNodesIt = (*tria)->nodesIterator();
while ( triangleNodesIt->more() ) {
const SMDS_MeshNode * node =
static_cast<const SMDS_MeshNode *>(triangleNodesIt->next());
if(myTool->IsMedium(node))
continue;
Netgen_triangle[ *reverse ? 2 - i : i ] = nodeToNetgenID[ node ];
++i;
}
if ( !hasDegen ||
// ignore degenerated triangles, they have 2 or 3 same ids
(Netgen_triangle[0] != Netgen_triangle[1] &&
Netgen_triangle[0] != Netgen_triangle[2] &&
Netgen_triangle[2] != Netgen_triangle[1] ))
{
Ng_AddSurfaceElement(Netgen_mesh, NG_TRIG, Netgen_triangle);
}
}
// -------------------------
// Generate the volume mesh
// -------------------------
Ng_Meshing_Parameters Netgen_param;
Netgen_param.secondorder = Netgen_param2ndOrder;
Netgen_param.fineness = Netgen_paramFine;
Netgen_param.maxh = Netgen_paramSize;
Ng_Result status;
try {
#if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
OCC_CATCH_SIGNALS;
#endif
status = Ng_GenerateVolumeMesh(Netgen_mesh, &Netgen_param);
}
catch (Standard_Failure& exc) {
error(COMPERR_OCC_EXCEPTION, exc.GetMessageString());
status = NG_VOLUME_FAILURE;
}
catch (...) {
error("Exception in Ng_GenerateVolumeMesh()");
status = NG_VOLUME_FAILURE;
}
if ( GetComputeError()->IsOK() ) {
switch ( status ) {
case NG_SURFACE_INPUT_ERROR:
error( status, "NG_SURFACE_INPUT_ERROR");
case NG_VOLUME_FAILURE:
error( status, "NG_VOLUME_FAILURE");
case NG_STL_INPUT_ERROR:
error( status, "NG_STL_INPUT_ERROR");
case NG_SURFACE_FAILURE:
error( status, "NG_SURFACE_FAILURE");
case NG_FILE_NOT_FOUND:
error( status, "NG_FILE_NOT_FOUND");
};
}
int Netgen_NbOfNodesNew = Ng_GetNP(Netgen_mesh);
int Netgen_NbOfTetra = Ng_GetNE(Netgen_mesh);
MESSAGE("End of Volume Mesh Generation. status=" << status <<
", nb new nodes: " << Netgen_NbOfNodesNew - Netgen_NbOfNodes <<
", nb tetra: " << Netgen_NbOfTetra);
// -------------------------------------------------------------------
// Feed back the SMESHDS with the generated Nodes and Volume Elements
// -------------------------------------------------------------------
bool isOK = ( /*status == NG_OK &&*/ Netgen_NbOfTetra > 0 );// get whatever built
if ( isOK )
{
// vector of nodes in which node index == netgen ID
vector< const SMDS_MeshNode* > nodeVec ( Netgen_NbOfNodesNew + 1 );
// insert old nodes into nodeVec
for ( n_id = nodeToNetgenID.begin(); n_id != nodeToNetgenID.end(); ++n_id ) {
nodeVec.at( n_id->second ) = n_id->first;
}
// create and insert new nodes into nodeVec
int nodeIndex = Netgen_NbOfNodes + 1;
int shapeID = meshDS->ShapeToIndex( aShape );
for ( ; nodeIndex <= Netgen_NbOfNodesNew; ++nodeIndex )
{
Ng_GetPoint( Netgen_mesh, nodeIndex, Netgen_point );
SMDS_MeshNode * node = meshDS->AddNode(Netgen_point[0],
Netgen_point[1],
Netgen_point[2]);
meshDS->SetNodeInVolume(node, shapeID);
nodeVec.at(nodeIndex) = node;
}
// create tetrahedrons
for ( int elemIndex = 1; elemIndex <= Netgen_NbOfTetra; ++elemIndex )
{
Ng_GetVolumeElement(Netgen_mesh, elemIndex, Netgen_tetrahedron);
SMDS_MeshVolume * elt = myTool->AddVolume (nodeVec.at( Netgen_tetrahedron[0] ),
nodeVec.at( Netgen_tetrahedron[1] ),
nodeVec.at( Netgen_tetrahedron[2] ),
nodeVec.at( Netgen_tetrahedron[3] ));
meshDS->SetMeshElementOnShape(elt, shapeID );
}
}
Ng_DeleteMesh(Netgen_mesh);
Ng_Exit();
NETGENPlugin_Mesher::RemoveTmpFiles();
return (status == NG_OK);
}
bool NETGENPlugin_NETGEN_3D::Compute(SMESH_Mesh& aMesh,
SMESH_MesherHelper* aHelper)
{
const int invalid_ID = -1;
netgen::multithread.terminate = 0;
_progressByTic = -1.;
SMESH_MesherHelper::MType MeshType = aHelper->IsQuadraticMesh();
if ( MeshType == SMESH_MesherHelper::COMP )
return error( COMPERR_BAD_INPUT_MESH,
SMESH_Comment("Mesh with linear and quadratic elements given"));
aHelper->SetIsQuadratic( MeshType == SMESH_MesherHelper::QUADRATIC );
// ---------------------------------
// Feed the Netgen with surface mesh
// ---------------------------------
int Netgen_NbOfNodes = 0;
int Netgen_param2ndOrder = 0;
double Netgen_paramFine = 1.;
double Netgen_paramSize = pow( 72, 1/6. ) * pow( _maxElementVolume, 1/3. );
double Netgen_point[3];
int Netgen_triangle[3];
int Netgen_tetrahedron[4];
NETGENPlugin_NetgenLibWrapper ngLib;
Ng_Mesh * Netgen_mesh = ngLib._ngMesh;
SMESH_ProxyMesh::Ptr proxyMesh( new SMESH_ProxyMesh( aMesh ));
if ( aMesh.NbQuadrangles() > 0 )
{
StdMeshers_QuadToTriaAdaptor* Adaptor = new StdMeshers_QuadToTriaAdaptor;
Adaptor->Compute(aMesh);
proxyMesh.reset( Adaptor );
}
// maps nodes to ng ID
typedef map< const SMDS_MeshNode*, int, TIDCompare > TNodeToIDMap;
typedef TNodeToIDMap::value_type TN2ID;
TNodeToIDMap nodeToNetgenID;
SMDS_ElemIteratorPtr fIt = proxyMesh->GetFaces();
while( fIt->more())
{
// check element
const SMDS_MeshElement* elem = fIt->next();
if ( !elem )
return error( COMPERR_BAD_INPUT_MESH, "Null element encounters");
if ( elem->NbCornerNodes() != 3 )
return error( COMPERR_BAD_INPUT_MESH, "Not triangle element encounters");
// add three nodes of triangle
for ( int iN = 0; iN < 3; ++iN )
{
const SMDS_MeshNode* node = elem->GetNode( iN );
int& ngID = nodeToNetgenID.insert(TN2ID( node, invalid_ID )).first->second;
if ( ngID == invalid_ID )
{
ngID = ++Netgen_NbOfNodes;
Netgen_point [ 0 ] = node->X();
Netgen_point [ 1 ] = node->Y();
Netgen_point [ 2 ] = node->Z();
Ng_AddPoint(Netgen_mesh, Netgen_point);
}
Netgen_triangle[ iN ] = ngID;
}
Ng_AddSurfaceElement(Netgen_mesh, NG_TRIG, Netgen_triangle);
}
proxyMesh.reset(); // delete tmp faces
// vector of nodes in which node index == netgen ID
vector< const SMDS_MeshNode* > nodeVec ( nodeToNetgenID.size() + 1 );
// insert old nodes into nodeVec
TNodeToIDMap::iterator n_id = nodeToNetgenID.begin();
for ( ; n_id != nodeToNetgenID.end(); ++n_id )
nodeVec.at( n_id->second ) = n_id->first;
nodeToNetgenID.clear();
// -------------------------
// Generate the volume mesh
// -------------------------
return ( ngLib._isComputeOk = compute( aMesh, *aHelper, nodeVec, Netgen_mesh));
}
bool SMESHDS_GroupBase::IsEmpty()
{
SMDS_ElemIteratorPtr it = GetElements();
return ( !it || !it->more() );
}
bool NETGENPlugin_NETGEN_3D::Compute(SMESH_Mesh& aMesh,
const TopoDS_Shape& aShape)
{
netgen::multithread.terminate = 0;
netgen::multithread.task = "Volume meshing";
_progressByTic = -1.;
SMESHDS_Mesh* meshDS = aMesh.GetMeshDS();
SMESH_MesherHelper helper(aMesh);
bool _quadraticMesh = helper.IsQuadraticSubMesh(aShape);
helper.SetElementsOnShape( true );
int Netgen_NbOfNodes = 0;
double Netgen_point[3];
int Netgen_triangle[3];
NETGENPlugin_NetgenLibWrapper ngLib;
Ng_Mesh * Netgen_mesh = ngLib._ngMesh;
// vector of nodes in which node index == netgen ID
vector< const SMDS_MeshNode* > nodeVec;
{
const int invalid_ID = -1;
SMESH::Controls::Area areaControl;
SMESH::Controls::TSequenceOfXYZ nodesCoords;
// maps nodes to ng ID
typedef map< const SMDS_MeshNode*, int, TIDCompare > TNodeToIDMap;
typedef TNodeToIDMap::value_type TN2ID;
TNodeToIDMap nodeToNetgenID;
// find internal shapes
NETGENPlugin_Internals internals( aMesh, aShape, /*is3D=*/true );
// ---------------------------------
// Feed the Netgen with surface mesh
// ---------------------------------
TopAbs_ShapeEnum mainType = aMesh.GetShapeToMesh().ShapeType();
bool checkReverse = ( mainType == TopAbs_COMPOUND || mainType == TopAbs_COMPSOLID );
SMESH_ProxyMesh::Ptr proxyMesh( new SMESH_ProxyMesh( aMesh ));
if ( _viscousLayersHyp )
{
netgen::multithread.percent = 3;
proxyMesh = _viscousLayersHyp->Compute( aMesh, aShape );
if ( !proxyMesh )
return false;
}
if ( aMesh.NbQuadrangles() > 0 )
{
netgen::multithread.percent = 6;
StdMeshers_QuadToTriaAdaptor* Adaptor = new StdMeshers_QuadToTriaAdaptor;
Adaptor->Compute(aMesh,aShape,proxyMesh.get());
proxyMesh.reset( Adaptor );
}
for ( TopExp_Explorer exFa( aShape, TopAbs_FACE ); exFa.More(); exFa.Next())
{
const TopoDS_Shape& aShapeFace = exFa.Current();
int faceID = meshDS->ShapeToIndex( aShapeFace );
bool isInternalFace = internals.isInternalShape( faceID );
bool isRev = false;
if ( checkReverse && !isInternalFace &&
helper.NbAncestors(aShapeFace, aMesh, aShape.ShapeType()) > 1 )
// IsReversedSubMesh() can work wrong on strongly curved faces,
// so we use it as less as possible
isRev = helper.IsReversedSubMesh( TopoDS::Face( aShapeFace ));
const SMESHDS_SubMesh * aSubMeshDSFace = proxyMesh->GetSubMesh( aShapeFace );
if ( !aSubMeshDSFace ) continue;
SMDS_ElemIteratorPtr iteratorElem = aSubMeshDSFace->GetElements();
while ( iteratorElem->more() ) // loop on elements on a geom face
{
// check mesh face
const SMDS_MeshElement* elem = iteratorElem->next();
if ( !elem )
return error( COMPERR_BAD_INPUT_MESH, "Null element encounters");
if ( elem->NbCornerNodes() != 3 )
return error( COMPERR_BAD_INPUT_MESH, "Not triangle element encounters");
// Add nodes of triangles and triangles them-selves to netgen mesh
// add three nodes of triangle
bool hasDegen = false;
for ( int iN = 0; iN < 3; ++iN )
{
const SMDS_MeshNode* node = elem->GetNode( iN );
const int shapeID = node->getshapeId();
if ( node->GetPosition()->GetTypeOfPosition() == SMDS_TOP_EDGE &&
helper.IsDegenShape( shapeID ))
{
// ignore all nodes on degeneraged edge and use node on its vertex instead
TopoDS_Shape vertex = TopoDS_Iterator( meshDS->IndexToShape( shapeID )).Value();
node = SMESH_Algo::VertexNode( TopoDS::Vertex( vertex ), meshDS );
hasDegen = true;
}
int& ngID = nodeToNetgenID.insert(TN2ID( node, invalid_ID )).first->second;
if ( ngID == invalid_ID )
{
ngID = ++Netgen_NbOfNodes;
Netgen_point [ 0 ] = node->X();
Netgen_point [ 1 ] = node->Y();
Netgen_point [ 2 ] = node->Z();
Ng_AddPoint(Netgen_mesh, Netgen_point);
}
Netgen_triangle[ isRev ? 2-iN : iN ] = ngID;
}
// add triangle
if ( hasDegen && (Netgen_triangle[0] == Netgen_triangle[1] ||
Netgen_triangle[0] == Netgen_triangle[2] ||
Netgen_triangle[2] == Netgen_triangle[1] ))
continue;
Ng_AddSurfaceElement(Netgen_mesh, NG_TRIG, Netgen_triangle);
if ( isInternalFace && !proxyMesh->IsTemporary( elem ))
{
swap( Netgen_triangle[1], Netgen_triangle[2] );
Ng_AddSurfaceElement(Netgen_mesh, NG_TRIG, Netgen_triangle);
}
} // loop on elements on a face
} // loop on faces of a SOLID or SHELL
// insert old nodes into nodeVec
nodeVec.resize( nodeToNetgenID.size() + 1, 0 );
TNodeToIDMap::iterator n_id = nodeToNetgenID.begin();
for ( ; n_id != nodeToNetgenID.end(); ++n_id )
nodeVec[ n_id->second ] = n_id->first;
nodeToNetgenID.clear();
if ( internals.hasInternalVertexInSolid() )
{
netgen::OCCGeometry occgeo;
NETGENPlugin_Mesher::AddIntVerticesInSolids( occgeo,
(netgen::Mesh&) *Netgen_mesh,
nodeVec,
internals);
}
}
// -------------------------
// Generate the volume mesh
// -------------------------
return ( ngLib._isComputeOk = compute( aMesh, helper, nodeVec, Netgen_mesh));
}
bool StdMeshers_RadialPrism_3D::Compute(SMESH_Mesh& aMesh, const TopoDS_Shape& aShape)
{
TopExp_Explorer exp;
SMESHDS_Mesh * meshDS = aMesh.GetMeshDS();
myHelper = new SMESH_MesherHelper( aMesh );
myHelper->IsQuadraticSubMesh( aShape );
// to delete helper at exit from Compute()
std::auto_ptr<SMESH_MesherHelper> helperDeleter( myHelper );
// get 2 shells
TopoDS_Solid solid = TopoDS::Solid( aShape );
TopoDS_Shell outerShell = BRepClass3d::OuterShell( solid );
TopoDS_Shape innerShell;
int nbShells = 0;
for ( TopoDS_Iterator It (solid); It.More(); It.Next(), ++nbShells )
if ( !outerShell.IsSame( It.Value() ))
innerShell = It.Value();
if ( nbShells != 2 )
return error(COMPERR_BAD_SHAPE, SMESH_Comment("Must be 2 shells but not ")<<nbShells);
// ----------------------------------
// Associate sub-shapes of the shells
// ----------------------------------
ProjectionUtils::TShapeShapeMap shape2ShapeMaps[2];
bool mapOk1 = ProjectionUtils::FindSubShapeAssociation( innerShell, &aMesh,
outerShell, &aMesh,
shape2ShapeMaps[0]);
bool mapOk2 = ProjectionUtils::FindSubShapeAssociation( innerShell.Reversed(), &aMesh,
outerShell, &aMesh,
shape2ShapeMaps[1]);
if ( !mapOk1 && !mapOk2 )
return error(COMPERR_BAD_SHAPE,"Topology of inner and outer shells seems different" );
int iMap;
if ( shape2ShapeMaps[0].Extent() == shape2ShapeMaps[1].Extent() )
{
// choose an assiciation by shortest distance between VERTEXes
double dist1 = 0, dist2 = 0;
TopTools_DataMapIteratorOfDataMapOfShapeShape ssIt( shape2ShapeMaps[0]._map1to2 );
for (; ssIt.More(); ssIt.Next() )
{
if ( ssIt.Key().ShapeType() != TopAbs_VERTEX ) continue;
gp_Pnt pIn = BRep_Tool::Pnt( TopoDS::Vertex( ssIt.Key() ));
gp_Pnt pOut1 = BRep_Tool::Pnt( TopoDS::Vertex( ssIt.Value() ));
gp_Pnt pOut2 = BRep_Tool::Pnt( TopoDS::Vertex( shape2ShapeMaps[1]( ssIt.Key() )));
dist1 += pIn.SquareDistance( pOut1 );
dist2 += pIn.SquareDistance( pOut2 );
}
iMap = ( dist1 < dist2 ) ? 0 : 1;
}
else
{
iMap = ( shape2ShapeMaps[0].Extent() > shape2ShapeMaps[1].Extent() ) ? 0 : 1;
}
ProjectionUtils::TShapeShapeMap& shape2ShapeMap = shape2ShapeMaps[iMap];
// ------------------
// Make mesh
// ------------------
TNode2ColumnMap node2columnMap;
myLayerPositions.clear();
for ( exp.Init( outerShell, TopAbs_FACE ); exp.More(); exp.Next() )
{
// Corresponding sub-shapes
TopoDS_Face outFace = TopoDS::Face( exp.Current() );
TopoDS_Face inFace;
if ( !shape2ShapeMap.IsBound( outFace, /*isOut=*/true )) {
return error(SMESH_Comment("Corresponding inner face not found for face #" )
<< meshDS->ShapeToIndex( outFace ));
} else {
inFace = TopoDS::Face( shape2ShapeMap( outFace, /*isOut=*/true ));
}
// Find matching nodes of in and out faces
ProjectionUtils::TNodeNodeMap nodeIn2OutMap;
if ( ! ProjectionUtils::FindMatchingNodesOnFaces( inFace, &aMesh, outFace, &aMesh,
shape2ShapeMap, nodeIn2OutMap ))
return error(COMPERR_BAD_INPUT_MESH,SMESH_Comment("Mesh on faces #")
<< meshDS->ShapeToIndex( outFace ) << " and "
<< meshDS->ShapeToIndex( inFace ) << " seems different" );
// Create volumes
SMDS_ElemIteratorPtr faceIt = meshDS->MeshElements( inFace )->GetElements();
while ( faceIt->more() ) // loop on faces on inFace
{
const SMDS_MeshElement* face = faceIt->next();
if ( !face || face->GetType() != SMDSAbs_Face )
continue;
int nbNodes = face->NbNodes();
if ( face->IsQuadratic() )
nbNodes /= 2;
// find node columns for each node
vector< const TNodeColumn* > columns( nbNodes );
for ( int i = 0; i < nbNodes; ++i )
{
const SMDS_MeshNode* nIn = face->GetNode( i );
TNode2ColumnMap::iterator n_col = node2columnMap.find( nIn );
if ( n_col != node2columnMap.end() ) {
columns[ i ] = & n_col->second;
}
else {
TNodeNodeMap::iterator nInOut = nodeIn2OutMap.find( nIn );
if ( nInOut == nodeIn2OutMap.end() )
RETURN_BAD_RESULT("No matching node for "<< nIn->GetID() <<
" in face "<< face->GetID());
columns[ i ] = makeNodeColumn( node2columnMap, nIn, nInOut->second );
}
}
StdMeshers_Prism_3D::AddPrisms( columns, myHelper );
}
} // loop on faces of out shell
return true;
}
bool SMESH_Algo::IsReversedSubMesh (const TopoDS_Face& theFace,
SMESHDS_Mesh* theMeshDS)
{
if ( theFace.IsNull() || !theMeshDS )
return false;
// find out orientation of a meshed face
int faceID = theMeshDS->ShapeToIndex( theFace );
TopoDS_Shape aMeshedFace = theMeshDS->IndexToShape( faceID );
bool isReversed = ( theFace.Orientation() != aMeshedFace.Orientation() );
const SMESHDS_SubMesh * aSubMeshDSFace = theMeshDS->MeshElements( faceID );
if ( !aSubMeshDSFace )
return isReversed;
// find element with node located on face and get its normal
const SMDS_FacePosition* facePos = 0;
int vertexID = 0;
gp_Pnt nPnt[3];
gp_Vec Ne;
bool normalOK = false;
SMDS_ElemIteratorPtr iteratorElem = aSubMeshDSFace->GetElements();
while ( iteratorElem->more() ) // loop on elements on theFace
{
const SMDS_MeshElement* elem = iteratorElem->next();
if ( elem && elem->NbNodes() > 2 ) {
SMDS_ElemIteratorPtr nodesIt = elem->nodesIterator();
const SMDS_FacePosition* fPos = 0;
int i = 0, vID = 0;
while ( nodesIt->more() ) { // loop on nodes
const SMDS_MeshNode* node
= static_cast<const SMDS_MeshNode *>(nodesIt->next());
if ( i == 3 ) i = 2;
nPnt[ i++ ].SetCoord( node->X(), node->Y(), node->Z() );
// check position
const SMDS_PositionPtr& pos = node->GetPosition();
if ( !pos ) continue;
if ( pos->GetTypeOfPosition() == SMDS_TOP_FACE ) {
fPos = dynamic_cast< const SMDS_FacePosition* >( pos.get() );
}
else if ( pos->GetTypeOfPosition() == SMDS_TOP_VERTEX ) {
vID = pos->GetShapeId();
}
}
if ( fPos || ( !normalOK && vID )) {
// compute normal
gp_Vec v01( nPnt[0], nPnt[1] ), v02( nPnt[0], nPnt[2] );
if ( v01.SquareMagnitude() > RealSmall() &&
v02.SquareMagnitude() > RealSmall() )
{
Ne = v01 ^ v02;
normalOK = ( Ne.SquareMagnitude() > RealSmall() );
}
// we need position on theFace or at least on vertex
if ( normalOK ) {
vertexID = vID;
if ((facePos = fPos))
break;
}
}
}
}
if ( !normalOK )
return isReversed;
// node position on face
double u,v;
if ( facePos ) {
u = facePos->GetUParameter();
v = facePos->GetVParameter();
}
else if ( vertexID ) {
TopoDS_Shape V = theMeshDS->IndexToShape( vertexID );
if ( V.IsNull() || V.ShapeType() != TopAbs_VERTEX )
return isReversed;
gp_Pnt2d uv = BRep_Tool::Parameters( TopoDS::Vertex( V ), theFace );
u = uv.X();
v = uv.Y();
}
else
{
return isReversed;
}
// face normal at node position
TopLoc_Location loc;
Handle(Geom_Surface) surf = BRep_Tool::Surface( theFace, loc );
if ( surf.IsNull() || surf->Continuity() < GeomAbs_C1 ) return isReversed;
gp_Vec d1u, d1v;
surf->D1( u, v, nPnt[0], d1u, d1v );
gp_Vec Nf = (d1u ^ d1v).Transformed( loc );
if ( theFace.Orientation() == TopAbs_REVERSED )
Nf.Reverse();
return Ne * Nf < 0.;
}
bool StdMeshers_RadialPrism_3D::Compute(SMESH_Mesh& aMesh, const TopoDS_Shape& aShape)
{
TopExp_Explorer exp;
SMESHDS_Mesh * meshDS = aMesh.GetMeshDS();
myHelper = new SMESH_MesherHelper( aMesh );
myHelper->IsQuadraticSubMesh( aShape );
// to delete helper at exit from Compute()
std::auto_ptr<SMESH_MesherHelper> helperDeleter( myHelper );
// get 2 shells
TopoDS_Solid solid = TopoDS::Solid( aShape );
TopoDS_Shell outerShell = BRepClass3d::OuterShell( solid );
TopoDS_Shape innerShell;
int nbShells = 0;
for ( TopoDS_Iterator It (solid); It.More(); It.Next(), ++nbShells )
if ( !outerShell.IsSame( It.Value() ))
innerShell = It.Value();
if ( nbShells != 2 )
return error(COMPERR_BAD_SHAPE, SMESH_Comment("Must be 2 shells but not ")<<nbShells);
// ----------------------------------
// Associate subshapes of the shells
// ----------------------------------
TAssocTool::TShapeShapeMap shape2ShapeMap;
if ( !TAssocTool::FindSubShapeAssociation( outerShell, &aMesh,
innerShell, &aMesh,
shape2ShapeMap) )
return error(COMPERR_BAD_SHAPE,"Topology of inner and outer shells seems different" );
// ------------------
// Make mesh
// ------------------
TNode2ColumnMap node2columnMap;
myLayerPositions.clear();
for ( exp.Init( outerShell, TopAbs_FACE ); exp.More(); exp.Next() )
{
// Corresponding subshapes
TopoDS_Face outFace = TopoDS::Face( exp.Current() );
TopoDS_Face inFace;
if ( !shape2ShapeMap.IsBound( outFace )) {
return error(SMESH_Comment("Corresponding inner face not found for face #" )
<< meshDS->ShapeToIndex( outFace ));
} else {
inFace = TopoDS::Face( shape2ShapeMap( outFace ));
}
// Find matching nodes of in and out faces
TNodeNodeMap nodeIn2OutMap;
if ( ! TAssocTool::FindMatchingNodesOnFaces( inFace, &aMesh, outFace, &aMesh,
shape2ShapeMap, nodeIn2OutMap ))
return error(COMPERR_BAD_INPUT_MESH,SMESH_Comment("Mesh on faces #")
<< meshDS->ShapeToIndex( outFace ) << " and "
<< meshDS->ShapeToIndex( inFace ) << " seems different" );
// Create volumes
SMDS_ElemIteratorPtr faceIt = meshDS->MeshElements( inFace )->GetElements();
while ( faceIt->more() ) // loop on faces on inFace
{
const SMDS_MeshElement* face = faceIt->next();
if ( !face || face->GetType() != SMDSAbs_Face )
continue;
int nbNodes = face->NbNodes();
if ( face->IsQuadratic() )
nbNodes /= 2;
// find node columns for each node
vector< const TNodeColumn* > columns( nbNodes );
for ( int i = 0; i < nbNodes; ++i )
{
const SMDS_MeshNode* nIn = face->GetNode( i );
TNode2ColumnMap::iterator n_col = node2columnMap.find( nIn );
if ( n_col != node2columnMap.end() ) {
columns[ i ] = & n_col->second;
}
else {
TNodeNodeMap::iterator nInOut = nodeIn2OutMap.find( nIn );
if ( nInOut == nodeIn2OutMap.end() )
RETURN_BAD_RESULT("No matching node for "<< nIn->GetID() <<
" in face "<< face->GetID());
columns[ i ] = makeNodeColumn( node2columnMap, nIn, nInOut->second );
}
}
StdMeshers_Prism_3D::AddPrisms( columns, myHelper );
}
} // loop on faces of out shell
return true;
}
bool StdMeshers_Projection_3D::Compute(SMESH_Mesh& aMesh, const TopoDS_Shape& aShape)
{
if ( !_sourceHypo )
return false;
SMESH_Mesh * srcMesh = _sourceHypo->GetSourceMesh();
SMESH_Mesh * tgtMesh = & aMesh;
if ( !srcMesh )
srcMesh = tgtMesh;
SMESHDS_Mesh * srcMeshDS = srcMesh->GetMeshDS();
SMESHDS_Mesh * tgtMeshDS = tgtMesh->GetMeshDS();
// get shell from shape3D
TopoDS_Shell srcShell, tgtShell;
TopExp_Explorer exp( _sourceHypo->GetSource3DShape(), TopAbs_SHELL );
int nbShell;
for ( nbShell = 0; exp.More(); exp.Next(), ++nbShell )
srcShell = TopoDS::Shell( exp.Current() );
if ( nbShell != 1 )
return error(COMPERR_BAD_SHAPE,
SMESH_Comment("Source shape must have 1 shell but not ") << nbShell);
exp.Init( aShape, TopAbs_SHELL );
for ( nbShell = 0; exp.More(); exp.Next(), ++nbShell )
tgtShell = TopoDS::Shell( exp.Current() );
if ( nbShell != 1 )
return error(COMPERR_BAD_SHAPE,
SMESH_Comment("Target shape must have 1 shell but not ") << nbShell);
// Check that shapes are blocks
if ( TAssocTool::Count( tgtShell, TopAbs_FACE , 1 ) != 6 ||
TAssocTool::Count( tgtShell, TopAbs_EDGE , 1 ) != 12 ||
TAssocTool::Count( tgtShell, TopAbs_WIRE , 1 ) != 6 )
return error(COMPERR_BAD_SHAPE, "Target shape is not a block");
if ( TAssocTool::Count( srcShell, TopAbs_FACE , 1 ) != 6 ||
TAssocTool::Count( srcShell, TopAbs_EDGE , 1 ) != 12 ||
TAssocTool::Count( srcShell, TopAbs_WIRE , 1 ) != 6 )
return error(COMPERR_BAD_SHAPE, "Source shape is not a block");
// Assure that mesh on a source shape is computed
SMESH_subMesh* srcSubMesh = srcMesh->GetSubMesh( _sourceHypo->GetSource3DShape() );
//SMESH_subMesh* tgtSubMesh = tgtMesh->GetSubMesh( aShape );
if ( tgtMesh == srcMesh && !aShape.IsSame( _sourceHypo->GetSource3DShape() )) {
if ( !TAssocTool::MakeComputed( srcSubMesh ))
return error(COMPERR_BAD_INPUT_MESH,"Source mesh not computed");
}
else {
if ( !srcSubMesh->IsMeshComputed() )
return error(COMPERR_BAD_INPUT_MESH,"Source mesh not computed");
}
// Find 2 pairs of corresponding vertices
TopoDS_Vertex tgtV000, tgtV100, srcV000, srcV100;
TAssocTool::TShapeShapeMap shape2ShapeMap;
if ( _sourceHypo->HasVertexAssociation() )
{
tgtV000 = _sourceHypo->GetTargetVertex(1);
tgtV100 = _sourceHypo->GetTargetVertex(2);
srcV000 = _sourceHypo->GetSourceVertex(1);
srcV100 = _sourceHypo->GetSourceVertex(2);
}
else
{
if ( !TAssocTool::FindSubShapeAssociation( tgtShell, tgtMesh, srcShell, srcMesh,
shape2ShapeMap) )
return error(COMPERR_BAD_SHAPE,"Topology of source and target shapes seems different" );
exp.Init( tgtShell, TopAbs_EDGE );
TopExp::Vertices( TopoDS::Edge( exp.Current() ), tgtV000, tgtV100 );
if ( !shape2ShapeMap.IsBound( tgtV000 ) || !shape2ShapeMap.IsBound( tgtV100 ))
return error("Association of subshapes failed" );
srcV000 = TopoDS::Vertex( shape2ShapeMap( tgtV000 ));
srcV100 = TopoDS::Vertex( shape2ShapeMap( tgtV100 ));
if ( !TAssocTool::IsSubShape( srcV000, srcShell ) ||
!TAssocTool::IsSubShape( srcV100, srcShell ))
return error("Incorrect association of subshapes" );
}
// Load 2 SMESH_Block's with src and tgt shells
SMESH_Block srcBlock, tgtBlock;
TopTools_IndexedMapOfOrientedShape scrShapes, tgtShapes;
if ( !tgtBlock.LoadBlockShapes( tgtShell, tgtV000, tgtV100, tgtShapes ))
return error(COMPERR_BAD_SHAPE, "Can't detect block subshapes. Not a block?");
if ( !srcBlock.LoadBlockShapes( srcShell, srcV000, srcV100, scrShapes ))
return error(COMPERR_BAD_SHAPE, "Can't detect block subshapes. Not a block?");
// Find matching nodes of src and tgt shells
TNodeNodeMap src2tgtNodeMap;
for ( int fId = SMESH_Block::ID_FirstF; fId < SMESH_Block::ID_Shell; ++fId )
{
// Corresponding subshapes
TopoDS_Face srcFace = TopoDS::Face( scrShapes( fId ));
TopoDS_Face tgtFace = TopoDS::Face( tgtShapes( fId ));
if ( _sourceHypo->HasVertexAssociation() ) { // associate face subshapes
shape2ShapeMap.Clear();
vector< int > edgeIdVec;
SMESH_Block::GetFaceEdgesIDs( fId, edgeIdVec );
for ( int i = 0; i < edgeIdVec.size(); ++i ) {
int eID = edgeIdVec[ i ];
shape2ShapeMap.Bind( tgtShapes( eID ), scrShapes( eID ));
if ( i < 2 ) {
vector< int > vertexIdVec;
SMESH_Block::GetEdgeVertexIDs( eID, vertexIdVec );
shape2ShapeMap.Bind( tgtShapes( vertexIdVec[0] ), scrShapes( vertexIdVec[0] ));
shape2ShapeMap.Bind( tgtShapes( vertexIdVec[1] ), scrShapes( vertexIdVec[1] ));
}
}
}
// Find matching nodes of tgt and src faces
TNodeNodeMap faceMatchingNodes;
if ( ! TAssocTool::FindMatchingNodesOnFaces( srcFace, srcMesh, tgtFace, tgtMesh,
shape2ShapeMap, faceMatchingNodes ))
return error(COMPERR_BAD_INPUT_MESH,SMESH_Comment("Mesh on faces #")
<< srcMeshDS->ShapeToIndex( srcFace ) << " and "
<< tgtMeshDS->ShapeToIndex( tgtFace ) << " seems different" );
// put found matching nodes of 2 faces to the global map
src2tgtNodeMap.insert( faceMatchingNodes.begin(), faceMatchingNodes.end() );
}
// ------------------
// Make mesh
// ------------------
SMDS_VolumeTool volTool;
SMESH_MesherHelper helper( *tgtMesh );
helper.IsQuadraticSubMesh( aShape );
SMESHDS_SubMesh* srcSMDS = srcSubMesh->GetSubMeshDS();
SMDS_ElemIteratorPtr volIt = srcSMDS->GetElements();
while ( volIt->more() ) // loop on source volumes
{
const SMDS_MeshElement* srcVol = volIt->next();
if ( !srcVol || srcVol->GetType() != SMDSAbs_Volume )
continue;
int nbNodes = srcVol->NbNodes();
SMDS_VolumeTool::VolumeType volType = volTool.GetType( nbNodes );
if ( srcVol->IsQuadratic() )
nbNodes = volTool.NbCornerNodes( volType );
// Find or create a new tgt node for each node of a src volume
vector< const SMDS_MeshNode* > nodes( nbNodes );
for ( int i = 0; i < nbNodes; ++i )
{
const SMDS_MeshNode* srcNode = srcVol->GetNode( i );
const SMDS_MeshNode* tgtNode = 0;
TNodeNodeMap::iterator sN_tN = src2tgtNodeMap.find( srcNode );
if ( sN_tN != src2tgtNodeMap.end() ) // found
{
tgtNode = sN_tN->second;
}
else // Create a new tgt node
{
// compute normalized parameters of source node in srcBlock
gp_Pnt srcCoord = gpXYZ( srcNode );
gp_XYZ srcParam;
if ( !srcBlock.ComputeParameters( srcCoord, srcParam ))
return error(SMESH_Comment("Can't compute normalized parameters ")
<< "for source node " << srcNode->GetID());
// compute coordinates of target node by srcParam
gp_XYZ tgtXYZ;
if ( !tgtBlock.ShellPoint( srcParam, tgtXYZ ))
return error("Can't compute coordinates by normalized parameters");
// add node
SMDS_MeshNode* newNode = tgtMeshDS->AddNode( tgtXYZ.X(), tgtXYZ.Y(), tgtXYZ.Z() );
tgtMeshDS->SetNodeInVolume( newNode, helper.GetSubShapeID() );
tgtNode = newNode;
src2tgtNodeMap.insert( make_pair( srcNode, tgtNode ));
}
nodes[ i ] = tgtNode;
}
// Create a new volume
SMDS_MeshVolume * tgtVol = 0;
int id = 0, force3d = false;
switch ( volType ) {
case SMDS_VolumeTool::TETRA :
case SMDS_VolumeTool::QUAD_TETRA:
tgtVol = helper.AddVolume( nodes[0],
nodes[1],
nodes[2],
nodes[3], id, force3d); break;
case SMDS_VolumeTool::PYRAM :
case SMDS_VolumeTool::QUAD_PYRAM:
tgtVol = helper.AddVolume( nodes[0],
nodes[1],
nodes[2],
nodes[3],
nodes[4], id, force3d); break;
case SMDS_VolumeTool::PENTA :
case SMDS_VolumeTool::QUAD_PENTA:
tgtVol = helper.AddVolume( nodes[0],
nodes[1],
nodes[2],
nodes[3],
nodes[4],
nodes[5], id, force3d); break;
case SMDS_VolumeTool::HEXA :
case SMDS_VolumeTool::QUAD_HEXA :
tgtVol = helper.AddVolume( nodes[0],
nodes[1],
nodes[2],
nodes[3],
nodes[4],
nodes[5],
nodes[6],
nodes[7], id, force3d); break;
default: // polyhedron
const SMDS_PolyhedralVolumeOfNodes * poly =
dynamic_cast<const SMDS_PolyhedralVolumeOfNodes*>( srcVol );
if ( !poly )
RETURN_BAD_RESULT("Unexpected volume type");
tgtVol = tgtMeshDS->AddPolyhedralVolume( nodes, poly->GetQuanities() );
}
if ( tgtVol ) {
tgtMeshDS->SetMeshElementOnShape( tgtVol, helper.GetSubShapeID() );
}
} // loop on volumes of src shell
return true;
}
bool NETGENPlugin_NETGEN_2D_ONLY::Compute(SMESH_Mesh& aMesh,
const TopoDS_Shape& aShape)
{
netgen::multithread.terminate = 0;
//netgen::multithread.task = "Surface meshing";
SMESHDS_Mesh* meshDS = aMesh.GetMeshDS();
SMESH_MesherHelper helper(aMesh);
helper.SetElementsOnShape( true );
NETGENPlugin_NetgenLibWrapper ngLib;
ngLib._isComputeOk = false;
netgen::Mesh ngMeshNoLocSize;
#if NETGEN_VERSION < 6
netgen::Mesh * ngMeshes[2] = { (netgen::Mesh*) ngLib._ngMesh, & ngMeshNoLocSize };
#else
netgen::Mesh * ngMeshes[2] = { (netgen::Mesh*) ngLib._ngMesh.get(), & ngMeshNoLocSize };
#endif
netgen::OCCGeometry occgeoComm;
// min / max sizes are set as follows:
// if ( _hypParameters )
// min and max are defined by the user
// else if ( _hypLengthFromEdges )
// min = aMesher.GetDefaultMinSize()
// max = average segment len of a FACE
// else if ( _hypMaxElementArea )
// min = aMesher.GetDefaultMinSize()
// max = f( _hypMaxElementArea )
// else
// min = aMesher.GetDefaultMinSize()
// max = max segment len of a FACE
NETGENPlugin_Mesher aMesher( &aMesh, aShape, /*isVolume=*/false);
aMesher.SetParameters( _hypParameters ); // _hypParameters -> netgen::mparam
const bool toOptimize = _hypParameters ? _hypParameters->GetOptimize() : true;
if ( _hypMaxElementArea )
{
netgen::mparam.maxh = sqrt( 2. * _hypMaxElementArea->GetMaxArea() / sqrt(3.0) );
}
if ( _hypQuadranglePreference )
netgen::mparam.quad = true;
// local size is common for all FACEs in aShape?
const bool isCommonLocalSize = ( !_hypLengthFromEdges && !_hypMaxElementArea && netgen::mparam.uselocalh );
const bool isDefaultHyp = ( !_hypLengthFromEdges && !_hypMaxElementArea && !_hypParameters );
if ( isCommonLocalSize ) // compute common local size in ngMeshes[0]
{
//list< SMESH_subMesh* > meshedSM[4]; --> all sub-shapes are added to occgeoComm
aMesher.PrepareOCCgeometry( occgeoComm, aShape, aMesh );//, meshedSM );
// local size set at MESHCONST_ANALYSE step depends on
// minh, face_maxh, grading and curvaturesafety; find minh if not set by the user
if ( !_hypParameters || netgen::mparam.minh < DBL_MIN )
{
if ( !_hypParameters )
netgen::mparam.maxh = occgeoComm.GetBoundingBox().Diam() / 3.;
netgen::mparam.minh = aMesher.GetDefaultMinSize( aShape, netgen::mparam.maxh );
}
// set local size depending on curvature and NOT closeness of EDGEs
netgen::occparam.resthcloseedgeenable = false;
//netgen::occparam.resthcloseedgefac = 1.0 + netgen::mparam.grading;
occgeoComm.face_maxh = netgen::mparam.maxh;
netgen::OCCSetLocalMeshSize( occgeoComm, *ngMeshes[0] );
occgeoComm.emap.Clear();
occgeoComm.vmap.Clear();
// set local size according to size of existing segments
const double factor = netgen::occparam.resthcloseedgefac;
TopTools_IndexedMapOfShape edgeMap;
TopExp::MapShapes( aMesh.GetShapeToMesh(), TopAbs_EDGE, edgeMap );
for ( int iE = 1; iE <= edgeMap.Extent(); ++iE )
{
const TopoDS_Shape& edge = edgeMap( iE );
if ( SMESH_Algo::isDegenerated( TopoDS::Edge( edge ))/* ||
helper.IsSubShape( edge, aShape )*/)
continue;
SMESHDS_SubMesh* smDS = meshDS->MeshElements( edge );
if ( !smDS ) continue;
SMDS_ElemIteratorPtr segIt = smDS->GetElements();
while ( segIt->more() )
{
const SMDS_MeshElement* seg = segIt->next();
SMESH_TNodeXYZ n1 = seg->GetNode(0);
SMESH_TNodeXYZ n2 = seg->GetNode(1);
gp_XYZ p = 0.5 * ( n1 + n2 );
netgen::Point3d pi(p.X(), p.Y(), p.Z());
ngMeshes[0]->RestrictLocalH( pi, factor * ( n1 - n2 ).Modulus() );
}
}
}
netgen::mparam.uselocalh = toOptimize; // restore as it is used at surface optimization
// ==================
// Loop on all FACEs
// ==================
vector< const SMDS_MeshNode* > nodeVec;
TopExp_Explorer fExp( aShape, TopAbs_FACE );
for ( int iF = 0; fExp.More(); fExp.Next(), ++iF )
{
TopoDS_Face F = TopoDS::Face( fExp.Current() /*.Oriented( TopAbs_FORWARD )*/);
int faceID = meshDS->ShapeToIndex( F );
SMESH_ComputeErrorPtr& faceErr = aMesh.GetSubMesh( F )->GetComputeError();
_quadraticMesh = helper.IsQuadraticSubMesh( F );
const bool ignoreMediumNodes = _quadraticMesh;
// build viscous layers if required
if ( F.Orientation() != TopAbs_FORWARD &&
F.Orientation() != TopAbs_REVERSED )
F.Orientation( TopAbs_FORWARD ); // avoid pb with TopAbs_INTERNAL
SMESH_ProxyMesh::Ptr proxyMesh = StdMeshers_ViscousLayers2D::Compute( aMesh, F );
if ( !proxyMesh )
continue;
// ------------------------
// get all EDGEs of a FACE
// ------------------------
TSideVector wires =
StdMeshers_FaceSide::GetFaceWires( F, aMesh, ignoreMediumNodes, faceErr, proxyMesh );
if ( faceErr && !faceErr->IsOK() )
continue;
int nbWires = wires.size();
if ( nbWires == 0 )
{
faceErr.reset
( new SMESH_ComputeError
( COMPERR_ALGO_FAILED, "Problem in StdMeshers_FaceSide::GetFaceWires()" ));
continue;
}
if ( wires[0]->NbSegments() < 3 ) // ex: a circle with 2 segments
{
faceErr.reset
( new SMESH_ComputeError
( COMPERR_BAD_INPUT_MESH, SMESH_Comment("Too few segments: ")<<wires[0]->NbSegments()) );
continue;
}
// ----------------------
// compute maxh of a FACE
// ----------------------
if ( !_hypParameters )
{
double edgeLength = 0;
if (_hypLengthFromEdges )
{
// compute edgeLength as an average segment length
int nbSegments = 0;
for ( int iW = 0; iW < nbWires; ++iW )
{
edgeLength += wires[ iW ]->Length();
nbSegments += wires[ iW ]->NbSegments();
}
if ( nbSegments )
edgeLength /= nbSegments;
netgen::mparam.maxh = edgeLength;
}
else if ( isDefaultHyp )
{
// set edgeLength by a longest segment
double maxSeg2 = 0;
for ( int iW = 0; iW < nbWires; ++iW )
{
const UVPtStructVec& points = wires[ iW ]->GetUVPtStruct();
if ( points.empty() )
return error( COMPERR_BAD_INPUT_MESH );
gp_Pnt pPrev = SMESH_TNodeXYZ( points[0].node );
for ( size_t i = 1; i < points.size(); ++i )
{
gp_Pnt p = SMESH_TNodeXYZ( points[i].node );
maxSeg2 = Max( maxSeg2, p.SquareDistance( pPrev ));
pPrev = p;
}
}
edgeLength = sqrt( maxSeg2 ) * 1.05;
netgen::mparam.maxh = edgeLength;
}
if ( netgen::mparam.maxh < DBL_MIN )
netgen::mparam.maxh = occgeoComm.GetBoundingBox().Diam();
if ( !isCommonLocalSize )
{
netgen::mparam.minh = aMesher.GetDefaultMinSize( F, netgen::mparam.maxh );
}
}
// prepare occgeom
netgen::OCCGeometry occgeom;
occgeom.shape = F;
occgeom.fmap.Add( F );
occgeom.CalcBoundingBox();
occgeom.facemeshstatus.SetSize(1);
occgeom.facemeshstatus = 0;
occgeom.face_maxh_modified.SetSize(1);
occgeom.face_maxh_modified = 0;
occgeom.face_maxh.SetSize(1);
occgeom.face_maxh = netgen::mparam.maxh;
// -------------------------
// Fill netgen mesh
// -------------------------
// MESHCONST_ANALYSE step may lead to a failure, so we make an attempt
// w/o MESHCONST_ANALYSE at the second loop
int err = 0;
enum { LOC_SIZE, NO_LOC_SIZE };
int iLoop = isCommonLocalSize ? 0 : 1;
for ( ; iLoop < 2; iLoop++ )
{
//bool isMESHCONST_ANALYSE = false;
InitComputeError();
netgen::Mesh * ngMesh = ngMeshes[ iLoop ];
ngMesh->DeleteMesh();
if ( iLoop == NO_LOC_SIZE )
{
ngMesh->SetGlobalH ( mparam.maxh );
ngMesh->SetMinimalH( mparam.minh );
Box<3> bb = occgeom.GetBoundingBox();
bb.Increase (bb.Diam()/10);
ngMesh->SetLocalH (bb.PMin(), bb.PMax(), mparam.grading);
}
nodeVec.clear();
faceErr = aMesher.AddSegmentsToMesh( *ngMesh, occgeom, wires, helper, nodeVec,
/*overrideMinH=*/!_hypParameters);
if ( faceErr && !faceErr->IsOK() )
break;
//if ( !isCommonLocalSize )
//limitSize( ngMesh, mparam.maxh * 0.8);
// -------------------------
// Generate surface mesh
// -------------------------
const int startWith = MESHCONST_MESHSURFACE;
const int endWith = toOptimize ? MESHCONST_OPTSURFACE : MESHCONST_MESHSURFACE;
SMESH_Comment str;
try {
OCC_CATCH_SIGNALS;
#if NETGEN_VERSION >=6
std::shared_ptr<netgen::Mesh> mesh_ptr(ngMesh, [](netgen::Mesh*) {});
err = netgen::OCCGenerateMesh(occgeom, mesh_ptr, netgen::mparam, startWith, endWith);
#elif NETGEN_VERSION > 4
err = netgen::OCCGenerateMesh(occgeom, ngMesh, netgen::mparam, startWith, endWith);
#else
char *optstr = 0;
err = netgen::OCCGenerateMesh(occgeom, ngMesh, startWith, endWith, optstr);
#endif
if ( netgen::multithread.terminate )
return false;
if ( err )
str << "Error in netgen::OCCGenerateMesh() at " << netgen::multithread.task;
}
catch (Standard_Failure& ex)
{
err = 1;
str << "Exception in netgen::OCCGenerateMesh()"
<< " at " << netgen::multithread.task
<< ": " << ex.DynamicType()->Name();
if ( ex.GetMessageString() && strlen( ex.GetMessageString() ))
str << ": " << ex.GetMessageString();
}
catch (...) {
err = 1;
str << "Exception in netgen::OCCGenerateMesh()"
<< " at " << netgen::multithread.task;
}
if ( err )
{
if ( aMesher.FixFaceMesh( occgeom, *ngMesh, 1 ))
break;
if ( iLoop == LOC_SIZE )
{
netgen::mparam.minh = netgen::mparam.maxh;
netgen::mparam.maxh = 0;
for ( int iW = 0; iW < wires.size(); ++iW )
{
StdMeshers_FaceSidePtr wire = wires[ iW ];
const vector<UVPtStruct>& uvPtVec = wire->GetUVPtStruct();
for ( size_t iP = 1; iP < uvPtVec.size(); ++iP )
{
SMESH_TNodeXYZ p( uvPtVec[ iP ].node );
netgen::Point3d np( p.X(),p.Y(),p.Z());
double segLen = p.Distance( uvPtVec[ iP-1 ].node );
double size = ngMesh->GetH( np );
netgen::mparam.minh = Min( netgen::mparam.minh, size );
netgen::mparam.maxh = Max( netgen::mparam.maxh, segLen );
}
}
//cerr << "min " << netgen::mparam.minh << " max " << netgen::mparam.maxh << endl;
netgen::mparam.minh *= 0.9;
netgen::mparam.maxh *= 1.1;
continue;
}
else
{
faceErr.reset( new SMESH_ComputeError( COMPERR_ALGO_FAILED, str ));
}
}
// ----------------------------------------------------
// Fill the SMESHDS with the generated nodes and faces
// ----------------------------------------------------
int nbNodes = ngMesh->GetNP();
int nbFaces = ngMesh->GetNSE();
int nbInputNodes = nodeVec.size()-1;
nodeVec.resize( nbNodes+1, 0 );
// add nodes
for ( int ngID = nbInputNodes + 1; ngID <= nbNodes; ++ngID )
{
const MeshPoint& ngPoint = ngMesh->Point( ngID );
SMDS_MeshNode * node = meshDS->AddNode(ngPoint(0), ngPoint(1), ngPoint(2));
nodeVec[ ngID ] = node;
}
// create faces
int i,j;
vector<const SMDS_MeshNode*> nodes;
for ( i = 1; i <= nbFaces ; ++i )
{
const Element2d& elem = ngMesh->SurfaceElement(i);
nodes.resize( elem.GetNP() );
for (j=1; j <= elem.GetNP(); ++j)
{
int pind = elem.PNum(j);
if ( pind < 1 )
break;
nodes[ j-1 ] = nodeVec[ pind ];
if ( nodes[ j-1 ]->GetPosition()->GetTypeOfPosition() == SMDS_TOP_3DSPACE )
{
const PointGeomInfo& pgi = elem.GeomInfoPi(j);
meshDS->SetNodeOnFace( nodes[ j-1 ], faceID, pgi.u, pgi.v);
}
}
if ( j > elem.GetNP() )
{
SMDS_MeshFace* face = 0;
if ( elem.GetType() == TRIG )
face = helper.AddFace(nodes[0],nodes[1],nodes[2]);
else
face = helper.AddFace(nodes[0],nodes[1],nodes[2],nodes[3]);
}
}
break;
} // two attempts
} // loop on FACEs
return true;
}
bool StdMeshers_Projection_3D::Evaluate(SMESH_Mesh& aMesh,
const TopoDS_Shape& aShape,
MapShapeNbElems& aResMap)
{
if ( !_sourceHypo )
return false;
SMESH_Mesh * srcMesh = _sourceHypo->GetSourceMesh();
SMESH_Mesh * tgtMesh = & aMesh;
if ( !srcMesh )
srcMesh = tgtMesh;
// get shell from shape3D
TopoDS_Shell srcShell, tgtShell;
TopExp_Explorer exp( _sourceHypo->GetSource3DShape(), TopAbs_SHELL );
int nbShell;
for ( nbShell = 0; exp.More(); exp.Next(), ++nbShell )
srcShell = TopoDS::Shell( exp.Current() );
if ( nbShell != 1 )
return error(COMPERR_BAD_SHAPE,
SMESH_Comment("Source shape must have 1 shell but not ") << nbShell);
exp.Init( aShape, TopAbs_SHELL );
for ( nbShell = 0; exp.More(); exp.Next(), ++nbShell )
tgtShell = TopoDS::Shell( exp.Current() );
if ( nbShell != 1 )
return error(COMPERR_BAD_SHAPE,
SMESH_Comment("Target shape must have 1 shell but not ") << nbShell);
// Check that shapes are blocks
if ( SMESH_MesherHelper::Count( tgtShell, TopAbs_FACE , 1 ) != 6 ||
SMESH_MesherHelper::Count( tgtShell, TopAbs_EDGE , 1 ) != 12 ||
SMESH_MesherHelper::Count( tgtShell, TopAbs_WIRE , 1 ) != 6 )
return error(COMPERR_BAD_SHAPE, "Target shape is not a block");
if ( SMESH_MesherHelper::Count( srcShell, TopAbs_FACE , 1 ) != 6 ||
SMESH_MesherHelper::Count( srcShell, TopAbs_EDGE , 1 ) != 12 ||
SMESH_MesherHelper::Count( srcShell, TopAbs_WIRE , 1 ) != 6 )
return error(COMPERR_BAD_SHAPE, "Source shape is not a block");
// Assure that mesh on a source shape is computed
SMESH_subMesh* srcSubMesh = srcMesh->GetSubMesh( _sourceHypo->GetSource3DShape() );
if ( !srcSubMesh->IsMeshComputed() )
return error(COMPERR_BAD_INPUT_MESH,"Source mesh not computed");
std::vector<int> aVec(SMDSEntity_Last);
for(int i=SMDSEntity_Node; i<SMDSEntity_Last; i++) aVec[i] = 0;
aVec[SMDSEntity_Node] = srcSubMesh->GetSubMeshDS()->NbNodes();
//bool quadratic = false;
SMDS_ElemIteratorPtr elemIt = srcSubMesh->GetSubMeshDS()->GetElements();
while ( elemIt->more() ) {
const SMDS_MeshElement* E = elemIt->next();
if( E->NbNodes()==4 ) {
aVec[SMDSEntity_Tetra]++;
}
else if( E->NbNodes()==5 ) {
aVec[SMDSEntity_Pyramid]++;
}
else if( E->NbNodes()==6 ) {
aVec[SMDSEntity_Penta]++;
}
else if( E->NbNodes()==8 ) {
aVec[SMDSEntity_Hexa]++;
}
else if( E->NbNodes()==10 && E->IsQuadratic() ) {
aVec[SMDSEntity_Quad_Tetra]++;
}
else if( E->NbNodes()==13 && E->IsQuadratic() ) {
aVec[SMDSEntity_Quad_Pyramid]++;
}
else if( E->NbNodes()==15 && E->IsQuadratic() ) {
aVec[SMDSEntity_Quad_Penta]++;
}
else if( E->NbNodes()==20 && E->IsQuadratic() ) {
aVec[SMDSEntity_Quad_Hexa]++;
}
else {
aVec[SMDSEntity_Polyhedra]++;
}
}
SMESH_subMesh * sm = aMesh.GetSubMesh(aShape);
aResMap.insert(std::make_pair(sm,aVec));
return true;
}
StdMeshers_FaceSide::StdMeshers_FaceSide(const TopoDS_Face& theFace,
list<TopoDS_Edge>& theEdges,
SMESH_Mesh* theMesh,
const bool theIsForward,
const bool theIgnoreMediumNodes)
{
int nbEdges = theEdges.size();
myEdge.resize( nbEdges );
myC2d.resize( nbEdges );
myFirst.resize( nbEdges );
myLast.resize( nbEdges );
myNormPar.resize( nbEdges );
myLength = 0;
myNbPonits = myNbSegments = 0;
myMesh = theMesh;
myMissingVertexNodes = false;
myIgnoreMediumNodes = theIgnoreMediumNodes;
if ( nbEdges == 0 ) return;
SMESHDS_Mesh* meshDS = theMesh->GetMeshDS();
vector<double> len( nbEdges );
int nbDegen = 0;
list<TopoDS_Edge>::iterator edge = theEdges.begin();
for ( int index = 0; edge != theEdges.end(); ++index, ++edge )
{
int i = theIsForward ? index : nbEdges - index - 1;
len[i] = SMESH_Algo::EdgeLength( *edge );
if ( len[i] < DBL_MIN ) nbDegen++;
myLength += len[i];
myEdge[i] = *edge;
if ( !theIsForward ) myEdge[i].Reverse();
if ( theFace.IsNull() )
BRep_Tool::Range( *edge, myFirst[i], myLast[i] );
else
myC2d[i] = BRep_Tool::CurveOnSurface( *edge, theFace, myFirst[i], myLast[i] );
if ( myEdge[i].Orientation() == TopAbs_REVERSED )
std::swap( myFirst[i], myLast[i] );
if ( SMESHDS_SubMesh* sm = meshDS->MeshElements( *edge )) {
int nbN = sm->NbNodes();
if ( theIgnoreMediumNodes ) {
SMDS_ElemIteratorPtr elemIt = sm->GetElements();
if ( elemIt->more() && elemIt->next()->IsQuadratic() )
nbN -= sm->NbElements();
}
myNbPonits += nbN;
myNbSegments += sm->NbElements();
}
if ( SMESH_Algo::VertexNode( TopExp::FirstVertex( *edge, 1), meshDS ))
myNbPonits += 1; // for the first end
else
myMissingVertexNodes = true;
}
if ( SMESH_Algo::VertexNode( TopExp::LastVertex( theEdges.back(), 1), meshDS ))
myNbPonits++; // for the last end
else
myMissingVertexNodes = true;
if ( nbEdges > 1 && myLength > DBL_MIN ) {
const double degenNormLen = 1.e-5;
double totLength = myLength;
if ( nbDegen )
totLength += myLength * degenNormLen * nbDegen;
double prevNormPar = 0;
for ( int i = 0; i < nbEdges; ++i ) {
if ( len[ i ] < DBL_MIN )
len[ i ] = myLength * degenNormLen;
myNormPar[ i ] = prevNormPar + len[i]/totLength;
prevNormPar = myNormPar[ i ];
}
}
myNormPar[nbEdges-1] = 1.;
//dump();
}
bool SMESH_MesherHelper::LoadNodeColumns(TParam2ColumnMap & theParam2ColumnMap,
const TopoDS_Face& theFace,
const TopoDS_Edge& theBaseEdge,
SMESHDS_Mesh* theMesh)
{
// get vertices of theBaseEdge
TopoDS_Vertex vfb, vlb, vft; // first and last, bottom and top vertices
TopoDS_Edge eFrw = TopoDS::Edge( theBaseEdge.Oriented( TopAbs_FORWARD ));
TopExp::Vertices( eFrw, vfb, vlb );
// find the other edges of theFace and orientation of e1
TopoDS_Edge e1, e2, eTop;
bool rev1, CumOri = false;
TopExp_Explorer exp( theFace, TopAbs_EDGE );
int nbEdges = 0;
for ( ; exp.More(); exp.Next() ) {
if ( ++nbEdges > 4 ) {
return false; // more than 4 edges in theFace
}
TopoDS_Edge e = TopoDS::Edge( exp.Current() );
if ( theBaseEdge.IsSame( e ))
continue;
TopoDS_Vertex vCommon;
if ( !TopExp::CommonVertex( theBaseEdge, e, vCommon ))
eTop = e;
else if ( vCommon.IsSame( vfb )) {
e1 = e;
vft = TopExp::LastVertex( e1, CumOri );
rev1 = vfb.IsSame( vft );
if ( rev1 )
vft = TopExp::FirstVertex( e1, CumOri );
}
else
e2 = e;
}
if ( nbEdges < 4 ) {
return false; // less than 4 edges in theFace
}
if ( e2.IsNull() && vfb.IsSame( vlb ))
e2 = e1;
// submeshes corresponding to shapes
SMESHDS_SubMesh* smFace = theMesh->MeshElements( theFace );
SMESHDS_SubMesh* smb = theMesh->MeshElements( theBaseEdge );
SMESHDS_SubMesh* smt = theMesh->MeshElements( eTop );
SMESHDS_SubMesh* sm1 = theMesh->MeshElements( e1 );
SMESHDS_SubMesh* sm2 = theMesh->MeshElements( e2 );
SMESHDS_SubMesh* smVfb = theMesh->MeshElements( vfb );
SMESHDS_SubMesh* smVlb = theMesh->MeshElements( vlb );
SMESHDS_SubMesh* smVft = theMesh->MeshElements( vft );
if (!smFace || !smb || !smt || !sm1 || !sm2 || !smVfb || !smVlb || !smVft ) {
RETURN_BAD_RESULT( "NULL submesh " <<smFace<<" "<<smb<<" "<<smt<<" "<<
sm1<<" "<<sm2<<" "<<smVfb<<" "<<smVlb<<" "<<smVft);
}
if ( smb->NbNodes() != smt->NbNodes() || sm1->NbNodes() != sm2->NbNodes() ) {
RETURN_BAD_RESULT(" Diff nb of nodes on opposite edges" );
}
if (smVfb->NbNodes() != 1 || smVlb->NbNodes() != 1 || smVft->NbNodes() != 1) {
RETURN_BAD_RESULT("Empty submesh of vertex");
}
// define whether mesh is quadratic
bool isQuadraticMesh = false;
SMDS_ElemIteratorPtr eIt = smFace->GetElements();
if ( !eIt->more() ) {
RETURN_BAD_RESULT("No elements on the face");
}
const SMDS_MeshElement* e = eIt->next();
isQuadraticMesh = e->IsQuadratic();
if ( sm1->NbNodes() * smb->NbNodes() != smFace->NbNodes() ) {
// check quadratic case
if ( isQuadraticMesh ) {
// what if there are quadrangles and triangles mixed?
// int n1 = sm1->NbNodes()/2;
// int n2 = smb->NbNodes()/2;
// int n3 = sm1->NbNodes() - n1;
// int n4 = smb->NbNodes() - n2;
// int nf = sm1->NbNodes()*smb->NbNodes() - n3*n4;
// if( nf != smFace->NbNodes() ) {
// MESSAGE( "Wrong nb face nodes: " <<
// sm1->NbNodes()<<" "<<smb->NbNodes()<<" "<<smFace->NbNodes());
// return false;
// }
}
else {
RETURN_BAD_RESULT( "Wrong nb face nodes: " <<
sm1->NbNodes()<<" "<<smb->NbNodes()<<" "<<smFace->NbNodes());
}
}
// IJ size
int vsize = sm1->NbNodes() + 2;
int hsize = smb->NbNodes() + 2;
if(isQuadraticMesh) {
vsize = vsize - sm1->NbNodes()/2 -1;
hsize = hsize - smb->NbNodes()/2 -1;
}
// load nodes from theBaseEdge
std::set<const SMDS_MeshNode*> loadedNodes;
const SMDS_MeshNode* nullNode = 0;
std::vector<const SMDS_MeshNode*> & nVecf = theParam2ColumnMap[ 0.];
nVecf.resize( vsize, nullNode );
loadedNodes.insert( nVecf[ 0 ] = smVfb->GetNodes()->next() );
std::vector<const SMDS_MeshNode*> & nVecl = theParam2ColumnMap[ 1.];
nVecl.resize( vsize, nullNode );
loadedNodes.insert( nVecl[ 0 ] = smVlb->GetNodes()->next() );
double f, l;
BRep_Tool::Range( eFrw, f, l );
double range = l - f;
SMDS_NodeIteratorPtr nIt = smb->GetNodes();
const SMDS_MeshNode* node;
while ( nIt->more() ) {
node = nIt->next();
if(IsMedium(node, SMDSAbs_Edge))
continue;
const SMDS_EdgePosition* pos =
dynamic_cast<const SMDS_EdgePosition*>( node->GetPosition().get() );
if ( !pos ) {
return false;
}
double u = ( pos->GetUParameter() - f ) / range;
std::vector<const SMDS_MeshNode*> & nVec = theParam2ColumnMap[ u ];
nVec.resize( vsize, nullNode );
loadedNodes.insert( nVec[ 0 ] = node );
}
if ( theParam2ColumnMap.size() != hsize ) {
RETURN_BAD_RESULT( "Wrong node positions on theBaseEdge" );
}
// load nodes from e1
std::map< double, const SMDS_MeshNode*> sortedNodes; // sort by param on edge
nIt = sm1->GetNodes();
while ( nIt->more() ) {
node = nIt->next();
if(IsMedium(node))
continue;
const SMDS_EdgePosition* pos =
dynamic_cast<const SMDS_EdgePosition*>( node->GetPosition().get() );
if ( !pos ) {
return false;
}
sortedNodes.insert( std::make_pair( pos->GetUParameter(), node ));
}
loadedNodes.insert( nVecf[ vsize - 1 ] = smVft->GetNodes()->next() );
std::map< double, const SMDS_MeshNode*>::iterator u_n = sortedNodes.begin();
int row = rev1 ? vsize - 1 : 0;
int dRow = rev1 ? -1 : +1;
for ( ; u_n != sortedNodes.end(); u_n++ ) {
row += dRow;
loadedNodes.insert( nVecf[ row ] = u_n->second );
}
// try to load the rest nodes
// get all faces from theFace
TIDSortedElemSet allFaces, foundFaces;
eIt = smFace->GetElements();
while ( eIt->more() ) {
const SMDS_MeshElement* e = eIt->next();
if ( e->GetType() == SMDSAbs_Face )
allFaces.insert( e );
}
// Starting from 2 neighbour nodes on theBaseEdge, look for a face
// the nodes belong to, and between the nodes of the found face,
// look for a not loaded node considering this node to be the next
// in a column of the starting second node. Repeat, starting
// from nodes next to the previous starting nodes in their columns,
// and so on while a face can be found. Then go the the next pair
// of nodes on theBaseEdge.
TParam2ColumnMap::iterator par_nVec_1 = theParam2ColumnMap.begin();
TParam2ColumnMap::iterator par_nVec_2 = par_nVec_1;
// loop on columns
int col = 0;
for ( par_nVec_2++; par_nVec_2 != theParam2ColumnMap.end(); par_nVec_1++, par_nVec_2++ ) {
col++;
row = 0;
const SMDS_MeshNode* n1 = par_nVec_1->second[ row ];
const SMDS_MeshNode* n2 = par_nVec_2->second[ row ];
const SMDS_MeshElement* face = 0;
bool lastColOnClosedFace = ( nVecf[ row ] == n2 );
do {
// look for a face by 2 nodes
face = SMESH_MeshEditor::FindFaceInSet( n1, n2, allFaces, foundFaces );
if ( face ) {
int nbFaceNodes = face->NbNodes();
if ( face->IsQuadratic() )
nbFaceNodes /= 2;
if ( nbFaceNodes>4 ) {
RETURN_BAD_RESULT(" Too many nodes in a face: " << nbFaceNodes );
}
// look for a not loaded node of the <face>
bool found = false;
const SMDS_MeshNode* n3 = 0; // a node defferent from n1 and n2
for ( int i = 0; i < nbFaceNodes && !found; ++i ) {
node = face->GetNode( i );
found = loadedNodes.insert( node ).second;
if ( !found && node != n1 && node != n2 )
n3 = node;
}
if ( lastColOnClosedFace && row + 1 < vsize ) {
node = nVecf[ row + 1 ];
found = ( face->GetNodeIndex( node ) >= 0 );
}
if ( found ) {
if ( ++row > vsize - 1 ) {
RETURN_BAD_RESULT( "Too many nodes in column "<< col <<": "<< row+1);
}
par_nVec_2->second[ row ] = node;
foundFaces.insert( face );
n2 = node;
if ( nbFaceNodes==4 ) {
n1 = par_nVec_1->second[ row ];
}
}
else if ( nbFaceNodes==3 && n3 == par_nVec_1->second[ row + 1 ] ) {
n1 = n3;
}
else {
RETURN_BAD_RESULT( "Not quad mesh, column "<< col );
}
}
}
while ( face && n1 && n2 );
if ( row < vsize - 1 ) {
MESSAGE( "Too few nodes in column "<< col <<": "<< row+1);
MESSAGE( "Base node 1: "<< par_nVec_1->second[0]);
MESSAGE( "Base node 2: "<< par_nVec_2->second[0]);
if ( n1 ) { MESSAGE( "Current node 1: "<< n1); }
else { MESSAGE( "Current node 1: NULL"); }
if ( n2 ) { MESSAGE( "Current node 2: "<< n2); }
else { MESSAGE( "Current node 2: NULL"); }
MESSAGE( "first base node: "<< theParam2ColumnMap.begin()->second[0]);
MESSAGE( "last base node: "<< theParam2ColumnMap.rbegin()->second[0]);
return false;
}
} // loop on columns
return true;
}
bool StdMeshers_Hexa_3D::Compute(SMESH_Mesh & aMesh,
const TopoDS_Shape & aShape)// throw(SALOME_Exception)
{
// PAL14921. Enable catching std::bad_alloc and Standard_OutOfMemory outside
//Unexpect aCatch(SalomeException);
MESSAGE("StdMeshers_Hexa_3D::Compute");
SMESHDS_Mesh * meshDS = aMesh.GetMeshDS();
// 0. - shape and face mesh verification
// 0.1 - shape must be a solid (or a shell) with 6 faces
vector < SMESH_subMesh * >meshFaces;
for (TopExp_Explorer exp(aShape, TopAbs_FACE); exp.More(); exp.Next()) {
SMESH_subMesh *aSubMesh = aMesh.GetSubMeshContaining(exp.Current());
ASSERT(aSubMesh);
meshFaces.push_back(aSubMesh);
}
if (meshFaces.size() != 6) {
//return error(COMPERR_BAD_SHAPE, TComm(meshFaces.size())<<" instead of 6 faces in a block");
static StdMeshers_CompositeHexa_3D compositeHexa(-10, 0, aMesh.GetGen());
if ( !compositeHexa.Compute( aMesh, aShape ))
return error( compositeHexa.GetComputeError() );
return true;
}
// 0.2 - is each face meshed with Quadrangle_2D? (so, with a wire of 4 edges)
// tool for working with quadratic elements
SMESH_MesherHelper aTool (aMesh);
_quadraticMesh = aTool.IsQuadraticSubMesh(aShape);
// cube structure
typedef struct cubeStruct
{
TopoDS_Vertex V000;
TopoDS_Vertex V001;
TopoDS_Vertex V010;
TopoDS_Vertex V011;
TopoDS_Vertex V100;
TopoDS_Vertex V101;
TopoDS_Vertex V110;
TopoDS_Vertex V111;
faceQuadStruct* quad_X0;
faceQuadStruct* quad_X1;
faceQuadStruct* quad_Y0;
faceQuadStruct* quad_Y1;
faceQuadStruct* quad_Z0;
faceQuadStruct* quad_Z1;
Point3DStruct* np; // normalised 3D coordinates
} CubeStruct;
CubeStruct aCube;
// bounding faces
FaceQuadStruct* aQuads[6];
for (int i = 0; i < 6; i++)
aQuads[i] = 0;
for (int i = 0; i < 6; i++)
{
TopoDS_Shape aFace = meshFaces[i]->GetSubShape();
SMESH_Algo *algo = _gen->GetAlgo(aMesh, aFace);
string algoName = algo->GetName();
bool isAllQuad = false;
if (algoName == "Quadrangle_2D") {
SMESHDS_SubMesh * sm = meshDS->MeshElements( aFace );
if ( sm ) {
isAllQuad = true;
SMDS_ElemIteratorPtr eIt = sm->GetElements();
while ( isAllQuad && eIt->more() ) {
const SMDS_MeshElement* elem = eIt->next();
isAllQuad = ( elem->NbNodes()==4 ||(_quadraticMesh && elem->NbNodes()==8) );
}
}
}
if ( ! isAllQuad ) {
SMESH_ComputeErrorPtr err = ComputePentahedralMesh(aMesh, aShape);
return ClearAndReturn( aQuads, error(err));
}
StdMeshers_Quadrangle_2D *quadAlgo =
dynamic_cast < StdMeshers_Quadrangle_2D * >(algo);
ASSERT(quadAlgo);
try {
aQuads[i] = quadAlgo->CheckAnd2Dcompute(aMesh, aFace, _quadraticMesh);
if(!aQuads[i]) {
return error( quadAlgo->GetComputeError());
}
}
catch(SALOME_Exception & S_ex) {
return ClearAndReturn( aQuads, error(COMPERR_SLM_EXCEPTION,TComm(S_ex.what()) <<
" Raised by StdMeshers_Quadrangle_2D "
" on face #" << meshDS->ShapeToIndex( aFace )));
}
// 0.2.1 - number of points on the opposite edges must be the same
if (aQuads[i]->side[0]->NbPoints() != aQuads[i]->side[2]->NbPoints() ||
aQuads[i]->side[1]->NbPoints() != aQuads[i]->side[3]->NbPoints()
/*aQuads[i]->side[0]->NbEdges() != 1 ||
aQuads[i]->side[1]->NbEdges() != 1 ||
aQuads[i]->side[2]->NbEdges() != 1 ||
aQuads[i]->side[3]->NbEdges() != 1*/) {
MESSAGE("different number of points on the opposite edges of face " << i);
// Try to go into penta algorithm 'cause it has been improved.
SMESH_ComputeErrorPtr err = ComputePentahedralMesh(aMesh, aShape);
return ClearAndReturn( aQuads, error(err));
}
}
// 1. - identify faces and vertices of the "cube"
// 1.1 - ancestor maps vertex->edges in the cube
// TopTools_IndexedDataMapOfShapeListOfShape MS;
// TopExp::MapShapesAndAncestors(aShape, TopAbs_VERTEX, TopAbs_EDGE, MS);
// 1.2 - first face is choosen as face Y=0 of the unit cube
const TopoDS_Shape & aFace = meshFaces[0]->GetSubShape();
//const TopoDS_Face & F = TopoDS::Face(aFace);
// 1.3 - identify the 4 vertices of the face Y=0: V000, V100, V101, V001
aCube.V000 = aQuads[0]->side[0]->FirstVertex(); // will be (0,0,0) on the unit cube
aCube.V100 = aQuads[0]->side[0]->LastVertex(); // will be (1,0,0) on the unit cube
aCube.V001 = aQuads[0]->side[2]->FirstVertex(); // will be (0,0,1) on the unit cube
aCube.V101 = aQuads[0]->side[2]->LastVertex(); // will be (1,0,1) on the unit cube
TopTools_IndexedMapOfShape MV0;
TopExp::MapShapes(aFace, TopAbs_VERTEX, MV0);
aCube.V010 = OppositeVertex( aCube.V000, MV0, aQuads);
aCube.V110 = OppositeVertex( aCube.V100, MV0, aQuads);
aCube.V011 = OppositeVertex( aCube.V001, MV0, aQuads);
aCube.V111 = OppositeVertex( aCube.V101, MV0, aQuads);
// 1.6 - find remaining faces given 4 vertices
int _indY0 = 0;
int _indY1 = GetFaceIndex(aMesh, aShape, meshFaces,
aCube.V010, aCube.V011, aCube.V110, aCube.V111);
int _indZ0 = GetFaceIndex(aMesh, aShape, meshFaces,
aCube.V000, aCube.V010, aCube.V100, aCube.V110);
int _indZ1 = GetFaceIndex(aMesh, aShape, meshFaces,
aCube.V001, aCube.V011, aCube.V101, aCube.V111);
int _indX0 = GetFaceIndex(aMesh, aShape, meshFaces,
aCube.V000, aCube.V001, aCube.V010, aCube.V011);
int _indX1 = GetFaceIndex(aMesh, aShape, meshFaces,
aCube.V100, aCube.V101, aCube.V110, aCube.V111);
// IPAL21120: SIGSEGV on Meshing attached Compound with Automatic Hexadralization
if ( _indY1 < 1 || _indZ0 < 1 || _indZ1 < 1 || _indX0 < 1 || _indX1 < 1 )
return error(COMPERR_BAD_SHAPE);
aCube.quad_Y0 = aQuads[_indY0];
aCube.quad_Y1 = aQuads[_indY1];
aCube.quad_Z0 = aQuads[_indZ0];
aCube.quad_Z1 = aQuads[_indZ1];
aCube.quad_X0 = aQuads[_indX0];
aCube.quad_X1 = aQuads[_indX1];
// 1.7 - get convertion coefs from face 2D normalized to 3D normalized
Conv2DStruct cx0; // for face X=0
Conv2DStruct cx1; // for face X=1
Conv2DStruct cy0;
Conv2DStruct cy1;
Conv2DStruct cz0;
Conv2DStruct cz1;
GetConv2DCoefs(*aCube.quad_X0, meshFaces[_indX0]->GetSubShape(),
aCube.V000, aCube.V010, aCube.V011, aCube.V001, cx0);
GetConv2DCoefs(*aCube.quad_X1, meshFaces[_indX1]->GetSubShape(),
aCube.V100, aCube.V110, aCube.V111, aCube.V101, cx1);
GetConv2DCoefs(*aCube.quad_Y0, meshFaces[_indY0]->GetSubShape(),
aCube.V000, aCube.V100, aCube.V101, aCube.V001, cy0);
GetConv2DCoefs(*aCube.quad_Y1, meshFaces[_indY1]->GetSubShape(),
aCube.V010, aCube.V110, aCube.V111, aCube.V011, cy1);
GetConv2DCoefs(*aCube.quad_Z0, meshFaces[_indZ0]->GetSubShape(),
aCube.V000, aCube.V100, aCube.V110, aCube.V010, cz0);
GetConv2DCoefs(*aCube.quad_Z1, meshFaces[_indZ1]->GetSubShape(),
aCube.V001, aCube.V101, aCube.V111, aCube.V011, cz1);
// 1.8 - create a 3D structure for normalized values
int nbx = aCube.quad_Z0->side[0]->NbPoints();
if (cz0.a1 == 0.) nbx = aCube.quad_Z0->side[1]->NbPoints();
int nby = aCube.quad_X0->side[0]->NbPoints();
if (cx0.a1 == 0.) nby = aCube.quad_X0->side[1]->NbPoints();
int nbz = aCube.quad_Y0->side[0]->NbPoints();
if (cy0.a1 != 0.) nbz = aCube.quad_Y0->side[1]->NbPoints();
int i1, j1, nbxyz = nbx * nby * nbz;
Point3DStruct *np = new Point3DStruct[nbxyz];
// 1.9 - store node indexes of faces
{
const TopoDS_Face & F = TopoDS::Face(meshFaces[_indX0]->GetSubShape());
faceQuadStruct *quad = aCube.quad_X0;
int i = 0; // j = x/face , k = y/face
int nbdown = quad->side[0]->NbPoints();
int nbright = quad->side[1]->NbPoints();
SMDS_NodeIteratorPtr itf= aMesh.GetSubMesh(F)->GetSubMeshDS()->GetNodes();
while(itf->more()) {
const SMDS_MeshNode * node = itf->next();
if(aTool.IsMedium(node))
continue;
if ( !findIJ( node, quad, i1, j1 ))
return ClearAndReturn( aQuads, false );
int ij1 = j1 * nbdown + i1;
quad->uv_grid[ij1].node = node;
}
for (int i1 = 0; i1 < nbdown; i1++)
for (int j1 = 0; j1 < nbright; j1++) {
int ij1 = j1 * nbdown + i1;
int j = cx0.ia * i1 + cx0.ib * j1 + cx0.ic; // j = x/face
int k = cx0.ja * i1 + cx0.jb * j1 + cx0.jc; // k = y/face
int ijk = k * nbx * nby + j * nbx + i;
//MESSAGE(" "<<ij1<<" "<<i<<" "<<j<<" "<<ijk);
np[ijk].node = quad->uv_grid[ij1].node;
//SCRUTE(np[ijk].nodeId);
}
}
{
const TopoDS_Face & F = TopoDS::Face(meshFaces[_indX1]->GetSubShape());
SMDS_NodeIteratorPtr itf= aMesh.GetSubMesh(F)->GetSubMeshDS()->GetNodes();
faceQuadStruct *quad = aCube.quad_X1;
int i = nbx - 1; // j = x/face , k = y/face
int nbdown = quad->side[0]->NbPoints();
int nbright = quad->side[1]->NbPoints();
while(itf->more()) {
const SMDS_MeshNode * node = itf->next();
if(aTool.IsMedium(node))
continue;
if ( !findIJ( node, quad, i1, j1 ))
return ClearAndReturn( aQuads, false );
int ij1 = j1 * nbdown + i1;
quad->uv_grid[ij1].node = node;
}
for (int i1 = 0; i1 < nbdown; i1++)
for (int j1 = 0; j1 < nbright; j1++) {
int ij1 = j1 * nbdown + i1;
int j = cx1.ia * i1 + cx1.ib * j1 + cx1.ic; // j = x/face
int k = cx1.ja * i1 + cx1.jb * j1 + cx1.jc; // k = y/face
int ijk = k * nbx * nby + j * nbx + i;
//MESSAGE(" "<<ij1<<" "<<i<<" "<<j<<" "<<ijk);
np[ijk].node = quad->uv_grid[ij1].node;
//SCRUTE(np[ijk].nodeId);
}
}
{
const TopoDS_Face & F = TopoDS::Face(meshFaces[_indY0]->GetSubShape());
SMDS_NodeIteratorPtr itf= aMesh.GetSubMesh(F)->GetSubMeshDS()->GetNodes();
faceQuadStruct *quad = aCube.quad_Y0;
int j = 0; // i = x/face , k = y/face
int nbdown = quad->side[0]->NbPoints();
int nbright = quad->side[1]->NbPoints();
while(itf->more()) {
const SMDS_MeshNode * node = itf->next();
if(aTool.IsMedium(node))
continue;
if ( !findIJ( node, quad, i1, j1 ))
return ClearAndReturn( aQuads, false );
int ij1 = j1 * nbdown + i1;
quad->uv_grid[ij1].node = node;
}
for (int i1 = 0; i1 < nbdown; i1++)
for (int j1 = 0; j1 < nbright; j1++) {
int ij1 = j1 * nbdown + i1;
int i = cy0.ia * i1 + cy0.ib * j1 + cy0.ic; // i = x/face
int k = cy0.ja * i1 + cy0.jb * j1 + cy0.jc; // k = y/face
int ijk = k * nbx * nby + j * nbx + i;
//MESSAGE(" "<<ij1<<" "<<i<<" "<<j<<" "<<ijk);
np[ijk].node = quad->uv_grid[ij1].node;
//SCRUTE(np[ijk].nodeId);
}
}
{
const TopoDS_Face & F = TopoDS::Face(meshFaces[_indY1]->GetSubShape());
SMDS_NodeIteratorPtr itf= aMesh.GetSubMesh(F)->GetSubMeshDS()->GetNodes();
faceQuadStruct *quad = aCube.quad_Y1;
int j = nby - 1; // i = x/face , k = y/face
int nbdown = quad->side[0]->NbPoints();
int nbright = quad->side[1]->NbPoints();
while(itf->more()) {
const SMDS_MeshNode * node = itf->next();
if(aTool.IsMedium(node))
continue;
if ( !findIJ( node, quad, i1, j1 ))
return ClearAndReturn( aQuads, false );
int ij1 = j1 * nbdown + i1;
quad->uv_grid[ij1].node = node;
}
for (int i1 = 0; i1 < nbdown; i1++)
for (int j1 = 0; j1 < nbright; j1++) {
int ij1 = j1 * nbdown + i1;
int i = cy1.ia * i1 + cy1.ib * j1 + cy1.ic; // i = x/face
int k = cy1.ja * i1 + cy1.jb * j1 + cy1.jc; // k = y/face
int ijk = k * nbx * nby + j * nbx + i;
//MESSAGE(" "<<ij1<<" "<<i<<" "<<j<<" "<<ijk);
np[ijk].node = quad->uv_grid[ij1].node;
//SCRUTE(np[ijk].nodeId);
}
}
{
const TopoDS_Face & F = TopoDS::Face(meshFaces[_indZ0]->GetSubShape());
SMDS_NodeIteratorPtr itf= aMesh.GetSubMesh(F)->GetSubMeshDS()->GetNodes();
faceQuadStruct *quad = aCube.quad_Z0;
int k = 0; // i = x/face , j = y/face
int nbdown = quad->side[0]->NbPoints();
int nbright = quad->side[1]->NbPoints();
while(itf->more()) {
const SMDS_MeshNode * node = itf->next();
if(aTool.IsMedium(node))
continue;
if ( !findIJ( node, quad, i1, j1 ))
return ClearAndReturn( aQuads, false );
int ij1 = j1 * nbdown + i1;
quad->uv_grid[ij1].node = node;
}
for (int i1 = 0; i1 < nbdown; i1++)
for (int j1 = 0; j1 < nbright; j1++) {
int ij1 = j1 * nbdown + i1;
int i = cz0.ia * i1 + cz0.ib * j1 + cz0.ic; // i = x/face
int j = cz0.ja * i1 + cz0.jb * j1 + cz0.jc; // j = y/face
int ijk = k * nbx * nby + j * nbx + i;
//MESSAGE(" "<<ij1<<" "<<i<<" "<<j<<" "<<ijk);
np[ijk].node = quad->uv_grid[ij1].node;
//SCRUTE(np[ijk].nodeId);
}
}
{
const TopoDS_Face & F = TopoDS::Face(meshFaces[_indZ1]->GetSubShape());
SMDS_NodeIteratorPtr itf= aMesh.GetSubMesh(F)->GetSubMeshDS()->GetNodes();
faceQuadStruct *quad = aCube.quad_Z1;
int k = nbz - 1; // i = x/face , j = y/face
int nbdown = quad->side[0]->NbPoints();
int nbright = quad->side[1]->NbPoints();
while(itf->more()) {
const SMDS_MeshNode * node = itf->next();
if(aTool.IsMedium(node))
continue;
if ( !findIJ( node, quad, i1, j1 ))
return ClearAndReturn( aQuads, false );
int ij1 = j1 * nbdown + i1;
quad->uv_grid[ij1].node = node;
}
for (int i1 = 0; i1 < nbdown; i1++)
for (int j1 = 0; j1 < nbright; j1++) {
int ij1 = j1 * nbdown + i1;
int i = cz1.ia * i1 + cz1.ib * j1 + cz1.ic; // i = x/face
int j = cz1.ja * i1 + cz1.jb * j1 + cz1.jc; // j = y/face
int ijk = k * nbx * nby + j * nbx + i;
//MESSAGE(" "<<ij1<<" "<<i<<" "<<j<<" "<<ijk);
np[ijk].node = quad->uv_grid[ij1].node;
//SCRUTE(np[ijk].nodeId);
}
}
// 2.0 - for each node of the cube:
// - get the 8 points 3D = 8 vertices of the cube
// - get the 12 points 3D on the 12 edges of the cube
// - get the 6 points 3D on the 6 faces with their ID
// - compute the point 3D
// - store the point 3D in SMESHDS, store its ID in 3D structure
int shapeID = meshDS->ShapeToIndex( aShape );
Pt3 p000, p001, p010, p011, p100, p101, p110, p111;
Pt3 px00, px01, px10, px11;
Pt3 p0y0, p0y1, p1y0, p1y1;
Pt3 p00z, p01z, p10z, p11z;
Pt3 pxy0, pxy1, px0z, px1z, p0yz, p1yz;
GetPoint(p000, 0, 0, 0, nbx, nby, nbz, np, meshDS);
GetPoint(p001, 0, 0, nbz - 1, nbx, nby, nbz, np, meshDS);
GetPoint(p010, 0, nby - 1, 0, nbx, nby, nbz, np, meshDS);
GetPoint(p011, 0, nby - 1, nbz - 1, nbx, nby, nbz, np, meshDS);
GetPoint(p100, nbx - 1, 0, 0, nbx, nby, nbz, np, meshDS);
GetPoint(p101, nbx - 1, 0, nbz - 1, nbx, nby, nbz, np, meshDS);
GetPoint(p110, nbx - 1, nby - 1, 0, nbx, nby, nbz, np, meshDS);
GetPoint(p111, nbx - 1, nby - 1, nbz - 1, nbx, nby, nbz, np, meshDS);
for (int i = 1; i < nbx - 1; i++) {
for (int j = 1; j < nby - 1; j++) {
for (int k = 1; k < nbz - 1; k++) {
// *** seulement maillage regulier
// 12 points on edges
GetPoint(px00, i, 0, 0, nbx, nby, nbz, np, meshDS);
GetPoint(px01, i, 0, nbz - 1, nbx, nby, nbz, np, meshDS);
GetPoint(px10, i, nby - 1, 0, nbx, nby, nbz, np, meshDS);
GetPoint(px11, i, nby - 1, nbz - 1, nbx, nby, nbz, np, meshDS);
GetPoint(p0y0, 0, j, 0, nbx, nby, nbz, np, meshDS);
GetPoint(p0y1, 0, j, nbz - 1, nbx, nby, nbz, np, meshDS);
GetPoint(p1y0, nbx - 1, j, 0, nbx, nby, nbz, np, meshDS);
GetPoint(p1y1, nbx - 1, j, nbz - 1, nbx, nby, nbz, np, meshDS);
GetPoint(p00z, 0, 0, k, nbx, nby, nbz, np, meshDS);
GetPoint(p01z, 0, nby - 1, k, nbx, nby, nbz, np, meshDS);
GetPoint(p10z, nbx - 1, 0, k, nbx, nby, nbz, np, meshDS);
GetPoint(p11z, nbx - 1, nby - 1, k, nbx, nby, nbz, np, meshDS);
// 12 points on faces
GetPoint(pxy0, i, j, 0, nbx, nby, nbz, np, meshDS);
GetPoint(pxy1, i, j, nbz - 1, nbx, nby, nbz, np, meshDS);
GetPoint(px0z, i, 0, k, nbx, nby, nbz, np, meshDS);
GetPoint(px1z, i, nby - 1, k, nbx, nby, nbz, np, meshDS);
GetPoint(p0yz, 0, j, k, nbx, nby, nbz, np, meshDS);
GetPoint(p1yz, nbx - 1, j, k, nbx, nby, nbz, np, meshDS);
int ijk = k * nbx * nby + j * nbx + i;
double x = double (i) / double (nbx - 1); // *** seulement
double y = double (j) / double (nby - 1); // *** maillage
double z = double (k) / double (nbz - 1); // *** regulier
Pt3 X;
for (int i = 0; i < 3; i++) {
X[i] = (1 - x) * p0yz[i] + x * p1yz[i]
+ (1 - y) * px0z[i] + y * px1z[i]
+ (1 - z) * pxy0[i] + z * pxy1[i]
- (1 - x) * ((1 - y) * p00z[i] + y * p01z[i])
- x * ((1 - y) * p10z[i] + y * p11z[i])
- (1 - y) * ((1 - z) * px00[i] + z * px01[i])
- y * ((1 - z) * px10[i] + z * px11[i])
- (1 - z) * ((1 - x) * p0y0[i] + x * p1y0[i])
- z * ((1 - x) * p0y1[i] + x * p1y1[i])
+ (1 - x) * ((1 - y) * ((1 - z) * p000[i] + z * p001[i])
+ y * ((1 - z) * p010[i] + z * p011[i]))
+ x * ((1 - y) * ((1 - z) * p100[i] + z * p101[i])
+ y * ((1 - z) * p110[i] + z * p111[i]));
}
SMDS_MeshNode * node = meshDS->AddNode(X[0], X[1], X[2]);
np[ijk].node = node;
meshDS->SetNodeInVolume(node, shapeID);
}
}
}
// find orientation of furute volumes according to MED convention
vector< bool > forward( nbx * nby );
SMDS_VolumeTool vTool;
for (int i = 0; i < nbx - 1; i++) {
for (int j = 0; j < nby - 1; j++) {
int n1 = j * nbx + i;
int n2 = j * nbx + i + 1;
int n3 = (j + 1) * nbx + i + 1;
int n4 = (j + 1) * nbx + i;
int n5 = nbx * nby + j * nbx + i;
int n6 = nbx * nby + j * nbx + i + 1;
int n7 = nbx * nby + (j + 1) * nbx + i + 1;
int n8 = nbx * nby + (j + 1) * nbx + i;
SMDS_VolumeOfNodes tmpVol (np[n1].node,np[n2].node,np[n3].node,np[n4].node,
np[n5].node,np[n6].node,np[n7].node,np[n8].node);
vTool.Set( &tmpVol );
forward[ n1 ] = vTool.IsForward();
}
}
//2.1 - for each node of the cube (less 3 *1 Faces):
// - store hexahedron in SMESHDS
MESSAGE("Storing hexahedron into the DS");
for (int i = 0; i < nbx - 1; i++) {
for (int j = 0; j < nby - 1; j++) {
bool isForw = forward.at( j * nbx + i );
for (int k = 0; k < nbz - 1; k++) {
int n1 = k * nbx * nby + j * nbx + i;
int n2 = k * nbx * nby + j * nbx + i + 1;
int n3 = k * nbx * nby + (j + 1) * nbx + i + 1;
int n4 = k * nbx * nby + (j + 1) * nbx + i;
int n5 = (k + 1) * nbx * nby + j * nbx + i;
int n6 = (k + 1) * nbx * nby + j * nbx + i + 1;
int n7 = (k + 1) * nbx * nby + (j + 1) * nbx + i + 1;
int n8 = (k + 1) * nbx * nby + (j + 1) * nbx + i;
SMDS_MeshVolume * elt;
if ( isForw ) {
elt = aTool.AddVolume(np[n1].node, np[n2].node,
np[n3].node, np[n4].node,
np[n5].node, np[n6].node,
np[n7].node, np[n8].node);
}
else {
elt = aTool.AddVolume(np[n1].node, np[n4].node,
np[n3].node, np[n2].node,
np[n5].node, np[n8].node,
np[n7].node, np[n6].node);
}
meshDS->SetMeshElementOnShape(elt, shapeID);
}
}
}
if ( np ) delete [] np;
return ClearAndReturn( aQuads, true );
}