X-Git-Url: http://git.salome-platform.org/gitweb/?p=modules%2Fsmesh.git;a=blobdiff_plain;f=src%2FSMESH_SWIG%2Fsmesh_algorithm.py;h=46f2270c1d7b8d7f68ca9d8b65e02930cd792966;hp=eda19fea4db6a753a3c016861de0315078e11799;hb=214d7e4bdce3ce892f52229fd37d74ebf251cd8e;hpb=bd8f1aee7c78f7d2eb82bd4fec5e08c9e3d280ce diff --git a/src/SMESH_SWIG/smesh_algorithm.py b/src/SMESH_SWIG/smesh_algorithm.py index eda19fea4..46f2270c1 100644 --- a/src/SMESH_SWIG/smesh_algorithm.py +++ b/src/SMESH_SWIG/smesh_algorithm.py @@ -1,9 +1,9 @@ -# 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 @@ -22,7 +22,7 @@ # 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 @@ -32,15 +32,15 @@ import SMESH # # 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() @@ -167,7 +167,7 @@ class Mesh_Algorithm: ## 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 @@ -180,7 +180,7 @@ class Mesh_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: @@ -191,25 +191,18 @@ class Mesh_Algorithm: ## 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): @@ -221,8 +214,8 @@ class Mesh_Algorithm: ## 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 @@ -234,7 +227,7 @@ class Mesh_Algorithm: 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: @@ -250,8 +243,9 @@ class Mesh_Algorithm: 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 @@ -263,80 +257,94 @@ class Mesh_Algorithm: ## 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 ))