328 lines
10 KiB
Python
328 lines
10 KiB
Python
# 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):
|
|
self.algoType = NETGEN_1D2D
|
|
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)
|