--- /dev/null
+# Copyright (C) 2007-2011 CEA/DEN, EDF R&D, OPEN CASCADE
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+#
+
+from smesh import Mesh_Algorithm, AssureGeomPublished, ParseParameters
+
+# import NETGENPlugin module if possible
+noNETGENPlugin = 0
+try:
+ import NETGENPlugin
+except ImportError:
+ noNETGENPlugin = 1
+ pass
+
+# Types of algorithms
+NETGEN_3D = "NETGEN_3D"
+NETGEN_1D2D3D = "NETGEN_2D3D"
+NETGEN_1D2D = "NETGEN_2D"
+NETGEN_2D = "NETGEN_2D_ONLY"
+NETGEN_FULL = NETGEN_1D2D3D
+NETGEN = NETGEN_3D
+FULL_NETGEN = NETGEN_FULL
+
+SOLE = 0
+SIMPLE = 1
+
+# Fineness enumeration
+VeryCoarse = 0
+Coarse = 1
+Moderate = 2
+Fine = 3
+VeryFine = 4
+Custom = 5
+
+## Base of all NETGEN algorithms.
+#
+# @ingroup l3_algos_basic
+class NETGEN_Algorithm(Mesh_Algorithm):
+
+ def __init__(self, mesh, geom=0):
+ Mesh_Algorithm.__init__(self)
+ if noNETGENPlugin: print "Warning: NETGENPlugin module unavailable"
+ self.Create(mesh, geom, self.algoType, "libNETGENEngine.so")
+ self.params = None
+
+ ## Sets MaxSize
+ #
+ # @ingroup l3_hypos_netgen
+ def SetMaxSize(self, theSize):
+ if self.Parameters():
+ self.params.SetMaxSize(theSize)
+
+ ## Sets MinSize
+ #
+ # @ingroup l3_hypos_netgen
+ def SetMinSize(self, theSize):
+ if self.Parameters():
+ self.params.SetMinSize(theSize)
+
+
+ ## Sets Optimize flag
+ #
+ # @ingroup l3_hypos_netgen
+ def SetOptimize(self, theVal):
+ if self.Parameters():
+ self.params.SetOptimize(theVal)
+
+ ## Sets Fineness
+ # @param theFineness is:
+ # VeryCoarse, Coarse, Moderate, Fine, VeryFine or Custom
+ #
+ # @ingroup l3_hypos_netgen
+ def SetFineness(self, theFineness):
+ if self.Parameters():
+ self.params.SetFineness(theFineness)
+
+ ## Sets GrowthRate
+ #
+ # @ingroup l3_hypos_netgen
+ def SetGrowthRate(self, theRate):
+ if self.Parameters():
+ self.params.SetGrowthRate(theRate)
+
+ ## Defines hypothesis having several parameters
+ #
+ # @ingroup l3_hypos_netgen
+ def Parameters(self, which=SOLE):
+ if self.algoType == NETGEN_1D2D:
+ if which == SIMPLE:
+ hypType = "NETGEN_SimpleParameters_2D"
+ else:
+ hypType = "NETGEN_Parameters_2D"
+ elif self.algoType == NETGEN_1D2D3D:
+ if which == SIMPLE:
+ hypType = "NETGEN_SimpleParameters_3D"
+ else:
+ hypType = "NETGEN_Parameters"
+ elif self.algoType == NETGEN_2D:
+ hypType = "NETGEN_Parameters_2D_ONLY"
+ else:
+ hypType = "NETGEN_Parameters_3D"
+
+ if self.params and self.params.GetName() != hypType:
+ self.mesh.RemoveHypothesis( self.params, self.geom )
+ self.params = None
+ if not self.params:
+ self.params = self.Hypothesis(hypType, [],"libNETGENEngine.so",UseExisting=0)
+
+ return self.params
+
+
+
+## Defines a tetrahedron 1D-2D-3D algorithm
+# It is created by calling Mesh.Triangle( NETGEN_1D2D3D, geom=0 )
+#
+# @ingroup l3_algos_basic
+class NETGEN_1D2D3D_Algorithm(NETGEN_Algorithm):
+
+ meshMethod = "Tetrahedron"
+ algoType = NETGEN_1D2D3D
+
+ ## Private constructor.
+ def __init__(self, mesh, geom=0):
+ NETGEN_Algorithm.__init__(self, mesh, geom)
+
+ ## Sets SecondOrder flag
+ #
+ # @ingroup l3_hypos_netgen
+ def SetSecondOrder(self, theVal):
+ if self.Parameters():
+ self.params.SetSecondOrder(theVal)
+
+ ## Sets NbSegPerEdge
+ #
+ # @ingroup l3_hypos_netgen
+ def SetNbSegPerEdge(self, theVal):
+ if self.Parameters():
+ self.params.SetNbSegPerEdge(theVal)
+
+ ## Sets NbSegPerRadius
+ #
+ # @ingroup l3_hypos_netgen
+ def SetNbSegPerRadius(self, theVal):
+ if self.Parameters():
+ self.params.SetNbSegPerRadius(theVal)
+
+
+ ## Sets number of segments overriding the value set by SetLocalLength()
+ #
+ # @ingroup l3_hypos_netgen
+ def SetNumberOfSegments(self, theVal):
+ self.Parameters(SIMPLE).SetNumberOfSegments(theVal)
+
+ ## Sets number of segments overriding the value set by SetNumberOfSegments()
+ #
+ # @ingroup l3_hypos_netgen
+ def SetLocalLength(self, theVal):
+ self.Parameters(SIMPLE).SetLocalLength(theVal)
+
+ ## Defines "MaxElementArea" parameter of NETGEN_SimpleParameters_3D hypothesis.
+ # Overrides value set by LengthFromEdges()
+ # @ingroup l3_hypos_netgen
+ def MaxElementArea(self, area):
+ self.Parameters(SIMPLE).SetMaxElementArea(area)
+
+ ## Defines "LengthFromEdges" parameter of NETGEN_SimpleParameters_3D hypothesis
+ # Overrides value set by MaxElementArea()
+ # @ingroup l3_hypos_netgen
+ def LengthFromEdges(self):
+ self.Parameters(SIMPLE).LengthFromEdges()
+
+ ## Defines "LengthFromFaces" parameter of NETGEN_SimpleParameters_3D hypothesis
+ # Overrides value set by MaxElementVolume()
+ # @ingroup l3_hypos_netgen
+ def LengthFromFaces(self):
+ self.Parameters(SIMPLE).LengthFromFaces()
+
+ ## Defines "MaxElementVolume" parameter of NETGEN_SimpleParameters_3D hypothesis
+ # Overrides value set by LengthFromFaces()
+ # @ingroup l3_hypos_netgen
+ def MaxElementVolume(self, vol):
+ self.Parameters(SIMPLE).SetMaxElementVolume(vol)
+
+
+## Triangle NETGEN 1D-2D algorithm.
+# It is created by calling Mesh.Triangle( NETGEN_1D2D, geom=0 )
+#
+# @ingroup l3_algos_basic
+class NETGEN_1D2D_Algorithm(NETGEN_1D2D3D_Algorithm):
+
+ meshMethod = "Triangle"
+ algoType = NETGEN_1D2D
+
+ ## Private constructor.
+ def __init__(self, mesh, geom=0):
+ NETGEN_1D2D3D_Algorithm.__init__(self, mesh, geom)
+
+ ## Sets QuadAllowed flag.
+ # @ingroup l3_hypos_netgen
+ def SetQuadAllowed(self, toAllow=True):
+ if self.Parameters():
+ self.params.SetQuadAllowed(toAllow)
+
+
+
+## Triangle NETGEN 2D algorithm
+# It is created by calling Mesh.Triangle( NETGEN_2D, geom=0 )
+#
+# @ingroup l3_algos_basic
+class NETGEN_2D_Only_Algorithm(NETGEN_Algorithm):
+
+ meshMethod = "Triangle"
+ algoType = NETGEN_2D
+
+ ## Private constructor.
+ def __init__(self, mesh, geom=0):
+ NETGEN_Algorithm.__init__(self, mesh, geom)
+
+ ## 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
+ #
+ # @ingroup l3_hypos_2dhyps
+ def MaxElementArea(self, area, UseExisting=0):
+ compFun = lambda hyp, args: IsEqual(hyp.GetMaxElementArea(), args[0])
+ hyp = self.Hypothesis("MaxElementArea", [area], UseExisting=UseExisting,
+ CompareMethod=compFun)
+ hyp.SetMaxElementArea(area)
+ return hyp
+
+ ## Defines "LengthFromEdges" hypothesis to build triangles
+ # based on the length of the edges taken from the wire
+ #
+ # @ingroup l3_hypos_2dhyps
+ def LengthFromEdges(self):
+ hyp = self.Hypothesis("LengthFromEdges", UseExisting=1, CompareMethod=self.CompareEqualHyp)
+ return hyp
+
+ ## Sets QuadAllowed flag.
+ # @ingroup l3_hypos_netgen
+ def SetQuadAllowed(self, toAllow=True):
+ if not self.params:
+ # use simple hyps
+ hasSimpleHyps = False
+ simpleHyps = ["QuadranglePreference","LengthFromEdges","MaxElementArea"]
+ for hyp in self.mesh.GetHypothesisList( self.geom ):
+ if hyp.GetName() in simpleHyps:
+ hasSimpleHyps = True
+ if hyp.GetName() == "QuadranglePreference":
+ if not toAllow: # remove QuadranglePreference
+ self.mesh.RemoveHypothesis( self.geom, hyp )
+ else:
+ return hyp
+ return None
+ pass
+ pass
+ if hasSimpleHyps:
+ if toAllow: # add QuadranglePreference
+ return self.Hypothesis("QuadranglePreference", UseExisting=1, CompareMethod=self.CompareEqualHyp)
+ return None
+ pass
+ self.Parameters().SetQuadAllowed( toAllow )
+ return self.params
+
+## Defines a tetrahedron 3D algorithm
+# It is created by calling Mesh.Tetrahedron()
+#
+# @ingroup l3_algos_basic
+class NETGEN_3D_Algorithm(NETGEN_Algorithm):
+
+ meshMethod = "Tetrahedron"
+ algoType = NETGEN
+ isDefault = True
+
+ ## Private constructor.
+ def __init__(self, mesh, geom=0):
+ NETGEN_Algorithm.__init__(self, mesh, geom)
+
+ ## Defines "MaxElementVolume" hypothesis to give the maximun volume of each tetrahedron
+ # @param vol for the maximum volume of each tetrahedron
+ # @param UseExisting if ==true - searches for the existing hypothesis created with
+ # the same parameters, else (default) - creates a new one
+ # @ingroup l3_hypos_maxvol
+ def MaxElementVolume(self, vol, UseExisting=0):
+ compFun = lambda hyp, args: IsEqual(hyp.GetMaxElementVolume(), args[0])
+ hyp = self.Hypothesis("MaxElementVolume", [vol], UseExisting=UseExisting,
+ CompareMethod=compFun)
+ hyp.SetMaxElementVolume(vol)
+ return hyp
+
+
+# Class just to create NETGEN_1D2D by calling Mesh.Triangle(NETGEN)
+class NETGEN_1D2D_Algorithm_2(NETGEN_1D2D_Algorithm):
+
+ algoType = NETGEN
+
+ ## Private constructor.
+ def __init__(self, mesh, geom=0):
+ NETGEN_1D2D_Algorithm.__init__(self,mesh, geom)
+
+
+# Class just to create NETGEN_1D2D3D by calling Mesh.Netgen()
+class NETGEN_1D2D3D_Algorithm_2(NETGEN_1D2D3D_Algorithm):
+
+ meshMethod = "Netgen"
+
+ ## Private constructor.
+ def __init__(self, mesh, geom=0):
+ NETGEN_1D2D3D_Algorithm.__init__(self,mesh, geom)
