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

Merge from BR_imps_2013 14/01/2014

Browse Source
This commit is contained in:
vsr 2014-01-15 10:08:00 +00:00
parent c32068e4d7
commit 3302782c77
18 changed files with 347 additions and 75 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
doc/salome/gui/NETGENPLUGIN/images/netgen2d3d.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 32 KiB

After

Width:  |  Height:  |  Size: 26 KiB

BIN
doc/salome/gui/NETGENPLUGIN/images/netgen2d3d_only.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 28 KiB

After

Width:  |  Height:  |  Size: 28 KiB

58
doc/salome/gui/NETGENPLUGIN/input/netgen_2d_3d_hypo.doc
View File

@ -10,8 +10,8 @@ hypotheses and algorithms (2D and 1D for meshing 3D objects and 1D for
meshing 2D objects).
\image html netgen2d3d.png
<center><em>Dialog boxes of <b>Netgen 1D-2D</b> and <b>Netgen
1D-2D-3D</b> algorithms </em></center>
<center><em>Hypothesis dialog boxes of <b>Netgen 1D-2D</b> and <b>Netgen
1D-2D-3D</b> algorithms are same</em></center>
<br>
\image html netgen2d3d_only.png
@ -24,21 +24,35 @@ algorithms </em></center>
- <b>Min Size</b> - minimum linear dimensions for mesh cells. It is
ignored if it is more than <b>Max Size</b>.
- <b>Second Order</b> - if this box is checked in, the algorithm will
create second order nodes on the mesh, which will then become quadratic.
- <b>Fineness</b> - ranging from Very Coarse to Very Fine allows to set the
level of meshing detalization using the three parameters below. You
can select Custom to define them manually.
create second order mesh.
- <b>Fineness</b> - ranging from <em>Very Coarse</em> to <em>Very Fine</em>
allows to set the level of meshing detalization using the three
parameters below. You can select \a Custom to define them manually.
- <b>Growth rate</b> - allows to define how much the linear dimensions of
two adjacent cells can differ (i.e. 0.3 means 30%).
- <b>Nb. Segs per Edge</b> and <b>Nb Segs per Radius</b> - allows to define the
minimum number of mesh segments in which edges and radiuses will be
split.
- <b>Allow Quadrangles</b> - allows to use quadrangle elements in a
triangle 2D mesh. This checkbox is not present in Netgen 3D parameters
because currently building a tetrahedral mesh with quadrangle faces is
not possible.
- <b>Optimize</b> - if this box is checked in, the algorithm will try to
create regular (possessing even sides) elements.
- <b>Nb. Segs per Edge</b> - allows to define the minimum number of
mesh segments in which edges will be split. This parameter is used
only if <b>Limit Size by Surface Curvature</b> is checked.
- <b>Nb Segs per Radius</b> - allows to define the size of
mesh segments and mesh faces in which curved edges and surfaces will
be split. This parameter is used only if <b>Limit Size by Surface
Curvature</b> is checked.
- <b>Limit Size by Surface Curvature</b> - if this box is checked in,
then size of mesh segments and mesh faces on curved edges and surfaces
is defined using value of <b>Nb Segs per Radius</b> parameter, and
number of segments on straight edges is defined by values of
<b>Nb. Segs per Edge</b> parameter. If this box is not checked in,
then size of elements is defined by three parameters only:
<b>Max Size</b>, <b>Min Size</b> and <b>Growth rate</b>.
- <b>Allow Quadrangles</b> - if this box is checked in, the mesher
tries to generate quadrangle 2D mesh. Triangle elements are created
where quadrangles are not possible.
- <b>Optimize</b> - if this box is checked in, the algorithm will modify
initially created mesh in order to improve quality of elements. Optimization
process is rather time consuming comparing to creation of initial mesh.
- <b>Fuse Coincident Nodes on Edges and Vertices</b> - allows merging
mesh nodes on vertices and edges which are geometrically coincident
but are topologically different.
\image html netgen3d_local_size.png
@ -66,14 +80,12 @@ consists of setting required \b length of segments.
\b 2D group allows defining the size of 2D elements
- <b>Length from edges</b> if checked in, hypothesis forces building of
2D mesh segments having a length calculated as an average edge length
2D mesh elements having a length calculated as an average edge length
for a given wire, else
- <b>Max. Element Area</b> specifies expected maximum element area for
each 2d element.
- <b>Allow Quadrangles</b> - allows to use quadrangle elements in a
triangle 2D mesh. This checkbox is not present in Netgen 3D simple parameters
because currently building a tetrahedral mesh with quadrangle faces is
not possible.
- <b>Allow Quadrangles</b> - allows to generate quadrangle elements
wherever possible.
\b 3D groups allows defining the size of 3D elements.
- <b>Length from faces</b> if checked in, the area of sides of
@ -89,13 +101,9 @@ edge. This parameter is used only to define the local element size
(size at the given point), so local sizes of adjacent edges influence
each other.
- NETGEN additionally restricts the element size according to edge curvature.
- The local size of edges influences the size of close triangles.
- The local size of segments influences the size of close triangles.
- The order of elements and their size in the 1D mesh generated by
NETGEN differ from those in the 1D mesh generated by Regular_1D
algorithm, resulting in different 2D and 3D meshes.
\note In the case where two points are geometrically confounded, a single node is generated.
*/

