X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FSMESH_SWIG%2Fsmesh.py;h=50df727f9aa4f5aa0ec9b61d52aaf30b3d842b78;hb=2850e5f7ba27175aaa4af13a3f5d268b40c6d53f;hp=36f34541af5506808c9b2f6e4673f0574bfd31e5;hpb=22496e8ddca45c3f0307628bf2c6661c212d11fd;p=modules%2Fsmesh.git

diff --git a/src/SMESH_SWIG/smesh.py b/src/SMESH_SWIG/smesh.py
index 36f34541a..50df727f9 100644
--- a/src/SMESH_SWIG/smesh.py
+++ b/src/SMESH_SWIG/smesh.py
@@ -46,11 +46,16 @@ smesh.SetCurrentStudy(salome.myStudy)
 # Private functions
 # -----------------
 
+NO_NAME = "NoName"
+
 def GetName(obj):
     ior  = salome.orb.object_to_string(obj)
     sobj = salome.myStudy.FindObjectIOR(ior)
-    attr = sobj.FindAttribute("AttributeName")[1]
-    return attr.Value()
+    if sobj is None:
+        return NO_NAME
+    else:
+        attr = sobj.FindAttribute("AttributeName")[1]
+        return attr.Value()
 
 def SetName(obj, name):
     ior  = salome.orb.object_to_string(obj)
@@ -91,8 +96,10 @@ class Mesh_Algorithm:
             name = GetName(piece)
         else:
             self.geom = geom
-            name = geompy.SubShapeName(geom, piece)
-            geompy.addToStudyInFather(piece, geom, name)
+            name = GetName(geom)
+            if name==NO_NAME:
+                name = geompy.SubShapeName(geom, piece)
+                geompy.addToStudyInFather(piece, geom, name)
             self.subm = mesh.mesh.GetSubMesh(geom, hypo)
 
         algo = smesh.CreateHypothesis(hypo, so)
@@ -149,6 +156,7 @@ class Mesh_Segment(Mesh_Algorithm):
             hyp = self.Hypothesis("NumberOfSegments", [n])
         else:
             hyp = self.Hypothesis("NumberOfSegments", [n,s])
+            hyp.SetDistrType( 1 )
             hyp.SetScaleFactor(s)
         hyp.SetNumberOfSegments(n)
         return hyp
@@ -191,6 +199,12 @@ class Mesh_Segment(Mesh_Algorithm):
         """
         return self.Hypothesis("Propagation")
 
+    def AutomaticLength(self):
+        """
+         Define "AutomaticLength" hypothesis
+        """
+        return self.Hypothesis("AutomaticLength")
+
 # Public class: Mesh_Segment_Python
 # ---------------------------------
 
@@ -340,6 +354,21 @@ class Mesh:
         """
         return self.geom
 
+    def MeshDimension(self):
+        """
+        Returns mesh dimension depending on shape one
+        """
+        shells = geompy.SubShapeAllIDs( self.geom, geompy.ShapeType["SHELL"] )
+        if len( shells ) > 0 :
+            return 3
+        elif geompy.NumberOfFaces( self.geom ) > 0 :
+            return 2
+        elif geompy.NumberOfEdges( self.geom ) > 0 :
+            return 1
+        else:
+            return 0;
+        pass
+
     def Segment(self, algo=REGULAR, geom=0):
         """
          Creates a segment discretization 1D algorithm.
@@ -400,29 +429,95 @@ class Mesh:
         """
         b = smesh.Compute(self.mesh, self.geom)
         if salome.sg.hasDesktop():
+            smeshgui = salome.ImportComponentGUI("SMESH")
+            smeshgui.Init(salome.myStudyId)
+            smeshgui.SetMeshIcon( salome.ObjectToID( self.mesh ), b )
             salome.sg.updateObjBrowser(1)
         return b
 
+    def AutomaticTetrahedralization(self):
+        """
+        Compute tetrahedral mesh using AutomaticLength + MEFISTO + NETGEN
+        """
+        dim = self.MeshDimension()
+        # assign hypotheses
+        self.RemoveGlobalHypotheses()
+        self.Segment().AutomaticLength()
+        if dim > 1 :
+            self.Triangle().LengthFromEdges()
+            pass
+        if dim > 2 :
+            self.Tetrahedron(NETGEN)
+            pass
+        self.Compute()
+        pass
+
+    def AutomaticHexahedralization(self):
+        """
+        Compute hexahedral mesh using AutomaticLength + Quadrangle + Hexahedron
+        """
+        dim = self.MeshDimension()
+        # assign hypotheses
+        self.RemoveGlobalHypotheses()
+        self.Segment().AutomaticLength()
+        if dim > 1 :
+            self.Quadrangle()
+            pass
+        if dim > 2 :
+            self.Hexahedron()            
+            pass
+        self.Compute()
+        pass
+
+    def RemoveGlobalHypotheses(self):
+        """
+        Removes all global hypotheses
+        """
+        current_hyps = self.mesh.GetHypothesisList( self.geom )
+        for hyp in current_hyps:
+            self.mesh.RemoveHypothesis( self.geom, hyp )
+            pass
+        pass
+
     def Group(self, grp, name=""):
         """
          Create a mesh group based on geometric object \a grp
          and give a \a name, if this parameter is not defined
          the name is the same as the geometric group name
-         \param grp  is a geometric group
+         \param grp  is a geometric group, a vertex, an edge, a face or a solid
          \param name is the name of the mesh group
         """
         if name == "":
             name = grp.GetName()
-        tgeo = geompy.GetType(grp)
-        if tgeo == geompy.ShapeType["VERTEX"]:
+
+        type = []
+        tgeo = str(grp.GetShapeType())
+        if tgeo == "VERTEX":
             type = SMESH.NODE
-        elif tgeo == geompy.ShapeType["EDGE"]:
+        elif tgeo == "EDGE":
             type = SMESH.EDGE
-        elif tgeo == geompy.ShapeType["FACE"]:
+        elif tgeo == "FACE":
             type = SMESH.FACE
-        elif tgeo == geompy.ShapeType["SOLID"]:
+        elif tgeo == "SOLID":
+            type = SMESH.VOLUME
+        elif tgeo == "SHELL":
             type = SMESH.VOLUME
-        return self.mesh.CreateGroupFromGEOM(type, name, grp)
+        elif tgeo == "COMPOUND":
+            tgeo = geompy.GetType(grp)
+            if tgeo == geompy.ShapeType["VERTEX"]:
+                type = SMESH.NODE
+            elif tgeo == geompy.ShapeType["EDGE"]:
+                type = SMESH.EDGE
+            elif tgeo == geompy.ShapeType["FACE"]:
+                type = SMESH.FACE
+            elif tgeo == geompy.ShapeType["SOLID"]:
+                type = SMESH.VOLUME
+
+        if type == []:
+            print "Mesh.Group: bad first argument: expected a group, a vertex, an edge, a face or a solid"
+            return 0
+        else:
+            return self.mesh.CreateGroupFromGEOM(type, name, grp)
 
     def ExportToMED(self, f, version, opt=0):
         """