22357: EDF NETGENPLUGIN: NETGEN options

doc/salome/gui/NETGENPLUGIN/input/netgen_2d_3d_hypo.doc

@@ -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,26 +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>Set size by Surface Curvature</b> - if this box is checked in, then  
-prevents creation of meshes of desired coarseness else mesher defines 
-density of 1D and 2D mesh depending on curvature of faces and edges. 
-- <b>Fuse consignment Edges and Vertices</b> - prevents to merging of 
-nodes of edges which are coincident geometrically but are different topologically.
-- <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
 
@@ -71,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
@@ -94,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.
-
 */
-
-

idl/NETGENPlugin_Algorithm.idl

@@ -98,8 +98,8 @@ module NETGENPlugin
     void SetQuadAllowed(in boolean value);
     boolean GetQuadAllowed();
     
-    void SetSurfaceCurvature(in boolean value);
-    boolean GetSurfaceCurvature();
+    void SetUseSurfaceCurvature(in boolean value);
+    boolean GetUseSurfaceCurvature();
     
     void SetFuseEdges(in boolean value);
     boolean GetFuseEdges();

src/GUI/NETGENPluginGUI_HypothesisCreator.cxx

@@ -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 );
@@ -204,34 +205,35 @@ QFrame* NETGENPluginGUI_HypothesisCreator::buildFrame()
     row++;
   }
 
-  myAllowQuadrangles = 0;
   mySurfaceCurvature = 0;
-  myFuseEdges = 0;
-  if ( myIs2D || !myIsONLY ) // issue 0021676
+  if ( myIs2D || !myIsONLY )
   {
-    myAllowQuadrangles = new QCheckBox( tr( "NETGEN_ALLOW_QUADRANGLES" ), GroupC1 );
-    aGroupLayout->addWidget( myAllowQuadrangles, row, 0 );
-    row++;
-
     mySurfaceCurvature = new QCheckBox( tr( "NETGEN_SURFACE_CURVATURE" ), GroupC1 );
-    aGroupLayout->addWidget( mySurfaceCurvature, row, 0 );
+    aGroupLayout->addWidget( mySurfaceCurvature, row, 0, 1, 2 );
+    connect( mySurfaceCurvature, SIGNAL( stateChanged( int ) ), this, SLOT( onSurfaceCurvatureChanged() ) );
     row++;
   }
+
+  myAllowQuadrangles = 0;
+  if ( myIs2D || !myIsONLY ) // disable only for NETGEN 3D
+  {
+    myAllowQuadrangles = new QCheckBox( tr( "NETGEN_ALLOW_QUADRANGLES" ), GroupC1 );
+    aGroupLayout->addWidget( myAllowQuadrangles, row, 0, 1, 2 );
+    row++;
+  }
+
+  myOptimize = new QCheckBox( tr( "NETGEN_OPTIMIZE" ), GroupC1 );
+  aGroupLayout->addWidget( myOptimize, row, 0, 1, 2 );
+  row++;
+
+  myFuseEdges = 0;
   if (!myIsONLY)
   {
     myFuseEdges = new QCheckBox( tr( "NETGEN_FUSE_EDGES" ), GroupC1 );
-    aGroupLayout->addWidget( myFuseEdges, row, 0 );
+    aGroupLayout->addWidget( myFuseEdges, row, 0, 1, 2 );
     row++;
   }
 
