-# Copyright (C) 2007-2013 CEA/DEN, EDF R&D, OPEN CASCADE
+# Copyright (C) 2007-2014 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.
+# version 2.1 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# This package is a part of SALOME %Mesh module Python API
import salome
-import geompyDC
+from salome.geom import geomBuilder
import SMESH
## The base class to define meshing algorithms
#
# For each meshing algorithm, a python class inheriting from class %Mesh_Algorithm
# should be defined. This descendant class should have two attributes defining the way
-# it is created by class Mesh (see e.g. class @ref StdMeshersDC.StdMeshersDC_Segment "StdMeshersDC_Segment"
-# in StdMeshersDC package):
+# it is created by class Mesh (see e.g. class @ref StdMeshersBuilder.StdMeshersBuilder_Segment "StdMeshersBuilder_Segment"
+# in StdMeshersBuilder package):
# - @c meshMethod attribute defines name of method of class smesh.Mesh by calling which the
# python class of algorithm is created; this method is dynamically added to the smesh.Mesh class
# in runtime. For example, if in @c class MyPlugin_Algorithm this attribute is defined as
# @code
# meshMethod = "MyAlgorithm"
# @endcode
-# then an instance of @c MyPlugin_Algorithm can be created by the direct invokation of the function
+# then an instance of @c MyPlugin_Algorithm can be created by the direct invocation of the function
# of smesh.Mesh class:
# @code
# my_algo = mesh.MyAlgorithm()
## Gets the name of the algorithm
def GetName(self):
- from smesh import GetName
+ from salome.smesh.smeshBuilder import GetName
return GetName(self.algo)
## Sets the name to the algorithm
## Private method.
def Create(self, mesh, geom, hypo, so="libStdMeshersEngine.so"):
- if geom is None:
+ if geom is None and mesh.mesh.HasShapeToMesh():
raise RuntimeError, "Attemp to create " + hypo + " algoritm on None shape"
algo = self.FindAlgorithm(hypo, mesh.smeshpyD)
if algo is None:
## Private method
def Assign(self, algo, mesh, geom):
- from smesh import AssureGeomPublished, TreatHypoStatus, GetName
- if geom is None:
+ from salome.smesh.smeshBuilder import AssureGeomPublished, TreatHypoStatus, GetName
+ if geom is None and mesh.mesh.HasShapeToMesh():
raise RuntimeError, "Attemp to create " + algo + " algoritm on None shape"
self.mesh = mesh
- name = ""
if not geom or geom.IsSame( mesh.geom ):
self.geom = mesh.geom
else:
self.geom = geom
AssureGeomPublished( mesh, geom )
- try:
- name = GetName(geom)
- pass
- except:
- pass
self.subm = mesh.mesh.GetSubMesh(geom, algo.GetName())
self.algo = algo
- status = mesh.mesh.AddHypothesis(self.geom, self.algo)
- TreatHypoStatus( status, algo.GetName(), name, True )
+ status = mesh.AddHypothesis(self.algo, self.geom)
return
def CompareHyp (self, hyp, args):
## Private method
def Hypothesis (self, hyp, args=[], so="libStdMeshersEngine.so",
- UseExisting=0, CompareMethod=""):
- from smesh import TreatHypoStatus, GetName
+ UseExisting=0, CompareMethod="", toAdd=True):
+ from salome.smesh.smeshBuilder import TreatHypoStatus, GetName
hypo = None
if UseExisting:
if CompareMethod == "": CompareMethod = self.CompareHyp
s = "="
for arg in args:
argStr = str(arg)
- if isinstance( arg, geompyDC.GEOM._objref_GEOM_Object ):
+ if isinstance( arg, geomBuilder.GEOM._objref_GEOM_Object ):
argStr = arg.GetStudyEntry()
if not argStr: argStr = "GEOM_Obj_%s", arg.GetEntry()
if len( argStr ) > 10:
geomName=""
if self.geom:
geomName = GetName(self.geom)
- status = self.mesh.mesh.AddHypothesis(self.geom, hypo)
- TreatHypoStatus( status, GetName(hypo), geomName, 0 )
+ if toAdd:
+ status = self.mesh.mesh.AddHypothesis(self.geom, hypo)
+ TreatHypoStatus( status, GetName(hypo), geomName, 0, self.mesh )
return hypo
## Returns entry of the shape to mesh in the study
## Defines "ViscousLayers" hypothesis to give parameters of layers of prisms to build
# near mesh boundary. This hypothesis can be used by several 3D algorithms:
- # NETGEN 3D, GHS3D, Hexahedron(i,j,k)
+ # NETGEN 3D, MG-Tetra, Hexahedron(i,j,k)
# @param thickness total thickness of layers of prisms
# @param numberOfLayers number of layers of prisms
# @param stretchFactor factor (>1.0) of growth of layer thickness towards inside of mesh
- # @param ignoreFaces list of geometrical faces (or their ids) not to generate layers on
+ # @param faces list of geometrical faces (or their ids).
+ # Viscous layers are either generated on these faces or not, depending on
+ # the value of \a isFacesToIgnore parameter.
+ # @param isFacesToIgnore if \c True, the Viscous layers are not generated on the
+ # faces specified by the previous parameter (\a faces).
# @ingroup l3_hypos_additi
- def ViscousLayers(self, thickness, numberOfLayers, stretchFactor, ignoreFaces=[]):
+ def ViscousLayers(self, thickness, numberOfLayers, stretchFactor,
+ faces=[], isFacesToIgnore=True ):
if not isinstance(self.algo, SMESH._objref_SMESH_3D_Algo):
raise TypeError, "ViscousLayers are supported by 3D algorithms only"
if not "ViscousLayers" in self.GetCompatibleHypothesis():
raise TypeError, "ViscousLayers are not supported by %s"%self.algo.GetName()
- if ignoreFaces and isinstance( ignoreFaces[0], geompyDC.GEOM._objref_GEOM_Object ):
- ignoreFaces = [ self.mesh.geompyD.GetSubShapeID(self.mesh.geom, f) for f in ignoreFaces ]
+ if faces and isinstance( faces[0], geomBuilder.GEOM._objref_GEOM_Object ):
+ faces = [ self.mesh.geompyD.GetSubShapeID(self.mesh.geom, f) for f in faces ]
hyp = self.Hypothesis("ViscousLayers",
- [thickness, numberOfLayers, stretchFactor, ignoreFaces])
+ [thickness, numberOfLayers, stretchFactor, faces, isFacesToIgnore],
+ toAdd=False)
hyp.SetTotalThickness(thickness)
hyp.SetNumberLayers(numberOfLayers)
hyp.SetStretchFactor(stretchFactor)
- hyp.SetIgnoreFaces(ignoreFaces)
+ hyp.SetFaces(faces, isFacesToIgnore)
+ self.mesh.AddHypothesis( hyp, self.geom )
return hyp
## Defines "ViscousLayers2D" hypothesis to give parameters of layers of quadrilateral
# elements to build near mesh boundary. This hypothesis can be used by several 2D algorithms:
- # NETGEN 2D, NETGEN 1D-2D, Quadrangle (mapping), MEFISTO, BLSURF
+ # NETGEN 2D, NETGEN 1D-2D, Quadrangle (mapping), MEFISTO, MG-CADSurf
# @param thickness total thickness of layers of quadrilaterals
# @param numberOfLayers number of layers
# @param stretchFactor factor (>1.0) of growth of layer thickness towards inside of mesh
- # @param ignoreEdges list of geometrical edge (or their ids) not to generate layers on
+ # @param edges list of geometrical edges (or their ids).
+ # Viscous layers are either generated on these edges or not, depending on
+ # the value of \a isEdgesToIgnore parameter.
+ # @param isEdgesToIgnore if \c True, the Viscous layers are not generated on the
+ # edges specified by the previous parameter (\a edges).
# @ingroup l3_hypos_additi
- def ViscousLayers2D(self, thickness, numberOfLayers, stretchFactor, ignoreEdges=[]):
+ def ViscousLayers2D(self, thickness, numberOfLayers, stretchFactor,
+ edges=[], isEdgesToIgnore=True ):
if not isinstance(self.algo, SMESH._objref_SMESH_2D_Algo):
raise TypeError, "ViscousLayers2D are supported by 2D algorithms only"
if not "ViscousLayers2D" in self.GetCompatibleHypothesis():
raise TypeError, "ViscousLayers2D are not supported by %s"%self.algo.GetName()
- if ignoreEdges and isinstance( ignoreEdges[0], geompyDC.GEOM._objref_GEOM_Object ):
- ignoreEdges = [ self.mesh.geompyD.GetSubShapeID(self.mesh.geom, f) for f in ignoreEdges ]
+ if edges and isinstance( edges[0], geomBuilder.GEOM._objref_GEOM_Object ):
+ edges = [ self.mesh.geompyD.GetSubShapeID(self.mesh.geom, f) for f in edges ]
hyp = self.Hypothesis("ViscousLayers2D",
- [thickness, numberOfLayers, stretchFactor, ignoreEdges])
+ [thickness, numberOfLayers, stretchFactor, edges, isEdgesToIgnore],
+ toAdd=False)
hyp.SetTotalThickness(thickness)
hyp.SetNumberLayers(numberOfLayers)
hyp.SetStretchFactor(stretchFactor)
- hyp.SetIgnoreEdges(ignoreEdges)
+ hyp.SetEdges(edges, isEdgesToIgnore)
+ self.mesh.AddHypothesis( hyp, self.geom )
return hyp
- ## Transform a list of ether edges or tuples (edge, 1st_vertex_of_edge)
+ ## Transform a list of either edges or tuples (edge, 1st_vertex_of_edge)
# into a list acceptable to SetReversedEdges() of some 1D hypotheses
# @ingroup l3_hypos_1dhyps
def ReversedEdgeIndices(self, reverseList):
- from smesh import FirstVertexOnCurve
+ from salome.smesh.smeshBuilder import FirstVertexOnCurve
resList = []
geompy = self.mesh.geompyD
for i in reverseList:
if isinstance( i, int ):
s = geompy.SubShapes(self.mesh.geom, [i])[0]
- if s.GetShapeType() != geompyDC.GEOM.EDGE:
+ if s.GetShapeType() != geomBuilder.GEOM.EDGE:
raise TypeError, "Not EDGE index given"
resList.append( i )
- elif isinstance( i, geompyDC.GEOM._objref_GEOM_Object ):
- if i.GetShapeType() != geompyDC.GEOM.EDGE:
+ elif isinstance( i, geomBuilder.GEOM._objref_GEOM_Object ):
+ if i.GetShapeType() != geomBuilder.GEOM.EDGE:
raise TypeError, "Not an EDGE given"
resList.append( geompy.GetSubShapeID(self.mesh.geom, i ))
elif len( i ) > 1:
e = i[0]
v = i[1]
- if not isinstance( e, geompyDC.GEOM._objref_GEOM_Object ) or \
- not isinstance( v, geompyDC.GEOM._objref_GEOM_Object ):
+ if not isinstance( e, geomBuilder.GEOM._objref_GEOM_Object ) or \
+ not isinstance( v, geomBuilder.GEOM._objref_GEOM_Object ):
raise TypeError, "A list item must be a tuple (edge, 1st_vertex_of_edge)"
- if v.GetShapeType() == geompyDC.GEOM.EDGE and \
- e.GetShapeType() == geompyDC.GEOM.VERTEX:
+ if v.GetShapeType() == geomBuilder.GEOM.EDGE and \
+ e.GetShapeType() == geomBuilder.GEOM.VERTEX:
v,e = e,v
- if e.GetShapeType() != geompyDC.GEOM.EDGE or \
- v.GetShapeType() != geompyDC.GEOM.VERTEX:
+ if e.GetShapeType() != geomBuilder.GEOM.EDGE or \
+ v.GetShapeType() != geomBuilder.GEOM.VERTEX:
raise TypeError, "A list item must be a tuple (edge, 1st_vertex_of_edge)"
- vFirst = FirstVertexOnCurve( e )
+ vFirst = FirstVertexOnCurve( self.mesh, e )
tol = geompy.Tolerance( vFirst )[-1]
if geompy.MinDistance( v, vFirst ) > 1.5*tol:
resList.append( geompy.GetSubShapeID(self.mesh.geom, e ))
