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

Merge from V6_main (04/10/2012)

Browse Source
This commit is contained in:
vsr 2012-10-08 13:15:52 +00:00
parent bf1d93fc2f
commit b8fc64c6d7
17 changed files with 437 additions and 224 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
doc/salome/gui/NETGENPLUGIN/Makefile.am
View File

@ -29,16 +29,15 @@ EXTRA_DIST += images input static/footer.html static/doxygen.css
guidocdir = $(docdir)/gui/NETGENPLUGIN guidocdir = $(docdir)/gui/NETGENPLUGIN
guidoc_DATA = images/head.png guidoc_DATA = images/head.png
DOC_PYTHONPATH=$(prefix)/bin/salome:$(SMESH_ROOT_DIR)/bin/salome:$(SMESH_ROOT_DIR)/lib/python$(PYTHON_VERSION)/site-packages/salome:$(MED_ROOT_DIR)/lib/python$(PYTHON_VERSION)/site-packages/salome:$(GEOM_ROOT_DIR)/bin/salome:$(GEOM_ROOT_DIR)/lib/python$(PYTHON_VERSION)/site-packages/salome:$(KERNEL_ROOT_DIR)/bin/salome:$(KERNEL_ROOT_DIR)/lib/python$(PYTHON_VERSION)/site-packages/salome:$(OMNIORB_ROOT)/lib/python$(PYTHON_VERSION)/site-packages:$(OMNIORB_ROOT)/lib64/python$(PYTHON_VERSION)/site-packages
DOC_SMESH_MeshersList=NETGENPlugin
usr_docs: doxyfile smesh.py: $(top_srcdir)/src/NETGENPlugin/NETGENPluginDC.py
echo "===========================================" ; \ @PYTHONPATH=$(DOC_PYTHONPATH):${PYTHONPATH} SMESH_MeshersList=$(DOC_SMESH_MeshersList) $(PYTHON) $(SMESH_ROOT_DIR)/bin/salome/collect_mesh_methods.py -d -o $@ NETGENPlugin
echo "Generating Python interface documentation"; \
echo "===========================================" ; \ usr_docs: doxyfile_py doxyfile smesh.py
$(DOXYGEN) doxyfile_py \ @$(DOXYGEN) doxyfile_py ; \
echo "===========================================" ; \ $(DOXYGEN) doxyfile
echo "Generating GUI documentation" ; \
echo "===========================================" ; \
$(DOXYGEN) doxyfile ;
docs: usr_docs docs: usr_docs

24
doc/salome/gui/NETGENPLUGIN/doxyfile_py.in
View File

@ -99,7 +99,9 @@ EXAMPLE_RECURSIVE = NO
#--------------------------------------------------------------------------- #---------------------------------------------------------------------------
#Input related options #Input related options
#--------------------------------------------------------------------------- #---------------------------------------------------------------------------
INPUT = @top_srcdir@/src/NETGENPlugin/NETGENPluginDC.py INPUT = @top_srcdir@/src/NETGENPlugin/NETGENPluginDC.py \
smesh.py \
@SMESH_ROOT_DIR@/bin/salome/smesh_algorithm.py
FILE_PATTERNS = FILE_PATTERNS =
IMAGE_PATH = @srcdir@/images IMAGE_PATH = @srcdir@/images
RECURSIVE = NO RECURSIVE = NO
@ -132,24 +134,24 @@ GENERATE_RTF = NO
#--------------------------------------------------------------------------- #---------------------------------------------------------------------------
CLASS_DIAGRAMS = NO CLASS_DIAGRAMS = NO
HIDE_UNDOC_RELATIONS = NO HIDE_UNDOC_RELATIONS = NO
HAVE_DOT = NO HAVE_DOT = YES
CLASS_GRAPH = NO CLASS_GRAPH = YES
COLLABORATION_GRAPH = NO COLLABORATION_GRAPH = NO
GROUP_GRAPHS = NO GROUP_GRAPHS = NO
UML_LOOK = NO UML_LOOK = NO
TEMPLATE_RELATIONS = NO TEMPLATE_RELATIONS = YES
INCLUDE_GRAPH = NO INCLUDE_GRAPH = YES
INCLUDED_BY_GRAPH = NO INCLUDED_BY_GRAPH = YES
CALL_GRAPH = NO CALL_GRAPH = NO
GRAPHICAL_HIERARCHY = NO GRAPHICAL_HIERARCHY = YES
DIRECTORY_GRAPH = NO DIRECTORY_GRAPH = YES
DOT_IMAGE_FORMAT = jpg DOT_IMAGE_FORMAT = png
DOT_FONTNAME = Arial DOT_FONTNAME = Arial
DOT_PATH = DOT_PATH =
DOTFILE_DIRS = DOTFILE_DIRS =
MAX_DOT_GRAPH_WIDTH = 1024 MAX_DOT_GRAPH_WIDTH = 1024
MAX_DOT_GRAPH_HEIGHT = 1200 MAX_DOT_GRAPH_HEIGHT = 1024
MAX_DOT_GRAPH_DEPTH = 0 MAX_DOT_GRAPH_DEPTH = 1000
DOT_TRANSPARENT = NO DOT_TRANSPARENT = NO
DOT_MULTI_TARGETS = NO DOT_MULTI_TARGETS = NO
GENERATE_LEGEND = NO GENERATE_LEGEND = NO

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

@ -24,8 +24,7 @@ algorithms </em></center>
- <b>Min Size</b> - minimum linear dimensions for mesh cells. It is - <b>Min Size</b> - minimum linear dimensions for mesh cells. It is
ignored if it is more than <b>Max Size</b>. ignored if it is more than <b>Max Size</b>.
- <b>Second Order</b> - if this box is checked in, the algorithm will - <b>Second Order</b> - if this box is checked in, the algorithm will
create second order nodes on the mesh, which actually will become create second order nodes on the mesh, which will then become quadratic.
\ref adding_quadratic_elements_page "Quadratic".
- <b>Fineness</b> - ranging from Very Coarse to Very Fine allows to set the - <b>Fineness</b> - ranging from Very Coarse to Very Fine allows to set the
level of meshing detalization using the three parameters below. You level of meshing detalization using the three parameters below. You
can select Custom to define them manually. can select Custom to define them manually.
@ -59,17 +58,18 @@ parameters</b> allow defining the size of elements for each
dimension. dimension.
\b 1D group allows defining the size of 1D elements in either of two ways: \b 1D group allows defining the size of 1D elements in either of two ways:
- <b>Number of Segments</b> has the same sense as \ref - <b>Number of Segments</b> allows specifying number of segments, that
number_of_segments_anchor "Number of segments" hypothesis with will split each edge, with equidistant distribution.
equidistant distribution. - <b>Local Length</b> can be applied for meshing of edges
- <b>Local Length</b> has the same sense as \ref composing geometrical object. Definition of this hypothesis
average_length_anchor "Local Length" hypothesis. consists of setting required \b length of segments.
\b 2D group allows defining the size of 2D elements \b 2D group allows defining the size of 2D elements
- <b>Length from edges</b> if checked in, acts like \ref - <b>Length from edges</b> if checked in, hypothesis forces building of
length_from_edges_anchor "Length from Edges" hypothesis, else 2D mesh segments having a length calculated as an average edge length
- <b>Max. Element Area</b> defines the maximum element area like \ref for a given wire, else
max_element_area_anchor "Max Element Area" hypothesis. - <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 - <b>Allow Quadrangles</b> - allows to use quadrangle elements in a
triangle 2D mesh. This checkbox is not present in Netgen 3D simple parameters triangle 2D mesh. This checkbox is not present in Netgen 3D simple parameters
because currently building a tetrahedral mesh with quadrangle faces is because currently building a tetrahedral mesh with quadrangle faces is
@ -78,9 +78,8 @@ not possible.
\b 3D groups allows defining the size of 3D elements. \b 3D groups allows defining the size of 3D elements.
- <b>Length from faces</b> if checked in, the area of sides of - <b>Length from faces</b> if checked in, the area of sides of
volumic elements will be equal to an average area of 2D elements, else volumic elements will be equal to an average area of 2D elements, else
- <b>Max. Element Volume</b> defines the maximum element volume like - <b>Max. Element Volume</b> specifies expected maximum element volume
\ref max_element_volume_hypo_page "Max Element Volume" of each 3d element.
hypothesis.
\note Netgen algorithm does not strictly follow the input \note Netgen algorithm does not strictly follow the input
parameters. The actual mesh can be more or less dense than parameters. The actual mesh can be more or less dense than

