X-Git-Url: http://git.salome-platform.org/gitweb/?p=modules%2Fsmesh.git;a=blobdiff_plain;f=src%2FSMESH_SWIG%2Fsmesh_algorithm.py;h=172dcca74e2a3f9de4b7dcfbcc50a8c697454fae;hp=6dc35e6b28fcb875897d737332e4c2b11096620c;hb=88141f757b048eaa5aae0be49faaf274448bbcaf;hpb=b4fdb7ebdeb340a3211ab01f92215ef3e7ce5fcc diff --git a/src/SMESH_SWIG/smesh_algorithm.py b/src/SMESH_SWIG/smesh_algorithm.py index 6dc35e6b2..172dcca74 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-2016 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 @@ -23,53 +23,65 @@ import salome from salome.geom import geomBuilder -import SMESH +import SMESH, StdMeshers -## The base class to define meshing algorithms -# -# @note This class should not be used directly, it is supposed to be sub-classed -# for implementing Python API for specific 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 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 -# of smesh.Mesh class: -# @code -# my_algo = mesh.MyAlgorithm() -# @endcode -# - @c algoType defines type of algorithm and is used mostly to discriminate -# algorithms that are created by the same method of class smesh.Mesh. For example, if this attribute -# is specified in @c MyPlugin_Algorithm class as -# @code -# algoType = "MyPLUGIN" -# @endcode -# then it's creation code can be: -# @code -# my_algo = mesh.MyAlgorithm(algo="MyPLUGIN") -# @endcode -# @ingroup l2_algorithms class Mesh_Algorithm: + """ + The base class to define meshing algorithms + + Note: + This class should not be used directly, it is supposed to be sub-classed + for implementing Python API for specific 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 :class:`~StdMeshersBuilder.StdMeshersBuilder_Segment` + in StdMeshersBuilder package): + + - :code:`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 :code:`class MyPlugin_Algorithm` this attribute is defined as + :: + + meshMethod = "MyAlgorithm" + + then an instance of :code:`MyPlugin_Algorithm` can be created by the direct invocation of the function + of smesh.Mesh class: + :: + + my_algo = mesh.MyAlgorithm() + + - :code:`algoType` defines type of algorithm and is used mostly to discriminate + algorithms that are created by the same method of class smesh.Mesh. For example, if this attribute + is specified in :code:`MyPlugin_Algorithm` class as + :: + + algoType = "MyPLUGIN" + + then it's creation code can be: + :: + + my_algo = mesh.MyAlgorithm(algo="MyPLUGIN") + """ + - ## Private constuctor def __init__(self): + """ + Private constuctor + """ self.mesh = None self.geom = None self.subm = None self.algo = None pass - ## Finds a hypothesis in the study by its type name and parameters. - # Finds only the hypotheses created in smeshpyD engine. - # @return SMESH.SMESH_Hypothesis def FindHypothesis (self, hypname, args, CompareMethod, smeshpyD): + """ + Finds a hypothesis in the study by its type name and parameters. + Finds only the hypotheses created in smeshpyD engine. + Returns: + SMESH.SMESH_Hypothesis + """ study = smeshpyD.GetCurrentStudy() if not study: return None #to do: find component by smeshpyD object, not by its data type @@ -85,6 +97,7 @@ class Mesh_Algorithm: attr = hypo_so_i.FindAttribute("AttributeIOR")[1] if attr is not None: anIOR = attr.Value() + if not anIOR: continue # prevent exception in orb.string_to_object() hypo_o_i = salome.orb.string_to_object(anIOR) if hypo_o_i is not None: # Check if this is a hypothesis @@ -109,10 +122,14 @@ class Mesh_Algorithm: pass return None - ## Finds the algorithm in the study by its type name. - # Finds only the algorithms, which have been created in smeshpyD engine. - # @return SMESH.SMESH_Algo def FindAlgorithm (self, algoname, smeshpyD): + """ + Finds the algorithm in the study by its type name. + Finds only the algorithms, which have been created in smeshpyD engine. + + Returns: + SMESH.SMESH_Algo + """ study = smeshpyD.GetCurrentStudy() if not study: return None #to do: find component by smeshpyD object, not by its data type @@ -128,6 +145,7 @@ class Mesh_Algorithm: attr = algo_so_i.FindAttribute("AttributeIOR")[1] if attr is not None: anIOR = attr.Value() + if not anIOR: continue # prevent exception in orb.string_to_object() algo_o_i = salome.orb.string_to_object(anIOR) if algo_o_i is not None: # Check if this is an algorithm @@ -149,39 +167,53 @@ class Mesh_Algorithm: pass return None - ## If the algorithm is global, returns 0; \n - # else returns the submesh associated to this algorithm. def GetSubMesh(self): + """ + If the algorithm is global, returns 0; + else returns the submesh associated to this algorithm. + """ return self.subm - ## Returns the wrapped mesher. def GetAlgorithm(self): + """ + Returns the wrapped mesher. + """ return self.algo - ## Gets the list of hypothesis that can be used with this algorithm def GetCompatibleHypothesis(self): + """ + Gets the list of hypothesis that can be used with this algorithm + """ mylist = [] if self.algo: mylist = self.algo.GetCompatibleHypothesis() return mylist - ## Gets the name of the algorithm def GetName(self): + """ + Gets the name of the algorithm + """ from salome.smesh.smeshBuilder import GetName return GetName(self.algo) - ## Sets the name to the algorithm def SetName(self, name): + """ + Sets the name to the algorithm + """ self.mesh.smeshpyD.SetName(self.algo, name) - ## Gets the id of the algorithm def GetId(self): + """ + Gets the id of the algorithm + """ return self.algo.GetId() - ## Private method. def Create(self, mesh, geom, hypo, so="libStdMeshersEngine.so"): + """ + Private method. + """ if geom is None and mesh.mesh.HasShapeToMesh(): - raise RuntimeError, "Attemp to create " + hypo + " algoritm on None shape" + raise RuntimeError, "Attempt to create " + hypo + " algorithm on None shape" algo = self.FindAlgorithm(hypo, mesh.smeshpyD) if algo is None: algo = mesh.smeshpyD.CreateHypothesis(hypo, so) @@ -189,27 +221,22 @@ class Mesh_Algorithm: self.Assign(algo, mesh, geom) return self.algo - ## Private method def Assign(self, algo, mesh, geom): + """ + Private method + """ 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" + raise RuntimeError, "Attempt to create " + algo + " algorithm 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): @@ -219,9 +246,11 @@ class Mesh_Algorithm: def CompareEqualHyp (self, hyp, args): return True - ## Private method def Hypothesis (self, hyp, args=[], so="libStdMeshersEngine.so", - UseExisting=0, CompareMethod=""): + UseExisting=0, CompareMethod="", toAdd=True): + """ + Private method + """ from salome.smesh.smeshBuilder import TreatHypoStatus, GetName hypo = None if UseExisting: @@ -250,67 +279,123 @@ 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 def MainShapeEntry(self): + """ + Returns entry of the shape to mesh in the study + """ if not self.mesh or not self.mesh.GetMesh(): return "" if not self.mesh.GetMesh().HasShapeToMesh(): return "" shape = self.mesh.GetShape() return shape.GetStudyEntry() - ## 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) - # @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 - # @ingroup l3_hypos_additi - def ViscousLayers(self, thickness, numberOfLayers, stretchFactor, ignoreFaces=[]): + def ViscousLayers(self, thickness, numberOfLayers, stretchFactor, + faces=[], isFacesToIgnore=True, extrMethod=StdMeshers.SURF_OFFSET_SMOOTH ): + """ + 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, MG-Tetra, Hexahedron(i,j,k) + + Parameters: + thickness: total thickness of layers of prisms + numberOfLayers: number of layers of prisms + stretchFactor: factor (>1.0) of growth of layer thickness towards inside of mesh + faces: list of geometrical faces (or their ids). + Viscous layers are either generated on these faces or not, depending on + the value of **isFacesToIgnore** parameter. + isFacesToIgnore: if *True*, the Viscous layers are not generated on the + faces specified by the previous parameter (**faces**). + extrMethod: extrusion method defines how position of new nodes are found during + prism construction and how creation of distorted and intersecting prisms is + prevented. Possible values are: + + - StdMeshers.SURF_OFFSET_SMOOTH (default) method extrudes nodes along normal + to underlying geometrical surface. Smoothing of internal surface of + element layers can be used to avoid creation of invalid prisms. + - StdMeshers.FACE_OFFSET method extrudes nodes along average normal of + surrounding mesh faces till intersection with a neighbor mesh face + translated along its own normal by the layers thickness. Thickness + of layers can be limited to avoid creation of invalid prisms. + - StdMeshers.NODE_OFFSET method extrudes nodes along average normal of + surrounding mesh faces by the layers thickness. Thickness of + layers can be limited to avoid creation of invalid prisms. + """ + 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], geomBuilder.GEOM._objref_GEOM_Object ): - ignoreFaces = [ self.mesh.geompyD.GetSubShapeID(self.mesh.geom, f) for f in ignoreFaces ] + if faces and isinstance( faces, geomBuilder.GEOM._objref_GEOM_Object ): + faces = [ faces ] + if faces and isinstance( faces[0], geomBuilder.GEOM._objref_GEOM_Object ): + faceIDs = [] + for shape in faces: + ff = self.mesh.geompyD.SubShapeAll( shape, self.mesh.geompyD.ShapeType["FACE"] ) + for f in ff: + faceIDs.append( self.mesh.geompyD.GetSubShapeID(self.mesh.geom, f)) + faces = faceIDs hyp = self.Hypothesis("ViscousLayers", - [thickness, numberOfLayers, stretchFactor, ignoreFaces]) - hyp.SetTotalThickness(thickness) - hyp.SetNumberLayers(numberOfLayers) - hyp.SetStretchFactor(stretchFactor) - hyp.SetIgnoreFaces(ignoreFaces) + [thickness, numberOfLayers, stretchFactor, faces, isFacesToIgnore], + toAdd=False) + hyp.SetTotalThickness( thickness ) + hyp.SetNumberLayers( numberOfLayers ) + hyp.SetStretchFactor( stretchFactor ) + hyp.SetFaces( faces, isFacesToIgnore ) + hyp.SetMethod( extrMethod ) + 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 - # @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 - # @ingroup l3_hypos_additi - def ViscousLayers2D(self, thickness, numberOfLayers, stretchFactor, ignoreEdges=[]): + def ViscousLayers2D(self, thickness, numberOfLayers, stretchFactor, + edges=[], isEdgesToIgnore=True ): + """ + 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, MG-CADSurf + + Parameters: + thickness: total thickness of layers of quadrilaterals + numberOfLayers: number of layers + stretchFactor: factor (>1.0) of growth of layer thickness towards inside of mesh + edges: list of geometrical edges (or their ids). + Viscous layers are either generated on these edges or not, depending on + the value of **isEdgesToIgnore** parameter. + isEdgesToIgnore: if *True*, the Viscous layers are not generated on the + edges specified by the previous parameter (**edges**). + """ + 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], geomBuilder.GEOM._objref_GEOM_Object ): - ignoreEdges = [ self.mesh.geompyD.GetSubShapeID(self.mesh.geom, f) for f in ignoreEdges ] + if edges and not isinstance( edges, list ) and not isinstance( edges, tuple ): + edges = [edges] + if edges and isinstance( edges[0], geomBuilder.GEOM._objref_GEOM_Object ): + edgeIDs = [] + for shape in edges: + ee = self.mesh.geompyD.SubShapeAll( shape, self.mesh.geompyD.ShapeType["EDGE"]) + for e in ee: + edgeIDs.append( self.mesh.geompyD.GetSubShapeID( self.mesh.geom, e )) + edges = edgeIDs 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) - # into a list acceptable to SetReversedEdges() of some 1D hypotheses - # @ingroup l3_hypos_1dhyps def ReversedEdgeIndices(self, reverseList): + """ + Transform a list of either edges or tuples (edge, 1st_vertex_of_edge) + into a list acceptable to SetReversedEdges() of some 1D hypotheses + """ + from salome.smesh.smeshBuilder import FirstVertexOnCurve resList = [] geompy = self.mesh.geompyD