6
idl/NETGENPlugin_Algorithm.idl
View File

@ -97,6 +97,12 @@ module NETGENPlugin
void SetQuadAllowed(in boolean value);
boolean GetQuadAllowed();
void SetUseSurfaceCurvature(in boolean value);
boolean GetUseSurfaceCurvature();
void SetFuseEdges(in boolean value);
boolean GetFuseEdges();
void SetLocalSizeOnShape(in GEOM::GEOM_Object GeomObj, in double localSize);
void SetLocalSizeOnEntry(in string entry, in double localSize);

2
resources/NETGENPlugin.xml
View File

@ -67,6 +67,7 @@
opt-hypos="ViscousLayers"
need-geom="false"
input="TRIA,QUAD"
output="TETRA,PYRAMID"
dim="3">
<python-wrap>
<algo>NETGEN_3D=Tetrahedron()</algo>
@ -114,6 +115,7 @@
label-id="Netgen 1D-2D-3D"
icon-id="mesh_algo_netgen_2d3d.png"
hypos="NETGEN_Parameters, NETGEN_SimpleParameters_3D"
output="TETRA,PYRAMID"
dim="3"
support-submeshes="true">
<python-wrap>

92
src/GUI/NETGENPluginGUI_HypothesisCreator.cxx
View File