6
doc/salome/gui/NETGENPLUGIN/input/netgenplugin_python_interface.doc
View File

@ -2,9 +2,11 @@
\page netgenplugin_python_interface_page Python Interface \page netgenplugin_python_interface_page Python Interface
Python package \ref NETGENPluginDC "NETGENPlugin" defines several classes, destined for creation of the 2D and 3D meshes. Python package NETGENPluginDC defines several classes, destined for
creation of the 2D and 3D meshes.
Documentation for NETGENPlugin package is available in linear form grouped by classes, declared in the NETGENPluginDC.py file. NETGEN meshing plugin dynamically adds several methods to the
smesh.Mesh class to create meshing algorithms.
Below you can see an example of usage of the NETGENPlugin package for mesh generation: Below you can see an example of usage of the NETGENPlugin package for mesh generation:

10
src/GUI/NETGENPluginGUI_HypothesisCreator.cxx
View File

@ -389,13 +389,13 @@ bool NETGENPluginGUI_HypothesisCreator::readParamsFromHypo( NetgenHypothesisData
h_data.myMinSize = h->GetMinSize(); h_data.myMinSize = h->GetMinSize();
h_data.myMinSizeVar = getVariableName("SetMinSize"); h_data.myMinSizeVar = getVariableName("SetMinSize");
if ( myIs2D ) //if ( myIs2D )
{ {
NETGENPlugin::NETGENPlugin_Hypothesis_2D_var h_2d = NETGENPlugin::NETGENPlugin_Hypothesis_var h =
NETGENPlugin::NETGENPlugin_Hypothesis_2D::_narrow( initParamsHypothesis() ); NETGENPlugin::NETGENPlugin_Hypothesis::_narrow( initParamsHypothesis() );
if ( !h_2d->_is_nil() ) if ( !h->_is_nil() )
h_data.myAllowQuadrangles = h_2d->GetQuadAllowed(); h_data.myAllowQuadrangles = h->GetQuadAllowed();
} }
NETGENPluginGUI_HypothesisCreator* that = (NETGENPluginGUI_HypothesisCreator*)this; NETGENPluginGUI_HypothesisCreator* that = (NETGENPluginGUI_HypothesisCreator*)this;

2
src/GUI/NETGENPluginGUI_SimpleCreator.cxx
View File

@ -253,7 +253,7 @@ void NETGENPluginGUI_SimpleCreator::retrieveParams() const
// set values of hypothesis // set values of hypothesis
SMESH::ListOfParameters_var aParameters = h->GetLastParameters(); //SMESH::ListOfParameters_var aParameters = h->GetLastParameters();
// 1D // 1D
int nbSeg = isCreation() ? dfltNbSeg : (int) h->GetNumberOfSegments(); int nbSeg = isCreation() ? dfltNbSeg : (int) h->GetNumberOfSegments();

303
src/NETGENPlugin/NETGENPluginDC.py
View File

@ -17,7 +17,12 @@
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
# #
from smesh import Mesh_Algorithm, AssureGeomPublished, ParseParameters, IsEqual ##
# @package NETGENPluginDC
# Python API for the NETGEN meshing plug-in module.
from smesh_algorithm import Mesh_Algorithm
from smesh import AssureGeomPublished, ParseParameters, IsEqual
# import NETGENPlugin module if possible # import NETGENPlugin module if possible
noNETGENPlugin = 0 noNETGENPlugin = 0
@ -27,71 +32,117 @@ except ImportError:
noNETGENPlugin = 1 noNETGENPlugin = 1
pass pass
# Types of algorithms #----------------------------
# Mesh algo type identifiers
#----------------------------
## Algorithm type: Netgen tetrahedron 3D algorithm, see NETGEN_3D_Algorithm
NETGEN_3D = "NETGEN_3D" NETGEN_3D = "NETGEN_3D"
## Algorithm type: Netgen tetrahedron 1D-2D-3D algorithm, see NETGEN_1D2D3D_Algorithm
NETGEN_1D2D3D = "NETGEN_2D3D" NETGEN_1D2D3D = "NETGEN_2D3D"
## Algorithm type: Netgen triangle 1D-2D algorithm, see NETGEN_1D2D_Algorithm
NETGEN_1D2D = "NETGEN_2D" NETGEN_1D2D = "NETGEN_2D"
## Algorithm type: Netgen triangle 2D algorithm, see NETGEN_2D_Only_Algorithm
NETGEN_2D = "NETGEN_2D_ONLY" NETGEN_2D = "NETGEN_2D_ONLY"
## Algorithm type: Synonim of NETGEN_1D2D3D, see NETGEN_1D2D3D_Algorithm
NETGEN_FULL = NETGEN_1D2D3D NETGEN_FULL = NETGEN_1D2D3D
## Algorithm type: Synonim of NETGEN_3D, see NETGEN_3D_Algorithm
NETGEN = NETGEN_3D NETGEN = NETGEN_3D
## Algorithm type: Synonim of NETGEN_1D2D3D, see NETGEN_1D2D3D_Algorithm
FULL_NETGEN = NETGEN_FULL FULL_NETGEN = NETGEN_FULL
#----------------------------
# Hypothesis type enumeration
#----------------------------
## Hypothesis type enumeration: complex hypothesis
# (full set of parameters can be specified),
# see NETGEN_Algorithm.Parameters()
SOLE = 0 SOLE = 0
## Hypothesis type enumeration: simple hypothesis
# (only major parameters are specified),
# see NETGEN_Algorithm.Parameters()
SIMPLE = 1 SIMPLE = 1
#----------------------
# Fineness enumeration # Fineness enumeration
#----------------------
## Fineness enumeration: very coarse quality of mesh,
# see NETGEN_Algorithm.SetFineness()
VeryCoarse = 0 VeryCoarse = 0
## Fineness enumeration: coarse quality of mesh,
# see NETGEN_Algorithm.SetFineness()
Coarse = 1 Coarse = 1
## Fineness enumeration: moderate quality of mesh,
# see NETGEN_Algorithm.SetFineness()
Moderate = 2 Moderate = 2
## Fineness enumeration: fine quality of mesh,
# see NETGEN_Algorithm.SetFineness()
Fine = 3 Fine = 3
## Fineness enumeration: very fine quality of mesh,
# see NETGEN_Algorithm.SetFineness()
VeryFine = 4 VeryFine = 4
## Fineness enumeration: custom quality of mesh specified by other parameters),
# see NETGEN_Algorithm.SetFineness()
Custom = 5 Custom = 5
#----------------------
# Algorithms
#----------------------
## Base of all NETGEN algorithms. ## Base of all NETGEN algorithms.
# #
# This class provides common methods for all algorithms implemented by NETGEN plugin.
# @note This class must not be instantiated directly.
class NETGEN_Algorithm(Mesh_Algorithm): class NETGEN_Algorithm(Mesh_Algorithm):
## Private constructor
# @param mesh parent mesh object algorithm is assigned to
# @param geom geometry (shape/sub-shape) algorithm is assigned to;
# if it is @c 0 (default), the algorithm is assigned to the main shape
def __init__(self, mesh, geom=0): def __init__(self, mesh, geom=0):
Mesh_Algorithm.__init__(self) Mesh_Algorithm.__init__(self)
if noNETGENPlugin: print "Warning: NETGENPlugin module unavailable" if noNETGENPlugin: print "Warning: NETGENPlugin module unavailable"
self.Create(mesh, geom, self.algoType, "libNETGENEngine.so") self.Create(mesh, geom, self.algoType, "libNETGENEngine.so")
self.params = None self.params = None
pass
## Sets MaxSize ## Sets @c MaxSize parameter
# # @param theSize new value of the @c MaxSize parameter
def SetMaxSize(self, theSize): def SetMaxSize(self, theSize):
if self.Parameters(): if self.Parameters(): self.params.SetMaxSize(theSize)
self.params.SetMaxSize(theSize) pass
## Sets MinSize ## Sets @c MinSize parameter
# # @param theSize new value of the @c MinSize parameter
def SetMinSize(self, theSize): def SetMinSize(self, theSize):
if self.Parameters(): if self.Parameters(): self.params.SetMinSize(theSize)
self.params.SetMinSize(theSize) pass
## Sets @c Optimize flag
## Sets Optimize flag # @param theVal new value of the @c Optimize parameter
#
def SetOptimize(self, theVal): def SetOptimize(self, theVal):
if self.Parameters(): if self.Parameters(): self.params.SetOptimize(theVal)
self.params.SetOptimize(theVal) pass
## Sets Fineness ## Sets @c Fineness parameter
# @param theFineness is: # @param theFineness new value of the @c Fineness parameter; it can be:
# VeryCoarse, Coarse, Moderate, Fine, VeryFine or Custom # @ref VeryCoarse, @ref Coarse, @ref Moderate, @ref Fine, @ref VeryFine or @ref Custom
#
def SetFineness(self, theFineness): def SetFineness(self, theFineness):
if self.Parameters(): if self.Parameters(): self.params.SetFineness(theFineness)
self.params.SetFineness(theFineness) pass
## Sets GrowthRate ## Sets @c GrowthRate parameter
# # @param theRate new value of the @c GrowthRate parameter
def SetGrowthRate(self, theRate): def SetGrowthRate(self, theRate):
if self.Parameters(): if self.Parameters(): self.params.SetGrowthRate(theRate)
self.params.SetGrowthRate(theRate) pass
## Defines hypothesis having several parameters ## Creates meshing hypothesis according to the chosen algorithm type
# # and initializes it with default parameters
# @param which hypothesis type; can be either @ref SOLE (default) or @ref SIMPLE
# @return hypothesis object
def Parameters(self, which=SOLE): def Parameters(self, which=SOLE):
if self.algoType == NETGEN_1D2D: if self.algoType == NETGEN_1D2D:
if which == SIMPLE: if which == SIMPLE:
@ -116,111 +167,161 @@ class NETGEN_Algorithm(Mesh_Algorithm):
return self.params return self.params
pass # end of NETGEN_Algorithm class
## Defines a tetrahedron 1D-2D-3D algorithm ## Tetrahedron 1D-2D-3D algorithm.
# It is created by calling Mesh.Triangle( NETGEN_1D2D3D, geom=0 )
# #
# It can be created by calling smesh.Mesh.Tetrahedron( smesh.NETGEN_1D2D3D, geom=0 ).
# This algorithm generates all 1D (edges), 2D (faces) and 3D (volumes) elements
# for given geometrical shape.
class NETGEN_1D2D3D_Algorithm(NETGEN_Algorithm): class NETGEN_1D2D3D_Algorithm(NETGEN_Algorithm):
## name of the dynamic method in smesh.Mesh class
# @internal
meshMethod = "Tetrahedron" meshMethod = "Tetrahedron"
## type of algorithm used with helper function in smesh.Mesh class
# @internal
algoType = NETGEN_1D2D3D algoType = NETGEN_1D2D3D
## doc string of the method
# @internal
docHelper = "Creates tetrahedron 3D algorithm for solids"
## Private constructor. ## Private constructor.
# @param mesh parent mesh object algorithm is assigned to
# @param geom geometry (shape/sub-shape) algorithm is assigned to;
# if it is @c 0 (default), the algorithm is assigned to the main shape
def __init__(self, mesh, geom=0): def __init__(self, mesh, geom=0):
NETGEN_Algorithm.__init__(self, mesh, geom) NETGEN_Algorithm.__init__(self, mesh, geom)
pass
## Sets SecondOrder flag ## Sets @c SecondOrder flag
# # @param theVal new value of the @c SecondOrder parameter
def SetSecondOrder(self, theVal): def SetSecondOrder(self, theVal):
if self.Parameters(): if self.Parameters(): self.params.SetSecondOrder(theVal)
self.params.SetSecondOrder(theVal) pass
## Sets NbSegPerEdge ## Sets @c NbSegPerEdge parameter
# # @param theVal new value of the @c NbSegPerEdge parameter
def SetNbSegPerEdge(self, theVal): def SetNbSegPerEdge(self, theVal):
if self.Parameters(): if self.Parameters(): self.params.SetNbSegPerEdge(theVal)
self.params.SetNbSegPerEdge(theVal) pass
## Sets NbSegPerRadius ## Sets @c NbSegPerRadius parameter
# # @param theVal new value of the @c NbSegPerRadius parameter
def SetNbSegPerRadius(self, theVal): def SetNbSegPerRadius(self, theVal):
if self.Parameters(): if self.Parameters(): self.params.SetNbSegPerRadius(theVal)
self.params.SetNbSegPerRadius(theVal) pass
## Sets QuadAllowed flag. ## Sets @c QuadAllowed flag
# @param toAllow new value of the @c QuadAllowed parameter (@c True by default)
def SetQuadAllowed(self, toAllow=True): def SetQuadAllowed(self, toAllow=True):
if self.Parameters(): if self.Parameters(): self.params.SetQuadAllowed(toAllow)
self.params.SetQuadAllowed(toAllow) pass
## Sets number of segments overriding the value set by SetLocalLength() ## Sets number of segments overriding the value set by SetLocalLength()
# # @param theVal new value of number of segments parameter
def SetNumberOfSegments(self, theVal): def SetNumberOfSegments(self, theVal):
self.Parameters(SIMPLE).SetNumberOfSegments(theVal) self.Parameters(SIMPLE).SetNumberOfSegments(theVal)
pass
## Sets number of segments overriding the value set by SetNumberOfSegments() ## Sets number of segments overriding the value set by SetNumberOfSegments()
# # @param theVal new value of local length parameter
def SetLocalLength(self, theVal): def SetLocalLength(self, theVal):
self.Parameters(SIMPLE).SetLocalLength(theVal) self.Parameters(SIMPLE).SetLocalLength(theVal)
pass
## Defines "MaxElementArea" parameter of NETGEN_SimpleParameters_3D hypothesis. ## Defines @c MaxElementArea parameter of @c NETGEN_SimpleParameters_3D hypothesis.
# Overrides value set by LengthFromEdges() # Overrides value set by LengthFromEdges()
# @param area new value of @c MaxElementArea parameter
def MaxElementArea(self, area): def MaxElementArea(self, area):
self.Parameters(SIMPLE).SetMaxElementArea(area) self.Parameters(SIMPLE).SetMaxElementArea(area)
pass
## Defines "LengthFromEdges" parameter of NETGEN_SimpleParameters_3D hypothesis ## Defines @c LengthFromEdges parameter of @c NETGEN_SimpleParameters_3D hypothesis.
# Overrides value set by MaxElementArea() # Overrides value set by MaxElementArea()
def LengthFromEdges(self): def LengthFromEdges(self):
self.Parameters(SIMPLE).LengthFromEdges() self.Parameters(SIMPLE).LengthFromEdges()
pass
## Defines "LengthFromFaces" parameter of NETGEN_SimpleParameters_3D hypothesis ## Defines @c LengthFromFaces parameter of @c NETGEN_SimpleParameters_3D hypothesis.
# Overrides value set by MaxElementVolume() # Overrides value set by MaxElementVolume()
def LengthFromFaces(self): def LengthFromFaces(self):
self.Parameters(SIMPLE).LengthFromFaces() self.Parameters(SIMPLE).LengthFromFaces()
pass
## Defines "MaxElementVolume" parameter of NETGEN_SimpleParameters_3D hypothesis ## Defines @c MaxElementVolume parameter of @c NETGEN_SimpleParameters_3D hypothesis.
# Overrides value set by LengthFromFaces() # Overrides value set by LengthFromFaces()
# @param vol new value of @c MaxElementVolume parameter
def MaxElementVolume(self, vol): def MaxElementVolume(self, vol):
self.Parameters(SIMPLE).SetMaxElementVolume(vol) self.Parameters(SIMPLE).SetMaxElementVolume(vol)
pass
pass # end of NETGEN_1D2D3D_Algorithm class
## Triangle NETGEN 1D-2D algorithm. ## Triangle NETGEN 1D-2D algorithm.
# It is created by calling Mesh.Triangle( NETGEN_1D2D, geom=0 )
# #
# It can be created by calling smesh.Mesh.Triangle( smesh.NETGEN_1D2D, geom=0 )
#
# This algorithm generates 1D (edges) and 2D (faces) elements
# for given geometrical shape.
class NETGEN_1D2D_Algorithm(NETGEN_1D2D3D_Algorithm): class NETGEN_1D2D_Algorithm(NETGEN_1D2D3D_Algorithm):
## name of the dynamic method in smesh.Mesh class
# @internal
meshMethod = "Triangle" meshMethod = "Triangle"
## type of algorithm used with helper function in smesh.Mesh class
# @internal
algoType = NETGEN_1D2D algoType = NETGEN_1D2D
## doc string of the method
# @internal
docHelper = "Creates triangle 2D algorithm for faces"
## Private constructor. ## Private constructor.
# @param mesh parent mesh object algorithm is assigned to
# @param geom geometry (shape/sub-shape) algorithm is assigned to;
# if it is @c 0 (default), the algorithm is assigned to the main shape
def __init__(self, mesh, geom=0): def __init__(self, mesh, geom=0):
NETGEN_1D2D3D_Algorithm.__init__(self, mesh, geom) NETGEN_1D2D3D_Algorithm.__init__(self, mesh, geom)
pass
pass # end of NETGEN_1D2D_Algorithm class
## Triangle NETGEN 2D algorithm ## Triangle NETGEN 2D algorithm
# It is created by calling Mesh.Triangle( NETGEN_2D, geom=0 )
# #
# It can be created by calling smesh.Mesh.Triangle( smesh.NETGEN_2D, geom=0 )
#
# This algorithm generates only 2D (faces) elements for given geometrical shape
# and, in contrast to NETGEN_1D2D_Algorithm class, should be used in conjunction
# with other 1D meshing algorithm.
class NETGEN_2D_Only_Algorithm(NETGEN_Algorithm): class NETGEN_2D_Only_Algorithm(NETGEN_Algorithm):
## name of the dynamic method in smesh.Mesh class
# @internal
meshMethod = "Triangle" meshMethod = "Triangle"
## type of algorithm used with helper function in smesh.Mesh class
# @internal
algoType = NETGEN_2D algoType = NETGEN_2D
## doc string of the method
# @internal
docHelper = "Creates triangle 2D algorithm for faces"
## Private constructor. ## Private constructor.
# @param mesh parent mesh object algorithm is assigned to
# @param geom geometry (shape/sub-shape) algorithm is assigned to;
# if it is @c 0 (default), the algorithm is assigned to the main shape
def __init__(self, mesh, geom=0): def __init__(self, mesh, geom=0):
NETGEN_Algorithm.__init__(self, mesh, geom) NETGEN_Algorithm.__init__(self, mesh, geom)
pass
## Sets QuadAllowed flag. ## Defines @c MaxElementArea parameter of hypothesis basing on the definition of the
def SetQuadAllowed(self, toAllow=True): # maximum area of each triangle
if self.Parameters(): # @param area maximum area value of each triangle
self.params.SetQuadAllowed(toAllow) # @param UseExisting if \c True - searches for an existing hypothesis created with the
## Defines "MaxElementArea" hypothesis basing on the definition of the maximum area of each triangle
# @param area for the maximum area of each triangle
# @param UseExisting if ==true - searches for an existing hypothesis created with the
# same parameters, else (default) - creates a new one # same parameters, else (default) - creates a new one
# # @return hypothesis object
def MaxElementArea(self, area, UseExisting=0): def MaxElementArea(self, area, UseExisting=0):
compFun = lambda hyp, args: IsEqual(hyp.GetMaxElementArea(), args[0]) compFun = lambda hyp, args: IsEqual(hyp.GetMaxElementArea(), args[0])
hyp = self.Hypothesis("MaxElementArea", [area], UseExisting=UseExisting, hyp = self.Hypothesis("MaxElementArea", [area], UseExisting=UseExisting,
@ -228,14 +329,16 @@ class NETGEN_2D_Only_Algorithm(NETGEN_Algorithm):
hyp.SetMaxElementArea(area) hyp.SetMaxElementArea(area)
return hyp return hyp
## Defines "LengthFromEdges" hypothesis to build triangles ## Defines @c LengthFromEdges hypothesis to build triangles
# based on the length of the edges taken from the wire # based on the length of the edges taken from the wire
# # @return hypothesis object
def LengthFromEdges(self): def LengthFromEdges(self):
hyp = self.Hypothesis("LengthFromEdges", UseExisting=1, CompareMethod=self.CompareEqualHyp) hyp = self.Hypothesis("LengthFromEdges", UseExisting=1, CompareMethod=self.CompareEqualHyp)
return hyp return hyp
## Sets QuadAllowed flag. ## Sets @c QuadAllowed flag.
# @param toAllow new value of the @c QuadAllowed parameter (@c True by default)
# @return hypothesis object
def SetQuadAllowed(self, toAllow=True): def SetQuadAllowed(self, toAllow=True):
if not self.params: if not self.params:
# use simple hyps # use simple hyps
@ -260,23 +363,45 @@ class NETGEN_2D_Only_Algorithm(NETGEN_Algorithm):
self.Parameters().SetQuadAllowed( toAllow ) self.Parameters().SetQuadAllowed( toAllow )
return self.params return self.params
## Defines a tetrahedron 3D algorithm pass # end of NETGEN_2D_Only_Algorithm class
# It is created by calling Mesh.Tetrahedron()
## Tetrahedron 3D algorithm
# #
# It can be created by calling smesh.Mesh.Tetrahedron() or smesh.Mesh.Tetrahedron( smesh.NETGEN, geom=0 )
#
# This algorithm generates only 3D (volumes) elements for given geometrical shape
# and, in contrast to NETGEN_1D2D3D_Algorithm class, should be used in conjunction
# with other 1D and 2D meshing algorithms.
class NETGEN_3D_Algorithm(NETGEN_Algorithm): class NETGEN_3D_Algorithm(NETGEN_Algorithm):
## name of the dynamic method in smesh.Mesh class
# @internal
meshMethod = "Tetrahedron" meshMethod = "Tetrahedron"
## type of algorithm used with helper function in smesh.Mesh class
# @internal
algoType = NETGEN algoType = NETGEN
## flag pointing either this algorithm should be used by default in dynamic method
# of smesh.Mesh class
# @internal
isDefault = True isDefault = True
## doc string of the method
# @internal
docHelper = "Creates tetrahedron 3D algorithm for solids"
## Private constructor. ## Private constructor.
# @param mesh parent mesh object algorithm is assigned to
# @param geom geometry (shape/sub-shape) algorithm is assigned to;
# if it is @c 0 (default), the algorithm is assigned to the main shape
def __init__(self, mesh, geom=0): def __init__(self, mesh, geom=0):
NETGEN_Algorithm.__init__(self, mesh, geom) NETGEN_Algorithm.__init__(self, mesh, geom)
pass
## Defines "MaxElementVolume" hypothesis to give the maximun volume of each tetrahedron ## Defines @c MaxElementVolume hypothesis to specify the maximum volume value of each tetrahedron
# @param vol for the maximum volume of each tetrahedron # @param vol maximum volume value of each tetrahedron
# @param UseExisting if ==true - searches for the existing hypothesis created with # @param UseExisting if \c True - searches for the existing hypothesis created with
# the same parameters, else (default) - creates a new one # the same parameters, else (default) - creates a new one
# @return hypothesis object
def MaxElementVolume(self, vol, UseExisting=0): def MaxElementVolume(self, vol, UseExisting=0):
compFun = lambda hyp, args: IsEqual(hyp.GetMaxElementVolume(), args[0]) compFun = lambda hyp, args: IsEqual(hyp.GetMaxElementVolume(), args[0])
hyp = self.Hypothesis("MaxElementVolume", [vol], UseExisting=UseExisting, hyp = self.Hypothesis("MaxElementVolume", [vol], UseExisting=UseExisting,
@ -284,23 +409,57 @@ class NETGEN_3D_Algorithm(NETGEN_Algorithm):
hyp.SetMaxElementVolume(vol) hyp.SetMaxElementVolume(vol)
return hyp return hyp
pass # end of NETGEN_3D_Algorithm class
# Class just to create NETGEN_1D2D by calling Mesh.Triangle(NETGEN)
## Triangle (helper) 1D-2D algorithm
#
# This is the helper class that is used just to allow creating of create NETGEN_1D2D algorithm
# by calling smesh.Mesh.Triangle( smesh.NETGEN, geom=0 ); this is required for backward compatibility
# with old Python scripts.
#
# @note This class (and corresponding smesh.Mesh function) is obsolete;
# use smesh.Mesh.Triangle( smesh.NETGEN_1D2D, geom=0 ) instead.
class NETGEN_1D2D_Algorithm_2(NETGEN_1D2D_Algorithm): class NETGEN_1D2D_Algorithm_2(NETGEN_1D2D_Algorithm):
## name of the dynamic method in smesh.Mesh class
# @internal
algoType = NETGEN algoType = NETGEN
## Private constructor. ## Private constructor.
# @param mesh parent mesh object algorithm is assigned to
# @param geom geometry (shape/sub-shape) algorithm is assigned to;
# if it is @c 0 (default), the algorithm is assigned to the main shape
def __init__(self, mesh, geom=0): def __init__(self, mesh, geom=0):
self.algoType = NETGEN_1D2D self.algoType = NETGEN_1D2D
NETGEN_1D2D_Algorithm.__init__(self,mesh, geom) NETGEN_1D2D_Algorithm.__init__(self,mesh, geom)
pass
pass # end of NETGEN_1D2D_Algorithm_2 class
# Class just to create NETGEN_1D2D3D by calling Mesh.Netgen() ## Tetrahedron (helper) 1D-2D-3D algorithm.
#
# This is the helper class that is used just to allow creating of create NETGEN_1D2D3D
# by calling smesh.Mesh.Netgen(); this is required for backward compatibility with old Python scripts.
#
# @note This class (and corresponding smesh.Mesh function) is obsolete;
# use smesh.Mesh.Tetrahedron( smesh.NETGEN_1D2D3D, geom=0 ) instead.
class NETGEN_1D2D3D_Algorithm_2(NETGEN_1D2D3D_Algorithm): class NETGEN_1D2D3D_Algorithm_2(NETGEN_1D2D3D_Algorithm):
## name of the dynamic method in smesh.Mesh class
# @internal
meshMethod = "Netgen" meshMethod = "Netgen"
## doc string of the method
# @internal
docHelper = "Deprecated, used only for compatibility! See Tetrahedron() method."
## Private constructor. ## Private constructor.
# @param mesh parent mesh object algorithm is assigned to
# @param geom geometry (shape/sub-shape) algorithm is assigned to;
# if it is @c 0 (default), the algorithm is assigned to the main shape
def __init__(self, mesh, geom=0): def __init__(self, mesh, geom=0):
NETGEN_1D2D3D_Algorithm.__init__(self,mesh, geom) NETGEN_1D2D3D_Algorithm.__init__(self,mesh, geom)
pass
pass # end of NETGEN_1D2D3D_Algorithm_2 class

94
src/NETGENPlugin/NETGENPlugin_Hypothesis_2D.cxx
View File

@ -39,8 +39,8 @@ using namespace std;
//============================================================================= //=============================================================================
NETGENPlugin_Hypothesis_2D::NETGENPlugin_Hypothesis_2D (int hypId, int studyId, NETGENPlugin_Hypothesis_2D::NETGENPlugin_Hypothesis_2D (int hypId, int studyId,
SMESH_Gen * gen) SMESH_Gen * gen)
: NETGENPlugin_Hypothesis(hypId, studyId, gen), : NETGENPlugin_Hypothesis(hypId, studyId, gen)/*,
_quadAllowed (GetDefaultQuadAllowed()) _quadAllowed (GetDefaultQuadAllowed())*/
{ {
_name = "NETGEN_Parameters_2D"; _name = "NETGEN_Parameters_2D";
_param_algo_dim = 2; _param_algo_dim = 2;
@ -51,56 +51,56 @@ NETGENPlugin_Hypothesis_2D::NETGENPlugin_Hypothesis_2D (int hypId, int studyId,
* *
*/ */
//============================================================================= //=============================================================================
void NETGENPlugin_Hypothesis_2D::SetQuadAllowed(bool theVal) // void NETGENPlugin_Hypothesis_2D::SetQuadAllowed(bool theVal)
{ // {
if (theVal != _quadAllowed) // if (theVal != _quadAllowed)
{ // {
_quadAllowed = theVal; // _quadAllowed = theVal;
NotifySubMeshesHypothesisModification(); // NotifySubMeshesHypothesisModification();
} // }
} // }
//============================================================================= // //=============================================================================
/*! // /*!
* // *
*/ // */
//============================================================================= // //=============================================================================
bool NETGENPlugin_Hypothesis_2D::GetDefaultQuadAllowed() // bool NETGENPlugin_Hypothesis_2D::GetDefaultQuadAllowed()
{ // {
return false; // return false;
} // }
//============================================================================= // //=============================================================================
/*! // /*!
* // *
*/ // */
//============================================================================= // //=============================================================================
ostream & NETGENPlugin_Hypothesis_2D::SaveTo(ostream & save) // ostream & NETGENPlugin_Hypothesis_2D::SaveTo(ostream & save)
{ // {
NETGENPlugin_Hypothesis::SaveTo(save); // NETGENPlugin_Hypothesis::SaveTo(save);
save << " " << (int)_quadAllowed; // save << " " << (int)_quadAllowed;
return save; // return save;
} // }
//============================================================================= // //=============================================================================
/*! // /*!
* // *
*/ // */
//============================================================================= // //=============================================================================
istream & NETGENPlugin_Hypothesis_2D::LoadFrom(istream & load) // istream & NETGENPlugin_Hypothesis_2D::LoadFrom(istream & load)
{ // {
NETGENPlugin_Hypothesis::LoadFrom(load); // NETGENPlugin_Hypothesis::LoadFrom(load);
bool isOK = true; // bool isOK = true;
int is; // int is;
isOK = (load >> is); // isOK = (load >> is);
if (isOK) // if (isOK)
_quadAllowed = (bool) is; // _quadAllowed = (bool) is;
else // else
load.clear(ios::badbit | load.rdstate()); // load.clear(ios::badbit | load.rdstate());
return load; // return load;
} // }

14
src/NETGENPlugin/NETGENPlugin_Hypothesis_2D.hxx
View File

@ -45,16 +45,16 @@ public:
NETGENPlugin_Hypothesis_2D(int hypId, int studyId, SMESH_Gen * gen); NETGENPlugin_Hypothesis_2D(int hypId, int studyId, SMESH_Gen * gen);
void SetQuadAllowed(bool theVal); // void SetQuadAllowed(bool theVal);
bool GetQuadAllowed() const { return _quadAllowed; } // bool GetQuadAllowed() const { return _quadAllowed; }
static bool GetDefaultQuadAllowed(); // static bool GetDefaultQuadAllowed();
// Persistence // Persistence
virtual ostream & SaveTo(ostream & save); // virtual ostream & SaveTo(ostream & save);
virtual istream & LoadFrom(istream & load); // virtual istream & LoadFrom(istream & load);
private: // private:
bool _quadAllowed; // bool _quadAllowed;
}; };
#endif #endif

77
src/NETGENPlugin/NETGENPlugin_Mesher.cxx
View File

@ -2340,7 +2340,9 @@ bool NETGENPlugin_Mesher::Evaluate(MapShapeNbElems& aResMap)
// Prepare OCC geometry // Prepare OCC geometry
// ------------------------- // -------------------------
netgen::OCCGeometry occgeo; netgen::OCCGeometry occgeo;
PrepareOCCgeometry( occgeo, _shape, *_mesh ); list< SMESH_subMesh* > meshedSM[3]; // for 0-2 dimensions
NETGENPlugin_Internals internals( *_mesh, _shape, _isVolume );
PrepareOCCgeometry( occgeo, _shape, *_mesh, meshedSM, &internals );
bool tooManyElems = false; bool tooManyElems = false;
const int hugeNb = std::numeric_limits<int>::max() / 100; const int hugeNb = std::numeric_limits<int>::max() / 100;
@ -2349,26 +2351,31 @@ bool NETGENPlugin_Mesher::Evaluate(MapShapeNbElems& aResMap)
// evaluate 1D // evaluate 1D
// ---------------- // ----------------
// pass 1D simple parameters to NETGEN // pass 1D simple parameters to NETGEN
if ( _simpleHyp ) { if ( _simpleHyp )
if ( int nbSeg = _simpleHyp->GetNumberOfSegments() ) { {
// not to RestrictLocalH() according to curvature during MESHCONST_ANALYSE
mparams.uselocalh = false;
mparams.grading = 0.8; // not limitited size growth
if ( _simpleHyp->GetNumberOfSegments() )
// nb of segments // nb of segments
mparams.segmentsperedge = nbSeg + 0.1;
mparams.maxh = occgeo.boundingbox.Diam(); mparams.maxh = occgeo.boundingbox.Diam();
mparams.minh = GetDefaultMinSize( _shape, mparams.maxh ); else
mparams.grading = 0.01;
}
else {
// segment length // segment length
mparams.segmentsperedge = 1;
mparams.maxh = _simpleHyp->GetLocalLength(); mparams.maxh = _simpleHyp->GetLocalLength();
} }
}
if ( mparams.maxh == 0.0 )
mparams.maxh = occgeo.boundingbox.Diam();
if ( _simpleHyp || ( mparams.minh == 0.0 && _fineness != NETGENPlugin_Hypothesis::UserDefined))
mparams.minh = GetDefaultMinSize( _shape, mparams.maxh );
// let netgen create ngMesh and calculate element size on not meshed shapes // let netgen create ngMesh and calculate element size on not meshed shapes
NETGENPlugin_NetgenLibWrapper ngLib; NETGENPlugin_NetgenLibWrapper ngLib;
netgen::Mesh *ngMesh = NULL; netgen::Mesh *ngMesh = NULL;
char *optstr = 0; char *optstr = 0;
int startWith = netgen::MESHCONST_ANALYSE; int startWith = netgen::MESHCONST_ANALYSE;
int endWith = netgen::MESHCONST_MESHEDGES; int endWith = netgen::MESHCONST_ANALYSE;
int err = netgen::OCCGenerateMesh(occgeo, ngMesh, startWith, endWith, optstr); int err = netgen::OCCGenerateMesh(occgeo, ngMesh, startWith, endWith, optstr);
#ifdef WITH_SMESH_CANCEL_COMPUTE #ifdef WITH_SMESH_CANCEL_COMPUTE
if(netgen::multithread.terminate) if(netgen::multithread.terminate)
@ -2380,7 +2387,53 @@ bool NETGENPlugin_Mesher::Evaluate(MapShapeNbElems& aResMap)
sm->GetComputeError().reset( new SMESH_ComputeError( COMPERR_ALGO_FAILED )); sm->GetComputeError().reset( new SMESH_ComputeError( COMPERR_ALGO_FAILED ));
return false; return false;
} }
if ( _simpleHyp )
{
// Pass 1D simple parameters to NETGEN
// --------------------------------
int nbSeg = _simpleHyp->GetNumberOfSegments();
double segSize = _simpleHyp->GetLocalLength();
for ( int iE = 1; iE <= occgeo.emap.Extent(); ++iE )
{
const TopoDS_Edge& e = TopoDS::Edge( occgeo.emap(iE));
if ( nbSeg )
segSize = SMESH_Algo::EdgeLength( e ) / ( nbSeg - 0.4 );
setLocalSize( e, segSize, *ngMesh );
}
}
else // if ( ! _simpleHyp )
{
// Local size on vertices and edges
// --------------------------------
for(std::map<int,double>::const_iterator it=EdgeId2LocalSize.begin(); it!=EdgeId2LocalSize.end(); it++)
{
int key = (*it).first;
double hi = (*it).second;
const TopoDS_Shape& shape = ShapesWithLocalSize.FindKey(key);
const TopoDS_Edge& e = TopoDS::Edge(shape);
setLocalSize( e, hi, *ngMesh );
}
for(std::map<int,double>::const_iterator it=VertexId2LocalSize.begin(); it!=VertexId2LocalSize.end(); it++)
{
int key = (*it).first;
double hi = (*it).second;
const TopoDS_Shape& shape = ShapesWithLocalSize.FindKey(key);
const TopoDS_Vertex& v = TopoDS::Vertex(shape);
gp_Pnt p = BRep_Tool::Pnt(v);
NETGENPlugin_Mesher::RestrictLocalSize( *ngMesh, p.XYZ(), hi );
}
for(map<int,double>::const_iterator it=FaceId2LocalSize.begin();
it!=FaceId2LocalSize.end(); it++)
{
int key = (*it).first;
double val = (*it).second;
const TopoDS_Shape& shape = ShapesWithLocalSize.FindKey(key);
int faceNgID = occgeo.fmap.FindIndex(shape);
occgeo.SetFaceMaxH(faceNgID, val);
for ( TopExp_Explorer edgeExp( shape, TopAbs_EDGE ); edgeExp.More(); edgeExp.Next() )
setLocalSize( TopoDS::Edge( edgeExp.Current() ), val, *ngMesh );
}
}
// calculate total nb of segments and length of edges // calculate total nb of segments and length of edges
double fullLen = 0.0; double fullLen = 0.0;
int fullNbSeg = 0; int fullNbSeg = 0;

5
src/NETGENPlugin/NETGENPlugin_NETGEN_2D.hxx
View File

@ -25,7 +25,6 @@
// Author : Michael Sazonov (OCN) // Author : Michael Sazonov (OCN)
// Date : 20/03/2006 // Date : 20/03/2006
// Project : SALOME // Project : SALOME
// $Header$
//============================================================================= //=============================================================================
// //
#ifndef _NETGENPlugin_NETGEN_2D_HXX_ #ifndef _NETGENPlugin_NETGEN_2D_HXX_
@ -33,13 +32,11 @@
#include "NETGENPlugin_Defs.hxx" #include "NETGENPlugin_Defs.hxx"
#include "SMESH_2D_Algo.hxx" #include "SMESH_Algo.hxx"
#include "SMESH_Mesh.hxx" #include "SMESH_Mesh.hxx"
#include "StdMeshers_MaxElementVolume.hxx" #include "StdMeshers_MaxElementVolume.hxx"
#include "Utils_SALOME_Exception.hxx" #include "Utils_SALOME_Exception.hxx"
//class NETGENPlugin_Hypothesis_2D;
class NETGENPLUGIN_EXPORT NETGENPlugin_NETGEN_2D: public SMESH_2D_Algo class NETGENPLUGIN_EXPORT NETGENPlugin_NETGEN_2D: public SMESH_2D_Algo
{ {
public: public:

9
src/NETGENPlugin/NETGENPlugin_NETGEN_2D3D.cxx
View File

@ -25,7 +25,6 @@
// Author : Michael Sazonov (OCN) // Author : Michael Sazonov (OCN)
// Date : 20/03/2006 // Date : 20/03/2006
// Project : SALOME // Project : SALOME
// $Header$
//============================================================================= //=============================================================================
// //
#include "NETGENPlugin_NETGEN_2D3D.hxx" #include "NETGENPlugin_NETGEN_2D3D.hxx"
@ -135,15 +134,19 @@ bool NETGENPlugin_NETGEN_2D3D::Compute(SMESH_Mesh& aMesh,
#ifdef WITH_SMESH_CANCEL_COMPUTE #ifdef WITH_SMESH_CANCEL_COMPUTE
netgen::multithread.terminate = 0; netgen::multithread.terminate = 0;
#endif #endif
// SMESHDS_Mesh* meshDS = aMesh.GetMeshDS();
NETGENPlugin_Mesher mesher(&aMesh, aShape, true); NETGENPlugin_Mesher mesher(&aMesh, aShape, true);
// NETGENPlugin_Mesher mesher(meshDS, aShape, true);
mesher.SetParameters(dynamic_cast<const NETGENPlugin_Hypothesis*>(_hypothesis)); mesher.SetParameters(dynamic_cast<const NETGENPlugin_Hypothesis*>(_hypothesis));
mesher.SetParameters(dynamic_cast<const NETGENPlugin_SimpleHypothesis_2D*>(_hypothesis)); mesher.SetParameters(dynamic_cast<const NETGENPlugin_SimpleHypothesis_2D*>(_hypothesis));
return mesher.Compute(); return mesher.Compute();
} }
//=============================================================================
/*!
*
*/
//=============================================================================
#ifdef WITH_SMESH_CANCEL_COMPUTE #ifdef WITH_SMESH_CANCEL_COMPUTE
void NETGENPlugin_NETGEN_2D3D::CancelCompute() void NETGENPlugin_NETGEN_2D3D::CancelCompute()
{ {

11
src/NETGENPlugin/NETGENPlugin_NETGEN_2D3D.hxx
View File

@ -25,7 +25,6 @@
// Author : Michael Sazonov (OCN) // Author : Michael Sazonov (OCN)
// Date : 20/03/2006 // Date : 20/03/2006
// Project : SALOME // Project : SALOME
// $Header$
//============================================================================= //=============================================================================
// //
#ifndef _NETGENPlugin_NETGEN_2D3D_HXX_ #ifndef _NETGENPlugin_NETGEN_2D3D_HXX_
@ -33,12 +32,10 @@
#include "NETGENPlugin_Defs.hxx" #include "NETGENPlugin_Defs.hxx"
#include "SMESH_3D_Algo.hxx" #include <SMESH_Algo.hxx>
#include "SMESH_Mesh.hxx" #include <SMESH_Mesh.hxx>
#include "StdMeshers_MaxElementVolume.hxx" #include <StdMeshers_MaxElementVolume.hxx>
#include "Utils_SALOME_Exception.hxx" #include <Utils_SALOME_Exception.hxx>
//class NETGENPlugin_Hypothesis;
class NETGENPLUGIN_EXPORT NETGENPlugin_NETGEN_2D3D: public SMESH_3D_Algo class NETGENPLUGIN_EXPORT NETGENPlugin_NETGEN_2D3D: public SMESH_3D_Algo
{ {

25
src/NETGENPlugin/NETGENPlugin_NETGEN_2D_ONLY.cxx
View File

@ -26,23 +26,24 @@
#include "NETGENPlugin_Mesher.hxx" #include "NETGENPlugin_Mesher.hxx"
#include "NETGENPlugin_Hypothesis_2D.hxx" #include "NETGENPlugin_Hypothesis_2D.hxx"
#include "SMDS_MeshElement.hxx" #include <SMDS_MeshElement.hxx>
#include "SMDS_MeshNode.hxx" #include <SMDS_MeshNode.hxx>
#include "SMESHDS_Mesh.hxx" #include <SMESHDS_Mesh.hxx>
#include "SMESH_Comment.hxx" #include <SMESH_Comment.hxx>
#include "SMESH_Gen.hxx" #include <SMESH_Gen.hxx>
#include "SMESH_Mesh.hxx" #include <SMESH_Mesh.hxx>
#include "SMESH_MesherHelper.hxx" #include <SMESH_MesherHelper.hxx>
#include "StdMeshers_FaceSide.hxx" #include <SMESH_subMesh.hxx>
#include "StdMeshers_MaxElementArea.hxx" #include <StdMeshers_FaceSide.hxx>
#include "StdMeshers_LengthFromEdges.hxx" #include <StdMeshers_LengthFromEdges.hxx>
#include "StdMeshers_QuadranglePreference.hxx" #include <StdMeshers_MaxElementArea.hxx>
#include <StdMeshers_QuadranglePreference.hxx>
#include <Precision.hxx> #include <Precision.hxx>
#include <Standard_ErrorHandler.hxx> #include <Standard_ErrorHandler.hxx>
#include <Standard_Failure.hxx> #include <Standard_Failure.hxx>
#include "utilities.h" #include <utilities.h>
#include <list> #include <list>
#include <vector> #include <vector>

4
src/NETGENPlugin/NETGENPlugin_NETGEN_2D_ONLY.hxx
View File

@ -24,8 +24,8 @@
#ifndef _NETGENPlugin_NETGEN_2D_ONLY_HXX_ #ifndef _NETGENPlugin_NETGEN_2D_ONLY_HXX_
#define _NETGENPlugin_NETGEN_2D_ONLY_HXX_ #define _NETGENPlugin_NETGEN_2D_ONLY_HXX_
#include "SMESH_2D_Algo.hxx" #include <SMESH_Algo.hxx>
#include "SMESH_Mesh.hxx" #include <SMESH_Mesh.hxx>
class StdMeshers_MaxElementArea; class StdMeshers_MaxElementArea;
class StdMeshers_LengthFromEdges; class StdMeshers_LengthFromEdges;

27
src/NETGENPlugin/NETGENPlugin_NETGEN_3D.cxx
View File

@ -32,18 +32,19 @@
#include "NETGENPlugin_Hypothesis.hxx" #include "NETGENPlugin_Hypothesis.hxx"
#include "SMDS_MeshElement.hxx" #include <SMDS_MeshElement.hxx>
#include "SMDS_MeshNode.hxx" #include <SMDS_MeshNode.hxx>
#include "SMESHDS_Mesh.hxx" #include <SMESHDS_Mesh.hxx>
#include "SMESH_Comment.hxx" #include <SMESH_Comment.hxx>
#include "SMESH_ControlsDef.hxx" #include <SMESH_ControlsDef.hxx>
#include "SMESH_Gen.hxx" #include <SMESH_Gen.hxx>
#include "SMESH_Mesh.hxx" #include <SMESH_Mesh.hxx>
#include "SMESH_MesherHelper.hxx" #include <SMESH_MeshEditor.hxx>
#include "SMESH_MeshEditor.hxx" #include <SMESH_MesherHelper.hxx>
#include "StdMeshers_QuadToTriaAdaptor.hxx" #include <SMESH_subMesh.hxx>
#include "StdMeshers_MaxElementVolume.hxx" #include <StdMeshers_MaxElementVolume.hxx>
#include "StdMeshers_ViscousLayers.hxx" #include <StdMeshers_QuadToTriaAdaptor.hxx>
#include <StdMeshers_ViscousLayers.hxx>
#include <BRepGProp.hxx> #include <BRepGProp.hxx>
#include <BRep_Tool.hxx> #include <BRep_Tool.hxx>
@ -56,7 +57,7 @@
#include <Standard_Failure.hxx> #include <Standard_Failure.hxx>
#include <Standard_ErrorHandler.hxx> #include <Standard_ErrorHandler.hxx>
#include "utilities.h" #include <utilities.h>
#include <list> #include <list>
#include <vector> #include <vector>

2
src/NETGENPlugin/NETGENPlugin_NETGEN_3D.hxx
View File

@ -34,7 +34,7 @@
#include "NETGENPlugin_Defs.hxx" #include "NETGENPlugin_Defs.hxx"
#include "NETGENPlugin_Mesher.hxx" #include "NETGENPlugin_Mesher.hxx"
#include "SMESH_3D_Algo.hxx" #include "SMESH_Algo.hxx"
#include "Utils_SALOME_Exception.hxx" #include "Utils_SALOME_Exception.hxx"
class StdMeshers_ViscousLayers; class StdMeshers_ViscousLayers;