X-Git-Url: http://git.salome-platform.org/gitweb/?p=modules%2Fsmesh.git;a=blobdiff_plain;f=src%2FSMESH_SWIG%2Fsmesh.py;h=251e7d36b08e63ad08399940f35d73fcff55228c;hp=bf7fed0117ea63d8c442c7a12fe32bef6b2def19;hb=30310d58ad574246b7a220002e3b6758e47e340c;hpb=57b43b4d010e2d0a1529d3c131bbb9d416e63258

diff --git a/src/SMESH_SWIG/smesh.py b/src/SMESH_SWIG/smesh.py
index bf7fed011..251e7d36b 100644
--- a/src/SMESH_SWIG/smesh.py
+++ b/src/SMESH_SWIG/smesh.py
@@ -1,4 +1,8 @@
-#  Copyright (C) 2005  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+#! /usr/bin/python
+#  -*- coding: iso-8859-1 -*-
+#  Copyright (C) 2007-2008  CEA/DEN, EDF R&D, OPEN CASCADE
+#
+#  Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 #  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
 #
 #  This library is free software; you can redistribute it and/or
@@ -15,693 +19,29 @@
 #  License along with this library; if not, write to the Free Software
 #  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 #
-#  See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+#  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 #
 #  File   : smesh.py
 #  Author : Francis KLOSS, OCC
 #  Module : SMESH