@ -89,7 +89,7 @@ NETGENPluginGUI_HypothesisCreator::NETGENPluginGUI_HypothesisCreator( const QStr
{
myGeomSelectionTools = NULL;
myLocalSizeMap.clear();
myIs2D = ( theHypType.startsWith("NETGEN_Parameters_2D"));
myIs2D = ( theHypType.startsWith("NETGEN_Parameters_2D"));
myIsONLY = ( theHypType == "NETGEN_Parameters_2D_ONLY" ||
theHypType == "NETGEN_Parameters_3D");
}
@ -166,7 +166,7 @@ QFrame* NETGENPluginGUI_HypothesisCreator::buildFrame()
if ( !myIsONLY )
{
mySecondOrder = new QCheckBox( tr( "NETGEN_SECOND_ORDER" ), GroupC1 );
aGroupLayout->addWidget( mySecondOrder, row, 0 );
aGroupLayout->addWidget( mySecondOrder, row, 0, 1, 2 );
row++;
}
@ -177,6 +177,7 @@ QFrame* NETGENPluginGUI_HypothesisCreator::buildFrame()
tr( "NETGEN_FINE" ) << tr( "NETGEN_VERYFINE" ) << tr( "NETGEN_CUSTOM" );
myFineness->addItems( types );
aGroupLayout->addWidget( myFineness, row, 1 );
connect( myFineness, SIGNAL( activated( int ) ), this, SLOT( onFinenessChanged() ) );
row++;
aGroupLayout->addWidget( new QLabel( tr( "NETGEN_GROWTH_RATE" ), GroupC1 ), row, 0 );
@ -203,19 +204,35 @@ QFrame* NETGENPluginGUI_HypothesisCreator::buildFrame()
aGroupLayout->addWidget( myNbSegPerRadius, row, 1 );
row++;
}
mySurfaceCurvature = 0;
if ( myIs2D || !myIsONLY )
{
mySurfaceCurvature = new QCheckBox( tr( "NETGEN_SURFACE_CURVATURE" ), GroupC1 );
aGroupLayout->addWidget( mySurfaceCurvature, row, 0, 1, 2 );
connect( mySurfaceCurvature, SIGNAL( stateChanged( int ) ), this, SLOT( onSurfaceCurvatureChanged() ) );
row++;
}
myAllowQuadrangles = 0;
if ( myIs2D || !myIsONLY ) // issue 0021676
if ( myIs2D || !myIsONLY ) // disable only for NETGEN 3D
{
myAllowQuadrangles = new QCheckBox( tr( "NETGEN_ALLOW_QUADRANGLES" ), GroupC1 );
aGroupLayout->addWidget( myAllowQuadrangles, row, 0 );
aGroupLayout->addWidget( myAllowQuadrangles, row, 0, 1, 2 );
row++;
}
myOptimize = new QCheckBox( tr( "NETGEN_OPTIMIZE" ), GroupC1 );
aGroupLayout->addWidget( myOptimize, row, 0 );
aGroupLayout->addWidget( myOptimize, row, 0, 1, 2 );
row++;
connect( myFineness, SIGNAL( activated( int ) ), this, SLOT( onFinenessChanged() ) );
myFuseEdges = 0;
if (!myIsONLY)
{
myFuseEdges = new QCheckBox( tr( "NETGEN_FUSE_EDGES" ), GroupC1 );
aGroupLayout->addWidget( myFuseEdges, row, 0, 1, 2 );
row++;
}
myLocalSizeTable = 0;
if ( !myIsONLY )
@ -306,13 +323,21 @@ void NETGENPluginGUI_HypothesisCreator::retrieveParams() const
if (myAllowQuadrangles)
myAllowQuadrangles->setChecked( data.myAllowQuadrangles );
if (mySurfaceCurvature)
mySurfaceCurvature->setChecked( data.mySurfaceCurvature );
if (myFuseEdges)
myFuseEdges->setChecked( data.myFuseEdges );
// update widgets
bool isCustom = (myFineness->currentIndex() == UserDefined);
myGrowthRate->setEnabled(isCustom);
bool isSurfaceCurvature = (mySurfaceCurvature ? mySurfaceCurvature->checkState() == Qt::Checked : true);
myFineness->setEnabled(isSurfaceCurvature);
myGrowthRate->setEnabled(isCustom && isSurfaceCurvature);
if ( myNbSegPerEdge )
myNbSegPerEdge->setEnabled(isCustom);
myNbSegPerEdge->setEnabled(isCustom && isSurfaceCurvature);
if ( myNbSegPerRadius )
myNbSegPerRadius->setEnabled(isCustom);
myNbSegPerRadius->setEnabled(isCustom && isSurfaceCurvature);
if ( myLocalSizeTable )
{
@ -357,6 +382,12 @@ QString NETGENPluginGUI_HypothesisCreator::storeParams() const
if ( myIs2D && data.myAllowQuadrangles )
valStr += "; " + tr("NETGEN_ALLOW_QUADRANGLES");
if ( data.mySurfaceCurvature )
valStr += "; " + tr("NETGEN_SURFACE_CURVATURE");
if ( data.myFuseEdges )
valStr += "; " + tr("NETGEN_FUSE_EDGES");
return valStr;
}
@ -382,6 +413,8 @@ bool NETGENPluginGUI_HypothesisCreator::readParamsFromHypo( NetgenHypothesisData
h_data.myNbSegPerRadiusVar = getVariableName("SetNbSegPerRadius");
h_data.myMinSize = h->GetMinSize();
h_data.myMinSizeVar = getVariableName("SetMinSize");
h_data.mySurfaceCurvature = h->GetUseSurfaceCurvature();
h_data.myFuseEdges = h->GetFuseEdges();
//if ( myIs2D )
{
@ -425,23 +458,25 @@ bool NETGENPluginGUI_HypothesisCreator::storeParamsToHypo( const NetgenHypothesi
if( isCreation() )
SMESH::SetName( SMESH::FindSObject( h ), h_data.myName.toLatin1().data() );
h->SetVarParameter( h_data.myMaxSizeVar.toLatin1().constData(), "SetMaxSize");
h->SetMaxSize( h_data.myMaxSize );
h->SetSecondOrder( h_data.mySecondOrder );
h->SetOptimize( h_data.myOptimize );
h->SetMaxSize ( h_data.myMaxSize );
h->SetSecondOrder ( h_data.mySecondOrder );
h->SetOptimize ( h_data.myOptimize );
int fineness = h_data.myFineness;
h->SetFineness( fineness );
h->SetFineness ( fineness );
if( fineness==UserDefined )
{
h->SetVarParameter( h_data.myGrowthRateVar.toLatin1().constData(), "SetGrowthRate");
h->SetGrowthRate( h_data.myGrowthRate );
h->SetVarParameter( h_data.myNbSegPerEdgeVar.toLatin1().constData(), "SetNbSegPerEdge");
h->SetNbSegPerEdge( h_data.myNbSegPerEdge );
h->SetVarParameter( h_data.myNbSegPerRadiusVar.toLatin1().constData(), "SetNbSegPerRadius");
h->SetVarParameter ( h_data.myGrowthRateVar.toLatin1().constData(), "SetGrowthRate");
h->SetGrowthRate ( h_data.myGrowthRate );
h->SetVarParameter ( h_data.myNbSegPerEdgeVar.toLatin1().constData(), "SetNbSegPerEdge");
h->SetNbSegPerEdge ( h_data.myNbSegPerEdge );
h->SetVarParameter ( h_data.myNbSegPerRadiusVar.toLatin1().constData(), "SetNbSegPerRadius");
h->SetNbSegPerRadius( h_data.myNbSegPerRadius );
}
h->SetVarParameter( h_data.myMinSizeVar.toLatin1().constData(), "SetMinSize");
h->SetMinSize( h_data.myMinSize );
h->SetVarParameter ( h_data.myMinSizeVar.toLatin1().constData(), "SetMinSize");
h->SetMinSize ( h_data.myMinSize );
h->SetUseSurfaceCurvature( h_data.mySurfaceCurvature );
h->SetFuseEdges ( h_data.myFuseEdges );
//if ( myIs2D )
{
@ -507,6 +542,12 @@ bool NETGENPluginGUI_HypothesisCreator::readParamsFromWidgets( NetgenHypothesisD
if ( myAllowQuadrangles )
h_data.myAllowQuadrangles = myAllowQuadrangles->isChecked();
if ( mySurfaceCurvature )
h_data.mySurfaceCurvature = mySurfaceCurvature->isChecked();
if ( myFuseEdges )
h_data.myFuseEdges = myFuseEdges->isChecked();
if ( myLocalSizeTable )
{
NETGENPluginGUI_HypothesisCreator* that = (NETGENPluginGUI_HypothesisCreator*)this;
@ -521,6 +562,17 @@ bool NETGENPluginGUI_HypothesisCreator::readParamsFromWidgets( NetgenHypothesisD
return true;
}
void NETGENPluginGUI_HypothesisCreator::onSurfaceCurvatureChanged()
{
bool isSurfaceCurvature = (mySurfaceCurvature ? mySurfaceCurvature->isChecked() : true);
bool isCustom = (myFineness->currentIndex() == UserDefined);
myGrowthRate->setEnabled(isCustom);
if ( myNbSegPerEdge )
myNbSegPerEdge->setEnabled(isCustom && isSurfaceCurvature);
if ( myNbSegPerRadius )
myNbSegPerRadius->setEnabled(isCustom && isSurfaceCurvature);
}
void NETGENPluginGUI_HypothesisCreator::onFinenessChanged()
{
bool isCustom = (myFineness->currentIndex() == UserDefined);

5
src/GUI/NETGENPluginGUI_HypothesisCreator.h
View File

@ -46,7 +46,7 @@ typedef struct
{
double myMaxSize, myMinSize, myGrowthRate, myNbSegPerEdge, myNbSegPerRadius;
int myFineness;
bool mySecondOrder, myAllowQuadrangles, myOptimize;
bool mySecondOrder, myAllowQuadrangles, myOptimize, mySurfaceCurvature, myFuseEdges;
QString myName;
QString myMaxSizeVar, myMinSizeVar, myGrowthRateVar, myNbSegPerEdgeVar, myNbSegPerRadiusVar;
} NetgenHypothesisData;
@ -76,6 +76,7 @@ protected:
protected slots:
virtual void onFinenessChanged();
virtual void onSurfaceCurvatureChanged();
virtual void onAddLocalSizeOnVertex();
virtual void onAddLocalSizeOnEdge();
virtual void onAddLocalSizeOnFace();
@ -100,6 +101,8 @@ private:
SMESHGUI_SpinBox* myNbSegPerEdge;
SMESHGUI_SpinBox* myNbSegPerRadius;
QCheckBox* myAllowQuadrangles;
QCheckBox* mySurfaceCurvature;
QCheckBox* myFuseEdges;
bool myIs2D;
bool myIsONLY;

8
src/GUI/NETGENPlugin_msg_en.ts
View File

@ -55,6 +55,10 @@
<source>NETGEN_FINENESS</source>
<translation>Fineness</translation>
</message>
<message>
<source>NETGEN_FUSE_EDGES</source>
<translation>Fuse Coincident Nodes on Edges and Vertices</translation>
</message>
<message>
<source>NETGEN_GROWTH_RATE</source>
<translation>Growth Rate</translation>
@ -87,6 +91,10 @@
<source>NETGEN_SEG_PER_RADIUS</source>
<translation>Nb. Segs per Radius</translation>
</message>
<message>
<source>NETGEN_SURFACE_CURVATURE</source>
<translation>Limit Size by Surface Curvature</translation>
</message>
<message>
<source>NETGEN_VERYCOARSE</source>
<translation>Very Coarse</translation>

8
src/GUI/NETGENPlugin_msg_fr.ts
View File

@ -55,6 +55,10 @@
<source>NETGEN_FINENESS</source>
<translation>Finesse</translation>
</message>
<message>
<source>NETGEN_FUSE_EDGES</source>
<translation type="unfinished">Fuse Coincident Nodes on Edges and Vertices</translation>
</message>
<message>
<source>NETGEN_GROWTH_RATE</source>
<translation>Taux d&apos;accroissement</translation>
@ -87,6 +91,10 @@
<source>NETGEN_SEG_PER_RADIUS</source>
<translation>Nb. segments par rayon</translation>
</message>
<message>
<source>NETGEN_SURFACE_CURVATURE</source>
<translation type="unfinished">Limit Size by Surface Curvature</translation>
</message>
<message>
<source>NETGEN_VERYCOARSE</source>
<translation>Très grossier</translation>

8
src/GUI/NETGENPlugin_msg_ja.ts
View File

@ -55,6 +55,10 @@
<source>NETGEN_FINENESS</source>
<translation>細かさ</translation>
</message>
<message>
<source>NETGEN_FUSE_EDGES</source>
<translation type="unfinished">Fuse Coincident Nodes on Edges and Vertices</translation>
</message>
<message>
<source>NETGEN_GROWTH_RATE</source>
<translation>増加率</translation>
@ -87,6 +91,10 @@
<source>NETGEN_SEG_PER_RADIUS</source>
<translation>半径毎の分割数</translation>
</message>
<message>
<source>NETGEN_SURFACE_CURVATURE</source>
<translation type="unfinished">Limit Size by Surface Curvature</translation>
</message>
<message>
<source>NETGEN_VERYCOARSE</source>
<translation>非常に粗く</translation>

35
src/NETGEN/netgen49ForSalome.patch
View File

@ -1012,3 +1012,38 @@ diff -Naur netgen-4.9.13_orig/nglib/nglib.h netgen-4.9.13_new/nglib/nglib.h
#define DLL_HEADER __declspec(dllexport)
#else
#define DLL_HEADER __declspec(dllimport)
}
diff -Naur netgen-4.9.13_orig/libsrc/occ/occgenmesh.cpp /netgen-4.9.13_new/libsrc/occ/occgenmesh.cpp
--- netgen-4.9.13_orig/libsrc/occ/occgenmesh.cpp 2013-12-04 14:39:45.000000000 +0400
+++ netgen-4.9.13_new/libsrc/occ/occgenmesh.cpp 2013-12-04 15:20:24.000000000 +0400
@@ -564,17 +564,20 @@
bool exists = 0;
int j;
for (j = first_ep; j <= mesh.GetNP(); j++)
+ {
+ if (!merge_solids && mesh.Point(j).GetLayer() != geomedgenr ) continue; // to support SALOME fuse edges
if ((mesh.Point(j)-Point<3>(mp[i-1])).Length() < eps)
{
exists = 1;
break;
}
+ }
if (exists)
pnums[i] = j;
else
{
- mesh.AddPoint (mp[i-1]);
+ mesh.AddPoint (mp[i-1], geomedgenr); // to support SALOME fuse edges
(*testout) << "add meshpoint " << mp[i-1] << endl;
pnums[i] = mesh.GetNP();
}
@@ -658,6 +661,8 @@
// (*testout) << "edge " << mesh.LineSegment(i).edgenr << " face " << mesh.LineSegment(i).si
// << " p1 " << mesh.LineSegment(i)[0] << " p2 " << mesh.LineSegment(i)[1] << endl;
// exit(10);
+ for (int j = 1; j <= mesh.GetNP(); j++) // to support SALOME fuse edges: set level to zero
+ mesh.Point(j) = MeshPoint( (Point<3>&) mesh.Point(j) );
mesh.CalcSurfacesOfNode();
multithread.task = savetask;

16
src/NETGENPlugin/NETGENPluginBuilder.py
View File

@ -218,6 +218,16 @@ class NETGEN_1D2D3D_Algorithm(NETGEN_Algorithm):
def SetQuadAllowed(self, toAllow=True):
if self.Parameters(): self.params.SetQuadAllowed(toAllow)
pass
## Sets @c UseSurfaceCurvature flag
# @param toUse new value of the @c UseSurfaceCurvature parameter (@c True by default)
def SetUseSurfaceCurvature(self, toUse=True):
if self.Parameters(): self.params.SetUseSurfaceCurvature(toUse)
pass
## Sets @c FuseEdges flag
# @param toFuse new value of the @c FuseEdges parameter (@c False by default)
def SetFuseEdges(self, toFuse=False):
if self.Parameters(): self.params.SetFuseEdges(toFuse)
pass
## Sets number of segments overriding the value set by SetLocalLength()
# @param theVal new value of number of segments parameter
@ -335,6 +345,12 @@ class NETGEN_2D_Only_Algorithm(NETGEN_Algorithm):
def LengthFromEdges(self):
hyp = self.Hypothesis("LengthFromEdges", UseExisting=1, CompareMethod=self.CompareEqualHyp)
return hyp
## Sets @c SurfaceCurvature flag
# @param toAllow new value of the @c SurfaceCurvature parameter (@c True by default)
def SetSurfaceCurvature(self, toAllow=True):
if self.Parameters(): self.params.SetSurfaceCurvature(toAllow)
pass
## Sets @c QuadAllowed flag.
# @param toAllow new value of the @c QuadAllowed parameter (@c True by default)

80
src/NETGENPlugin/NETGENPlugin_Hypothesis.cxx
View File

@ -43,16 +43,18 @@ using namespace std;
NETGENPlugin_Hypothesis::NETGENPlugin_Hypothesis (int hypId, int studyId,
SMESH_Gen * gen)
: SMESH_Hypothesis(hypId, studyId, gen),
_maxSize (GetDefaultMaxSize()),
_minSize (0),
_growthRate (GetDefaultGrowthRate()),
_nbSegPerEdge (GetDefaultNbSegPerEdge()),
_nbSegPerRadius(GetDefaultNbSegPerRadius()),
_fineness (GetDefaultFineness()),
_secondOrder (GetDefaultSecondOrder()),
_optimize (GetDefaultOptimize()),
_localSize (GetDefaultLocalSize()),
_quadAllowed (GetDefaultQuadAllowed())
_maxSize (GetDefaultMaxSize()),
_minSize (0),
_growthRate (GetDefaultGrowthRate()),
_nbSegPerEdge (GetDefaultNbSegPerEdge()),
_nbSegPerRadius (GetDefaultNbSegPerRadius()),
_fineness (GetDefaultFineness()),
_secondOrder (GetDefaultSecondOrder()),
_optimize (GetDefaultOptimize()),
_localSize (GetDefaultLocalSize()),
_quadAllowed (GetDefaultQuadAllowed()),
_surfaceCurvature(GetDefaultSurfaceCurvature()),
_fuseEdges (GetDefaultFuseEdges())
{
_name = "NETGEN_Parameters";
_param_algo_dim = 3;
@ -274,6 +276,54 @@ bool NETGENPlugin_Hypothesis::GetDefaultQuadAllowed()
*
*/
//=============================================================================
void NETGENPlugin_Hypothesis::SetSurfaceCurvature(bool theVal)
{
if (theVal != _surfaceCurvature)
{
_surfaceCurvature = theVal;
NotifySubMeshesHypothesisModification();
}
}
//=============================================================================
/*!
*
*/
//=============================================================================
bool NETGENPlugin_Hypothesis::GetDefaultSurfaceCurvature()
{
return true;
}
//=============================================================================
/*!
*
*/
//=============================================================================
void NETGENPlugin_Hypothesis::SetFuseEdges(bool theVal)
{
if (theVal != _fuseEdges)
{
_fuseEdges = theVal;
NotifySubMeshesHypothesisModification();
}
}
//=============================================================================
/*!
*
*/
//=============================================================================
bool NETGENPlugin_Hypothesis::GetDefaultFuseEdges()
{
return false;
}
//=============================================================================
/*!
*
*/
//=============================================================================
ostream & NETGENPlugin_Hypothesis::SaveTo(ostream & save)
{
save << _maxSize << " " << _fineness;
@ -294,6 +344,8 @@ ostream & NETGENPlugin_Hypothesis::SaveTo(ostream & save)
}
save << " " << _minSize;
save << " " << _quadAllowed;
save << " " << _surfaceCurvature;
save << " " << _fuseEdges;
return save;
}
@ -385,6 +437,14 @@ istream & NETGENPlugin_Hypothesis::LoadFrom(istream & load)
if ( !isOK )
_quadAllowed = GetDefaultQuadAllowed();
isOK = ( load >> _surfaceCurvature );
if ( !isOK )
_surfaceCurvature = GetDefaultSurfaceCurvature();
isOK = ( load >> _fuseEdges );
if ( !isOK )
_fuseEdges = GetDefaultFuseEdges();
return load;
}

10
src/NETGENPlugin/NETGENPlugin_Hypothesis.hxx
View File

@ -93,6 +93,12 @@ public:
void SetQuadAllowed(bool theVal);
bool GetQuadAllowed() const { return _quadAllowed; }
void SetSurfaceCurvature(bool theVal);
bool GetSurfaceCurvature() const { return _surfaceCurvature; }
void SetFuseEdges(bool theVal);
bool GetFuseEdges() const { return _fuseEdges; }
// the default values (taken from NETGEN 4.5 sources)
static double GetDefaultMaxSize();
@ -103,6 +109,8 @@ public:
static bool GetDefaultSecondOrder();
static bool GetDefaultOptimize();
static bool GetDefaultQuadAllowed();
static bool GetDefaultSurfaceCurvature();
static bool GetDefaultFuseEdges();
// Persistence
virtual ostream & SaveTo(ostream & save);
@ -134,6 +142,8 @@ private:
bool _optimize;
TLocalSize _localSize;
bool _quadAllowed;
bool _surfaceCurvature;
bool _fuseEdges;
};
#endif

40
src/NETGENPlugin/NETGENPlugin_Hypothesis_i.cxx
View File

@ -382,6 +382,46 @@ CORBA::Boolean NETGENPlugin_Hypothesis_i::GetQuadAllowed()
return this->GetImpl()->GetQuadAllowed();
}
//=============================================================================
void NETGENPlugin_Hypothesis_i::SetUseSurfaceCurvature (CORBA::Boolean theValue)
{
if ( NETGENPlugin_Hypothesis_i::isToSetParameter( GetUseSurfaceCurvature(),
theValue,
METH_SetSurfaceCurvature ))
{
this->GetImpl()->SetSurfaceCurvature(theValue);
SMESH::TPythonDump() << _this() << ".SetSurfaceCurvature( " << theValue << " )";
}
}
//=============================================================================
CORBA::Boolean NETGENPlugin_Hypothesis_i::GetUseSurfaceCurvature()
{
return this->GetImpl()->GetSurfaceCurvature();
}
//=============================================================================
void NETGENPlugin_Hypothesis_i::SetFuseEdges (CORBA::Boolean theValue)
{
if ( NETGENPlugin_Hypothesis_i::isToSetParameter( GetFuseEdges(),
theValue,
METH_SetFuseEdges ))
{
this->GetImpl()->SetFuseEdges(theValue);
SMESH::TPythonDump() << _this() << ".SetFuseEdges( " << theValue << " )";
}
}
//=============================================================================
CORBA::Boolean NETGENPlugin_Hypothesis_i::GetFuseEdges()
{
return this->GetImpl()->GetFuseEdges();
}
//=============================================================================
/*!
* NETGENPlugin_Hypothesis_i::GetImpl

10
src/NETGENPlugin/NETGENPlugin_Hypothesis_i.hxx
View File

@ -88,6 +88,12 @@ class NETGENPLUGIN_EXPORT NETGENPlugin_Hypothesis_i:
void SetQuadAllowed(CORBA::Boolean theVal);
CORBA::Boolean GetQuadAllowed();
void SetUseSurfaceCurvature(CORBA::Boolean theVal);
CORBA::Boolean GetUseSurfaceCurvature();
void SetFuseEdges(CORBA::Boolean theVal);
CORBA::Boolean GetFuseEdges();
// Get implementation
::NETGENPlugin_Hypothesis* GetImpl();
@ -109,7 +115,9 @@ class NETGENPLUGIN_EXPORT NETGENPlugin_Hypothesis_i:
METH_SetNbSegPerRadius = 128,
METH_SetLocalSizeOnEntry = 256,
METH_SetQuadAllowed = METH_SetLocalSizeOnEntry * 2,
METH_LAST = METH_SetQuadAllowed
METH_SetSurfaceCurvature = METH_SetQuadAllowed * 2,
METH_SetFuseEdges = METH_SetSurfaceCurvature * 2,
METH_LAST = METH_SetFuseEdges
};
int mySetMethodFlags;

41
src/NETGENPlugin/NETGENPlugin_Mesher.cxx
View File

@ -83,6 +83,7 @@ namespace netgen {
//extern void OCCSetLocalMeshSize(OCCGeometry & geom, Mesh & mesh);
extern MeshingParameters mparam;
extern volatile multithreadt multithread;
extern bool merge_solids;
}
#include <vector>
@ -184,22 +185,24 @@ void NETGENPlugin_Mesher::SetDefaultParameters()
{
netgen::MeshingParameters& mparams = netgen::mparam;
// maximal mesh edge size
mparams.maxh = 0;//NETGENPlugin_Hypothesis::GetDefaultMaxSize();
mparams.minh = 0;
mparams.maxh = 0;//NETGENPlugin_Hypothesis::GetDefaultMaxSize();
mparams.minh = 0;
// minimal number of segments per edge
mparams.segmentsperedge = NETGENPlugin_Hypothesis::GetDefaultNbSegPerEdge();
// rate of growth of size between elements
mparams.grading = NETGENPlugin_Hypothesis::GetDefaultGrowthRate();
mparams.grading = NETGENPlugin_Hypothesis::GetDefaultGrowthRate();
// safety factor for curvatures (elements per radius)
mparams.curvaturesafety = NETGENPlugin_Hypothesis::GetDefaultNbSegPerRadius();
// create elements of second order
mparams.secondorder = NETGENPlugin_Hypothesis::GetDefaultSecondOrder() ? 1 : 0;
mparams.secondorder = NETGENPlugin_Hypothesis::GetDefaultSecondOrder();
// quad-dominated surface meshing
if (_isVolume)
mparams.quad = 0;
mparams.quad = 0;
else
mparams.quad = NETGENPlugin_Hypothesis_2D::GetDefaultQuadAllowed() ? 1 : 0;
_fineness = NETGENPlugin_Hypothesis::GetDefaultFineness();
mparams.quad = NETGENPlugin_Hypothesis_2D::GetDefaultQuadAllowed();
_fineness = NETGENPlugin_Hypothesis::GetDefaultFineness();
mparams.uselocalh = NETGENPlugin_Hypothesis::GetDefaultSurfaceCurvature();
netgen::merge_solids = NETGENPlugin_Hypothesis::GetDefaultFuseEdges();
}
//=============================================================================
@ -242,23 +245,25 @@ void NETGENPlugin_Mesher::SetParameters(const NETGENPlugin_Hypothesis* hyp)
netgen::MeshingParameters& mparams = netgen::mparam;
// Initialize global NETGEN parameters:
// maximal mesh segment size
mparams.maxh = hyp->GetMaxSize();
mparams.maxh = hyp->GetMaxSize();
// maximal mesh element linear size
mparams.minh = hyp->GetMinSize();
mparams.minh = hyp->GetMinSize();
// minimal number of segments per edge
mparams.segmentsperedge = hyp->GetNbSegPerEdge();
// rate of growth of size between elements
mparams.grading = hyp->GetGrowthRate();
mparams.grading = hyp->GetGrowthRate();
// safety factor for curvatures (elements per radius)
mparams.curvaturesafety = hyp->GetNbSegPerRadius();
// create elements of second order
mparams.secondorder = hyp->GetSecondOrder() ? 1 : 0;
mparams.secondorder = hyp->GetSecondOrder() ? 1 : 0;
// quad-dominated surface meshing
// only triangles are allowed for volumic mesh (before realizing IMP 0021676)
//if (!_isVolume)
mparams.quad = hyp->GetQuadAllowed() ? 1 : 0;
_optimize = hyp->GetOptimize();
_fineness = hyp->GetFineness();
mparams.quad = hyp->GetQuadAllowed() ? 1 : 0;
_optimize = hyp->GetOptimize();
_fineness = hyp->GetFineness();
mparams.uselocalh = hyp->GetSurfaceCurvature();
netgen::merge_solids = hyp->GetFuseEdges();
_simpleHyp = NULL;
SMESH_Gen_i* smeshGen_i = SMESH_Gen_i::GetSMESHGen();
@ -2116,8 +2121,9 @@ bool NETGENPlugin_Mesher::Compute()
" growth rate = " << mparams.grading << "\n"
" elements per radius = " << mparams.curvaturesafety << "\n"
" second order = " << mparams.secondorder << "\n"
" quad allowed = " << mparams.quad);
//cout << " quad allowed = " << mparams.quad<<endl;
" quad allowed = " << mparams.quad << "\n"
" surface curvature = " << mparams.uselocalh << "\n"
" fuse edges = " << netgen::merge_solids);
SMESH_ComputeErrorPtr error = SMESH_ComputeError::New();
@ -3610,8 +3616,9 @@ NETGENPlugin_NetgenLibWrapper::NETGENPlugin_NetgenLibWrapper()
_coutBuffer = std::cout.rdbuf();
#ifdef _DEBUG_
cout << "NOTE: netgen output is redirected to file " << _outputFileName << endl;
#endif
#else
std::cout.rdbuf( netgen::mycout->rdbuf() );
#endif
_ngMesh = Ng_NewMesh();
}

3
src/NETGENPlugin/NETGENPlugin_NETGEN_2D_ONLY.cxx
View File

@ -283,7 +283,8 @@ bool NETGENPlugin_NETGEN_2D_ONLY::Compute(SMESH_Mesh& aMesh,
// MESHCONST_ANALYSE step may lead to a failure, so we make an attempt
// w/o MESHCONST_ANALYSE at the second loop
int err = 1;
for ( int iLoop = 0; iLoop < 2; iLoop++ )
int iLoop = netgen::mparam.uselocalh ? 0 : 1; // uselocalh depends on
for ( ; iLoop < 2; iLoop++ )
{
bool isMESHCONST_ANALYSE = false;
InitComputeError();