-  connect( mySurfaceCurvature, SIGNAL( stateChanged( int ) ), this, SLOT( onSurfaceCurvatureChanged() ) );
-
-  myOptimize = new QCheckBox( tr( "NETGEN_OPTIMIZE" ), GroupC1 );
-  aGroupLayout->addWidget( myOptimize, row, 0 );
-  row++;
-
-  connect( myFineness, SIGNAL( activated( int ) ), this, SLOT( onFinenessChanged() ) );
-
   myLocalSizeTable = 0;
   if ( !myIsONLY )
   {
@@ -411,7 +413,7 @@ bool NETGENPluginGUI_HypothesisCreator::readParamsFromHypo( NetgenHypothesisData
   h_data.myNbSegPerRadiusVar = getVariableName("SetNbSegPerRadius");
   h_data.myMinSize = h->GetMinSize();
   h_data.myMinSizeVar = getVariableName("SetMinSize");
-  h_data.mySurfaceCurvature = h->GetSurfaceCurvature();
+  h_data.mySurfaceCurvature = h->GetUseSurfaceCurvature();
   h_data.myFuseEdges = h->GetFuseEdges();
 
   //if ( myIs2D )
@@ -456,33 +458,34 @@ 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->SetSurfaceCurvature( h_data.mySurfaceCurvature );
-    h->SetFuseEdges( h_data.myFuseEdges );
+    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 ( myIs2D )
       {
-        NETGENPlugin::NETGENPlugin_Hypothesis_2D_var h_2d =
-          NETGENPlugin::NETGENPlugin_Hypothesis_2D::_narrow( h );
+        // NETGENPlugin::NETGENPlugin_Hypothesis_2D_var h_2d =
+        //   NETGENPlugin::NETGENPlugin_Hypothesis_2D::_narrow( h );
         
-        if ( !h_2d->_is_nil() )
-          h_2d->SetQuadAllowed( h_data.myAllowQuadrangles );
+        // if ( !h_2d->_is_nil() )
+        //   h_2d->SetQuadAllowed( h_data.myAllowQuadrangles );
+        h->SetQuadAllowed( h_data.myAllowQuadrangles );
       }
 
     QMapIterator<QString,QString> i(myLocalSizeMap);
@@ -561,10 +564,9 @@ bool NETGENPluginGUI_HypothesisCreator::readParamsFromWidgets( NetgenHypothesisD
 
 void NETGENPluginGUI_HypothesisCreator::onSurfaceCurvatureChanged()
 {
-  bool isSurfaceCurvature = (mySurfaceCurvature ? mySurfaceCurvature->checkState() == Qt::Checked : true);
-  bool isCustom = (myFineness->currentIndex() == UserDefined);
-  myFineness->setEnabled(isSurfaceCurvature);
-  myGrowthRate->setEnabled(isCustom && isSurfaceCurvature);
+  bool isSurfaceCurvature = (mySurfaceCurvature ? mySurfaceCurvature->isChecked() : true);
+  bool isCustom           = (myFineness->currentIndex() == UserDefined);
+  myGrowthRate->setEnabled(isCustom);
   if ( myNbSegPerEdge )
     myNbSegPerEdge->setEnabled(isCustom && isSurfaceCurvature);
   if ( myNbSegPerRadius )

src/GUI/NETGENPlugin_msg_en.ts

@@ -57,7 +57,7 @@
     </message>
     <message>
         <source>NETGEN_FUSE_EDGES</source>
-        <translation>Fuse consignment Edges and Vertices</translation>
+        <translation>Fuse Coincident Nodes on Edges and Vertices</translation>
     </message>
     <message>
         <source>NETGEN_GROWTH_RATE</source>
@@ -93,7 +93,7 @@
     </message>
     <message>
         <source>NETGEN_SURFACE_CURVATURE</source>
-        <translation>Set size by Surface Curvature</translation>
+        <translation>Limit Size by Surface Curvature</translation>
     </message>
     <message>
         <source>NETGEN_VERYCOARSE</source>

src/GUI/NETGENPlugin_msg_fr.ts

@@ -57,7 +57,7 @@
     </message>
     <message>
         <source>NETGEN_FUSE_EDGES</source>
-        <translation type="unfinished">Fuse consignment Edges and Vertices</translation>
+        <translation type="unfinished">Fuse Coincident Nodes on Edges and Vertices</translation>
     </message>
     <message>
         <source>NETGEN_GROWTH_RATE</source>
@@ -93,7 +93,7 @@
     </message>
     <message>
         <source>NETGEN_SURFACE_CURVATURE</source>
-        <translation type="unfinished">Set size by Surface Curvature</translation>
+        <translation type="unfinished">Limit Size by Surface Curvature</translation>
     </message>
     <message>
         <source>NETGEN_VERYCOARSE</source>

src/GUI/NETGENPlugin_msg_ja.ts

@@ -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>

src/NETGENPlugin/NETGENPluginBuilder.py

@@ -218,15 +218,15 @@ class NETGEN_1D2D3D_Algorithm(NETGEN_Algorithm):
     def SetQuadAllowed(self, toAllow=True):
         if self.Parameters(): self.params.SetQuadAllowed(toAllow)
         pass
-    ## 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)
+    ## 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 toAllow new value of the @c FuseEdges parameter (@c False by default)
-    def SetFuseEdges(self, toAllow=False):
-        if self.Parameters(): self.params.SetFuseEdges(toAllow)
+    #  @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()

src/NETGENPlugin/NETGENPlugin_Hypothesis_i.cxx

@@ -384,9 +384,9 @@ CORBA::Boolean NETGENPlugin_Hypothesis_i::GetQuadAllowed()
 
 //=============================================================================
 
-void NETGENPlugin_Hypothesis_i::SetSurfaceCurvature (CORBA::Boolean theValue)
+void NETGENPlugin_Hypothesis_i::SetUseSurfaceCurvature (CORBA::Boolean theValue)
 {
-  if ( NETGENPlugin_Hypothesis_i::isToSetParameter( GetSurfaceCurvature(),
+  if ( NETGENPlugin_Hypothesis_i::isToSetParameter( GetUseSurfaceCurvature(),
                                                     theValue,
                                                     METH_SetSurfaceCurvature ))
   {
@@ -397,7 +397,7 @@ void NETGENPlugin_Hypothesis_i::SetSurfaceCurvature (CORBA::Boolean theValue)
 
 //=============================================================================
 
-CORBA::Boolean NETGENPlugin_Hypothesis_i::GetSurfaceCurvature()
+CORBA::Boolean NETGENPlugin_Hypothesis_i::GetUseSurfaceCurvature()
 {
   return this->GetImpl()->GetSurfaceCurvature();
 }

src/NETGENPlugin/NETGENPlugin_Hypothesis_i.hxx

@@ -88,8 +88,8 @@ class NETGENPLUGIN_EXPORT NETGENPlugin_Hypothesis_i:
   void SetQuadAllowed(CORBA::Boolean theVal);
   CORBA::Boolean GetQuadAllowed();
 
-  void SetSurfaceCurvature(CORBA::Boolean theVal);
-  CORBA::Boolean GetSurfaceCurvature();
+  void SetUseSurfaceCurvature(CORBA::Boolean theVal);
+  CORBA::Boolean GetUseSurfaceCurvature();
 
   void SetFuseEdges(CORBA::Boolean theVal);
   CORBA::Boolean GetFuseEdges();

src/NETGENPlugin/NETGENPlugin_Mesher.cxx

@@ -185,24 +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.uselocalh = NETGENPlugin_Hypothesis::GetDefaultSurfaceCurvature();
-  netgen::merge_solids = NETGENPlugin_Hypothesis::GetDefaultFuseEdges();
+    mparams.quad          = NETGENPlugin_Hypothesis_2D::GetDefaultQuadAllowed();
+  _fineness               = NETGENPlugin_Hypothesis::GetDefaultFineness();
+  mparams.uselocalh       = NETGENPlugin_Hypothesis::GetDefaultSurfaceCurvature();
+  netgen::merge_solids    = NETGENPlugin_Hypothesis::GetDefaultFuseEdges();
 }
 
 //=============================================================================
@@ -245,25 +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.uselocalh = hyp->GetSurfaceCurvature();
-    netgen::merge_solids = hyp->GetFuseEdges();
+      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();

src/NETGENPlugin/NETGENPlugin_NETGEN_2D_ONLY.cxx

@@ -266,7 +266,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();