-
-"""
- \namespace smesh
+#
+"""@package smesh
  \brief Module smesh
 """
 
 import salome
-import geompy
-import StdMeshers
-import SMESH
-
-# Public variables
-# ----------------
+from salome import *
 
-REGULAR = 1
-PYTHON  = 2
-
-NETGEN  = 3
-GHS3D   = 4
+import geompy
+import smeshDC
+from smeshDC import *
 
 smesh = salome.lcc.FindOrLoadComponent("FactoryServer", "SMESH")
-smesh.SetCurrentStudy(salome.myStudy)
-
-# Private functions
-# -----------------
-
-NO_NAME = "NoName"
-
-def GetName(obj):
-    ior  = salome.orb.object_to_string(obj)
-    sobj = salome.myStudy.FindObjectIOR(ior)
-    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)
-    sobj = salome.myStudy.FindObjectIOR(ior)
-    attr = sobj.FindAttribute("AttributeName")[1]
-    attr.SetValue(name)
-
-# Algorithms and hypothesis
-# =========================
-
-# Private class: Mesh_Algorithm
-# -----------------------------
-
-class Mesh_Algorithm:
-    """
-    Mother class to define algorithm, recommended to don't use directly
-    """
-
-    mesh = 0
-    geom = 0
-    subm = 0
-    algo = 0
-
-    def GetSubMesh(self):
-        """
-         If the algorithm is global, return 0
-         else return the submesh associated to this algorithm
-        """
-        return self.subm
-
-    def GetAlgorithm(self):
-        """
-         Return the wrapped mesher
-        """
-        return self.algo
-
-    def TreatHypoStatus(self, status, hypName, geomName, isAlgo):
-        """
-        Private method. Print error message if a hypothesis was not assigned
-        """
-        if isAlgo:
-            hypType = "algorithm"
-        else:
-            hypType = "hypothesis"
-        if status == SMESH.HYP_UNKNOWN_FATAL :
-            reason = "for unknown reason"
-        elif status == SMESH.HYP_INCOMPATIBLE :
-            reason = "this hypothesis mismatches algorithm"
-        elif status == SMESH.HYP_NOTCONFORM :
-            reason = "not conform mesh would be built"
-        elif status == SMESH.HYP_ALREADY_EXIST :
-            reason = hypType + " of the same dimension already assigned to this shape"
-        elif status == SMESH.HYP_BAD_DIM :
-            reason = hypType + " mismatches shape"
-        elif status == SMESH.HYP_CONCURENT :
-            reason = "there are concurrent hypotheses on sub-shapes"
-        elif status == SMESH.HYP_BAD_SUBSHAPE :
-            reason = "shape is neither the main one, nor its subshape, nor a valid group"
-        else:
-            return
-        hypName = '"' + hypName + '"'
-        geomName= '"' + geomName+ '"'
-        if status < SMESH.HYP_UNKNOWN_FATAL:
-            print hypName, "was assigned to",    geomName,"but", reason
-        else:
-            print hypName, "was not assigned to",geomName,":", reason
-        pass
-
-    def Create(self, mesh, geom, hypo, so="libStdMeshersEngine.so"):
-        """
-         Private method
-        """
-        if geom is None:
-            raise RuntimeError, "Attemp to create " + hypo + " algoritm on None shape"
-        self.mesh = mesh
-        piece = mesh.geom
-        if geom==0:
-            self.geom = piece
-            name = GetName(piece)
-        else:
-            self.geom = geom
-            name = GetName(geom)
-            if name==NO_NAME:
-                name = geompy.SubShapeName(geom, piece)
-                geompy.addToStudyInFather(piece, geom, name)
-            self.subm = mesh.mesh.GetSubMesh(geom, hypo)
-
-        self.algo = smesh.CreateHypothesis(hypo, so)
-        SetName(self.algo, name + "/" + hypo)
-        status = mesh.mesh.AddHypothesis(self.geom, self.algo)
-        self.TreatHypoStatus( status, hypo, name, 1 )
-
-    def Hypothesis(self, hyp, args=[], so="libStdMeshersEngine.so"):
-        """
-         Private method
-        """
-        hypo = smesh.CreateHypothesis(hyp, so)
-        a = ""
-        s = "="
-        i = 0
-        n = len(args)
-        while i<n:
-            a = a + s + str(args[i])
-            s = ","
-            i = i + 1
-        name = GetName(self.geom)
-        SetName(hypo, name + "/" + hyp + a)
-        status = self.mesh.mesh.AddHypothesis(self.geom, hypo)
-        self.TreatHypoStatus( status, hyp, name, 0 )
-        return hypo
-
-# Public class: Mesh_Segment
-# --------------------------
-
-class Mesh_Segment(Mesh_Algorithm):
-    """
-    Class to define a segment 1D algorithm for discretization
-    """
-
-    def __init__(self, mesh, geom=0):
-        """
-         Private constructor
-        """
-        self.Create(mesh, geom, "Regular_1D")
-
-    def LocalLength(self, l):
-        """
-         Define "LocalLength" hypothesis to cut an edge in several segments with the same length
-         \param l for the length of segments that cut an edge
-        """
-        hyp = self.Hypothesis("LocalLength", [l])
-        hyp.SetLength(l)
-        return hyp
-
-    def NumberOfSegments(self, n, s=[]):
-        """
-         Define "NumberOfSegments" hypothesis to cut an edge in several fixed number of segments
-         \param n for the number of segments that cut an edge
-         \param s for the scale factor (optional)
-        """
-        if s == []:
-            hyp = self.Hypothesis("NumberOfSegments", [n])
-        else:
-            hyp = self.Hypothesis("NumberOfSegments", [n,s])
-            hyp.SetDistrType( 1 )
-            hyp.SetScaleFactor(s)
-        hyp.SetNumberOfSegments(n)
-        return hyp
-
-    def Arithmetic1D(self, start, end):
-        """
-         Define "Arithmetic1D" hypothesis to cut an edge in several segments with arithmetic length increasing
-         \param start for the length of the first segment
-         \param end   for the length of the last  segment
-        """
-        hyp = self.Hypothesis("Arithmetic1D", [start, end])
-        hyp.SetLength(start, 1)
-        hyp.SetLength(end  , 0)
-        return hyp
-
-    def StartEndLength(self, start, end):
-        """
-         Define "StartEndLength" hypothesis to cut an edge in several segments with geometric length increasing
-         \param start for the length of the first segment
-         \param end   for the length of the last  segment
-        """
-        hyp = self.Hypothesis("StartEndLength", [start, end])
-        hyp.SetLength(start, 1)
-        hyp.SetLength(end  , 0)
-        return hyp
-
-    def Deflection1D(self, d):
-        """
-         Define "Deflection1D" hypothesis
-         \param d for the deflection
-        """
-        hyp = self.Hypothesis("Deflection1D", [d])
-        hyp.SetDeflection(d)
-        return hyp
-
-    def Propagation(self):
-        """
-         Define "Propagation" hypothesis that propagate all other hypothesis on all others edges that are in
-         the opposite side in the case of quadrangular faces
-        """
-        return self.Hypothesis("Propagation")
-
-    def AutomaticLength(self, fineness=0):
-        """
-         Define "AutomaticLength" hypothesis
-         \param fineness for the fineness [0-1]
-        """
-        hyp = self.Hypothesis("AutomaticLength")
-        hyp.SetFineness( fineness )
-        return hyp
-
-    def QuadraticMesh(self):
-        """
-         Define "QuadraticMesh" hypothesis, forcing construction of quadratic edges.
-         If the 2D mesher sees that all boundary edges are quadratic ones,
-         it generates quadratic faces, else it generates linear faces using
-         medium nodes as if they were vertex ones.
-         The 3D mesher generates quadratic volumes only if all boundary faces
-         are quadratic ones, else it fails.
-        """
-        hyp = self.Hypothesis("QuadraticMesh")
-        return hyp
-
-# Public class: Mesh_Segment_Python
-# ---------------------------------
-
-class Mesh_Segment_Python(Mesh_Segment):
-    """
-    Class to define a segment 1D algorithm for discretization with python function
-    """
-
-    def __init__(self, mesh, geom=0):
-        """
-         Private constructor
-        """
-        import Python1dPlugin
-        self.Create(mesh, geom, "Python_1D", "libPython1dEngine.so")
-
-    def PythonSplit1D(self, n, func):
-        """
-         Define "PythonSplit1D" hypothesis based on the Erwan Adam patch, awaiting equivalent SALOME functionality
-         \param n for the number of segments that cut an edge
-         \param func for the python function that calculate the length of all segments
-        """
-        hyp = self.Hypothesis("PythonSplit1D", [n], "libPython1dEngine.so")
-        hyp.SetNumberOfSegments(n)
-        hyp.SetPythonLog10RatioFunction(func)
-        return hyp
-
-# Public class: Mesh_Triangle
-# ---------------------------
-
-class Mesh_Triangle(Mesh_Algorithm):
-    """
-    Class to define a triangle 2D algorithm
-    """
-
-    def __init__(self, mesh, geom=0):
-        """
-         Private constructor
-        """
-        self.Create(mesh, geom, "MEFISTO_2D")
-
-    def MaxElementArea(self, area):
-        """
-         Define "MaxElementArea" hypothesis to give the maximun area of each triangles
-         \param area for the maximum area of each triangles
-        """
-        hyp = self.Hypothesis("MaxElementArea", [area])
-        hyp.SetMaxElementArea(area)
-        return hyp
-
-    def LengthFromEdges(self):
-        """
-         Define "LengthFromEdges" hypothesis to build triangles based on the length of the edges taken from the wire
-        """
-        return self.Hypothesis("LengthFromEdges")
-
-# Public class: Mesh_Quadrangle
-# -----------------------------
-
-class Mesh_Quadrangle(Mesh_Algorithm):
-    """
-    Class to define a quadrangle 2D algorithm
-    """
-
-    def __init__(self, mesh, geom=0):
-        """
-         Private constructor
-        """
-        self.Create(mesh, geom, "Quadrangle_2D")
-
-    def QuadranglePreference(self):
-        """
-         Define "QuadranglePreference" hypothesis, forcing construction
-         of quadrangles if the number of nodes on opposite edges is not the same
-         in the case where the global number of nodes on edges is even
-        """
-        hyp = self.Hypothesis("QuadranglePreference")
-        return hyp
-
-# Public class: Mesh_Tetrahedron
-# ------------------------------
-
-class Mesh_Tetrahedron(Mesh_Algorithm):
-    """
-    Class to define a tetrahedron 3D algorithm
-    """
-
-    def __init__(self, mesh, algo, geom=0):
-        """
-         Private constructor
-        """
-        if algo == NETGEN:
-            self.Create(mesh, geom, "NETGEN_3D", "libNETGENEngine.so")
-        elif algo == GHS3D:
-            import GHS3DPlugin
-            self.Create(mesh, geom, "GHS3D_3D" , "libGHS3DEngine.so")
-
-    def MaxElementVolume(self, vol):
-        """
-         Define "MaxElementVolume" hypothesis to give the maximun volume of each tetrahedral
-         \param vol for the maximum volume of each tetrahedral
-        """
-        hyp = self.Hypothesis("MaxElementVolume", [vol])
-        hyp.SetMaxElementVolume(vol)
-        return hyp
-
-# Public class: Mesh_Hexahedron
-# ------------------------------
-
-class Mesh_Hexahedron(Mesh_Algorithm):
-    """
-    Class to define a hexahedron 3D algorithm
-    """
-
-    def __init__(self, mesh, geom=0):
-        """
-         Private constructor
-        """
-        self.Create(mesh, geom, "Hexa_3D")
-
-# Public class: Mesh_Netgen
-# ------------------------------
-
-class Mesh_Netgen(Mesh_Algorithm):
-    """
-    Class to define a NETGEN-based 2D or 3D algorithm
-    that need no discrete boundary (i.e. independent)
-    """
-
-    is3D = 0
-
-    def __init__(self, mesh, is3D, geom=0):
-        """
-         Private constructor
-        """
-        self.is3D = is3D
-        if is3D:
-            self.Create(mesh, geom, "NETGEN_2D3D", "libNETGENEngine.so")
-        else:
-            self.Create(mesh, geom, "NETGEN_2D", "libNETGENEngine.so")
-
-    def Parameters(self):
-        """
-         Define hypothesis containing parameters of the algorithm
-        """
-        if self.is3D:
-            hyp = self.Hypothesis("NETGEN_Parameters", [], "libNETGENEngine.so")
-        else:
-            hyp = self.Hypothesis("NETGEN_Parameters_2D", [], "libNETGENEngine.so")
-        return hyp
-
-# Public class: Mesh
-# ==================
-
-class Mesh:
-    """
-    Class to define a mesh
-    """
-
-    geom = 0
-    mesh = 0
-
-    def __init__(self, geom, name=0):
-        """
-         Constructor
-
-         Creates mesh on the shape \a geom,
-         sets GUI name of this mesh to \a name.
-         \param geom Shape to be meshed
-         \param name Study name of the mesh
-        """
-        self.geom = geom
-        self.mesh = smesh.CreateMesh(geom)
-        if name == 0:
-            SetName(self.mesh, GetName(geom))
-        else:
-            SetName(self.mesh, name)
-
-    def GetMesh(self):
-        """
-         Method that returns the mesh
-        """
-        return self.mesh
-
-    def GetShape(self):
-        """
-         Method that returns the shape associated to the 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.
-         If the optional \a algo parameter is not sets, this algorithm is REGULAR.
-         If the optional \a geom parameter is not sets, this algorithm is global.
-         Otherwise, this algorithm define a submesh based on \a geom subshape.
-         \param algo values are smesh.REGULAR or smesh.PYTHON for discretization via python function
-         \param geom If defined, subshape to be meshed
-        """
-        ## if Segment(geom) is called by mistake
-        if ( isinstance( algo, geompy.GEOM._objref_GEOM_Object)):
-            algo, geom = geom, algo
-            pass
-        if algo == REGULAR:
-            return Mesh_Segment(self, geom)
-        elif algo == PYTHON:
-            return Mesh_Segment_Python(self, geom)
-        else:
-            return Mesh_Segment(self, geom)
-
-    def Triangle(self, geom=0):
-        """
-         Creates a triangle 2D algorithm for faces.
-         If the optional \a geom parameter is not sets, this algorithm is global.
-         Otherwise, this algorithm define a submesh based on \a geom subshape.
-         \param geom If defined, subshape to be meshed
-        """
-        return Mesh_Triangle(self, geom)
-
-    def Quadrangle(self, geom=0):
-        """
-         Creates a quadrangle 2D algorithm for faces.
-         If the optional \a geom parameter is not sets, this algorithm is global.
-         Otherwise, this algorithm define a submesh based on \a geom subshape.
-         \param geom If defined, subshape to be meshed
-        """
-        return Mesh_Quadrangle(self, geom)
-
-    def Tetrahedron(self, algo, geom=0):
-        """
-         Creates a tetrahedron 3D algorithm for solids.
-         The parameter \a algo permits to choice the algorithm: NETGEN or GHS3D
-         If the optional \a geom parameter is not sets, this algorithm is global.
-         Otherwise, this algorithm define a submesh based on \a geom subshape.
-         \param algo values are: smesh.NETGEN, smesh.GHS3D
-         \param geom If defined, subshape to be meshed
-        """
-        ## if Tetrahedron(geom) is called by mistake
-        if ( isinstance( algo, geompy.GEOM._objref_GEOM_Object)):
-            algo, geom = geom, algo
-            pass
-        return Mesh_Tetrahedron(self, algo, geom)
-
-    def Hexahedron(self, geom=0):
-        """
-         Creates a hexahedron 3D algorithm for solids.
-         If the optional \a geom parameter is not sets, this algorithm is global.
-         Otherwise, this algorithm define a submesh based on \a geom subshape.
-         \param geom If defined, subshape to be meshed
-        """
-        return Mesh_Hexahedron(self, geom)
-
-    def Netgen(self, is3D, geom=0):
-        """
-         Creates a NETGEN-based 2D or 3D independent algorithm (i.e. needs no
-         discrete boundary).
-         If the optional \a geom parameter is not sets, this algorithm is global.
-         Otherwise, this algorithm defines a submesh based on \a geom subshape.
-         \param is3D If 0 then algorithm is 2D, otherwise 3D
-         \param geom If defined, subshape to be meshed
-        """
-        return Mesh_Netgen(self, is3D, geom)
-
-    def Compute(self):
-        """
-        Compute the mesh and return the status of the computation
-        """
-        ok = smesh.Compute(self.mesh, self.geom)
-        if not ok:
-            errors = smesh.GetAlgoState( self.mesh, self.geom )
-            allReasons = ""
-            for err in errors:
-                if err.isGlobalAlgo:
-                    glob = " global "
-                else:
-                    glob = " local "
-                    pass
-                dim = str(err.algoDim)
-                if err.name == SMESH.MISSING_ALGO:
-                    reason = glob + dim + "D algorithm is missing"
-                elif err.name == SMESH.MISSING_HYPO:
-                    name = '"' + err.algoName + '"'
-                    reason = glob + dim + "D algorithm " + name + " misses " + dim + "D hypothesis"
-                else:
-                    reason = "Global \"Not Conform mesh allowed\" hypothesis is missing"
-                    pass
-                if allReasons != "":
-                    allReasons += "\n"
-                    pass
-                allReasons += reason
-                pass
-            if allReasons != "":
-                print '"' + GetName(self.mesh) + '"',"not computed:"
-                print allReasons
-                pass
-            pass
-        if salome.sg.hasDesktop():
-            smeshgui = salome.ImportComponentGUI("SMESH")
-            smeshgui.Init(salome.myStudyId)
-            smeshgui.SetMeshIcon( salome.ObjectToID( self.mesh ), ok )
-            salome.sg.updateObjBrowser(1)
-            pass
-        return ok
-
-    def AutomaticTetrahedralization(self, fineness=0):
-        """
-        Compute tetrahedral mesh using AutomaticLength + MEFISTO + NETGEN
-        The parameter \a fineness [0.-1.] defines mesh fineness
-        """
-        dim = self.MeshDimension()
-        # assign hypotheses
-        self.RemoveGlobalHypotheses()
-        self.Segment().AutomaticLength(fineness)
-        if dim > 1 :
-            self.Triangle().LengthFromEdges()
-            pass
-        if dim > 2 :
-            self.Tetrahedron(NETGEN)
-            pass
-        return self.Compute()
-
-    def AutomaticHexahedralization(self, fineness=0):
-        """
-        Compute hexahedral mesh using AutomaticLength + Quadrangle + Hexahedron
-        The parameter \a fineness [0.-1.] defines mesh fineness
-        """
-        dim = self.MeshDimension()
-        # assign hypotheses
-        self.RemoveGlobalHypotheses()
-        self.Segment().AutomaticLength(fineness)
-        if dim > 1 :
-            self.Quadrangle()
-            pass
-        if dim > 2 :
-            self.Hexahedron()            
-            pass
-        return self.Compute()
-
-    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, a vertex, an edge, a face or a solid
-         \param name is the name of the mesh group
-        """
-        if name == "":
-            name = grp.GetName()
-
-        type = []
-        tgeo = str(grp.GetShapeType())
-        if tgeo == "VERTEX":
-            type = SMESH.NODE
-        elif tgeo == "EDGE":
-            type = SMESH.EDGE
-        elif tgeo == "FACE":
-            type = SMESH.FACE
-        elif tgeo == "SOLID":
-            type = SMESH.VOLUME
-        elif tgeo == "SHELL":
-            type = SMESH.VOLUME
-        elif tgeo == "COMPOUND":
-            if len( geompy.GetObjectIDs( grp )) == 0:
-                print "Mesh.Group: empty geometric group", GetName( grp )
-                return 0
-            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):
-        """
-         Export the mesh in a file with the MED format and choice the \a version of MED format
-         \param f is the file name
-         \param version values are SMESH.MED_V2_1, SMESH.MED_V2_2
-        """
-        self.mesh.ExportToMED(f, opt, version)
-
-    def ExportMED(self, f, opt=0):
-        """
-         Export the mesh in a file with the MED format
-         \param f is the file name
-        """
-        self.mesh.ExportMED(f, opt)
-
-    def ExportDAT(self, f):
-        """
-         Export the mesh in a file with the DAT format
-         \param f is the file name
-        """
-        self.mesh.ExportDAT(f)
+smesh.init_smesh(salome.myStudy,geompy.geom)
 
-    def ExportUNV(self, f):
-        """
-         Export the mesh in a file with the UNV format
-         \param f is the file name
-        """
-        self.mesh.ExportUNV(f)
+# Export the methods of smeshD
+for k in dir(smesh):
+  if k[0] == '_':continue
+  globals()[k]=getattr(smesh,k)
+del k
 
-    def ExportSTL(self, f, ascii=1):
-        """
-         Export the mesh in a file with the STL format
-         \param f is the file name
-         \param ascii defined the kind of file contents
-        """
-        self.mesh.ExportSTL(f, ascii)