ForkMaster/netgenplugin
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

[SALOME platform 0013410]: SubMesh not taken into account with Netgen 1D-2D et 1D-2D-3D

Browse Source 
add 2 hypotheses and support submeshes
This commit is contained in:
eap 2008-09-16 09:07:55 +00:00
parent b3a86141bf
commit 6d0e6cdf38
22 changed files with 1613 additions and 65 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

64
idl/NETGENPlugin_Algorithm.idl
View File

@ -26,6 +26,7 @@
#ifndef _SMESH_NETGENALGORITHM_IDL_ #ifndef _SMESH_NETGENALGORITHM_IDL_
#define _SMESH_NETGENALGORITHM_IDL_ #define _SMESH_NETGENALGORITHM_IDL_
#include "SALOME_Exception.idl"
#include "SMESH_Hypothesis.idl" #include "SMESH_Hypothesis.idl"
/*! /*!
@ -99,6 +100,69 @@ module NETGENPlugin
boolean GetQuadAllowed(); boolean GetQuadAllowed();
}; };
/*!
* NETGENPlugin_Hypothesis: interface of "NETGEN 2D simple parameters" hypothesis
*/
interface NETGENPlugin_SimpleHypothesis_2D : SMESH::SMESH_Hypothesis
{
/*!
* Sets <number of segments> value
*/
void SetNumberOfSegments(in short nb) raises (SALOME::SALOME_Exception);
/*!
* Returns <number of segments> value.
* Can be zero in case if LocalLength() has been set
*/
short GetNumberOfSegments();
/*!
* Sets <segment length> value
*/
void SetLocalLength(in double segmentLength);
/*!
* Returns <segment length> value.
* Can be zero in case if NumberOfSegments() has been set
*/
double GetLocalLength();
/*!
* Sets <maximum element area> to be dependent on 1D discretization
*/
void LengthFromEdges();
/*!
* Sets <maximum element area> value.
* Zero or negative value means same as LengthFromEdges().
*/
void SetMaxElementArea(in double area);
/*!
* Returns <maximum element area> value.
* Can be zero in case of LengthFromEdges()
*/
double GetMaxElementArea();
};
/*!
* NETGENPlugin_SimpleHypothesis_3D: interface of "NETGEN 3D simple parameters" hypothesis
*/
interface NETGENPlugin_SimpleHypothesis_3D : NETGENPlugin_SimpleHypothesis_2D
{
/*!
* Sets <maximum element volume> to be dependent on 2D discretization
*/
void LengthFromFaces();
/*!
* Sets <maximum element volume> value.
* Zero or negative value means same as LengthFromFaces().
*/
void SetMaxElementVolume(in double volume);
/*!
* Returns <maximum element volume> value
* Can be zero in case of LengthFromFaces()
*/
double GetMaxElementVolume();
};
}; };
#endif #endif

20
resources/NETGENPlugin.xml
View File

@ -18,6 +18,14 @@
label-id="NETGEN 2D Parameters" label-id="NETGEN 2D Parameters"
icon-id="mesh_hypo_netgen_2d.png" icon-id="mesh_hypo_netgen_2d.png"
dim="2"/> dim="2"/>
<hypothesis type="NETGEN_SimpleParameters_2D"
label-id="NETGEN 2D Simple Parameters"
icon-id="mesh_hypo_netgen_2d.png"
dim="2"/>
<hypothesis type="NETGEN_SimpleParameters_3D"
label-id="NETGEN 3D Simple Parameters"
icon-id="mesh_hypo_netgen.png"
dim="3"/>
</hypotheses> </hypotheses>
<algorithms> <algorithms>
<algorithm type="NETGEN_3D" <algorithm type="NETGEN_3D"
@ -30,14 +38,18 @@
<algorithm type="NETGEN_2D" <algorithm type="NETGEN_2D"
label-id="Netgen 1D-2D" label-id="Netgen 1D-2D"
icon-id="mesh_algo_netgen_2d.png" icon-id="mesh_algo_netgen_2d.png"
hypos="NETGEN_Parameters_2D" hypos="NETGEN_Parameters_2D, NETGEN_SimpleParameters_2D"
output="TRIA,QUAD" output="TRIA,QUAD"
dim="2"/> dim="2"
support-submeshes="true"
/>
<algorithm type="NETGEN_2D3D" <algorithm type="NETGEN_2D3D"
label-id="Netgen 1D-2D-3D" label-id="Netgen 1D-2D-3D"
icon-id="mesh_algo_netgen_2d3d.png" icon-id="mesh_algo_netgen_2d3d.png"
hypos="NETGEN_Parameters" hypos="NETGEN_Parameters, NETGEN_SimpleParameters_3D"
dim="3"/> dim="3"
support-submeshes="true"
/>
<algorithm type="NETGEN_2D_ONLY" <algorithm type="NETGEN_2D_ONLY"
label-id="Netgen 2D" label-id="Netgen 2D"
icon-id="mesh_algo_netgen_2d.png" icon-id="mesh_algo_netgen_2d.png"

6
src/GUI/Makefile.am
View File

@ -33,10 +33,12 @@ lib_LTLIBRARIES = libNETGENPluginGUI.la
dist_libNETGENPluginGUI_la_SOURCES = \ dist_libNETGENPluginGUI_la_SOURCES = \
NETGENPluginGUI.cxx \ NETGENPluginGUI.cxx \
NETGENPluginGUI_HypothesisCreator.cxx NETGENPluginGUI_HypothesisCreator.cxx \
NETGENPluginGUI_SimpleCreator.cxx
MOC_FILES = \ MOC_FILES = \
NETGENPluginGUI_HypothesisCreator_moc.cxx NETGENPluginGUI_HypothesisCreator_moc.cxx \
NETGENPluginGUI_SimpleCreator_moc.cxx
nodist_libNETGENPluginGUI_la_SOURCES= \ nodist_libNETGENPluginGUI_la_SOURCES= \
$(MOC_FILES) $(MOC_FILES)

4
src/GUI/NETGENPluginGUI.cxx
View File

