X-Git-Url: http://git.salome-platform.org/gitweb/?p=modules%2Fsmesh.git;a=blobdiff_plain;f=src%2FSMESH_SWIG%2FsmeshBuilder.py;h=767a5ef1494913132133776c59f6b145c60c6b63;hp=98b192177bc72f44baa5b317df4e1c8ab36ca251;hb=0d17fa17ac55c2f07beacb4a49618f783e3b49c8;hpb=e26ffcc005221f12d4ff91e074c4c8464ca044e4 diff --git a/src/SMESH_SWIG/smeshBuilder.py b/src/SMESH_SWIG/smeshBuilder.py index 98b192177..767a5ef14 100644 --- a/src/SMESH_SWIG/smeshBuilder.py +++ b/src/SMESH_SWIG/smeshBuilder.py @@ -383,10 +383,16 @@ class smeshBuilder(object, SMESH._objref_SMESH_Gen): def init_smesh(self,theStudy,geompyD = None): #print "init_smesh" self.SetCurrentStudy(theStudy,geompyD) - - ## Creates an empty Mesh. This mesh can have an underlying geometry. - # @param obj the Geometrical object on which the mesh is built. If not defined, - # the mesh will have no underlying geometry. + if theStudy: + global notebook + notebook.myStudy = theStudy + + ## Creates a mesh. This can be either an empty mesh, possibly having an underlying geometry, + # or a mesh wrapping a CORBA mesh given as a parameter. + # @param obj either (1) a CORBA mesh (SMESH._objref_SMESH_Mesh) got e.g. by calling + # salome.myStudy.FindObjectID("0:1:2:3").GetObject() or + # (2) a Geometrical object for meshing or + # (3) none. # @param name the name for the new mesh. # @return an instance of Mesh class. # @ingroup l2_construct @@ -450,7 +456,9 @@ class smeshBuilder(object, SMESH._objref_SMESH_Gen): # @return SMESH.AxisStruct # @ingroup l1_auxiliary def GetAxisStruct(self,theObj): + import GEOM edges = self.geompyD.SubShapeAll( theObj, geomBuilder.geomBuilder.ShapeType["EDGE"] ) + axis = None if len(edges) > 1: vertex1, vertex2 = self.geompyD.SubShapeAll( edges[0], geomBuilder.geomBuilder.ShapeType["VERTEX"] ) vertex3, vertex4 = self.geompyD.SubShapeAll( edges[1], geomBuilder.geomBuilder.ShapeType["VERTEX"] ) @@ -462,14 +470,18 @@ class smeshBuilder(object, SMESH._objref_SMESH_Gen): v2 = [vertex4[0]-vertex3[0], vertex4[1]-vertex3[1], vertex4[2]-vertex3[2]] normal = [ v1[1]*v2[2]-v2[1]*v1[2], v1[2]*v2[0]-v2[2]*v1[0], v1[0]*v2[1]-v2[0]*v1[1] ] axis = AxisStruct(vertex1[0], vertex1[1], vertex1[2], normal[0], normal[1], normal[2]) - return axis + axis._mirrorType = SMESH.SMESH_MeshEditor.PLANE elif len(edges) == 1: vertex1, vertex2 = self.geompyD.SubShapeAll( edges[0], geomBuilder.geomBuilder.ShapeType["VERTEX"] ) p1 = self.geompyD.PointCoordinates( vertex1 ) p2 = self.geompyD.PointCoordinates( vertex2 ) axis = AxisStruct(p1[0], p1[1], p1[2], p2[0]-p1[0], p2[1]-p1[1], p2[2]-p1[2]) - return axis - return None + axis._mirrorType = SMESH.SMESH_MeshEditor.AXIS + elif theObj.GetShapeType() == GEOM.VERTEX: + x,y,z = self.geompyD.PointCoordinates( theObj ) + axis = AxisStruct( x,y,z, 1,0,0,) + axis._mirrorType = SMESH.SMESH_MeshEditor.POINT + return axis # From SMESH_Gen interface: # ------------------------ @@ -1514,7 +1526,7 @@ class Mesh: smeshgui.SetMeshIcon( salome.ObjectToID( self.mesh ), False, True ) salome.sg.updateObjBrowser(1) - ## Computes a tetrahedral mesh using AutomaticLength + MEFISTO + NETGEN + ## Computes a tetrahedral mesh using AutomaticLength + MEFISTO + Tetrahedron # @param fineness [0.0,1.0] defines mesh fineness # @return True or False # @ingroup l3_algos_basic @@ -1527,8 +1539,7 @@ class Mesh: self.Triangle().LengthFromEdges() pass if dim > 2 : - from salome.NETGENPlugin.NETGENPluginBuilder import NETGEN - self.Tetrahedron(NETGEN) + self.Tetrahedron() pass return self.Compute() @@ -1563,23 +1574,26 @@ class Mesh: if not geom: geom = self.mesh.GetShapeToMesh() pass - hyp_name = hyp.GetName() - lib_name = hyp.GetLibName() - geom_name = "" - if geom: - geom_name = geom.GetName() isApplicable = True - isAlgo = hyp._narrow( SMESH_Algo ) if self.mesh.HasShapeToMesh(): - isApplicable = self.smeshpyD.IsApplicable(hyp_name, lib_name, geom, not geom.IsSame( self.mesh.GetShapeToMesh() ) ) + hyp_type = hyp.GetName() + lib_name = hyp.GetLibName() + checkAll = ( not geom.IsSame( self.mesh.GetShapeToMesh() )) + if checkAll and geom: + checkAll = geom.GetType() == 37 + isApplicable = self.smeshpyD.IsApplicable(hyp_type, lib_name, geom, checkAll) if isApplicable: AssureGeomPublished( self, geom, "shape for %s" % hyp.GetName()) status = self.mesh.AddHypothesis(geom, hyp) - TreatHypoStatus( status, hyp_name, geom_name, isAlgo ) - return status else: - TreatHypoStatus( HYP_BAD_GEOMETRY, hyp_name, geom_name, isAlgo ) - return HYP_BAD_GEOMETRY + status = HYP_BAD_GEOMETRY + hyp_name = GetName( hyp ) + geom_name = "" + if geom: + geom_name = geom.GetName() + isAlgo = hyp._narrow( SMESH_Algo ) + TreatHypoStatus( status, hyp_name, geom_name, isAlgo ) + return status ## Return True if an algorithm of hypothesis is assigned to a given shape # @param hyp a hypothesis to check @@ -1649,17 +1663,24 @@ class Mesh: # - 1D if all mesh nodes lie on OX coordinate axis, or # - 2D if all mesh nodes lie on XOY coordinate plane, or # - 3D in the rest cases. - # # If @a autoDimension is @c False, the space dimension is always 3. + # @param fields : list of GEOM fields defined on the shape to mesh. + # @param geomAssocFields : each character of this string means a need to export a + # corresponding field; correspondence between fields and characters is following: + # - 'v' stands for _vertices_ field; + # - 'e' stands for _edges_ field; + # - 'f' stands for _faces_ field; + # - 's' stands for _solids_ field. # @ingroup l2_impexp def ExportMED(self, f, auto_groups=0, version=MED_V2_2, - overwrite=1, meshPart=None, autoDimension=True): - if meshPart: + overwrite=1, meshPart=None, autoDimension=True, fields=[], geomAssocFields=''): + if meshPart or fields or geomAssocFields: unRegister = genObjUnRegister() if isinstance( meshPart, list ): meshPart = self.GetIDSource( meshPart, SMESH.ALL ) unRegister.set( meshPart ) - self.mesh.ExportPartToMED( meshPart, f, auto_groups, version, overwrite, autoDimension) + self.mesh.ExportPartToMED( meshPart, f, auto_groups, version, overwrite, autoDimension, + fields, geomAssocFields) else: self.mesh.ExportToMEDX(f, auto_groups, version, overwrite, autoDimension) @@ -3915,12 +3936,14 @@ class Mesh: # @param MakeGroups forces the generation of new groups from existing ones (if Copy) # @return list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise # @ingroup l2_modif_trsf - def Mirror(self, IDsOfElements, Mirror, theMirrorType, Copy=0, MakeGroups=False): + def Mirror(self, IDsOfElements, Mirror, theMirrorType=None, Copy=0, MakeGroups=False): if IDsOfElements == []: IDsOfElements = self.GetElementsId() if ( isinstance( Mirror, geomBuilder.GEOM._objref_GEOM_Object)): - Mirror = self.smeshpyD.GetAxisStruct(Mirror) - self.mesh.SetParameters(Mirror.parameters) + Mirror = self.smeshpyD.GetAxisStruct(Mirror) + theMirrorType = Mirror._mirrorType + else: + self.mesh.SetParameters(Mirror.parameters) if Copy and MakeGroups: return self.editor.MirrorMakeGroups(IDsOfElements, Mirror, theMirrorType) self.editor.Mirror(IDsOfElements, Mirror, theMirrorType, Copy) @@ -3935,12 +3958,14 @@ class Mesh: # @param NewMeshName a name of the new mesh to create # @return instance of Mesh class # @ingroup l2_modif_trsf - def MirrorMakeMesh(self, IDsOfElements, Mirror, theMirrorType, MakeGroups=0, NewMeshName=""): + def MirrorMakeMesh(self, IDsOfElements, Mirror, theMirrorType=0, MakeGroups=0, NewMeshName=""): if IDsOfElements == []: IDsOfElements = self.GetElementsId() if ( isinstance( Mirror, geomBuilder.GEOM._objref_GEOM_Object)): - Mirror = self.smeshpyD.GetAxisStruct(Mirror) - self.mesh.SetParameters(Mirror.parameters) + Mirror = self.smeshpyD.GetAxisStruct(Mirror) + theMirrorType = Mirror._mirrorType + else: + self.mesh.SetParameters(Mirror.parameters) mesh = self.editor.MirrorMakeMesh(IDsOfElements, Mirror, theMirrorType, MakeGroups, NewMeshName) return Mesh(self.smeshpyD,self.geompyD,mesh) @@ -3954,12 +3979,14 @@ class Mesh: # @param MakeGroups forces the generation of new groups from existing ones (if Copy) # @return list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise # @ingroup l2_modif_trsf - def MirrorObject (self, theObject, Mirror, theMirrorType, Copy=0, MakeGroups=False): + def MirrorObject (self, theObject, Mirror, theMirrorType=None, Copy=0, MakeGroups=False): if ( isinstance( theObject, Mesh )): theObject = theObject.GetMesh() if ( isinstance( Mirror, geomBuilder.GEOM._objref_GEOM_Object)): - Mirror = self.smeshpyD.GetAxisStruct(Mirror) - self.mesh.SetParameters(Mirror.parameters) + Mirror = self.smeshpyD.GetAxisStruct(Mirror) + theMirrorType = Mirror._mirrorType + else: + self.mesh.SetParameters(Mirror.parameters) if Copy and MakeGroups: return self.editor.MirrorObjectMakeGroups(theObject, Mirror, theMirrorType) self.editor.MirrorObject(theObject, Mirror, theMirrorType, Copy) @@ -3974,12 +4001,14 @@ class Mesh: # @param NewMeshName the name of the new mesh to create # @return instance of Mesh class # @ingroup l2_modif_trsf - def MirrorObjectMakeMesh (self, theObject, Mirror, theMirrorType,MakeGroups=0, NewMeshName=""): + def MirrorObjectMakeMesh (self, theObject, Mirror, theMirrorType=0,MakeGroups=0,NewMeshName=""): if ( isinstance( theObject, Mesh )): theObject = theObject.GetMesh() - if (isinstance(Mirror, geomBuilder.GEOM._objref_GEOM_Object)): - Mirror = self.smeshpyD.GetAxisStruct(Mirror) - self.mesh.SetParameters(Mirror.parameters) + if ( isinstance( Mirror, geomBuilder.GEOM._objref_GEOM_Object)): + Mirror = self.smeshpyD.GetAxisStruct(Mirror) + theMirrorType = Mirror._mirrorType + else: + self.mesh.SetParameters(Mirror.parameters) mesh = self.editor.MirrorObjectMakeMesh(theObject, Mirror, theMirrorType, MakeGroups, NewMeshName) return Mesh( self.smeshpyD,self.geompyD,mesh ) @@ -4493,9 +4522,11 @@ class Mesh: # Triangles are transformed in prisms, and quadrangles in hexahedrons. # @param theDomains - list of groups of volumes # @param createJointElems - if TRUE, create the elements + # @param onAllBoundaries - if TRUE, the nodes and elements are also created on + # the boundary between \a theDomains and the rest mesh # @return TRUE if operation has been completed successfully, FALSE otherwise - def DoubleNodesOnGroupBoundaries(self, theDomains, createJointElems ): - return self.editor.DoubleNodesOnGroupBoundaries( theDomains, createJointElems ) + def DoubleNodesOnGroupBoundaries(self, theDomains, createJointElems, onAllBoundaries=False ): + return self.editor.DoubleNodesOnGroupBoundaries( theDomains, createJointElems, onAllBoundaries ) ## Double nodes on some external faces and create flat elements. # Flat elements are mainly used by some types of mechanic calculations. @@ -4614,6 +4645,29 @@ class Mesh: def GetSkew(self, elemId): return self._valueFromFunctor(SMESH.FT_Skew, elemId) + ## Return minimal and maximal value of a given functor. + # @param funType a functor type, an item of SMESH.FunctorType enum + # (one of SMESH.FunctorType._items) + # @param meshPart a part of mesh (group, sub-mesh) to treat + # @return tuple (min,max) + # @ingroup l1_measurements + def GetMinMax(self, funType, meshPart=None): + unRegister = genObjUnRegister() + if isinstance( meshPart, list ): + meshPart = self.GetIDSource( meshPart, SMESH.ALL ) + unRegister.set( meshPart ) + if isinstance( meshPart, Mesh ): + meshPart = meshPart.mesh + fun = self._getFunctor( funType ) + if fun: + if meshPart: + hist = fun.GetLocalHistogram( 1, False, meshPart ) + else: + hist = fun.GetHistogram( 1, False ) + if hist: + return hist[0].min, hist[0].max + return None + pass # end of Mesh class ## Helper class for wrapping of SMESH.SMESH_Pattern CORBA class