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
- <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
\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
(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.
-
*/
-
-
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);
opt-hypos="ViscousLayers"
need-geom="false"
input="TRIA,QUAD"
+ output="TETRA,PYRAMID"
dim="3">
<python-wrap>
<algo>NETGEN_3D=Tetrahedron()</algo>
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>
{
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");
}
if ( !myIsONLY )
{
mySecondOrder = new QCheckBox( tr( "NETGEN_SECOND_ORDER" ), GroupC1 );
- aGroupLayout->addWidget( mySecondOrder, row, 0 );
+ aGroupLayout->addWidget( mySecondOrder, row, 0, 1, 2 );
row++;
}
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 );
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 )
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 )
{
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;
}
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 )
{
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 )
{
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;
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);
{
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;
protected slots:
virtual void onFinenessChanged();
+ virtual void onSurfaceCurvatureChanged();
virtual void onAddLocalSizeOnVertex();
virtual void onAddLocalSizeOnEdge();
virtual void onAddLocalSizeOnFace();
SMESHGUI_SpinBox* myNbSegPerEdge;
SMESHGUI_SpinBox* myNbSegPerRadius;
QCheckBox* myAllowQuadrangles;
+ QCheckBox* mySurfaceCurvature;
+ QCheckBox* myFuseEdges;
bool myIs2D;
bool myIsONLY;
<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>
<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>
<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'accroissement</translation>
<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>
<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>
<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>
#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\r
++ mesh.Point(j) = MeshPoint( (Point<3>&) mesh.Point(j) );
+
+ mesh.CalcSurfacesOfNode();
+ multithread.task = savetask;
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
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)
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;
*
*/
//=============================================================================
+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;
}
save << " " << _minSize;
save << " " << _quadAllowed;
+ save << " " << _surfaceCurvature;
+ save << " " << _fuseEdges;
return save;
}
if ( !isOK )
_quadAllowed = GetDefaultQuadAllowed();
+ isOK = ( load >> _surfaceCurvature );
+ if ( !isOK )
+ _surfaceCurvature = GetDefaultSurfaceCurvature();
+
+ isOK = ( load >> _fuseEdges );
+ if ( !isOK )
+ _fuseEdges = GetDefaultFuseEdges();
+
return load;
}
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();
static bool GetDefaultSecondOrder();
static bool GetDefaultOptimize();
static bool GetDefaultQuadAllowed();
+ static bool GetDefaultSurfaceCurvature();
+ static bool GetDefaultFuseEdges();
// Persistence
virtual ostream & SaveTo(ostream & save);
bool _optimize;
TLocalSize _localSize;
bool _quadAllowed;
+ bool _surfaceCurvature;
+ bool _fuseEdges;
};
#endif
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
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();
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;
//extern void OCCSetLocalMeshSize(OCCGeometry & geom, Mesh & mesh);
extern MeshingParameters mparam;
extern volatile multithreadt multithread;
+ extern bool merge_solids;
}
#include <vector>
{
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();
}
//=============================================================================
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();
" 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();
_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();
}
// 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();