@ -27,6 +27,7 @@
//#include "SMESHGUI_Hypotheses.h" //#include "SMESHGUI_Hypotheses.h"
#include "NETGENPluginGUI_HypothesisCreator.h" #include "NETGENPluginGUI_HypothesisCreator.h"
#include "NETGENPluginGUI_SimpleCreator.h"
//============================================================================= //=============================================================================
/*! GetHypothesisCreator /*! GetHypothesisCreator
@ -41,6 +42,9 @@ extern "C"
SMESHGUI_GenericHypothesisCreator* aCreator = NULL; SMESHGUI_GenericHypothesisCreator* aCreator = NULL;
if( aHypType=="NETGEN_Parameters_2D" || aHypType=="NETGEN_Parameters" ) if( aHypType=="NETGEN_Parameters_2D" || aHypType=="NETGEN_Parameters" )
aCreator = new NETGENPluginGUI_HypothesisCreator( aHypType ); aCreator = new NETGENPluginGUI_HypothesisCreator( aHypType );
else if ( aHypType=="NETGEN_SimpleParameters_2D" ||
aHypType=="NETGEN_SimpleParameters_3D" )
aCreator = new NETGENPluginGUI_SimpleCreator( aHypType );
return aCreator; return aCreator;
} }
} }

16
src/GUI/NETGENPlugin_images.ts
View File

@ -10,6 +10,14 @@
<source>ICON_DLG_NETGEN_PARAMETERS_2D</source> <source>ICON_DLG_NETGEN_PARAMETERS_2D</source>
<translation>mesh_hypo_netgen_2d.png</translation> <translation>mesh_hypo_netgen_2d.png</translation>
</message> </message>
<message>
<source>ICON_DLG_NETGEN_SimpleParameters_3D</source>
<translation>mesh_hypo_netgen.png</translation>
</message>
<message>
<source>ICON_DLG_NETGEN_SimpleParameters_2D</source>
<translation>mesh_hypo_netgen_2d.png</translation>
</message>
<message> <message>
<source>ICON_SMESH_TREE_ALGO_NETGEN_2D</source> <source>ICON_SMESH_TREE_ALGO_NETGEN_2D</source>
<translation>mesh_tree_algo_netgen_2d.png</translation> <translation>mesh_tree_algo_netgen_2d.png</translation>
@ -30,5 +38,13 @@
<source>ICON_SMESH_TREE_HYPO_NETGEN_Parameters_2D</source> <source>ICON_SMESH_TREE_HYPO_NETGEN_Parameters_2D</source>
<translation>mesh_tree_hypo_netgen_2d.png</translation> <translation>mesh_tree_hypo_netgen_2d.png</translation>
</message> </message>
<message>
<source>ICON_SMESH_TREE_HYPO_NETGEN_SimpleParameters_3D</source>
<translation>mesh_tree_hypo_netgen.png</translation>
</message>
<message>
<source>ICON_SMESH_TREE_HYPO_NETGEN_SimpleParameters_2D</source>
<translation>mesh_tree_hypo_netgen_2d.png</translation>
</message>
</context> </context>
</TS> </TS>

36
src/GUI/NETGENPlugin_msg_en.ts
View File

@ -18,6 +18,22 @@
<source>NETGEN_3D_TITLE</source> <source>NETGEN_3D_TITLE</source>
<translation>Hypothesis Construction</translation> <translation>Hypothesis Construction</translation>
</message> </message>
<message>
<source>NETGEN_SimpleParameters_3D_HYPOTHESIS</source>
<translation>Netgen 3D simple parameters</translation>
</message>
<message>
<source>NETGEN_SimpleParameters_3D_TITLE</source>
<translation>Hypothesis Construction</translation>
</message>
<message>
<source>NETGEN_SimpleParameters_2D_HYPOTHESIS</source>
<translation>Netgen 2D simple parameters</translation>
</message>
<message>
<source>NETGEN_SimpleParameters_2D_TITLE</source>
<translation>Hypothesis Construction</translation>
</message>
<message> <message>
<source>NETGEN_ALLOW_QUADRANGLES</source> <source>NETGEN_ALLOW_QUADRANGLES</source>
<translation>Allow Quadrangles</translation> <translation>Allow Quadrangles</translation>
@ -74,5 +90,25 @@
<source>NETGEN_VERYFINE</source> <source>NETGEN_VERYFINE</source>
<translation>Very Fine</translation> <translation>Very Fine</translation>
</message> </message>
<message>
<source>NG_1D</source>
<translation>1D</translation>
</message>
<message>
<source>NG_2D</source>
<translation>2D</translation>
</message>
<message>
<source>NG_3D</source>
<translation>3D</translation>
</message>
<message>
<source>NG_LENGTH_FROM_EDGES</source>
<translation>Length from edges</translation>
</message>
<message>
<source>NG_LENGTH_FROM_FACES</source>
<translation>Length from faces</translation>
</message>
</context> </context>
</TS> </TS>

455
src/NETGENPlugin/NETGENPlugin_Mesher.cxx
View File

@ -28,11 +28,13 @@
#include "NETGENPlugin_Mesher.hxx" #include "NETGENPlugin_Mesher.hxx"
#include "NETGENPlugin_Hypothesis_2D.hxx" #include "NETGENPlugin_Hypothesis_2D.hxx"
#include "NETGENPlugin_SimpleHypothesis_3D.hxx"
#include <SMESH_Mesh.hxx> #include <SMESH_Mesh.hxx>
#include <SMESH_Comment.hxx> #include <SMESH_Comment.hxx>
#include <SMESH_ComputeError.hxx> #include <SMESH_ComputeError.hxx>
#include <SMESH_subMesh.hxx> #include <SMESH_subMesh.hxx>
#include <SMESH_MesherHelper.hxx>
#include <SMESHDS_Mesh.hxx> #include <SMESHDS_Mesh.hxx>
#include <SMDS_MeshElement.hxx> #include <SMDS_MeshElement.hxx>
#include <SMDS_MeshNode.hxx> #include <SMDS_MeshNode.hxx>
@ -48,6 +50,7 @@
#include <OSD_Path.hxx> #include <OSD_Path.hxx>
#include <OSD_File.hxx> #include <OSD_File.hxx>
#include <TCollection_AsciiString.hxx> #include <TCollection_AsciiString.hxx>
#include <TopTools_ListIteratorOfListOfShape.hxx>
// Netgen include files // Netgen include files
namespace nglib { namespace nglib {
@ -76,14 +79,25 @@ NETGENPlugin_Mesher::NETGENPlugin_Mesher (SMESH_Mesh* mesh,
: _mesh (mesh), : _mesh (mesh),
_shape (aShape), _shape (aShape),
_isVolume(isVolume), _isVolume(isVolume),
_optimize(true) _optimize(true),
_simpleHyp(NULL)
{
defaultParameters();
}
//================================================================================
/*!
* \brief Initialize global NETGEN parameters with default values
*/
//================================================================================
void NETGENPlugin_Mesher::defaultParameters()
{ {
#ifdef WNT #ifdef WNT
netgen::MeshingParameters& mparams = netgen::GlobalMeshingParameters(); netgen::MeshingParameters& mparams = netgen::GlobalMeshingParameters();
#else #else
netgen::MeshingParameters& mparams = netgen::mparam; netgen::MeshingParameters& mparams = netgen::mparam;
#endif #endif
// Initialize global NETGEN parameters by default values:
// maximal mesh edge size // maximal mesh edge size
mparams.maxh = NETGENPlugin_Hypothesis::GetDefaultMaxSize(); mparams.maxh = NETGENPlugin_Hypothesis::GetDefaultMaxSize();
// minimal number of segments per edge // minimal number of segments per edge
@ -132,9 +146,23 @@ void NETGENPlugin_Mesher::SetParameters(const NETGENPlugin_Hypothesis* hyp)
mparams.quad = static_cast<const NETGENPlugin_Hypothesis_2D*> mparams.quad = static_cast<const NETGENPlugin_Hypothesis_2D*>
(hyp)->GetQuadAllowed() ? 1 : 0; (hyp)->GetQuadAllowed() ? 1 : 0;
_optimize = hyp->GetOptimize(); _optimize = hyp->GetOptimize();
_simpleHyp = NULL;
} }
} }
//=============================================================================
/*!
* Pass simple parameters to NETGEN
*/
//=============================================================================
void NETGENPlugin_Mesher::SetParameters(const NETGENPlugin_SimpleHypothesis_2D* hyp)
{
_simpleHyp = hyp;
if ( _simpleHyp )
defaultParameters();
}
//============================================================================= //=============================================================================
/*! /*!
* Link - a pair of integer numbers * Link - a pair of integer numbers
@ -165,12 +193,10 @@ Standard_Boolean IsEqual(const Link& aLink1, const Link& aLink2)
//================================================================================ //================================================================================
void NETGENPlugin_Mesher::PrepareOCCgeometry(netgen::OCCGeometry& occgeo, void NETGENPlugin_Mesher::PrepareOCCgeometry(netgen::OCCGeometry& occgeo,
const TopoDS_Shape& shape) const TopoDS_Shape& shape,
SMESH_Mesh& mesh,
list< SMESH_subMesh* > * meshedSM)
{ {
occgeo.shape = shape;
occgeo.changed = 1;
occgeo.BuildFMap();
BRepTools::Clean (shape); BRepTools::Clean (shape);
BRepMesh_IncrementalMesh::BRepMesh_IncrementalMesh (shape, 0.01, true); BRepMesh_IncrementalMesh::BRepMesh_IncrementalMesh (shape, 0.01, true);
Bnd_Box bb; Bnd_Box bb;
@ -183,6 +209,274 @@ void NETGENPlugin_Mesher::PrepareOCCgeometry(netgen::OCCGeometry& occgeo,
netgen::Point<3> p1 = netgen::Point<3> (x1,y1,z1); netgen::Point<3> p1 = netgen::Point<3> (x1,y1,z1);
netgen::Point<3> p2 = netgen::Point<3> (x2,y2,z2); netgen::Point<3> p2 = netgen::Point<3> (x2,y2,z2);
occgeo.boundingbox = netgen::Box<3> (p1,p2); occgeo.boundingbox = netgen::Box<3> (p1,p2);
occgeo.shape = shape;
occgeo.changed = 1;
//occgeo.BuildFMap();
// fill maps of shapes of occgeo with not yet meshed subshapes
// get root submeshes
list< SMESH_subMesh* > rootSM;
if ( SMESH_subMesh* sm = mesh.GetSubMeshContaining( shape )) {
rootSM.push_back( sm );
}
else {
for ( TopoDS_Iterator it( shape ); it.More(); it.Next() )
rootSM.push_back( mesh.GetSubMesh( it.Value() ));
}
// add subshapes of empty submeshes
list< SMESH_subMesh* >::iterator rootIt = rootSM.begin(), rootEnd = rootSM.end();
for ( ; rootIt != rootEnd; ++rootIt ) {
SMESH_subMesh * root = *rootIt;
SMESH_subMeshIteratorPtr smIt = root->getDependsOnIterator(/*includeSelf=*/true,
/*complexShapeFirst=*/true);
while ( smIt->more() ) {
SMESH_subMesh* sm = smIt->next();
if ( sm->IsEmpty() ) {
switch ( sm->GetSubShape().ShapeType() ) {
case TopAbs_FACE : occgeo.fmap.Add( sm->GetSubShape() ); break;
case TopAbs_EDGE : occgeo.emap.Add( sm->GetSubShape() ); break;
case TopAbs_VERTEX: occgeo.vmap.Add( sm->GetSubShape() ); break;
case TopAbs_SOLID :occgeo.somap.Add( sm->GetSubShape() ); break;
default:;
}
}
// collect submeshes of meshed shapes
else if (meshedSM) {
meshedSM->push_back( sm );
}
}
}
occgeo.facemeshstatus.SetSize (occgeo.fmap.Extent());
occgeo.facemeshstatus = 0;
}
//================================================================================
/*!
* \brief return id of netgen point corresponding to SMDS node
*/
//================================================================================
static int ngNodeId( const SMDS_MeshNode* node,
netgen::Mesh& ngMesh,
map< const SMDS_MeshNode*, int >& nodeNgIdMap)
{
int newNgId = ngMesh.GetNP() + 1;
pair< map< const SMDS_MeshNode*, int >::iterator, bool > it_isNew =
nodeNgIdMap.insert( make_pair( node, newNgId ));
if ( it_isNew.second ) {
netgen::MeshPoint p( netgen::Point<3> (node->X(), node->Y(), node->Z()) );
ngMesh.AddPoint( p );
}
return it_isNew.first->second;
}
//================================================================================
/*!
* \brief fill ngMesh with nodes and elements of computed submeshes
*/
//================================================================================
bool NETGENPlugin_Mesher::fillNgMesh(netgen::OCCGeometry& occgeom,
netgen::Mesh& ngMesh,
vector<SMDS_MeshNode*>& nodeVec,
const list< SMESH_subMesh* > & meshedSM)
{
map< const SMDS_MeshNode*, int > 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 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;
// 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->GetNode( i+1 )->GetPosition()->GetShapeId() ))
inFaceNode = f->GetNode( i-1 );
else
inFaceNode = f->GetNode( i+1 );
gp_XY uv = helper.GetNodeUV( geomFace, node, inFaceNode );
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 );
map< const SMDS_MeshNode*, int >::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;
} }
//============================================================================= //=============================================================================
@ -214,31 +508,133 @@ bool NETGENPlugin_Mesher::Compute()
// ------------------------- // -------------------------
netgen::OCCGeometry occgeo; netgen::OCCGeometry occgeo;
PrepareOCCgeometry( occgeo, _shape ); list< SMESH_subMesh* > meshedSM;
PrepareOCCgeometry( occgeo, _shape, *_mesh, &meshedSM );
// ------------------------- // -------------------------
// Generate the mesh // Generate the mesh
// ------------------------- // -------------------------
netgen::Mesh *ngMesh = NULL; netgen::Mesh *ngMesh = NULL;
// we start always with ANALYSE,
// but end depending on _optimize and _isVolume
int startWith = netgen::MESHCONST_ANALYSE;
int endWith = (_optimize
? (_isVolume ? netgen::MESHCONST_OPTVOLUME : netgen::MESHCONST_OPTSURFACE)
: netgen::MESHCONST_MESHSURFACE);
char *optstr = 0;
int err = 0;
SMESH_Comment comment; SMESH_Comment comment;
int err = 0;
int nbInitNod = 0;
int nbInitSeg = 0;
int nbInitFac = 0;
// vector of nodes in which node index == netgen ID
vector< SMDS_MeshNode* > nodeVec;
try try
{ {
// ----------------
// compute 1D mesh
// ----------------
// pass 1D simple parameters to NETGEN
if ( _simpleHyp ) {
if ( int nbSeg = _simpleHyp->GetNumberOfSegments() ) {
// nb of segments
mparams.segmentsperedge = nbSeg + 0.1;
mparams.maxh = occgeo.boundingbox.Diam();
mparams.grading = 0;
}
else {
// segment length
mparams.segmentsperedge = 1;
mparams.maxh = _simpleHyp->GetLocalLength();
}
}
// let netgen create ngMesh and calculate element size on not meshed shapes
char *optstr = 0;
int startWith = netgen::MESHCONST_ANALYSE;
int endWith = netgen::MESHCONST_ANALYSE;
err = netgen::OCCGenerateMesh(occgeo, ngMesh, startWith, endWith, optstr); err = netgen::OCCGenerateMesh(occgeo, ngMesh, startWith, endWith, optstr);
if (err) comment << "Error in netgen::OCCGenerateMesh()"; if (err) comment << "Error in netgen::OCCGenerateMesh() at MESHCONST_ANALYSE step";
if (!err && !_optimize)
// fill ngMesh with nodes and elements of computed submeshes
err = ! fillNgMesh(occgeo, *ngMesh, nodeVec, meshedSM);
nbInitNod = ngMesh->GetNP();
nbInitSeg = ngMesh->GetNSeg();
nbInitFac = ngMesh->GetNSE();
// compute mesh
if (!err)
{ {
// we have got surface mesh only, so generate volume mesh startWith = endWith = netgen::MESHCONST_MESHEDGES;
startWith = endWith = netgen::MESHCONST_MESHVOLUME; err = netgen::OCCGenerateMesh(occgeo, ngMesh, startWith, endWith, optstr);
if (err) comment << "Error in netgen::OCCGenerateMesh() at 1D mesh generation";
}
// ---------------------
// compute surface mesh
// ---------------------
if (!err)
{
// pass 2D simple parameters to NETGEN
if ( _simpleHyp ) {
if ( double area = _simpleHyp->GetMaxElementArea() ) {
// face area
mparams.maxh = sqrt(2. * area/sqrt(3.0));
mparams.grading = 0.4; // moderate size growth
}
else {
// length from edges
double length = 0;
for ( TopExp_Explorer exp( _shape, TopAbs_EDGE ); exp.More(); exp.Next() )
length += SMESH_Algo::EdgeLength( TopoDS::Edge( exp.Current() ));
if ( ngMesh->GetNSeg() )
mparams.maxh = length / ngMesh->GetNSeg();
else
mparams.maxh = 1000;
mparams.grading = 0.2; // slow size growth
}
mparams.maxh = min( mparams.maxh, occgeo.boundingbox.Diam()/2 );
ngMesh->SetGlobalH (mparams.maxh);
netgen::Box<3> bb = occgeo.GetBoundingBox();
bb.Increase (bb.Diam()/20);
ngMesh->SetLocalH (bb.PMin(), bb.PMax(), mparams.grading);
}
// let netgen compute 2D mesh
startWith = netgen::MESHCONST_MESHSURFACE;
endWith = _optimize ? netgen::MESHCONST_OPTSURFACE : netgen::MESHCONST_MESHSURFACE;
err = netgen::OCCGenerateMesh(occgeo, ngMesh, startWith, endWith, optstr);
if (err) comment << "Error in netgen::OCCGenerateMesh() at surface mesh generation";
}
// ---------------------
// generate volume mesh
// ---------------------
if (!err && _isVolume)
{
// add ng face descriptors of meshed faces
std::map< int, std::pair<int,int> >::iterator fId_soIds = _faceDescriptors.begin();
for ( ; fId_soIds != _faceDescriptors.end(); ++fId_soIds ) {
int faceID = fId_soIds->first;
int solidID1 = fId_soIds->second.first;
int solidID2 = fId_soIds->second.second;
ngMesh->AddFaceDescriptor (netgen::FaceDescriptor(faceID, solidID1, solidID2, 0));
}
// pass 3D simple parameters to NETGEN
const NETGENPlugin_SimpleHypothesis_3D* simple3d =
dynamic_cast< const NETGENPlugin_SimpleHypothesis_3D* > ( _simpleHyp );
if ( simple3d ) {
if ( double vol = simple3d->GetMaxElementVolume() ) {
// max volume
mparams.maxh = pow( 72 * vol * vol, 1/3. );
mparams.maxh = min( mparams.maxh, occgeo.boundingbox.Diam()/2 );
}
else {
// length from faces
mparams.maxh = ngMesh->AverageH();
}
// netgen::ARRAY<double> maxhdom;
// maxhdom.SetSize (occgeo.NrSolids());
// maxhdom = mparams.maxh;
// ngMesh->SetMaxHDomain (maxhdom);
ngMesh->SetGlobalH (mparams.maxh);
mparams.grading = 0.4;
ngMesh->CalcLocalH();
}
// let netgen compute 3D mesh
startWith = netgen::MESHCONST_MESHVOLUME;
endWith = _optimize ? netgen::MESHCONST_OPTVOLUME : netgen::MESHCONST_MESHVOLUME;
err = netgen::OCCGenerateMesh(occgeo, ngMesh, startWith, endWith, optstr); err = netgen::OCCGenerateMesh(occgeo, ngMesh, startWith, endWith, optstr);
if (err) comment << "Error in netgen::OCCGenerateMesh()"; if (err) comment << "Error in netgen::OCCGenerateMesh()";
} }
@ -273,22 +669,21 @@ bool NETGENPlugin_Mesher::Compute()
bool isOK = ( !err && (_isVolume ? (nbVol > 0) : (nbFac > 0)) ); bool isOK = ( !err && (_isVolume ? (nbVol > 0) : (nbFac > 0)) );
if ( true /*isOK*/ ) // get whatever built if ( true /*isOK*/ ) // get whatever built
{ {
// vector of nodes in which node index == netgen ID
vector< SMDS_MeshNode* > nodeVec ( nbNod + 1 );
// map of nodes assigned to submeshes // map of nodes assigned to submeshes
NCollection_Map<int> pindMap; NCollection_Map<int> pindMap;
// create and insert nodes into nodeVec // create and insert nodes into nodeVec
nodeVec.resize( nbNod + 1 );
int i; int i;
for (i = 1; i <= nbNod /*&& isOK*/; ++i ) for (i = nbInitNod+1; i <= nbNod /*&& isOK*/; ++i )
{ {
const netgen::MeshPoint& ngPoint = ngMesh->Point(i); const netgen::MeshPoint& ngPoint = ngMesh->Point(i);
SMDS_MeshNode* node = NULL; SMDS_MeshNode* node = NULL;
bool newNodeOnVertex = false; bool newNodeOnVertex = false;
TopoDS_Vertex aVert; TopoDS_Vertex aVert;
if (i <= occgeo.vmap.Extent()) if (i-nbInitNod <= occgeo.vmap.Extent())
{ {
// point on vertex // point on vertex
aVert = TopoDS::Vertex(occgeo.vmap(i)); aVert = TopoDS::Vertex(occgeo.vmap(i-nbInitNod));
SMESHDS_SubMesh * submesh = meshDS->MeshElements(aVert); SMESHDS_SubMesh * submesh = meshDS->MeshElements(aVert);
if (submesh) if (submesh)
{ {
@ -322,7 +717,7 @@ bool NETGENPlugin_Mesher::Compute()
// create mesh segments along geometric edges // create mesh segments along geometric edges
NCollection_Map<Link> linkMap; NCollection_Map<Link> linkMap;
for (i = 1; i <= nbSeg/* && isOK*/; ++i ) for (i = nbInitSeg+1; i <= nbSeg/* && isOK*/; ++i )
{ {
const netgen::Segment& seg = ngMesh->LineSegment(i); const netgen::Segment& seg = ngMesh->LineSegment(i);
Link link(seg.p1, seg.p2); Link link(seg.p1, seg.p2);
@ -352,7 +747,7 @@ bool NETGENPlugin_Mesher::Compute()
} }
else else
param = param2 * 0.5; param = param2 * 0.5;
if (pindMap.Contains(pind)) if (pind <= nbInitNod || pindMap.Contains(pind))
continue; continue;
if (!aEdge.IsNull()) if (!aEdge.IsNull())
{ {
@ -378,7 +773,7 @@ bool NETGENPlugin_Mesher::Compute()
} }
// create mesh faces along geometric faces // create mesh faces along geometric faces
for (i = 1; i <= nbFac/* && isOK*/; ++i ) for (i = nbInitFac+1; i <= nbFac/* && isOK*/; ++i )
{ {
const netgen::Element2d& elem = ngMesh->SurfaceElement(i); const netgen::Element2d& elem = ngMesh->SurfaceElement(i);
int aGeomFaceInd = elem.GetIndex(); int aGeomFaceInd = elem.GetIndex();
@ -391,7 +786,7 @@ bool NETGENPlugin_Mesher::Compute()
int pind = elem.PNum(j); int pind = elem.PNum(j);
SMDS_MeshNode* node = nodeVec.at(pind); SMDS_MeshNode* node = nodeVec.at(pind);
nodes.push_back(node); nodes.push_back(node);
if (pindMap.Contains(pind)) if (pind <= nbInitNod || pindMap.Contains(pind))
continue; continue;
if (!aFace.IsNull()) if (!aFace.IsNull())
{ {
@ -445,7 +840,7 @@ bool NETGENPlugin_Mesher::Compute()
int pind = elem.PNum(j); int pind = elem.PNum(j);
SMDS_MeshNode* node = nodeVec.at(pind); SMDS_MeshNode* node = nodeVec.at(pind);
nodes.push_back(node); nodes.push_back(node);
if (pindMap.Contains(pind)) if (pind <= nbInitNod || pindMap.Contains(pind))
continue; continue;
if (!aSolid.IsNull()) if (!aSolid.IsNull())
{ {

21
src/NETGENPlugin/NETGENPlugin_Mesher.hxx
View File

@ -31,13 +31,16 @@
#include "NETGENPlugin_Defs.hxx" #include "NETGENPlugin_Defs.hxx"
#include "StdMeshers_FaceSide.hxx" #include "StdMeshers_FaceSide.hxx"
#include <map>
class SMESH_Mesh; class SMESH_Mesh;
class SMESHDS_Mesh; class SMESHDS_Mesh;
class TopoDS_Shape; class TopoDS_Shape;
class NETGENPlugin_Hypothesis; class NETGENPlugin_Hypothesis;
class NETGENPlugin_SimpleHypothesis_2D;
namespace netgen { namespace netgen {
class OCCGeometry; class OCCGeometry;
class Mesh;
} }
/*! /*!
@ -53,19 +56,35 @@ class NETGENPLUGIN_EXPORT NETGENPlugin_Mesher
const bool isVolume); const bool isVolume);
void SetParameters(const NETGENPlugin_Hypothesis* hyp); void SetParameters(const NETGENPlugin_Hypothesis* hyp);
void SetParameters(const NETGENPlugin_SimpleHypothesis_2D* hyp);
bool Compute(); bool Compute();
static void PrepareOCCgeometry(netgen::OCCGeometry& occgeom, static void PrepareOCCgeometry(netgen::OCCGeometry& occgeom,
const TopoDS_Shape& shape); const TopoDS_Shape& shape,
SMESH_Mesh& mesh,
std::list< SMESH_subMesh* > * meshedSM=0);
static void RemoveTmpFiles(); static void RemoveTmpFiles();
protected:
bool fillNgMesh(netgen::OCCGeometry& occgeom,
netgen::Mesh& ngMesh,
std::vector<SMDS_MeshNode*>& nodeVec,
const std::list< SMESH_subMesh* > & meshedSM);
void defaultParameters();
private: private:
SMESH_Mesh* _mesh; SMESH_Mesh* _mesh;
const TopoDS_Shape& _shape; const TopoDS_Shape& _shape;
bool _isVolume; bool _isVolume;
bool _optimize; bool _optimize;
const NETGENPlugin_SimpleHypothesis_2D * _simpleHyp;
std::map< int, std::pair<int,int> > _faceDescriptors;
}; };
#endif #endif

23
src/NETGENPlugin/NETGENPlugin_NETGEN_2D.cxx
View File

@ -27,6 +27,7 @@
//============================================================================= //=============================================================================
#include "NETGENPlugin_NETGEN_2D.hxx" #include "NETGENPlugin_NETGEN_2D.hxx"
#include "NETGENPlugin_Hypothesis_2D.hxx" #include "NETGENPlugin_Hypothesis_2D.hxx"
#include "NETGENPlugin_SimpleHypothesis_2D.hxx"
#include "NETGENPlugin_Mesher.hxx" #include "NETGENPlugin_Mesher.hxx"
#include <SMESH_Gen.hxx> #include <SMESH_Gen.hxx>
@ -53,9 +54,11 @@ NETGENPlugin_NETGEN_2D::NETGENPlugin_NETGEN_2D(int hypId, int studyId,
_name = "NETGEN_2D"; _name = "NETGEN_2D";
_shapeType = (1 << TopAbs_FACE); // 1 bit /shape type _shapeType = (1 << TopAbs_FACE); // 1 bit /shape type
_compatibleHypothesis.push_back("NETGEN_Parameters_2D"); _compatibleHypothesis.push_back("NETGEN_Parameters_2D");
_compatibleHypothesis.push_back("NETGEN_SimpleParameters_2D");
_requireDescretBoundary = false; _requireDescretBoundary = false;
_onlyUnaryInput = false; _onlyUnaryInput = false;
_hypothesis = NULL; _hypothesis = NULL;
_supportSubmeshes = true;
} }
//============================================================================= //=============================================================================
@ -82,9 +85,6 @@ bool NETGENPlugin_NETGEN_2D::CheckHypothesis
{ {
_hypothesis = NULL; _hypothesis = NULL;
list<const SMESHDS_Hypothesis*>::const_iterator itl;
const SMESHDS_Hypothesis* theHyp;
const list<const SMESHDS_Hypothesis*>& hyps = GetUsedHypothesis(aMesh, aShape); const list<const SMESHDS_Hypothesis*>& hyps = GetUsedHypothesis(aMesh, aShape);
int nbHyp = hyps.size(); int nbHyp = hyps.size();
if (!nbHyp) if (!nbHyp)
@ -92,20 +92,20 @@ bool NETGENPlugin_NETGEN_2D::CheckHypothesis
aStatus = SMESH_Hypothesis::HYP_OK; aStatus = SMESH_Hypothesis::HYP_OK;
return true; // can work with no hypothesis return true; // can work with no hypothesis
} }
// use only the first hypothesis
itl = hyps.begin(); const SMESHDS_Hypothesis* theHyp = hyps.front();
theHyp = (*itl); // use only the first hypothesis
string hypName = theHyp->GetName(); string hypName = theHyp->GetName();
if ( find( _compatibleHypothesis.begin(), _compatibleHypothesis.end(),
if (hypName == "NETGEN_Parameters_2D") hypName ) != _compatibleHypothesis.end() )
{ {
_hypothesis = static_cast<const NETGENPlugin_Hypothesis_2D*> (theHyp); _hypothesis = theHyp;
ASSERT(_hypothesis);
aStatus = SMESH_Hypothesis::HYP_OK; aStatus = SMESH_Hypothesis::HYP_OK;
} }
else else
{
aStatus = SMESH_Hypothesis::HYP_INCOMPATIBLE; aStatus = SMESH_Hypothesis::HYP_INCOMPATIBLE;
}
return aStatus == SMESH_Hypothesis::HYP_OK; return aStatus == SMESH_Hypothesis::HYP_OK;
} }
@ -123,6 +123,7 @@ bool NETGENPlugin_NETGEN_2D::Compute(SMESH_Mesh& aMesh,
NETGENPlugin_Mesher mesher(&aMesh, aShape, false); NETGENPlugin_Mesher mesher(&aMesh, aShape, false);
// NETGENPlugin_Mesher mesher(meshDS, aShape, false); // NETGENPlugin_Mesher mesher(meshDS, aShape, false);
mesher.SetParameters(_hypothesis); mesher.SetParameters(dynamic_cast<const NETGENPlugin_Hypothesis*>(_hypothesis));
mesher.SetParameters(dynamic_cast<const NETGENPlugin_SimpleHypothesis_2D*>(_hypothesis));
return mesher.Compute(); return mesher.Compute();
} }

4
src/NETGENPlugin/NETGENPlugin_NETGEN_2D.hxx
View File

@ -36,7 +36,7 @@
#include "StdMeshers_MaxElementVolume.hxx" #include "StdMeshers_MaxElementVolume.hxx"
#include "Utils_SALOME_Exception.hxx" #include "Utils_SALOME_Exception.hxx"
class NETGENPlugin_Hypothesis_2D; //class NETGENPlugin_Hypothesis_2D;
class NETGENPLUGIN_EXPORT NETGENPlugin_NETGEN_2D: public SMESH_2D_Algo class NETGENPLUGIN_EXPORT NETGENPlugin_NETGEN_2D: public SMESH_2D_Algo
{ {
@ -52,7 +52,7 @@ public:
const TopoDS_Shape& aShape); const TopoDS_Shape& aShape);
protected: protected:
const NETGENPlugin_Hypothesis_2D* _hypothesis; const SMESHDS_Hypothesis* _hypothesis;
}; };
#endif #endif

20
src/NETGENPlugin/NETGENPlugin_NETGEN_2D3D.cxx
View File

@ -27,6 +27,7 @@
//============================================================================= //=============================================================================
#include "NETGENPlugin_NETGEN_2D3D.hxx" #include "NETGENPlugin_NETGEN_2D3D.hxx"
#include "NETGENPlugin_Hypothesis.hxx" #include "NETGENPlugin_Hypothesis.hxx"
#include "NETGENPlugin_SimpleHypothesis_2D.hxx"
#include "NETGENPlugin_Mesher.hxx" #include "NETGENPlugin_Mesher.hxx"
#include <SMESH_Gen.hxx> #include <SMESH_Gen.hxx>
@ -53,9 +54,11 @@ NETGENPlugin_NETGEN_2D3D::NETGENPlugin_NETGEN_2D3D(int hypId, int studyId,
_name = "NETGEN_2D3D"; _name = "NETGEN_2D3D";
_shapeType = (1 << TopAbs_SHELL) | (1 << TopAbs_SOLID);// 1 bit /shape type _shapeType = (1 << TopAbs_SHELL) | (1 << TopAbs_SOLID);// 1 bit /shape type
_compatibleHypothesis.push_back("NETGEN_Parameters"); _compatibleHypothesis.push_back("NETGEN_Parameters");
_compatibleHypothesis.push_back("NETGEN_SimpleParameters_3D");
_requireDescretBoundary = false; _requireDescretBoundary = false;
_onlyUnaryInput = false; _onlyUnaryInput = false;
_hypothesis = NULL; _hypothesis = NULL;
_supportSubmeshes = true;
} }
//============================================================================= //=============================================================================
@ -84,9 +87,6 @@ bool NETGENPlugin_NETGEN_2D3D::CheckHypothesis
_hypothesis = NULL; _hypothesis = NULL;
list<const SMESHDS_Hypothesis*>::const_iterator itl;
const SMESHDS_Hypothesis* theHyp;
const list<const SMESHDS_Hypothesis*>& hyps = GetUsedHypothesis(aMesh, aShape); const list<const SMESHDS_Hypothesis*>& hyps = GetUsedHypothesis(aMesh, aShape);
int nbHyp = hyps.size(); int nbHyp = hyps.size();
if (!nbHyp) if (!nbHyp)
@ -95,19 +95,20 @@ bool NETGENPlugin_NETGEN_2D3D::CheckHypothesis
return true; // can work with no hypothesis return true; // can work with no hypothesis
} }
itl = hyps.begin(); const SMESHDS_Hypothesis* theHyp = hyps.front(); // use only the first hypothesis
theHyp = (*itl); // use only the first hypothesis
string hypName = theHyp->GetName(); string hypName = theHyp->GetName();
if (hypName == "NETGEN_Parameters") if ( find( _compatibleHypothesis.begin(), _compatibleHypothesis.end(),
hypName ) != _compatibleHypothesis.end() )
{ {
_hypothesis = static_cast<const NETGENPlugin_Hypothesis*> (theHyp); _hypothesis = theHyp;
ASSERT(_hypothesis);
aStatus = SMESH_Hypothesis::HYP_OK; aStatus = SMESH_Hypothesis::HYP_OK;
} }
else else
{
aStatus = SMESH_Hypothesis::HYP_INCOMPATIBLE; aStatus = SMESH_Hypothesis::HYP_INCOMPATIBLE;
}
return aStatus == SMESH_Hypothesis::HYP_OK; return aStatus == SMESH_Hypothesis::HYP_OK;
} }
@ -125,6 +126,7 @@ bool NETGENPlugin_NETGEN_2D3D::Compute(SMESH_Mesh& aMesh,
NETGENPlugin_Mesher mesher(&aMesh, aShape, true); NETGENPlugin_Mesher mesher(&aMesh, aShape, true);
// NETGENPlugin_Mesher mesher(meshDS, aShape, true); // NETGENPlugin_Mesher mesher(meshDS, aShape, true);
mesher.SetParameters(_hypothesis); mesher.SetParameters(dynamic_cast<const NETGENPlugin_Hypothesis*>(_hypothesis));
mesher.SetParameters(dynamic_cast<const NETGENPlugin_SimpleHypothesis_2D*>(_hypothesis));
return mesher.Compute(); return mesher.Compute();
} }

4
src/NETGENPlugin/NETGENPlugin_NETGEN_2D3D.hxx
View File

@ -36,7 +36,7 @@
#include "StdMeshers_MaxElementVolume.hxx" #include "StdMeshers_MaxElementVolume.hxx"
#include "Utils_SALOME_Exception.hxx" #include "Utils_SALOME_Exception.hxx"
class NETGENPlugin_Hypothesis; //class NETGENPlugin_Hypothesis;
class NETGENPLUGIN_EXPORT NETGENPlugin_NETGEN_2D3D: public SMESH_3D_Algo class NETGENPLUGIN_EXPORT NETGENPlugin_NETGEN_2D3D: public SMESH_3D_Algo
{ {
@ -52,7 +52,7 @@ public:
const TopoDS_Shape& aShape); const TopoDS_Shape& aShape);
protected: protected:
const NETGENPlugin_Hypothesis* _hypothesis; const SMESHDS_Hypothesis* _hypothesis;
}; };
#endif #endif

2
src/NETGENPlugin/NETGENPlugin_NETGEN_2D_ONLY.cxx
View File

@ -318,7 +318,7 @@ bool NETGENPlugin_NETGEN_2D_ONLY::Compute(SMESH_Mesh& aMesh,
netgen::Mesh * ngMesh = new netgen::Mesh (); netgen::Mesh * ngMesh = new netgen::Mesh ();
netgen::OCCGeometry occgeo; netgen::OCCGeometry occgeo;
NETGENPlugin_Mesher::PrepareOCCgeometry( occgeo, F ); NETGENPlugin_Mesher::PrepareOCCgeometry( occgeo, F, aMesh );
vector< const SMDS_MeshNode* > nodeVec; vector< const SMDS_MeshNode* > nodeVec;
problem = AddSegmentsToMesh( *ngMesh, occgeo, wires, helper, nodeVec ); problem = AddSegmentsToMesh( *ngMesh, occgeo, wires, helper, nodeVec );

207
src/NETGENPlugin/NETGENPlugin_SimpleHypothesis_2D.cxx Normal file
View File

@ -0,0 +1,207 @@
// NETGENPlugin : C++ implementation
//
// Copyright (C) 2006 OPEN CASCADE, CEA/DEN, EDF R&D
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
//
// File : NETGENPlugin_SimpleHypothesis_2D.cxx
// Author : Edward AGAPOV
// Project : SALOME
//=============================================================================
#include "NETGENPlugin_SimpleHypothesis_2D.hxx"
#include "NETGENPlugin_Hypothesis.hxx"
#include <SMESH_Mesh.hxx>
#include <SMESH_subMesh.hxx>
#include <SMESH_ControlsDef.hxx>
#include <TopExp_Explorer.hxx>
#include <utilities.h>
using namespace std;
//=============================================================================
/*!
*
*/
//=============================================================================
NETGENPlugin_SimpleHypothesis_2D::NETGENPlugin_SimpleHypothesis_2D (int hypId,
int studyId,
SMESH_Gen * gen)
: SMESH_Hypothesis(hypId, studyId, gen),
_nbSegments ((int)NETGENPlugin_Hypothesis::GetDefaultNbSegPerEdge()),
_segmentLength(0),
_area (0.)
{
_name = "NETGEN_SimpleParameters_2D";
_param_algo_dim = 2;
}
//=============================================================================
/*!
*
*/
//=============================================================================
void NETGENPlugin_SimpleHypothesis_2D::SetNumberOfSegments(int nb) throw (SALOME_Exception)
{
if ( nb < 1 )
throw SALOME_Exception("Number of segments must be positive");
if (nb != _nbSegments)
{
_nbSegments = nb;
if ( _nbSegments ) _segmentLength = 0.;
NotifySubMeshesHypothesisModification();
}
}
//=============================================================================
/*!
*
*/
//=============================================================================
void NETGENPlugin_SimpleHypothesis_2D::SetLocalLength(double segmentLength)
throw (SALOME_Exception)
{
if ( segmentLength < DBL_MIN )
throw SALOME_Exception("segment length must be more than zero");
if (segmentLength != _segmentLength)
{
_segmentLength = segmentLength;
if ( _segmentLength > DBL_MIN ) _nbSegments = 0;
NotifySubMeshesHypothesisModification();
}
}
//=============================================================================
/*!
*
*/
//=============================================================================
void NETGENPlugin_SimpleHypothesis_2D::LengthFromEdges()
{
if (_area > DBL_MIN )
{
_area = 0;
NotifySubMeshesHypothesisModification();
}
}
//=============================================================================
/*!
*
*/
//=============================================================================
void NETGENPlugin_SimpleHypothesis_2D::SetMaxElementArea(double area)
{
if ( area < DBL_MIN )
area = 0.;
if (_area != area)
{
_area = area;
NotifySubMeshesHypothesisModification();
}
}
//=============================================================================
/*!
*
*/
//=============================================================================
ostream & NETGENPlugin_SimpleHypothesis_2D::SaveTo(ostream & save)
{
save << _nbSegments << " " << _segmentLength << " " << _area;
return save;
}
//=============================================================================
/*!
*
*/
//=============================================================================
istream & NETGENPlugin_SimpleHypothesis_2D::LoadFrom(istream & load)
{
bool isOK = true;
double val;
isOK = (load >> val);
if (isOK)
_nbSegments = (int) val;
else
load.clear(ios::badbit | load.rdstate());
isOK = (load >> val);
if (isOK)
_segmentLength = val;
else
load.clear(ios::badbit | load.rdstate());
isOK = (load >> val);
if (isOK)
_area = val;
else
load.clear(ios::badbit | load.rdstate());
return load;
}
//================================================================================
/*!
* \brief Does nothing
* \param theMesh - the built mesh
* \param theShape - the geometry of interest
* \retval bool - always false
*/
//================================================================================
bool NETGENPlugin_SimpleHypothesis_2D::SetParametersByMesh(const SMESH_Mesh* theMesh,
const TopoDS_Shape& theShape)
{
// Find out nb of segments.
int nbSeg = 0, nbEdges = 0;
TopExp_Explorer exp( theShape, TopAbs_EDGE );
for ( ; exp.More(); exp.Next() ) {
SMESH_subMesh* sm = theMesh->GetSubMeshContaining( exp.Current() );
if ( sm && !sm->IsEmpty() ) {
nbSeg += sm->GetSubMeshDS()->NbElements();
nbEdges++;
}
}
if ( nbEdges )
_nbSegments = nbSeg / nbEdges;
// Find out max face area
_area = 0;
SMESH::Controls::Area areaControl;
SMESH::Controls::TSequenceOfXYZ nodesCoords;
const int nbFacesToCheck = 100;
for ( exp.Init( theShape, TopAbs_FACE ); exp.More(); exp.Next() ) {
SMESH_subMesh* sm = theMesh->GetSubMeshContaining( exp.Current() );
if ( sm && !sm->IsEmpty() ) {
SMDS_ElemIteratorPtr fIt = sm->GetSubMeshDS()->GetElements();
int nbCheckedFaces = 0;
while ( fIt->more() && nbCheckedFaces++ < nbFacesToCheck ) {
const SMDS_MeshElement* elem = fIt->next();
areaControl.GetPoints( elem, nodesCoords );
_area = max( _area, areaControl.GetValue( nodesCoords ));
}
}
}
return nbEdges;
}

99
src/NETGENPlugin/NETGENPlugin_SimpleHypothesis_2D.hxx Normal file
View File

@ -0,0 +1,99 @@
// NETGENPlugin : C++ implementation
//
// Copyright (C) 2006 OPEN CASCADE, CEA/DEN, EDF R&D
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
//
// File : NETGENPlugin_SimpleHypothesis_2D.hxx
// Author : Edward AGAPOV
// Project : SALOME
//=============================================================================
#ifndef _NETGENPlugin_SimpleHypothesis_2D_HXX_
#define _NETGENPlugin_SimpleHypothesis_2D_HXX_
#include "NETGENPlugin_Defs.hxx"
#include "SMESH_Hypothesis.hxx"
#include "Utils_SALOME_Exception.hxx"
// Simplified parameters of NETGEN
//
using namespace std;
class NETGENPLUGIN_EXPORT NETGENPlugin_SimpleHypothesis_2D: public SMESH_Hypothesis
{
public:
NETGENPlugin_SimpleHypothesis_2D(int hypId, int studyId, SMESH_Gen * gen);
/*!
* Sets <number of segments> value
*/
void SetNumberOfSegments(int nb) throw (SALOME_Exception);
/*!
* Returns <number of segments> value.
* Can be zero in case if LocalLength() has been set
*/
int GetNumberOfSegments() const { return _nbSegments; }
/*!
* Sets <segment length> value
*/
void SetLocalLength(double segmentLength) throw (SALOME_Exception);
/*!
* Returns <segment length> value.
* Can be zero in case if NumberOfSegments() has been set
*/
double GetLocalLength() const { return _segmentLength; }
/*!
* Sets <maximum element area> to be dependent on 1D discretization
*/
void LengthFromEdges();
/*!
* Sets <maximum element area> value.
* Zero or negative value means same as LengthFromEdges().
*/
void SetMaxElementArea(double area);
/*!
* Returns <maximum element area> value.
* Can be zero in case of LengthFromEdges()
*/
double GetMaxElementArea() const { return _area; }
// Persistence
virtual ostream & SaveTo(ostream & save);
virtual istream & LoadFrom(istream & load);
/*!
* \brief Set parameters by mesh
* \param theMesh - the built mesh
* \param theShape - the geometry of interest
* \retval bool - true if theShape is meshed
*/
virtual bool SetParametersByMesh(const SMESH_Mesh* theMesh, const TopoDS_Shape& theShape);
private:
int _nbSegments;
double _segmentLength, _area;
};
#endif

194
src/NETGENPlugin/NETGENPlugin_SimpleHypothesis_2D_i.cxx Normal file
View File

@ -0,0 +1,194 @@
// NETGENPlugin : C++ implementation
//
// Copyright (C) 2006 OPEN CASCADE, CEA/DEN, EDF R&D
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
//
// File : NETGENPlugin_SimpleHypothesis_2D_i.cxx
// Author : Edward AGAPOV
// Project : SALOME
//=============================================================================
#include "NETGENPlugin_SimpleHypothesis_2D_i.hxx"
#include "NETGENPlugin_SimpleHypothesis_2D.hxx"
#include <SMESH_Gen.hxx>
#include <SMESH_PythonDump.hxx>
#include <Utils_CorbaException.hxx>
#include <utilities.h>
using namespace std;
//=============================================================================
/*!
* NETGENPlugin_SimpleHypothesis_2D_i::NETGENPlugin_SimpleHypothesis_2D_i
*
* Constructor
*/
//=============================================================================
NETGENPlugin_SimpleHypothesis_2D_i::
NETGENPlugin_SimpleHypothesis_2D_i (PortableServer::POA_ptr thePOA,
int theStudyId,
::SMESH_Gen* theGenImpl)
: SALOME::GenericObj_i( thePOA ),
SMESH_Hypothesis_i( thePOA )
{
MESSAGE( "NETGENPlugin_SimpleHypothesis_2D_i::NETGENPlugin_SimpleHypothesis_2D_i" );
myBaseImpl = new ::NETGENPlugin_SimpleHypothesis_2D (theGenImpl->GetANewId(),
theStudyId,
theGenImpl);
}
//=============================================================================
/*!
* NETGENPlugin_SimpleHypothesis_2D_i::~NETGENPlugin_SimpleHypothesis_2D_i
*
* Destructor
*/
//=============================================================================
NETGENPlugin_SimpleHypothesis_2D_i::~NETGENPlugin_SimpleHypothesis_2D_i()
{
MESSAGE( "NETGENPlugin_SimpleHypothesis_2D_i::~NETGENPlugin_SimpleHypothesis_2D_i" );
}
//=============================================================================
/*!
* NETGENPlugin_SimpleHypothesis_2D_i::SetNumberOfSegments
*/
//=============================================================================
void NETGENPlugin_SimpleHypothesis_2D_i::SetNumberOfSegments(CORBA::Short nb)
throw ( SALOME::SALOME_Exception )
{
MESSAGE("NETGENPlugin_SimpleHypothesis_2D_i::SetNumberOfSegments");
ASSERT(myBaseImpl);
try {
this->GetImpl()->SetNumberOfSegments(nb);
}
catch (SALOME_Exception& S_ex) {
THROW_SALOME_CORBA_EXCEPTION( S_ex.what(), SALOME::BAD_PARAM );
}
SMESH::TPythonDump() << _this() << ".SetNumberOfSegments( " << nb << " )";
}
//=============================================================================
/*!
* NETGENPlugin_SimpleHypothesis_2D_i::GetNumberOfSegments()
*/
//=============================================================================
CORBA::Short NETGENPlugin_SimpleHypothesis_2D_i::GetNumberOfSegments()
{
MESSAGE("NETGENPlugin_SimpleHypothesis_2D_i::GetNumberOfSegments");
ASSERT(myBaseImpl);
return this->GetImpl()->GetNumberOfSegments();
}
//================================================================================
/*!
* LocalLength()
*/
//================================================================================
void NETGENPlugin_SimpleHypothesis_2D_i::SetLocalLength(CORBA::Double segmentLength)
{
MESSAGE("NETGENPlugin_SimpleHypothesis_2D_i::SetLocalLength");
ASSERT(myBaseImpl);
try {
this->GetImpl()->SetLocalLength(segmentLength);
}
catch (SALOME_Exception& S_ex) {
THROW_SALOME_CORBA_EXCEPTION( S_ex.what(), SALOME::BAD_PARAM );
}
SMESH::TPythonDump() << _this() << ".LocalLength( " << segmentLength << " )";
}
//================================================================================
/*!
* GetLocalLength()
*/
//================================================================================
CORBA::Double NETGENPlugin_SimpleHypothesis_2D_i::GetLocalLength()
{
MESSAGE("NETGENPlugin_SimpleHypothesis_2D_i::GetLocalLength");
ASSERT(myBaseImpl);
return this->GetImpl()->GetLocalLength();
}
//=============================================================================
/*!
* NETGENPlugin_SimpleHypothesis_2D_i::LengthFromEdges()
*/
//=============================================================================
void NETGENPlugin_SimpleHypothesis_2D_i::LengthFromEdges()
{
MESSAGE("NETGENPlugin_SimpleHypothesis_2D_i::LengthFromEdges");
ASSERT(myBaseImpl);
this->GetImpl()->LengthFromEdges();
SMESH::TPythonDump() << _this() << ".LengthFromEdges()";
}
//=============================================================================
/*!
* NETGENPlugin_SimpleHypothesis_2D_i::SetMaxElementArea()
*/
//=============================================================================
void NETGENPlugin_SimpleHypothesis_2D_i::SetMaxElementArea(CORBA::Double area)
{
MESSAGE("NETGENPlugin_SimpleHypothesis_2D_i::SetMaxElementArea");
ASSERT(myBaseImpl);
this->GetImpl()->SetMaxElementArea(area);
SMESH::TPythonDump() << _this() << ".SetMaxElementArea( " << area << " )";
}
//=============================================================================
/*!
* NETGENPlugin_SimpleHypothesis_2D_i::GetMaxElementArea()
*/
//=============================================================================
CORBA::Double NETGENPlugin_SimpleHypothesis_2D_i::GetMaxElementArea()
{
MESSAGE("NETGENPlugin_SimpleHypothesis_2D_i::GetMaxElementArea");
ASSERT(myBaseImpl);
return this->GetImpl()->GetMaxElementArea();
}
//=============================================================================
/*!
* NETGENPlugin_SimpleHypothesis_2D_i::GetImpl
*/
//=============================================================================
::NETGENPlugin_SimpleHypothesis_2D* NETGENPlugin_SimpleHypothesis_2D_i::GetImpl()
{
MESSAGE("NETGENPlugin_SimpleHypothesis_2D_i::GetImpl");
return (::NETGENPlugin_SimpleHypothesis_2D*)myBaseImpl;
}
//================================================================================
/*!
* \brief Verify whether hypothesis supports given entity type
* \param type - dimension (see SMESH::Dimension enumeration)
* \retval CORBA::Boolean - TRUE if dimension is supported, FALSE otherwise
*
* Verify whether hypothesis supports given entity type (see SMESH::Dimension enumeration)
*/
//================================================================================
CORBA::Boolean NETGENPlugin_SimpleHypothesis_2D_i::IsDimSupported( SMESH::Dimension type )
{
return type == SMESH::DIM_2D;
}

74
src/NETGENPlugin/NETGENPlugin_SimpleHypothesis_2D_i.hxx Normal file
View File

@ -0,0 +1,74 @@
// NETGENPlugin : C++ implementation
//
// Copyright (C) 2006 OPEN CASCADE, CEA/DEN, EDF R&D
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
//
// File : NETGENPlugin_SimpleHypothesis_2D_i.hxx
// Author : Edward AGAPOV
// Project : SALOME
//=============================================================================
#ifndef _NETGENPlugin_SimpleHypothesis_2D_i_HXX_
#define _NETGENPlugin_SimpleHypothesis_2D_i_HXX_
#include "NETGENPlugin_Defs.hxx"
#include <SALOMEconfig.h>
#include CORBA_SERVER_HEADER(NETGENPlugin_Algorithm)
#include "SMESH_Hypothesis_i.hxx"
class SMESH_Gen;
class NETGENPlugin_SimpleHypothesis_2D;
// Simplified NETGEN parameters (2D case)
class NETGENPLUGIN_EXPORT NETGENPlugin_SimpleHypothesis_2D_i:
public virtual POA_NETGENPlugin::NETGENPlugin_SimpleHypothesis_2D,
public virtual SMESH_Hypothesis_i
{
public:
// Constructor
NETGENPlugin_SimpleHypothesis_2D_i (PortableServer::POA_ptr thePOA,
int theStudyId,
::SMESH_Gen* theGenImpl);
// Destructor
virtual ~NETGENPlugin_SimpleHypothesis_2D_i();
void SetNumberOfSegments(CORBA::Short nb) throw ( SALOME::SALOME_Exception );
CORBA::Short GetNumberOfSegments();
void SetLocalLength(CORBA::Double segmentLength);
CORBA::Double GetLocalLength();
void LengthFromEdges();
void SetMaxElementArea(CORBA::Double area);
CORBA::Double GetMaxElementArea();
// Get implementation
::NETGENPlugin_SimpleHypothesis_2D* GetImpl();
// Verify whether hypothesis supports given entity type
CORBA::Boolean IsDimSupported( SMESH::Dimension type );
};
#endif

151
src/NETGENPlugin/NETGENPlugin_SimpleHypothesis_3D.cxx Normal file
View File

@ -0,0 +1,151 @@
// NETGENPlugin : C++ implementation
//
// Copyright (C) 2006 OPEN CASCADE, CEA/DEN, EDF R&D
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
//
// File : NETGENPlugin_SimpleHypothesis_3D.cxx
// Author : Edward AGAPOV
// Project : SALOME
//=============================================================================
#include "NETGENPlugin_SimpleHypothesis_3D.hxx"
#include "NETGENPlugin_Hypothesis.hxx"
#include <SMESH_ControlsDef.hxx>
#include <SMESH_Mesh.hxx>
#include <SMESH_subMesh.hxx>
#include <TopExp_Explorer.hxx>
#include <utilities.h>
using namespace std;
//=============================================================================
/*!
*
*/
//=============================================================================
NETGENPlugin_SimpleHypothesis_3D::NETGENPlugin_SimpleHypothesis_3D (int hypId,
int studyId,
SMESH_Gen * gen)
: NETGENPlugin_SimpleHypothesis_2D(hypId, studyId, gen),
_volume(0)
{
_name = "NETGEN_SimpleParameters_3D";
_param_algo_dim = 3;
}
//=============================================================================
/*!
*
*/
//=============================================================================
void NETGENPlugin_SimpleHypothesis_3D::LengthFromFaces()
{
if (_volume > DBL_MIN )
{
_volume = 0;
NotifySubMeshesHypothesisModification();
}
}
//=============================================================================
/*!
*
*/
//=============================================================================
void NETGENPlugin_SimpleHypothesis_3D::SetMaxElementVolume(double value)
{
if ( value < DBL_MIN )
value = 0.;
if (_volume != value)
{
_volume = value;
NotifySubMeshesHypothesisModification();
}
}
//=============================================================================
/*!
*
*/
//=============================================================================
ostream & NETGENPlugin_SimpleHypothesis_3D::SaveTo(ostream & save)
{
NETGENPlugin_SimpleHypothesis_2D::SaveTo( save );
save << " " << _volume;
return save;
}
//=============================================================================
/*!
*
*/
//=============================================================================
istream & NETGENPlugin_SimpleHypothesis_3D::LoadFrom(istream & load)
{
NETGENPlugin_SimpleHypothesis_2D::LoadFrom(load);
bool isOK = true;
double val;
isOK = (load >> val);
if (isOK)
_volume = val;
else
load.clear(ios::badbit | load.rdstate());
return load;
}
//================================================================================
/*!
* \brief Does nothing
* \param theMesh - the built mesh
* \param theShape - the geometry of interest
* \retval bool - always false
*/
//================================================================================
bool NETGENPlugin_SimpleHypothesis_3D::SetParametersByMesh(const SMESH_Mesh* theMesh,
const TopoDS_Shape& theShape)
{
if ( NETGENPlugin_SimpleHypothesis_2D::SetParametersByMesh(theMesh, theShape) )
{
// Find out max volume
_volume = 0;
SMESH::Controls::Volume volControl;
volControl.SetMesh( ((SMESH_Mesh*)theMesh)->GetMeshDS() );
const int nbElemToCheck = 100;
for ( TopExp_Explorer exp( theShape, TopAbs_SOLID ); exp.More(); exp.Next() ) {
SMESH_subMesh* sm = theMesh->GetSubMeshContaining( exp.Current() );
if ( sm && !sm->IsEmpty() ) {
SMDS_ElemIteratorPtr fIt = sm->GetSubMeshDS()->GetElements();
int nbCheckedElems = 0;
while ( fIt->more() && nbCheckedElems++ < nbElemToCheck ) {
const SMDS_MeshElement* elem = fIt->next();
_volume = max( _volume, volControl.GetValue( elem->GetID() ));
}
}
}
return int( _volume );
}
return false;
}

67
src/NETGENPlugin/NETGENPlugin_SimpleHypothesis_3D.hxx Normal file
View File

@ -0,0 +1,67 @@
// NETGENPlugin : C++ implementation
//
// Copyright (C) 2006 OPEN CASCADE, CEA/DEN, EDF R&D
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
//
// File : NETGENPlugin_SimpleHypothesis_3D.hxx
// Author : Edward AGAPOV
// Project : SALOME
//=============================================================================
#ifndef _NETGENPlugin_SimpleHypothesis_3D_HXX_
#define _NETGENPlugin_SimpleHypothesis_3D_HXX_
#include "NETGENPlugin_Defs.hxx"
#include "NETGENPlugin_SimpleHypothesis_2D.hxx"
#include <Utils_SALOME_Exception.hxx>
// Simplified parameters of NETGEN
//
using namespace std;
class NETGENPLUGIN_EXPORT NETGENPlugin_SimpleHypothesis_3D: public NETGENPlugin_SimpleHypothesis_2D
{
public:
NETGENPlugin_SimpleHypothesis_3D(int hypId, int studyId, SMESH_Gen * gen);
void LengthFromFaces();
void SetMaxElementVolume(double value);
double GetMaxElementVolume() const { return _volume; }
// Persistence
virtual ostream & SaveTo(ostream & save);
virtual istream & LoadFrom(istream & load);
/*!
* \brief Set parameters by mesh
* \param theMesh - the built mesh
* \param theShape - the geometry of interest
* \retval bool - true if theShape is meshed
*/
virtual bool SetParametersByMesh(const SMESH_Mesh* theMesh, const TopoDS_Shape& theShape);
private:
double _volume;
};
#endif

134
src/NETGENPlugin/NETGENPlugin_SimpleHypothesis_3D_i.cxx Normal file
View File

@ -0,0 +1,134 @@
// NETGENPlugin : C++ implementation
//
// Copyright (C) 2006 OPEN CASCADE, CEA/DEN, EDF R&D
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
//
// File : NETGENPlugin_SimpleHypothesis_3D_i.cxx
// Author : Edward AGAPOV
// Project : SALOME
//=============================================================================
#include "NETGENPlugin_SimpleHypothesis_3D_i.hxx"
#include "NETGENPlugin_SimpleHypothesis_3D.hxx"
#include <SMESH_Gen.hxx>
#include <SMESH_PythonDump.hxx>
#include <Utils_CorbaException.hxx>
#include <utilities.h>
using namespace std;
//=============================================================================
/*!
* NETGENPlugin_SimpleHypothesis_3D_i::NETGENPlugin_SimpleHypothesis_3D_i
*
* Constructor
*/
//=============================================================================
NETGENPlugin_SimpleHypothesis_3D_i::
NETGENPlugin_SimpleHypothesis_3D_i (PortableServer::POA_ptr thePOA,
int theStudyId,
::SMESH_Gen* theGenImpl)
: SALOME::GenericObj_i( thePOA ),
SMESH_Hypothesis_i( thePOA ),
NETGENPlugin_SimpleHypothesis_2D_i( thePOA,theStudyId,theGenImpl )
{
MESSAGE( "NETGENPlugin_SimpleHypothesis_3D_i::NETGENPlugin_SimpleHypothesis_3D_i" );
if ( myBaseImpl )
delete myBaseImpl;
myBaseImpl = new ::NETGENPlugin_SimpleHypothesis_3D (theGenImpl->GetANewId(),
theStudyId,
theGenImpl);
}
//=============================================================================
/*!
* NETGENPlugin_SimpleHypothesis_3D_i::~NETGENPlugin_SimpleHypothesis_3D_i
*
* Destructor
*/
//=============================================================================
NETGENPlugin_SimpleHypothesis_3D_i::~NETGENPlugin_SimpleHypothesis_3D_i()
{
MESSAGE( "NETGENPlugin_SimpleHypothesis_3D_i::~NETGENPlugin_SimpleHypothesis_3D_i" );
}
//=============================================================================
/*!
* NETGENPlugin_SimpleHypothesis_3D_i::LengthFromFaces()
*/
//=============================================================================
void NETGENPlugin_SimpleHypothesis_3D_i::LengthFromFaces()
{
MESSAGE("NETGENPlugin_SimpleHypothesis_3D_i::LengthFromFaces");
ASSERT(myBaseImpl);
this->GetImpl()->LengthFromFaces();
SMESH::TPythonDump() << _this() << ".LengthFromFaces()";
}
//=============================================================================
/*!
* NETGENPlugin_SimpleHypothesis_3D_i::SetMaxElementVolume()
*/
//=============================================================================
void NETGENPlugin_SimpleHypothesis_3D_i::SetMaxElementVolume(CORBA::Double value)
{
MESSAGE("NETGENPlugin_SimpleHypothesis_3D_i::SetMaxElementVolume");
ASSERT(myBaseImpl);
this->GetImpl()->SetMaxElementVolume(value);
SMESH::TPythonDump() << _this() << ".SetMaxElementVolume( " << value << " )";
}
//=============================================================================
/*!
* NETGENPlugin_SimpleHypothesis_3D_i::GetMaxElementVolume()
*/
//=============================================================================
CORBA::Double NETGENPlugin_SimpleHypothesis_3D_i::GetMaxElementVolume()
{
MESSAGE("NETGENPlugin_SimpleHypothesis_3D_i::GetMaxElementVolume");
ASSERT(myBaseImpl);
return this->GetImpl()->GetMaxElementVolume();
}
//=============================================================================
/*!
* NETGENPlugin_SimpleHypothesis_3D_i::GetImpl
*/
//=============================================================================
::NETGENPlugin_SimpleHypothesis_3D* NETGENPlugin_SimpleHypothesis_3D_i::GetImpl()
{
MESSAGE("NETGENPlugin_SimpleHypothesis_3D_i::GetImpl");
return (::NETGENPlugin_SimpleHypothesis_3D*)myBaseImpl;
}
//================================================================================
/*!
* \brief Verify whether hypothesis supports given entity type
* \param type - dimension (see SMESH::Dimension enumeration)
* \retval CORBA::Boolean - TRUE if dimension is supported, FALSE otherwise
*
* Verify whether hypothesis supports given entity type (see SMESH::Dimension enumeration)
*/
//================================================================================
CORBA::Boolean NETGENPlugin_SimpleHypothesis_3D_i::IsDimSupported( SMESH::Dimension type )
{
return type == SMESH::DIM_3D;
}

65
src/NETGENPlugin/NETGENPlugin_SimpleHypothesis_3D_i.hxx Normal file
View File

@ -0,0 +1,65 @@
// NETGENPlugin : C++ implementation
//
// Copyright (C) 2006 OPEN CASCADE, CEA/DEN, EDF R&D
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
//
// File : NETGENPlugin_SimpleHypothesis_3D_i.hxx
// Author : Edward AGAPOV
// Project : SALOME
//=============================================================================
#ifndef _NETGENPlugin_SimpleHypothesis_3D_i_HXX_
#define _NETGENPlugin_SimpleHypothesis_3D_i_HXX_
#include "NETGENPlugin_Defs.hxx"
#include "NETGENPlugin_SimpleHypothesis_2D_i.hxx"
#include <SALOMEconfig.h>
#include CORBA_SERVER_HEADER(NETGENPlugin_Algorithm)
class SMESH_Gen;
class NETGENPlugin_SimpleHypothesis_3D;
// Simplified NETGEN parameters (3D case)
class NETGENPLUGIN_EXPORT NETGENPlugin_SimpleHypothesis_3D_i:
public virtual POA_NETGENPlugin::NETGENPlugin_SimpleHypothesis_3D,
public virtual NETGENPlugin_SimpleHypothesis_2D_i
{
public:
// Constructor
NETGENPlugin_SimpleHypothesis_3D_i (PortableServer::POA_ptr thePOA,
int theStudyId,
::SMESH_Gen* theGenImpl);
// Destructor
virtual ~NETGENPlugin_SimpleHypothesis_3D_i();
void LengthFromFaces();
void SetMaxElementVolume(CORBA::Double value);
CORBA::Double GetMaxElementVolume();
// Get implementation
::NETGENPlugin_SimpleHypothesis_3D* GetImpl();
// Verify whether hypothesis supports given entity type
CORBA::Boolean IsDimSupported( SMESH::Dimension type );
};
#endif

6
src/NETGENPlugin/NETGENPlugin_i.cxx
View File

@ -34,6 +34,8 @@
#include "NETGENPlugin_NETGEN_2D3D_i.hxx" #include "NETGENPlugin_NETGEN_2D3D_i.hxx"
#include "NETGENPlugin_Hypothesis_i.hxx" #include "NETGENPlugin_Hypothesis_i.hxx"
#include "NETGENPlugin_Hypothesis_2D_i.hxx" #include "NETGENPlugin_Hypothesis_2D_i.hxx"
#include "NETGENPlugin_SimpleHypothesis_2D_i.hxx"
#include "NETGENPlugin_SimpleHypothesis_3D_i.hxx"
template <class T> class NETGENPlugin_Creator_i:public HypothesisCreator_i<T> template <class T> class NETGENPlugin_Creator_i:public HypothesisCreator_i<T>
{ {
@ -72,6 +74,10 @@ extern "C"
aCreator = new NETGENPlugin_Creator_i<NETGENPlugin_Hypothesis_i>; aCreator = new NETGENPlugin_Creator_i<NETGENPlugin_Hypothesis_i>;
else if (strcmp(aHypName, "NETGEN_Parameters_2D") == 0) else if (strcmp(aHypName, "NETGEN_Parameters_2D") == 0)
aCreator = new NETGENPlugin_Creator_i<NETGENPlugin_Hypothesis_2D_i>; aCreator = new NETGENPlugin_Creator_i<NETGENPlugin_Hypothesis_2D_i>;
else if (strcmp(aHypName, "NETGEN_SimpleParameters_2D") == 0)
aCreator = new NETGENPlugin_Creator_i<NETGENPlugin_SimpleHypothesis_2D_i>;
else if (strcmp(aHypName, "NETGEN_SimpleParameters_3D") == 0)
aCreator = new NETGENPlugin_Creator_i<NETGENPlugin_SimpleHypothesis_3D_i>;
else ; else ;
return aCreator; return aCreator;