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

0021308: Remove hard-coded dependency of the external mesh plugins from the SMESH module

Browse Source 
+# Scripts to be installed.
+dist_salomescript_DATA= NETGENPluginDC.py
This commit is contained in:
eap 2012-03-07 15:19:43 +00:00
parent 403e97bf9c
commit c63b5761ca
2 changed files with 329 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/NETGENPlugin/Makefile.am
View File

@ -101,3 +101,6 @@ libNETGENEngine_la_LDFLAGS += \
$(MED_LDFLAGS) -lSalomeIDLMED \
$(SMESH_LDFLAGS) -lSMESHimpl -lSMESHEngine -lSMESHUtils -lStdMeshersEngine -lStdMeshers -lSMESHDS -lSMDS -lSMESHControls \
$(KERNEL_LDFLAGS) -lSalomeGenericObj -lSalomeNS -lSALOMELocalTrace -lOpUtil
# Scripts to be installed.
dist_salomescript_DATA= NETGENPluginDC.py

326
src/NETGENPlugin/NETGENPluginDC.py Normal file
View File

@ -0,0 +1,326 @@
# 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)