X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FSMESH_SWIG%2FsmeshDC.py;h=3949fca2d872e14350062253a336fed5e512abb3;hb=607f25cad19938400e6fff1bd093501ec472e207;hp=62d2f82cdb8606e7943c80de983f75ffaf76ae18;hpb=ec51778b0c03cb813edd827367aa69e3132951f0;p=modules%2Fsmesh.git diff --git a/src/SMESH_SWIG/smeshDC.py b/src/SMESH_SWIG/smeshDC.py index 62d2f82cd..3949fca2d 100644 --- a/src/SMESH_SWIG/smeshDC.py +++ b/src/SMESH_SWIG/smeshDC.py @@ -1,28 +1,25 @@ -# Copyright (C) 2007-2008 CEA/DEN, EDF R&D, OPEN CASCADE +# Copyright (C) 2007-2011 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 +# 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. # -# 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. +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. # -# This library is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -# Lesser General Public License for more details. +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA # -# You should have received a copy of the GNU Lesser General Public -# 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.salome-platform.org/ or email : webmaster.salome@opencascade.com +# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # # File : smesh.py # Author : Francis KLOSS, OCC # Module : SMESH -# + """ \namespace smesh \brief Module smesh @@ -51,6 +48,7 @@ ## @defgroup l3_hypos_ghs3dh GHS3D Parameters hypothesis ## @defgroup l3_hypos_blsurf BLSURF Parameters hypothesis ## @defgroup l3_hypos_hexotic Hexotic Parameters hypothesis +## @defgroup l3_hypos_quad Quadrangle Parameters hypothesis ## @defgroup l3_hypos_additi Additional Hypotheses ## @} @@ -88,6 +86,7 @@ ## @defgroup l2_modif_tofromqu Convert to/from Quadratic Mesh ## @} +## @defgroup l1_measurements Measurements import salome import geompyDC @@ -98,6 +97,7 @@ from SMESH import * import StdMeshers import SALOME +import SALOMEDS # import NETGENPlugin module if possible noNETGENPlugin = 0 @@ -107,6 +107,38 @@ except ImportError: noNETGENPlugin = 1 pass +# import GHS3DPlugin module if possible +noGHS3DPlugin = 0 +try: + import GHS3DPlugin +except ImportError: + noGHS3DPlugin = 1 + pass + +# import GHS3DPRLPlugin module if possible +noGHS3DPRLPlugin = 0 +try: + import GHS3DPRLPlugin +except ImportError: + noGHS3DPRLPlugin = 1 + pass + +# import HexoticPlugin module if possible +noHexoticPlugin = 0 +try: + import HexoticPlugin +except ImportError: + noHexoticPlugin = 1 + pass + +# import BLSURFPlugin module if possible +noBLSURFPlugin = 0 +try: + import BLSURFPlugin +except ImportError: + noBLSURFPlugin = 1 + pass + ## @addtogroup l1_auxiliary ## @{ @@ -129,6 +161,8 @@ Hexa = 8 Hexotic = 9 BLSURF = 10 GHS3DPRL = 11 +QUADRANGLE = 0 +RADIAL_QUAD = 1 # MirrorType enumeration POINT = SMESH_MeshEditor.POINT @@ -148,16 +182,28 @@ VeryFine = 4 Custom = 5 # Optimization level of GHS3D +# V3.1 None_Optimization, Light_Optimization, Medium_Optimization, Strong_Optimization = 0,1,2,3 +# V4.1 (partialy redefines V3.1). Issue 0020574 +None_Optimization, Light_Optimization, Standard_Optimization, StandardPlus_Optimization, Strong_Optimization = 0,1,2,3,4 # Topology treatment way of BLSURF -FromCAD, PreProcess, PreProcessPlus = 0,1,2 +FromCAD, PreProcess, PreProcessPlus, PreCAD = 0,1,2,3 # Element size flag of BLSURF -DefaultSize, DefaultGeom, Custom = 0,0,1 +DefaultSize, DefaultGeom, BLSURF_Custom, SizeMap = 0,0,1,2 PrecisionConfusion = 1e-07 +# TopAbs_State enumeration +[TopAbs_IN, TopAbs_OUT, TopAbs_ON, TopAbs_UNKNOWN] = range(4) + +# Methods of splitting a hexahedron into tetrahedra +Hex_5Tet, Hex_6Tet, Hex_24Tet = 1, 2, 3 + +# import items of enum QuadType +for e in StdMeshers.QuadType._items: exec('%s = StdMeshers.%s'%(e,e)) + ## Converts an angle from degrees to radians def DegreesToRadians(AngleInDegrees): from math import pi @@ -310,7 +356,7 @@ def ParseDirStruct(Dir): pntStr = Dir.pointStruct if isinstance(pntStr, PointStructStr6): Parameters = str(pntStr.x1Str) + var_separator + str(pntStr.x2Str) + var_separator - Parameters += str(pntStr.y1Str) + var_separator + str(pntStr.y2Str) + var_separator + Parameters += str(pntStr.y1Str) + var_separator + str(pntStr.y2Str) + var_separator Parameters += str(pntStr.z1Str) + var_separator + str(pntStr.z2Str) Point = PointStruct(pntStr.x2 - pntStr.x1, pntStr.y2 - pntStr.y1, pntStr.z2 - pntStr.z1) else: @@ -339,13 +385,13 @@ def ParseAngles(list): else: Result.append(parameter) pass - + Parameters = Parameters + str(parameter) Parameters = Parameters + var_separator pass Parameters = Parameters[:len(Parameters)-1] return Result, Parameters - + def IsEqual(val1, val2, tol=PrecisionConfusion): if abs(val1 - val2) < tol: return True @@ -355,13 +401,33 @@ NO_NAME = "NoName" ## Gets object name 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() + if obj: + # object not null + if isinstance(obj, SALOMEDS._objref_SObject): + # study object + return obj.GetName() + ior = salome.orb.object_to_string(obj) + if ior: + # CORBA object + studies = salome.myStudyManager.GetOpenStudies() + for sname in studies: + s = salome.myStudyManager.GetStudyByName(sname) + if not s: continue + sobj = s.FindObjectIOR(ior) + if not sobj: continue + return sobj.GetName() + if hasattr(obj, "GetName"): + # unknown CORBA object, having GetName() method + return obj.GetName() + else: + # unknown CORBA object, no GetName() method + return NO_NAME + pass + if hasattr(obj, "GetName"): + # unknown non-CORBA object, having GetName() method + return obj.GetName() + pass + raise RuntimeError, "Null or invalid object" ## Prints error message if a hypothesis was not assigned. def TreatHypoStatus(status, hypName, geomName, isAlgo): @@ -377,13 +443,14 @@ def TreatHypoStatus(status, hypName, geomName, isAlgo): elif status == HYP_NOTCONFORM : reason = "a non-conform mesh would be built" elif status == HYP_ALREADY_EXIST : + if isAlgo: return # it does not influence anything reason = hypType + " of the same dimension is already assigned to this shape" elif status == HYP_BAD_DIM : reason = hypType + " mismatches the shape" elif status == HYP_CONCURENT : reason = "there are concurrent hypotheses on sub-shapes" elif status == HYP_BAD_SUBSHAPE : - reason = "the shape is neither the main one, nor its subshape, nor a valid group" + reason = "the shape is neither the main one, nor its sub-shape, nor a valid group" elif status == HYP_BAD_GEOMETRY: reason = "geometry mismatches the expectation of the algorithm" elif status == HYP_HIDDEN_ALGO: @@ -396,18 +463,93 @@ def TreatHypoStatus(status, hypName, geomName, isAlgo): return hypName = '"' + hypName + '"' geomName= '"' + geomName+ '"' - if status < HYP_UNKNOWN_FATAL: + if status < HYP_UNKNOWN_FATAL and not geomName =='""': print hypName, "was assigned to", geomName,"but", reason - else: + elif not geomName == '""': print hypName, "was not assigned to",geomName,":", reason + else: + print hypName, "was not assigned:", reason pass +## Check meshing plugin availability +def CheckPlugin(plugin): + if plugin == NETGEN and noNETGENPlugin: + print "Warning: NETGENPlugin module unavailable" + return False + elif plugin == GHS3D and noGHS3DPlugin: + print "Warning: GHS3DPlugin module unavailable" + return False + elif plugin == GHS3DPRL and noGHS3DPRLPlugin: + print "Warning: GHS3DPRLPlugin module unavailable" + return False + elif plugin == Hexotic and noHexoticPlugin: + print "Warning: HexoticPlugin module unavailable" + return False + elif plugin == BLSURF and noBLSURFPlugin: + print "Warning: BLSURFPlugin module unavailable" + return False + return True + +## Private method. Add geom (sub-shape of the main shape) into the study if not yet there +def AssureGeomPublished(mesh, geom, name=''): + if not isinstance( geom, geompyDC.GEOM._objref_GEOM_Object ): + return + if not geom.IsSame( mesh.geom ) and not geom.GetStudyEntry(): + ## set the study + studyID = mesh.smeshpyD.GetCurrentStudy()._get_StudyId() + if studyID != mesh.geompyD.myStudyId: + mesh.geompyD.init_geom( mesh.smeshpyD.GetCurrentStudy()) + ## get a name + if not name and geom.GetShapeType() != geompyDC.GEOM.COMPOUND: + # for all groups SubShapeName() returns "Compound_-1" + name = mesh.geompyD.SubShapeName(geom, mesh.geom) + if not name: + name = "%s_%s"%(geom.GetShapeType(), id(geom)%10000) + ## publish + mesh.geompyD.addToStudyInFather( mesh.geom, geom, name ) + return + +## Return the first vertex of a geomertical edge by ignoring orienation +def FirstVertexOnCurve(edge): + from geompy import SubShapeAll, ShapeType, KindOfShape, PointCoordinates + vv = SubShapeAll( edge, ShapeType["VERTEX"]) + if not vv: + raise TypeError, "Given object has no vertices" + if len( vv ) == 1: return vv[0] + info = KindOfShape(edge) + xyz = info[1:4] # coords of the first vertex + xyz1 = PointCoordinates( vv[0] ) + xyz2 = PointCoordinates( vv[1] ) + dist1, dist2 = 0,0 + for i in range(3): + dist1 += abs( xyz[i] - xyz1[i] ) + dist2 += abs( xyz[i] - xyz2[i] ) + if dist1 < dist2: + return vv[0] + else: + return vv[1] + # end of l1_auxiliary ## @} # All methods of this class are accessible directly from the smesh.py package. class smeshDC(SMESH._objref_SMESH_Gen): + ## Dump component to the Python script + # This method overrides IDL function to allow default values for the parameters. + def DumpPython(self, theStudy, theIsPublished=True, theIsMultiFile=True): + return SMESH._objref_SMESH_Gen.DumpPython(self, theStudy, theIsPublished, theIsMultiFile) + + ## Set mode of DumpPython(), \a historical or \a snapshot. + # In the \a historical mode, the Python Dump script includes all commands + # performed by SMESH engine. In the \a snapshot mode, commands + # relating to objects removed from the Study are excluded from the script + # as well as commands not influencing the current state of meshes + def SetDumpPythonHistorical(self, isHistorical): + if isHistorical: val = "true" + else: val = "false" + SMESH._objref_SMESH_Gen.SetOption(self, "historical_python_dump", val) + ## Sets the current study and Geometry component # @ingroup l1_auxiliary def init_smesh(self,theStudy,geompyD): @@ -420,7 +562,9 @@ class smeshDC(SMESH._objref_SMESH_Gen): # @return an instance of Mesh class. # @ingroup l2_construct def Mesh(self, obj=0, name=0): - return Mesh(self,self.geompyD,obj,name) + if isinstance(obj,str): + obj,name = name,obj + return Mesh(self,self.geompyD,obj,name) ## Returns a long value from enumeration # Should be used for SMESH.FunctorType enumeration @@ -428,6 +572,20 @@ class smeshDC(SMESH._objref_SMESH_Gen): def EnumToLong(self,theItem): return theItem._v + ## Returns a string representation of the color. + # To be used with filters. + # @param c color value (SALOMEDS.Color) + # @ingroup l1_controls + def ColorToString(self,c): + val = "" + if isinstance(c, SALOMEDS.Color): + val = "%s;%s;%s" % (c.R, c.G, c.B) + elif isinstance(c, str): + val = c + else: + raise ValueError, "Color value should be of string or SALOMEDS.Color type" + return val + ## Gets PointStruct from vertex # @param theVertex a GEOM object(vertex) # @return SMESH.PointStruct @@ -493,7 +651,6 @@ class smeshDC(SMESH._objref_SMESH_Gen): # @param name a new object name # @ingroup l1_auxiliary def SetName(self, obj, name): - print "obj_name = ", name if isinstance( obj, Mesh ): obj = obj.GetMesh() elif isinstance( obj, Mesh_Algorithm ): @@ -550,6 +707,17 @@ class smeshDC(SMESH._objref_SMESH_Gen): aMeshes.append(aMesh) return aMeshes, aStatus + ## Creates a Mesh object(s) importing data from the given SAUV file + # @return a list of Mesh class instances + # @ingroup l2_impexp + def CreateMeshesFromSAUV( self,theFileName ): + aSmeshMeshes, aStatus = SMESH._objref_SMESH_Gen.CreateMeshesFromSAUV(self,theFileName) + aMeshes = [] + for iMesh in range(len(aSmeshMeshes)) : + aMesh = Mesh(self, self.geompyD, aSmeshMeshes[iMesh]) + aMeshes.append(aMesh) + return aMeshes, aStatus + ## Creates a Mesh object importing data from the given STL file # @return an instance of Mesh class # @ingroup l2_impexp @@ -558,6 +726,17 @@ class smeshDC(SMESH._objref_SMESH_Gen): aMesh = Mesh(self, self.geompyD, aSmeshMesh) return aMesh + ## Creates Mesh objects importing data from the given CGNS file + # @return an instance of Mesh class + # @ingroup l2_impexp + def CreateMeshesFromCGNS( self, theFileName ): + aSmeshMeshes, aStatus = SMESH._objref_SMESH_Gen.CreateMeshesFromCGNS(self,theFileName) + aMeshes = [] + for iMesh in range(len(aSmeshMeshes)) : + aMesh = Mesh(self, self.geompyD, aSmeshMeshes[iMesh]) + aMeshes.append(aMesh) + return aMeshes, aStatus + ## Concatenate the given meshes into one mesh. # @return an instance of Mesh class # @param meshes the meshes to combine into one mesh @@ -567,15 +746,34 @@ class smeshDC(SMESH._objref_SMESH_Gen): # @param allGroups forces creation of groups of all elements def Concatenate( self, meshes, uniteIdenticalGroups, mergeNodesAndElements = False, mergeTolerance = 1e-5, allGroups = False): + mergeTolerance,Parameters = geompyDC.ParseParameters(mergeTolerance) + for i,m in enumerate(meshes): + if isinstance(m, Mesh): + meshes[i] = m.GetMesh() if allGroups: aSmeshMesh = SMESH._objref_SMESH_Gen.ConcatenateWithGroups( self,meshes,uniteIdenticalGroups,mergeNodesAndElements,mergeTolerance) else: aSmeshMesh = SMESH._objref_SMESH_Gen.Concatenate( self,meshes,uniteIdenticalGroups,mergeNodesAndElements,mergeTolerance) + aSmeshMesh.SetParameters(Parameters) aMesh = Mesh(self, self.geompyD, aSmeshMesh) return aMesh + ## Create a mesh by copying a part of another mesh. + # @param meshPart a part of mesh to copy, either a Mesh, a sub-mesh or a group; + # to copy nodes or elements not contained in any mesh object, + # pass result of Mesh.GetIDSource( list_of_ids, type ) as meshPart + # @param meshName a name of the new mesh + # @param toCopyGroups to create in the new mesh groups the copied elements belongs to + # @param toKeepIDs to preserve IDs of the copied elements or not + # @return an instance of Mesh class + def CopyMesh( self, meshPart, meshName, toCopyGroups=False, toKeepIDs=False): + if (isinstance( meshPart, Mesh )): + meshPart = meshPart.GetMesh() + mesh = SMESH._objref_SMESH_Gen.CopyMesh( self,meshPart,meshName,toCopyGroups,toKeepIDs ) + return Mesh(self, self.geompyD, mesh) + ## From SMESH_Gen interface # @return the list of integer values # @ingroup l1_auxiliary @@ -597,26 +795,6 @@ class smeshDC(SMESH._objref_SMESH_Gen): def SetBoundaryBoxSegmentation(self, nbSegments): SMESH._objref_SMESH_Gen.SetBoundaryBoxSegmentation(self,nbSegments) - ## Concatenate the given meshes into one mesh. - # @return an instance of Mesh class - # @param meshes the meshes to combine into one mesh - # @param uniteIdenticalGroups if true, groups with same names are united, else they are renamed - # @param mergeNodesAndElements if true, equal nodes and elements aremerged - # @param mergeTolerance tolerance for merging nodes - # @param allGroups forces creation of groups of all elements - def Concatenate( self, meshes, uniteIdenticalGroups, - mergeNodesAndElements = False, mergeTolerance = 1e-5, allGroups = False): - mergeTolerance,Parameters = geompyDC.ParseParameters(mergeTolerance) - if allGroups: - aSmeshMesh = SMESH._objref_SMESH_Gen.ConcatenateWithGroups( - self,meshes,uniteIdenticalGroups,mergeNodesAndElements,mergeTolerance) - else: - aSmeshMesh = SMESH._objref_SMESH_Gen.Concatenate( - self,meshes,uniteIdenticalGroups,mergeNodesAndElements,mergeTolerance) - aSmeshMesh.SetParameters(Parameters) - aMesh = Mesh(self, self.geompyD, aSmeshMesh) - return aMesh - # Filtering. Auxiliary functions: # ------------------------------ @@ -638,26 +816,35 @@ class smeshDC(SMESH._objref_SMESH_Gen): UnaryOp, BinaryOp, Tolerance, TypeOfElement, Precision) ## Creates a criterion by the given parameters + # \n Criterion structures allow to define complex filters by combining them with logical operations (AND / OR) (see example below) # @param elementType the type of elements(NODE, EDGE, FACE, VOLUME) # @param CritType the type of criterion (FT_Taper, FT_Area, FT_RangeOfIds, FT_LyingOnGeom etc.) # @param Compare belongs to {FT_LessThan, FT_MoreThan, FT_EqualTo} - # @param Treshold the threshold value (range of ids as string, shape, numeric) + # @param Threshold the threshold value (range of ids as string, shape, numeric) # @param UnaryOp FT_LogicalNOT or FT_Undefined # @param BinaryOp a binary logical operation FT_LogicalAND, FT_LogicalOR or # FT_Undefined (must be for the last criterion of all criteria) + # @param Tolerance the tolerance used by FT_BelongToGeom, FT_BelongToSurface, + # FT_LyingOnGeom, FT_CoplanarFaces criteria # @return SMESH.Filter.Criterion + # + # Example of Criteria usage # @ingroup l1_controls def GetCriterion(self,elementType, CritType, Compare = FT_EqualTo, - Treshold="", + Threshold="", UnaryOp=FT_Undefined, - BinaryOp=FT_Undefined): + BinaryOp=FT_Undefined, + Tolerance=1e-07): + if not CritType in SMESH.FunctorType._items: + raise TypeError, "CritType should be of SMESH.FunctorType" aCriterion = self.GetEmptyCriterion() aCriterion.TypeOfElement = elementType aCriterion.Type = self.EnumToLong(CritType) + aCriterion.Tolerance = Tolerance - aTreshold = Treshold + aThreshold = Threshold if Compare in [FT_LessThan, FT_MoreThan, FT_EqualTo]: aCriterion.Compare = self.EnumToLong(Compare) @@ -667,47 +854,87 @@ class smeshDC(SMESH._objref_SMESH_Gen): aCriterion.Compare = self.EnumToLong(FT_LessThan) elif Compare == ">": aCriterion.Compare = self.EnumToLong(FT_MoreThan) - else: + elif Compare != FT_Undefined: aCriterion.Compare = self.EnumToLong(FT_EqualTo) - aTreshold = Compare + aThreshold = Compare if CritType in [FT_BelongToGeom, FT_BelongToPlane, FT_BelongToGenSurface, FT_BelongToCylinder, FT_LyingOnGeom]: - # Checks the treshold - if isinstance(aTreshold, geompyDC.GEOM._objref_GEOM_Object): - aCriterion.ThresholdStr = GetName(aTreshold) - aCriterion.ThresholdID = salome.ObjectToID(aTreshold) + # Checks the Threshold + if isinstance(aThreshold, geompyDC.GEOM._objref_GEOM_Object): + aCriterion.ThresholdStr = GetName(aThreshold) + aCriterion.ThresholdID = salome.ObjectToID(aThreshold) else: - print "Error: The treshold should be a shape." + print "Error: The Threshold should be a shape." return None + if isinstance(UnaryOp,float): + aCriterion.Tolerance = UnaryOp + UnaryOp = FT_Undefined + pass elif CritType == FT_RangeOfIds: - # Checks the treshold - if isinstance(aTreshold, str): - aCriterion.ThresholdStr = aTreshold + # Checks the Threshold + if isinstance(aThreshold, str): + aCriterion.ThresholdStr = aThreshold + else: + print "Error: The Threshold should be a string." + return None + elif CritType == FT_CoplanarFaces: + # Checks the Threshold + if isinstance(aThreshold, int): + aCriterion.ThresholdID = "%s"%aThreshold + elif isinstance(aThreshold, str): + ID = int(aThreshold) + if ID < 1: + raise ValueError, "Invalid ID of mesh face: '%s'"%aThreshold + aCriterion.ThresholdID = aThreshold else: - print "Error: The treshold should be a string." + raise ValueError,\ + "The Threshold should be an ID of mesh face and not '%s'"%aThreshold + elif CritType == FT_ElemGeomType: + # Checks the Threshold + try: + aCriterion.Threshold = self.EnumToLong(aThreshold) + assert( aThreshold in SMESH.GeometryType._items ) + except: + if isinstance(aThreshold, int): + aCriterion.Threshold = aThreshold + else: + print "Error: The Threshold should be an integer or SMESH.GeometryType." + return None + pass + pass + elif CritType == FT_GroupColor: + # Checks the Threshold + try: + aCriterion.ThresholdStr = self.ColorToString(aThreshold) + except: + print "Error: The threshold value should be of SALOMEDS.Color type" return None - elif CritType in [FT_FreeBorders, FT_FreeEdges, FT_BadOrientedVolume, FT_FreeNodes, - FT_FreeFaces, FT_ElemGeomType, FT_GroupColor]: - # At this point the treshold is unnecessary - if aTreshold == FT_LogicalNOT: + pass + elif CritType in [FT_FreeBorders, FT_FreeEdges, FT_FreeNodes, FT_FreeFaces, + FT_LinearOrQuadratic, FT_BadOrientedVolume, + FT_BareBorderFace, FT_BareBorderVolume, + FT_OverConstrainedFace, FT_OverConstrainedVolume, + FT_EqualNodes,FT_EqualEdges,FT_EqualFaces,FT_EqualVolumes ]: + # At this point the Threshold is unnecessary + if aThreshold == FT_LogicalNOT: aCriterion.UnaryOp = self.EnumToLong(FT_LogicalNOT) - elif aTreshold in [FT_LogicalAND, FT_LogicalOR]: - aCriterion.BinaryOp = aTreshold + elif aThreshold in [FT_LogicalAND, FT_LogicalOR]: + aCriterion.BinaryOp = aThreshold else: - # Check treshold + # Check Threshold try: - aTreshold = float(aTreshold) - aCriterion.Threshold = aTreshold + aThreshold = float(aThreshold) + aCriterion.Threshold = aThreshold except: - print "Error: The treshold should be a number." + print "Error: The Threshold should be a number." return None - if Treshold == FT_LogicalNOT or UnaryOp == FT_LogicalNOT: + if Threshold == FT_LogicalNOT or UnaryOp == FT_LogicalNOT: aCriterion.UnaryOp = self.EnumToLong(FT_LogicalNOT) - if Treshold in [FT_LogicalAND, FT_LogicalOR]: - aCriterion.BinaryOp = self.EnumToLong(Treshold) + if Threshold in [FT_LogicalAND, FT_LogicalOR]: + aCriterion.BinaryOp = self.EnumToLong(Threshold) if UnaryOp in [FT_LogicalAND, FT_LogicalOR]: aCriterion.BinaryOp = self.EnumToLong(UnaryOp) @@ -721,21 +948,40 @@ class smeshDC(SMESH._objref_SMESH_Gen): # @param elementType the type of elements in the group # @param CritType the type of criterion ( FT_Taper, FT_Area, FT_RangeOfIds, FT_LyingOnGeom etc. ) # @param Compare belongs to {FT_LessThan, FT_MoreThan, FT_EqualTo} - # @param Treshold the threshold value (range of id ids as string, shape, numeric) + # @param Threshold the threshold value (range of id ids as string, shape, numeric) # @param UnaryOp FT_LogicalNOT or FT_Undefined + # @param Tolerance the tolerance used by FT_BelongToGeom, FT_BelongToSurface, + # FT_LyingOnGeom, FT_CoplanarFaces and FT_EqualNodes criteria # @return SMESH_Filter + # + # Example of Filters usage # @ingroup l1_controls def GetFilter(self,elementType, CritType=FT_Undefined, Compare=FT_EqualTo, - Treshold="", - UnaryOp=FT_Undefined): - aCriterion = self.GetCriterion(elementType, CritType, Compare, Treshold, UnaryOp, FT_Undefined) + Threshold="", + UnaryOp=FT_Undefined, + Tolerance=1e-07): + aCriterion = self.GetCriterion(elementType, CritType, Compare, Threshold, UnaryOp, FT_Undefined,Tolerance) aFilterMgr = self.CreateFilterManager() aFilter = aFilterMgr.CreateFilter() aCriteria = [] aCriteria.append(aCriterion) aFilter.SetCriteria(aCriteria) + aFilterMgr.UnRegister() + return aFilter + + ## Creates a filter from criteria + # @param criteria a list of criteria + # @return SMESH_Filter + # + # Example of Filters usage + # @ingroup l1_controls + def GetFilterFromCriteria(self,criteria): + aFilterMgr = self.CreateFilterManager() + aFilter = aFilterMgr.CreateFilter() + aFilter.SetCriteria(criteria) + aFilterMgr.UnRegister() return aFilter ## Creates a numerical functor by its type @@ -760,6 +1006,10 @@ class smeshDC(SMESH._objref_SMESH_Gen): return aFilterMgr.CreateArea() elif theCriterion == FT_Volume3D: return aFilterMgr.CreateVolume3D() + elif theCriterion == FT_MaxElementLength2D: + return aFilterMgr.CreateMaxElementLength2D() + elif theCriterion == FT_MaxElementLength3D: + return aFilterMgr.CreateMaxElementLength3D() elif theCriterion == FT_MultiConnection: return aFilterMgr.CreateMultiConnection() elif theCriterion == FT_MultiConnection2D: @@ -772,12 +1022,130 @@ class smeshDC(SMESH._objref_SMESH_Gen): print "Error: given parameter is not numerucal functor type." ## Creates hypothesis - # @param - # @param + # @param theHType mesh hypothesis type (string) + # @param theLibName mesh plug-in library name # @return created hypothesis instance def CreateHypothesis(self, theHType, theLibName="libStdMeshersEngine.so"): return SMESH._objref_SMESH_Gen.CreateHypothesis(self, theHType, theLibName ) + ## Gets the mesh statistic + # @return dictionary "element type" - "count of elements" + # @ingroup l1_meshinfo + def GetMeshInfo(self, obj): + if isinstance( obj, Mesh ): + obj = obj.GetMesh() + d = {} + if hasattr(obj, "GetMeshInfo"): + values = obj.GetMeshInfo() + for i in range(SMESH.Entity_Last._v): + if i < len(values): d[SMESH.EntityType._item(i)]=values[i] + pass + return d + + ## Get minimum distance between two objects + # + # If @a src2 is None, and @a id2 = 0, distance from @a src1 / @a id1 to the origin is computed. + # If @a src2 is None, and @a id2 != 0, it is assumed that both @a id1 and @a id2 belong to @a src1. + # + # @param src1 first source object + # @param src2 second source object + # @param id1 node/element id from the first source + # @param id2 node/element id from the second (or first) source + # @param isElem1 @c True if @a id1 is element id, @c False if it is node id + # @param isElem2 @c True if @a id2 is element id, @c False if it is node id + # @return minimum distance value + # @sa GetMinDistance() + # @ingroup l1_measurements + def MinDistance(self, src1, src2=None, id1=0, id2=0, isElem1=False, isElem2=False): + result = self.GetMinDistance(src1, src2, id1, id2, isElem1, isElem2) + if result is None: + result = 0.0 + else: + result = result.value + return result + + ## Get measure structure specifying minimum distance data between two objects + # + # If @a src2 is None, and @a id2 = 0, distance from @a src1 / @a id1 to the origin is computed. + # If @a src2 is None, and @a id2 != 0, it is assumed that both @a id1 and @a id2 belong to @a src1. + # + # @param src1 first source object + # @param src2 second source object + # @param id1 node/element id from the first source + # @param id2 node/element id from the second (or first) source + # @param isElem1 @c True if @a id1 is element id, @c False if it is node id + # @param isElem2 @c True if @a id2 is element id, @c False if it is node id + # @return Measure structure or None if input data is invalid + # @sa MinDistance() + # @ingroup l1_measurements + def GetMinDistance(self, src1, src2=None, id1=0, id2=0, isElem1=False, isElem2=False): + if isinstance(src1, Mesh): src1 = src1.mesh + if isinstance(src2, Mesh): src2 = src2.mesh + if src2 is None and id2 != 0: src2 = src1 + if not hasattr(src1, "_narrow"): return None + src1 = src1._narrow(SMESH.SMESH_IDSource) + if not src1: return None + if id1 != 0: + m = src1.GetMesh() + e = m.GetMeshEditor() + if isElem1: + src1 = e.MakeIDSource([id1], SMESH.FACE) + else: + src1 = e.MakeIDSource([id1], SMESH.NODE) + pass + if hasattr(src2, "_narrow"): + src2 = src2._narrow(SMESH.SMESH_IDSource) + if src2 and id2 != 0: + m = src2.GetMesh() + e = m.GetMeshEditor() + if isElem2: + src2 = e.MakeIDSource([id2], SMESH.FACE) + else: + src2 = e.MakeIDSource([id2], SMESH.NODE) + pass + pass + aMeasurements = self.CreateMeasurements() + result = aMeasurements.MinDistance(src1, src2) + aMeasurements.UnRegister() + return result + + ## Get bounding box of the specified object(s) + # @param objects single source object or list of source objects + # @return tuple of six values (minX, minY, minZ, maxX, maxY, maxZ) + # @sa GetBoundingBox() + # @ingroup l1_measurements + def BoundingBox(self, objects): + result = self.GetBoundingBox(objects) + if result is None: + result = (0.0,)*6 + else: + result = (result.minX, result.minY, result.minZ, result.maxX, result.maxY, result.maxZ) + return result + + ## Get measure structure specifying bounding box data of the specified object(s) + # @param objects single source object or list of source objects + # @return Measure structure + # @sa BoundingBox() + # @ingroup l1_measurements + def GetBoundingBox(self, objects): + if isinstance(objects, tuple): + objects = list(objects) + if not isinstance(objects, list): + objects = [objects] + srclist = [] + for o in objects: + if isinstance(o, Mesh): + srclist.append(o.mesh) + elif hasattr(o, "_narrow"): + src = o._narrow(SMESH.SMESH_IDSource) + if src: srclist.append(src) + pass + pass + aMeasurements = self.CreateMeasurements() + result = aMeasurements.BoundingBox(srclist) + aMeasurements.UnRegister() + return result + import omniORB #Registering the new proxy for SMESH_Gen omniORB.registerObjref(SMESH._objref_SMESH_Gen._NP_RepositoryId, smeshDC) @@ -814,7 +1182,16 @@ class Mesh: if obj != 0: if isinstance(obj, geompyDC.GEOM._objref_GEOM_Object): self.geom = obj + # publish geom of mesh (issue 0021122) + if not self.geom.GetStudyEntry(): + studyID = smeshpyD.GetCurrentStudy()._get_StudyId() + if studyID != geompyD.myStudyId: + geompyD.init_geom( smeshpyD.GetCurrentStudy()) + pass + geo_name = "%s_%s"%(self.geom.GetShapeType(), id(self.geom)%100) + geompyD.addToStudy( self.geom, geo_name ) self.mesh = self.smeshpyD.CreateMesh(self.geom) + elif isinstance(obj, SMESH._objref_SMESH_Mesh): self.SetMesh(obj) else: @@ -857,12 +1234,13 @@ class Mesh: ## Gets the subMesh object associated to a \a theSubObject geometrical object. # The subMesh object gives access to the IDs of nodes and elements. - # @param theSubObject a geometrical object (shape) - # @param theName a name for the submesh + # @param geom a geometrical object (shape) + # @param name a name for the submesh # @return an object of type SMESH_SubMesh, representing a part of mesh, which lies on the given shape # @ingroup l2_submeshes - def GetSubMesh(self, theSubObject, theName): - submesh = self.mesh.GetSubMesh(theSubObject, theName) + def GetSubMesh(self, geom, name): + AssureGeomPublished( self, geom, name ) + submesh = self.mesh.GetSubMesh( geom, name ) return submesh ## Returns the shape associated to the mesh @@ -877,8 +1255,12 @@ class Mesh: def SetShape(self, geom): self.mesh = self.smeshpyD.CreateMesh(geom) + ## Loads mesh from the study after opening the study + def Load(self): + self.mesh.Load() + ## Returns true if the hypotheses are defined well - # @param theSubObject a subshape of a mesh shape + # @param theSubObject a sub-shape of a mesh shape # @return True or False # @ingroup l2_construct def IsReadyToCompute(self, theSubObject): @@ -886,7 +1268,7 @@ class Mesh: ## Returns errors of hypotheses definition. # The list of errors is empty if everything is OK. - # @param theSubObject a subshape of a mesh shape + # @param theSubObject a sub-shape of a mesh shape # @return a list of errors # @ingroup l2_construct def GetAlgoState(self, theSubObject): @@ -920,12 +1302,12 @@ class Mesh: ## Creates a segment discretization 1D algorithm. # If the optional \a algo parameter is not set, this algorithm is REGULAR. # \n If the optional \a geom parameter is not set, this algorithm is global. - # Otherwise, this algorithm defines a submesh based on \a geom subshape. + # Otherwise, this algorithm defines a submesh based on \a geom sub-shape. # @param algo the type of the required algorithm. Possible values are: # - smesh.REGULAR, # - smesh.PYTHON for discretization via a python function, # - smesh.COMPOSITE for meshing a set of edges on one face side as a whole. - # @param geom If defined is the subshape to be meshed + # @param geom If defined is the sub-shape to be meshed # @return an instance of Mesh_Segment or Mesh_Segment_Python, or Mesh_CompositeSegment class # @ingroup l3_algos_basic def Segment(self, algo=REGULAR, geom=0): @@ -943,12 +1325,30 @@ class Mesh: else: return Mesh_Segment(self, geom) + ## Creates 1D algorithm importing segments conatined in groups of other mesh. + # If the optional \a geom parameter is not set, this algorithm is global. + # Otherwise, this algorithm defines a submesh based on \a geom sub-shape. + # @param geom If defined the subshape is to be meshed + # @return an instance of Mesh_UseExistingElements class + # @ingroup l3_algos_basic + def UseExisting1DElements(self, geom=0): + return Mesh_UseExistingElements(1,self, geom) + + ## Creates 2D algorithm importing faces conatined in groups of other mesh. + # If the optional \a geom parameter is not set, this algorithm is global. + # Otherwise, this algorithm defines a submesh based on \a geom subshape. + # @param geom If defined the sub-shape is to be meshed + # @return an instance of Mesh_UseExistingElements class + # @ingroup l3_algos_basic + def UseExisting2DElements(self, geom=0): + return Mesh_UseExistingElements(2,self, geom) + ## Enables creation of nodes and segments usable by 2D algoritms. # The added nodes and segments must be bound to edges and vertices by # SetNodeOnVertex(), SetNodeOnEdge() and SetMeshElementOnShape() # If the optional \a geom parameter is not set, this algorithm is global. - # \n Otherwise, this algorithm defines a submesh based on \a geom subshape. - # @param geom the subshape to be manually meshed + # \n Otherwise, this algorithm defines a submesh based on \a geom sub-shape. + # @param geom the sub-shape to be manually meshed # @return StdMeshers_UseExisting_1D algorithm that generates nothing # @ingroup l3_algos_basic def UseExistingSegments(self, geom=0): @@ -959,8 +1359,8 @@ class Mesh: # The added nodes and faces must be bound to geom faces by SetNodeOnFace() # and SetMeshElementOnShape() # If the optional \a geom parameter is not set, this algorithm is global. - # \n Otherwise, this algorithm defines a submesh based on \a geom subshape. - # @param geom the subshape to be manually meshed + # \n Otherwise, this algorithm defines a submesh based on \a geom sub-shape. + # @param geom the sub-shape to be manually meshed # @return StdMeshers_UseExisting_2D algorithm that generates nothing # @ingroup l3_algos_basic def UseExistingFaces(self, geom=0): @@ -969,9 +1369,9 @@ class Mesh: ## Creates a triangle 2D algorithm for faces. # If the optional \a geom parameter is not set, this algorithm is global. - # \n Otherwise, this algorithm defines a submesh based on \a geom subshape. + # \n Otherwise, this algorithm defines a submesh based on \a geom sub-shape. # @param algo values are: smesh.MEFISTO || smesh.NETGEN_1D2D || smesh.NETGEN_2D || smesh.BLSURF - # @param geom If defined, the subshape to be meshed (GEOM_Object) + # @param geom If defined, the sub-shape to be meshed (GEOM_Object) # @return an instance of Mesh_Triangle algorithm # @ingroup l3_algos_basic def Triangle(self, algo=MEFISTO, geom=0): @@ -979,24 +1379,27 @@ class Mesh: if (isinstance(algo, geompyDC.GEOM._objref_GEOM_Object)): geom = algo algo = MEFISTO - return Mesh_Triangle(self, algo, geom) ## Creates a quadrangle 2D algorithm for faces. # If the optional \a geom parameter is not set, this algorithm is global. - # \n Otherwise, this algorithm defines a submesh based on \a geom subshape. - # @param geom If defined, the subshape to be meshed (GEOM_Object) + # \n Otherwise, this algorithm defines a submesh based on \a geom sub-shape. + # @param geom If defined, the sub-shape to be meshed (GEOM_Object) + # @param algo values are: smesh.QUADRANGLE || smesh.RADIAL_QUAD # @return an instance of Mesh_Quadrangle algorithm # @ingroup l3_algos_basic - def Quadrangle(self, geom=0): - return Mesh_Quadrangle(self, geom) + def Quadrangle(self, geom=0, algo=QUADRANGLE): + if algo==RADIAL_QUAD: + return Mesh_RadialQuadrangle1D2D(self,geom) + else: + return Mesh_Quadrangle(self, geom) ## Creates a tetrahedron 3D algorithm for solids. # The parameter \a algo permits to choose the algorithm: NETGEN or GHS3D # If the optional \a geom parameter is not set, this algorithm is global. - # \n Otherwise, this algorithm defines a submesh based on \a geom subshape. + # \n Otherwise, this algorithm defines a submesh based on \a geom sub-shape. # @param algo values are: smesh.NETGEN, smesh.GHS3D, smesh.GHS3DPRL, smesh.FULL_NETGEN - # @param geom If defined, the subshape to be meshed (GEOM_Object) + # @param geom If defined, the sub-shape to be meshed (GEOM_Object) # @return an instance of Mesh_Tetrahedron algorithm # @ingroup l3_algos_basic def Tetrahedron(self, algo=NETGEN, geom=0): @@ -1009,9 +1412,9 @@ class Mesh: ## Creates a hexahedron 3D algorithm for solids. # If the optional \a geom parameter is not set, this algorithm is global. - # \n Otherwise, this algorithm defines a submesh based on \a geom subshape. + # \n Otherwise, this algorithm defines a submesh based on \a geom sub-shape. # @param algo possible values are: smesh.Hexa, smesh.Hexotic - # @param geom If defined, the subshape to be meshed (GEOM_Object) + # @param geom If defined, the sub-shape to be meshed (GEOM_Object) # @return an instance of Mesh_Hexahedron algorithm # @ingroup l3_algos_basic def Hexahedron(self, algo=Hexa, geom=0): @@ -1029,26 +1432,35 @@ class Mesh: ## Creates a projection 1D algorithm for edges. # If the optional \a geom parameter is not set, this algorithm is global. - # Otherwise, this algorithm defines a submesh based on \a geom subshape. - # @param geom If defined, the subshape to be meshed + # Otherwise, this algorithm defines a submesh based on \a geom sub-shape. + # @param geom If defined, the sub-shape to be meshed # @return an instance of Mesh_Projection1D algorithm # @ingroup l3_algos_proj def Projection1D(self, geom=0): return Mesh_Projection1D(self, geom) + ## Creates a projection 1D-2D algorithm for faces. + # If the optional \a geom parameter is not set, this algorithm is global. + # Otherwise, this algorithm defines a submesh based on \a geom sub-shape. + # @param geom If defined, the sub-shape to be meshed + # @return an instance of Mesh_Projection2D algorithm + # @ingroup l3_algos_proj + def Projection1D2D(self, geom=0): + return Mesh_Projection2D(self, geom, "Projection_1D2D") + ## Creates a projection 2D algorithm for faces. # If the optional \a geom parameter is not set, this algorithm is global. - # Otherwise, this algorithm defines a submesh based on \a geom subshape. - # @param geom If defined, the subshape to be meshed + # Otherwise, this algorithm defines a submesh based on \a geom sub-shape. + # @param geom If defined, the sub-shape to be meshed # @return an instance of Mesh_Projection2D algorithm # @ingroup l3_algos_proj def Projection2D(self, geom=0): - return Mesh_Projection2D(self, geom) + return Mesh_Projection2D(self, geom, "Projection_2D") ## Creates a projection 3D algorithm for solids. # If the optional \a geom parameter is not set, this algorithm is global. - # Otherwise, this algorithm defines a submesh based on \a geom subshape. - # @param geom If defined, the subshape to be meshed + # Otherwise, this algorithm defines a submesh based on \a geom sub-shape. + # @param geom If defined, the sub-shape to be meshed # @return an instance of Mesh_Projection3D algorithm # @ingroup l3_algos_proj def Projection3D(self, geom=0): @@ -1056,8 +1468,8 @@ class Mesh: ## Creates a 3D extrusion (Prism 3D) or RadialPrism 3D algorithm for solids. # If the optional \a geom parameter is not set, this algorithm is global. - # Otherwise, this algorithm defines a submesh based on \a geom subshape. - # @param geom If defined, the subshape to be meshed + # Otherwise, this algorithm defines a submesh based on \a geom sub-shape. + # @param geom If defined, the sub-shape to be meshed # @return an instance of Mesh_Prism3D or Mesh_RadialPrism3D algorithm # @ingroup l3_algos_radialp l3_algos_3dextr def Prism(self, geom=0): @@ -1070,10 +1482,42 @@ class Mesh: return Mesh_Prism3D(self, geom) return Mesh_RadialPrism3D(self, geom) + ## Creates a "Body Fitted" 3D algorithm for solids, which generates + # 3D structured Cartesian mesh in the internal part of a solid shape + # and polyhedral volumes near the shape boundary. + # If the optional \a geom parameter is not set, this algorithm is global. + # Otherwise, this algorithm defines a submesh based on \a geom sub-shape. + # The algorithm does not support submeshes. + # Generally usage of this algorithm as a local one is useless since + # it does not discretize 1D and 2D sub-shapes in a usual way acceptable + # for other algorithms. + # @param geom If defined, the sub-shape to be meshed + # @return an instance of Mesh_Cartesian_3D algorithm + # @ingroup l3_algos_basic + def BodyFitted(self, geom=0): + return Mesh_Cartesian_3D(self, geom) + + ## Evaluates size of prospective mesh on a shape + # @return a list where i-th element is a number of elements of i-th SMESH.EntityType + # To know predicted number of e.g. edges, inquire it this way + # Evaluate()[ EnumToLong( Entity_Edge )] + def Evaluate(self, geom=0): + if geom == 0 or not isinstance(geom, geompyDC.GEOM._objref_GEOM_Object): + if self.geom == 0: + geom = self.mesh.GetShapeToMesh() + else: + geom = self.geom + return self.smeshpyD.Evaluate(self.mesh, geom) + + ## Computes the mesh and returns the status of the computation + # @param geom geomtrical shape on which mesh data should be computed + # @param discardModifs if True and the mesh has been edited since + # a last total re-compute and that may prevent successful partial re-compute, + # then the mesh is cleaned before Compute() # @return True or False # @ingroup l2_construct - def Compute(self, geom=0): + def Compute(self, geom=0, discardModifs=False): if geom == 0 or not isinstance(geom, geompyDC.GEOM._objref_GEOM_Object): if self.geom == 0: geom = self.mesh.GetShapeToMesh() @@ -1081,6 +1525,8 @@ class Mesh: geom = self.geom ok = False try: + if discardModifs and self.mesh.HasModificationsToDiscard(): # issue 0020693 + self.mesh.Clear() ok = self.smeshpyD.Compute(self.mesh, geom) except SALOME.SALOME_Exception, ex: print "Mesh computation failed, exception caught:" @@ -1090,8 +1536,64 @@ class Mesh: print "Mesh computation failed, exception caught:" traceback.print_exc() if True:#not ok: - errors = self.smeshpyD.GetAlgoState( self.mesh, geom ) allReasons = "" + + # Treat compute errors + computeErrors = self.smeshpyD.GetComputeErrors( self.mesh, geom ) + for err in computeErrors: + shapeText = "" + if self.mesh.HasShapeToMesh(): + try: + mainIOR = salome.orb.object_to_string(geom) + for sname in salome.myStudyManager.GetOpenStudies(): + s = salome.myStudyManager.GetStudyByName(sname) + if not s: continue + mainSO = s.FindObjectIOR(mainIOR) + if not mainSO: continue + if err.subShapeID == 1: + shapeText = ' on "%s"' % mainSO.GetName() + subIt = s.NewChildIterator(mainSO) + while subIt.More(): + subSO = subIt.Value() + subIt.Next() + obj = subSO.GetObject() + if not obj: continue + go = obj._narrow( geompyDC.GEOM._objref_GEOM_Object ) + if not go: continue + ids = go.GetSubShapeIndices() + if len(ids) == 1 and ids[0] == err.subShapeID: + shapeText = ' on "%s"' % subSO.GetName() + break + if not shapeText: + shape = self.geompyD.GetSubShape( geom, [err.subShapeID]) + if shape: + shapeText = " on %s #%s" % (shape.GetShapeType(), err.subShapeID) + else: + shapeText = " on subshape #%s" % (err.subShapeID) + except: + shapeText = " on subshape #%s" % (err.subShapeID) + errText = "" + stdErrors = ["OK", #COMPERR_OK + "Invalid input mesh", #COMPERR_BAD_INPUT_MESH + "std::exception", #COMPERR_STD_EXCEPTION + "OCC exception", #COMPERR_OCC_EXCEPTION + "SALOME exception", #COMPERR_SLM_EXCEPTION + "Unknown exception", #COMPERR_EXCEPTION + "Memory allocation problem", #COMPERR_MEMORY_PB + "Algorithm failed", #COMPERR_ALGO_FAILED + "Unexpected geometry"]#COMPERR_BAD_SHAPE + if err.code > 0: + if err.code < len(stdErrors): errText = stdErrors[err.code] + else: + errText = "code %s" % -err.code + if errText: errText += ". " + errText += err.comment + if allReasons != "":allReasons += "\n" + allReasons += '"%s" failed%s. Error: %s' %(err.algoName, shapeText, errText) + pass + + # Treat hyp errors + errors = self.smeshpyD.GetAlgoState( self.mesh, geom ) for err in errors: if err.isGlobalAlgo: glob = "global" @@ -1117,9 +1619,7 @@ class Mesh: reason = "For unknown reason."+\ " Revise Mesh.Compute() implementation in smeshDC.py!" pass - if allReasons != "": - allReasons += "\n" - pass + if allReasons != "":allReasons += "\n" allReasons += reason pass if allReasons != "": @@ -1138,6 +1638,18 @@ class Mesh: pass return ok + ## Return submesh objects list in meshing order + # @return list of list of submesh objects + # @ingroup l2_construct + def GetMeshOrder(self): + return self.mesh.GetMeshOrder() + + ## Return submesh objects list in meshing order + # @return list of list of submesh objects + # @ingroup l2_construct + def SetMeshOrder(self, submeshes): + return self.mesh.SetMeshOrder(submeshes) + ## Removes all nodes and elements # @ingroup l2_construct def Clear(self): @@ -1159,7 +1671,7 @@ class Mesh: salome.sg.updateObjBrowser(1) ## Computes a tetrahedral mesh using AutomaticLength + MEFISTO + NETGEN - # @param fineness [0,-1] defines mesh fineness + # @param fineness [0.0,1.0] defines mesh fineness # @return True or False # @ingroup l3_algos_basic def AutomaticTetrahedralization(self, fineness=0): @@ -1176,7 +1688,7 @@ class Mesh: return self.Compute() ## Computes an hexahedral mesh using AutomaticLength + Quadrangle + Hexahedron - # @param fineness [0,-1] defines mesh fineness + # @param fineness [0.0, 1.0] defines mesh fineness # @return True or False # @ingroup l3_algos_basic def AutomaticHexahedralization(self, fineness=0): @@ -1208,12 +1720,33 @@ class Mesh: pass status = self.mesh.AddHypothesis(geom, hyp) isAlgo = hyp._narrow( SMESH_Algo ) - TreatHypoStatus( status, GetName( hyp ), GetName( geom ), isAlgo ) + hyp_name = GetName( hyp ) + geom_name = "" + if geom: + geom_name = GetName( geom ) + 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 + # @param geom a subhape of mesh geometry + # @return True of False + # @ingroup l2_hypotheses + def IsUsedHypothesis(self, hyp, geom): + if not hyp or not geom: + return False + if isinstance( hyp, Mesh_Algorithm ): + hyp = hyp.GetAlgorithm() + pass + hyps = self.GetHypothesisList(geom) + for h in hyps: + if h.GetId() == hyp.GetId(): + return True + return False + ## Unassigns a hypothesis # @param hyp a hypothesis to unassign - # @param geom a subshape of mesh geometry + # @param geom a sub-shape of mesh geometry # @return SMESH.Hypothesis_Status # @ingroup l2_hypotheses def RemoveHypothesis(self, hyp, geom=0): @@ -1227,7 +1760,7 @@ class Mesh: return status ## Gets the list of hypotheses added on a geometry - # @param geom a subshape of mesh geometry + # @param geom a sub-shape of mesh geometry # @return the sequence of SMESH_Hypothesis # @ingroup l2_hypotheses def GetHypothesisList(self, geom): @@ -1242,54 +1775,95 @@ class Mesh: pass pass - ## Creates a mesh group based on the geometric object \a grp - # and gives a \a name, \n if this parameter is not defined - # the name is the same as the geometric group name \n - # Note: Works like GroupOnGeom(). - # @param grp a geometric group, a vertex, an edge, a face or a solid - # @param name the name of the mesh group - # @return SMESH_GroupOnGeom - # @ingroup l2_grps_create - def Group(self, grp, name=""): - return self.GroupOnGeom(grp, name) - - ## Deprecated, used only for compatibility! Please, use ExportMED() method instead. + ## Deprecated, used only for compatibility! Please, use ExportToMEDX() method instead. # Exports the mesh in a file in MED format and chooses the \a version of MED format + ## allowing to overwrite the file if it exists or add the exported data to its contents # @param f the file name # @param version values are SMESH.MED_V2_1, SMESH.MED_V2_2 + # @param opt boolean parameter for creating/not creating + # the groups Group_On_All_Nodes, Group_On_All_Faces, ... + # @param overwrite boolean parameter for overwriting/not overwriting the file # @ingroup l2_impexp - def ExportToMED(self, f, version, opt=0): - self.mesh.ExportToMED(f, opt, version) + def ExportToMED(self, f, version, opt=0, overwrite=1): + self.mesh.ExportToMEDX(f, opt, version, overwrite) - ## Exports the mesh in a file in MED format + ## Exports the mesh in a file in MED format and chooses the \a version of MED format + ## allowing to overwrite the file if it exists or add the exported data to its contents # @param f is the file name # @param auto_groups boolean parameter for creating/not creating # the groups Group_On_All_Nodes, Group_On_All_Faces, ... ; # the typical use is auto_groups=false. # @param version MED format version(MED_V2_1 or MED_V2_2) + # @param overwrite boolean parameter for overwriting/not overwriting the file + # @param meshPart a part of mesh (group, sub-mesh) to export instead of the mesh + # @ingroup l2_impexp + def ExportMED(self, f, auto_groups=0, version=MED_V2_2, overwrite=1, meshPart=None): + if meshPart: + if isinstance( meshPart, list ): + meshPart = self.GetIDSource( meshPart, SMESH.ALL ) + self.mesh.ExportPartToMED( meshPart, f, auto_groups, version, overwrite ) + else: + self.mesh.ExportToMEDX(f, auto_groups, version, overwrite) + + ## Exports the mesh in a file in SAUV format + # @param f is the file name + # @param auto_groups boolean parameter for creating/not creating + # the groups Group_On_All_Nodes, Group_On_All_Faces, ... ; + # the typical use is auto_groups=false. # @ingroup l2_impexp - def ExportMED(self, f, auto_groups=0, version=MED_V2_2): - self.mesh.ExportToMED(f, auto_groups, version) + def ExportSAUV(self, f, auto_groups=0): + self.mesh.ExportSAUV(f, auto_groups) ## Exports the mesh in a file in DAT format # @param f the file name + # @param meshPart a part of mesh (group, sub-mesh) to export instead of the mesh # @ingroup l2_impexp - def ExportDAT(self, f): - self.mesh.ExportDAT(f) + def ExportDAT(self, f, meshPart=None): + if meshPart: + if isinstance( meshPart, list ): + meshPart = self.GetIDSource( meshPart, SMESH.ALL ) + self.mesh.ExportPartToDAT( meshPart, f ) + else: + self.mesh.ExportDAT(f) ## Exports the mesh in a file in UNV format # @param f the file name + # @param meshPart a part of mesh (group, sub-mesh) to export instead of the mesh # @ingroup l2_impexp - def ExportUNV(self, f): - self.mesh.ExportUNV(f) + def ExportUNV(self, f, meshPart=None): + if meshPart: + if isinstance( meshPart, list ): + meshPart = self.GetIDSource( meshPart, SMESH.ALL ) + self.mesh.ExportPartToUNV( meshPart, f ) + else: + self.mesh.ExportUNV(f) ## Export the mesh in a file in STL format # @param f the file name # @param ascii defines the file encoding + # @param meshPart a part of mesh (group, sub-mesh) to export instead of the mesh # @ingroup l2_impexp - def ExportSTL(self, f, ascii=1): - self.mesh.ExportSTL(f, ascii) + def ExportSTL(self, f, ascii=1, meshPart=None): + if meshPart: + if isinstance( meshPart, list ): + meshPart = self.GetIDSource( meshPart, SMESH.ALL ) + self.mesh.ExportPartToSTL( meshPart, f, ascii ) + else: + self.mesh.ExportSTL(f, ascii) + ## Exports the mesh in a file in CGNS format + # @param f is the file name + # @param overwrite boolean parameter for overwriting/not overwriting the file + # @param meshPart a part of mesh (group, sub-mesh) to export instead of the mesh + # @ingroup l2_impexp + def ExportCGNS(self, f, overwrite=1, meshPart=None): + if isinstance( meshPart, list ): + meshPart = self.GetIDSource( meshPart, SMESH.ALL ) + if isinstance( meshPart, Mesh ): + meshPart = meshPart.mesh + elif not meshPart: + meshPart = self.mesh + self.mesh.ExportCGNS(meshPart, f, overwrite) # Operations with groups: # ---------------------- @@ -1302,6 +1876,17 @@ class Mesh: def CreateEmptyGroup(self, elementType, name): return self.mesh.CreateGroup(elementType, name) + ## Creates a mesh group based on the geometric object \a grp + # and gives a \a name, \n if this parameter is not defined + # the name is the same as the geometric group name \n + # Note: Works like GroupOnGeom(). + # @param grp a geometric group, a vertex, an edge, a face or a solid + # @param name the name of the mesh group + # @return SMESH_GroupOnGeom + # @ingroup l2_grps_create + def Group(self, grp, name=""): + return self.GroupOnGeom(grp, name) + ## Creates a mesh group based on the geometrical object \a grp # and gives a \a name, \n if this parameter is not defined # the name is the same as the geometrical group name @@ -1312,40 +1897,44 @@ class Mesh: # @return SMESH_GroupOnGeom # @ingroup l2_grps_create def GroupOnGeom(self, grp, name="", typ=None): + AssureGeomPublished( self, grp, name ) if name == "": name = grp.GetName() - - if typ == None: - tgeo = str(grp.GetShapeType()) - if tgeo == "VERTEX": - typ = NODE - elif tgeo == "EDGE": - typ = EDGE - elif tgeo == "FACE": - typ = FACE - elif tgeo == "SOLID": - typ = VOLUME - elif tgeo == "SHELL": - typ = VOLUME - elif tgeo == "COMPOUND": - if len( self.geompyD.GetObjectIDs( grp )) == 0: - print "Mesh.Group: empty geometric group", GetName( grp ) - return 0 - tgeo = self.geompyD.GetType(grp) - if tgeo == geompyDC.ShapeType["VERTEX"]: - typ = NODE - elif tgeo == geompyDC.ShapeType["EDGE"]: - typ = EDGE - elif tgeo == geompyDC.ShapeType["FACE"]: - typ = FACE - elif tgeo == geompyDC.ShapeType["SOLID"]: - typ = VOLUME - - if typ == None: - print "Mesh.Group: bad first argument: expected a group, a vertex, an edge, a face or a solid" - return 0 + if not typ: + typ = self._groupTypeFromShape( grp ) + return self.mesh.CreateGroupFromGEOM(typ, name, grp) + + ## Pivate method to get a type of group on geometry + def _groupTypeFromShape( self, shape ): + tgeo = str(shape.GetShapeType()) + if tgeo == "VERTEX": + typ = NODE + elif tgeo == "EDGE": + typ = EDGE + elif tgeo == "FACE" or tgeo == "SHELL": + typ = FACE + elif tgeo == "SOLID" or tgeo == "COMPSOLID": + typ = VOLUME + elif tgeo == "COMPOUND": + sub = self.geompyD.SubShapeAll( shape, geompyDC.ShapeType["SHAPE"]) + if not sub: + raise ValueError,"_groupTypeFromShape(): empty geometric group or compound '%s'" % GetName(shape) + return self._groupTypeFromShape( sub[0] ) else: - return self.mesh.CreateGroupFromGEOM(typ, name, grp) + raise ValueError, \ + "_groupTypeFromShape(): invalid geometry '%s'" % GetName(shape) + return typ + + ## Creates a mesh group with given \a name based on the \a filter which + ## is a special type of group dynamically updating it's contents during + ## mesh modification + # @param typ the type of elements in the group + # @param name the name of the mesh group + # @param filter the filter defining group contents + # @return SMESH_GroupOnFilter + # @ingroup l2_grps_create + def GroupOnFilter(self, typ, name, filter): + return self.mesh.CreateGroupFromFilter(typ, name, filter) ## Creates a mesh group by the given ids of elements # @param groupName the name of the mesh group @@ -1363,8 +1952,10 @@ class Mesh: # @param elementType the type of elements in the group # @param CritType the type of criterion( FT_Taper, FT_Area, FT_RangeOfIds, FT_LyingOnGeom etc. ) # @param Compare belongs to {FT_LessThan, FT_MoreThan, FT_EqualTo} - # @param Treshold the threshold value (range of id ids as string, shape, numeric) + # @param Threshold the threshold value (range of id ids as string, shape, numeric) # @param UnaryOp FT_LogicalNOT or FT_Undefined + # @param Tolerance the tolerance used by FT_BelongToGeom, FT_BelongToSurface, + # FT_LyingOnGeom, FT_CoplanarFaces criteria # @return SMESH_Group # @ingroup l2_grps_create def MakeGroup(self, @@ -1372,9 +1963,10 @@ class Mesh: elementType, CritType=FT_Undefined, Compare=FT_EqualTo, - Treshold="", - UnaryOp=FT_Undefined): - aCriterion = self.smeshpyD.GetCriterion(elementType, CritType, Compare, Treshold, UnaryOp, FT_Undefined) + Threshold="", + UnaryOp=FT_Undefined, + Tolerance=1e-07): + aCriterion = self.smeshpyD.GetCriterion(elementType, CritType, Compare, Threshold, UnaryOp, FT_Undefined,Tolerance) group = self.MakeGroupByCriterion(groupName, aCriterion) return group @@ -1390,6 +1982,7 @@ class Mesh: aCriteria.append(Criterion) aFilter.SetCriteria(aCriteria) group = self.MakeGroupByFilter(groupName, aFilter) + aFilterMgr.UnRegister() return group ## Creates a mesh group by the given criteria (list of criteria) @@ -1402,6 +1995,7 @@ class Mesh: aFilter = aFilterMgr.CreateFilter() aFilter.SetCriteria(theCriteria) group = self.MakeGroupByFilter(groupName, aFilter) + aFilterMgr.UnRegister() return group ## Creates a mesh group by the given filter @@ -1410,9 +2004,9 @@ class Mesh: # @return SMESH_Group # @ingroup l2_grps_create def MakeGroupByFilter(self, groupName, theFilter): - anIds = theFilter.GetElementsId(self.mesh) - anElemType = theFilter.GetElementType() - group = self.MakeGroupByIds(groupName, anElemType, anIds) + group = self.CreateEmptyGroup(theFilter.GetElementType(), groupName) + theFilter.SetMesh( self.mesh ) + group.AddFrom( theFilter ) return group ## Passes mesh elements through the given filter and return IDs of fitting elements @@ -1420,7 +2014,8 @@ class Mesh: # @return a list of ids # @ingroup l1_controls def GetIdsFromFilter(self, theFilter): - return theFilter.GetElementsId(self.mesh) + theFilter.SetMesh( self.mesh ) + return theFilter.GetIDs() ## Verifies whether a 2D mesh element has free edges (edges connected to one face only)\n # Returns a list of special structures (borders). @@ -1431,6 +2026,7 @@ class Mesh: aPredicate = aFilterMgr.CreateFreeEdges() aPredicate.SetMesh(self.mesh) aBorders = aPredicate.GetBorders() + aFilterMgr.UnRegister() return aBorders ## Removes a group @@ -1472,15 +2068,15 @@ class Mesh: # @ingroup l2_grps_operon def UnionGroups(self, group1, group2, name): return self.mesh.UnionGroups(group1, group2, name) - + ## Produces a union list of groups - # New group is created. All mesh elements that are present in + # New group is created. All mesh elements that are present in # initial groups are added to the new one # @return an instance of SMESH_Group # @ingroup l2_grps_operon def UnionListOfGroups(self, groups, name): return self.mesh.UnionListOfGroups(groups, name) - + ## Prodices an intersection of two groups # A new group is created. All mesh elements that are common # for the two initial groups are added to the new one. @@ -1488,9 +2084,9 @@ class Mesh: # @ingroup l2_grps_operon def IntersectGroups(self, group1, group2, name): return self.mesh.IntersectGroups(group1, group2, name) - + ## Produces an intersection of groups - # New group is created. All mesh elements that are present in all + # New group is created. All mesh elements that are present in all # initial groups simultaneously are added to the new one # @return an instance of SMESH_Group # @ingroup l2_grps_operon @@ -1504,19 +2100,19 @@ class Mesh: # @ingroup l2_grps_operon def CutGroups(self, main_group, tool_group, name): return self.mesh.CutGroups(main_group, tool_group, name) - + ## Produces a cut of groups - # A new group is created. All mesh elements that are present in main groups + # A new group is created. All mesh elements that are present in main groups # but do not present in tool groups are added to the new one # @return an instance of SMESH_Group # @ingroup l2_grps_operon def CutListOfGroups(self, main_groups, tool_groups, name): return self.mesh.CutListOfGroups(main_groups, tool_groups, name) - - ## Produces a group of elements with specified element type using list of existing groups - # A new group is created. System - # 1) extract all nodes on which groups elements are built - # 2) combine all elements of specified dimension laying on these nodes + + ## Produces a group of elements of specified type using list of existing groups + # A new group is created. System + # 1) extracts all nodes on which groups elements are built + # 2) combines all elements of specified dimension laying on these nodes # @return an instance of SMESH_Group # @ingroup l2_grps_operon def CreateDimGroup(self, groups, elem_type, name): @@ -1586,6 +2182,13 @@ class Mesh: def GetMeshEditor(self): return self.mesh.GetMeshEditor() + ## Wrap a list of IDs of elements or nodes into SMESH_IDSource which + # can be passed as argument to accepting mesh, group or sub-mesh + # @return an instance of SMESH_IDSource + # @ingroup l1_auxiliary + def GetIDSource(self, ids, elemType): + return self.GetMeshEditor().MakeIDSource(ids, elemType) + ## Gets MED Mesh # @return an instance of SALOME_MED::MESH # @ingroup l1_auxiliary @@ -1596,6 +2199,13 @@ class Mesh: # Get informations about mesh contents: # ------------------------------------ + ## Gets the mesh stattistic + # @return dictionary type element - count of elements + # @ingroup l1_meshinfo + def GetMeshInfo(self, obj = None): + if not obj: obj = self.mesh + return self.smeshpyD.GetMeshInfo(obj) + ## Returns the number of nodes in the mesh # @return an integer value # @ingroup l1_meshinfo @@ -1608,6 +2218,12 @@ class Mesh: def NbElements(self): return self.mesh.NbElements() + ## Returns the number of 0d elements in the mesh + # @return an integer value + # @ingroup l1_meshinfo + def Nb0DElements(self): + return self.mesh.Nb0DElements() + ## Returns the number of edges in the mesh # @return an integer value # @ingroup l1_meshinfo @@ -1664,6 +2280,12 @@ class Mesh: def NbQuadranglesOfOrder(self, elementOrder): return self.mesh.NbQuadranglesOfOrder(elementOrder) + ## Returns the number of biquadratic quadrangles in the mesh + # @return an integer value + # @ingroup l1_meshinfo + def NbBiQuadQuadrangles(self): + return self.mesh.NbBiQuadQuadrangles() + ## Returns the number of polygons in the mesh # @return an integer value # @ingroup l1_meshinfo @@ -1712,6 +2334,12 @@ class Mesh: def NbHexasOfOrder(self, elementOrder): return self.mesh.NbHexasOfOrder(elementOrder) + ## Returns the number of triquadratic hexahedrons in the mesh + # @return an integer value + # @ingroup l1_meshinfo + def NbTriQuadraticHexas(self): + return self.mesh.NbTriQuadraticHexas() + ## Returns the number of pyramids in the mesh # @return an integer value # @ingroup l1_meshinfo @@ -1740,6 +2368,12 @@ class Mesh: def NbPrismsOfOrder(self, elementOrder): return self.mesh.NbPrismsOfOrder(elementOrder) + ## Returns the number of hexagonal prisms in the mesh + # @return an integer value + # @ingroup l1_meshinfo + def NbHexagonalPrisms(self): + return self.mesh.NbHexagonalPrisms() + ## Returns the number of polyhedrons in the mesh # @return an integer value # @ingroup l1_meshinfo @@ -1759,7 +2393,7 @@ class Mesh: return self.mesh.GetElementsId() ## Returns the list of IDs of mesh elements with the given type - # @param elementType the required type of elements + # @param elementType the required type of elements (SMESH.NODE, SMESH.EDGE, SMESH.FACE or SMESH.VOLUME) # @return list of integer values # @ingroup l1_meshinfo def GetElementsByType(self, elementType): @@ -1780,9 +2414,15 @@ class Mesh: def GetElementType(self, id, iselem): return self.mesh.GetElementType(id, iselem) + ## Returns the geometric type of mesh element + # @return the value from SMESH::EntityType enumeration + # @ingroup l1_meshinfo + def GetElementGeomType(self, id): + return self.mesh.GetElementGeomType(id) + ## Returns the list of submesh elements IDs - # @param Shape a geom object(subshape) IOR - # Shape must be the subshape of a ShapeToMesh() + # @param Shape a geom object(sub-shape) IOR + # Shape must be the sub-shape of a ShapeToMesh() # @return the list of integer values # @ingroup l1_meshinfo def GetSubMeshElementsId(self, Shape): @@ -1793,8 +2433,8 @@ class Mesh: return self.mesh.GetSubMeshElementsId(ShapeID) ## Returns the list of submesh nodes IDs - # @param Shape a geom object(subshape) IOR - # Shape must be the subshape of a ShapeToMesh() + # @param Shape a geom object(sub-shape) IOR + # Shape must be the sub-shape of a ShapeToMesh() # @param all If true, gives all nodes of submesh elements, otherwise gives only submesh nodes # @return the list of integer values # @ingroup l1_meshinfo @@ -1805,10 +2445,10 @@ class Mesh: ShapeID = Shape return self.mesh.GetSubMeshNodesId(ShapeID, all) - ## Returns the list of IDs of submesh elements with the given type - # @param Shape a geom object(subshape) IOR - # Shape must be a subshape of a ShapeToMesh() - # @return the list of integer values + ## Returns type of elements on given shape + # @param Shape a geom object(sub-shape) IOR + # Shape must be a sub-shape of a ShapeToMesh() + # @return element type # @ingroup l1_meshinfo def GetSubMeshElementType(self, Shape): if ( isinstance( Shape, geompyDC.GEOM._objref_GEOM_Object)): @@ -1903,6 +2543,16 @@ class Mesh: def ElemNbFaces(self, id): return self.mesh.ElemNbFaces(id) + ## Returns nodes of given face (counted from zero) for given volumic element. + # @ingroup l1_meshinfo + def GetElemFaceNodes(self,elemId, faceIndex): + return self.mesh.GetElemFaceNodes(elemId, faceIndex) + + ## Returns an element based on all given nodes. + # @ingroup l1_meshinfo + def FindElementByNodes(self,nodes): + return self.mesh.FindElementByNodes(nodes) + ## Returns true if the given element is a polygon # @ingroup l1_meshinfo def IsPoly(self, id): @@ -1921,6 +2571,95 @@ class Mesh: return self.mesh.BaryCenter(id) + # Get mesh measurements information: + # ------------------------------------ + + ## Get minimum distance between two nodes, elements or distance to the origin + # @param id1 first node/element id + # @param id2 second node/element id (if 0, distance from @a id1 to the origin is computed) + # @param isElem1 @c True if @a id1 is element id, @c False if it is node id + # @param isElem2 @c True if @a id2 is element id, @c False if it is node id + # @return minimum distance value + # @sa GetMinDistance() + def MinDistance(self, id1, id2=0, isElem1=False, isElem2=False): + aMeasure = self.GetMinDistance(id1, id2, isElem1, isElem2) + return aMeasure.value + + ## Get measure structure specifying minimum distance data between two objects + # @param id1 first node/element id + # @param id2 second node/element id (if 0, distance from @a id1 to the origin is computed) + # @param isElem1 @c True if @a id1 is element id, @c False if it is node id + # @param isElem2 @c True if @a id2 is element id, @c False if it is node id + # @return Measure structure + # @sa MinDistance() + def GetMinDistance(self, id1, id2=0, isElem1=False, isElem2=False): + if isElem1: + id1 = self.editor.MakeIDSource([id1], SMESH.FACE) + else: + id1 = self.editor.MakeIDSource([id1], SMESH.NODE) + if id2 != 0: + if isElem2: + id2 = self.editor.MakeIDSource([id2], SMESH.FACE) + else: + id2 = self.editor.MakeIDSource([id2], SMESH.NODE) + pass + else: + id2 = None + + aMeasurements = self.smeshpyD.CreateMeasurements() + aMeasure = aMeasurements.MinDistance(id1, id2) + aMeasurements.UnRegister() + return aMeasure + + ## Get bounding box of the specified object(s) + # @param objects single source object or list of source objects or list of nodes/elements IDs + # @param isElem if @a objects is a list of IDs, @c True value in this parameters specifies that @a objects are elements, + # @c False specifies that @a objects are nodes + # @return tuple of six values (minX, minY, minZ, maxX, maxY, maxZ) + # @sa GetBoundingBox() + def BoundingBox(self, objects=None, isElem=False): + result = self.GetBoundingBox(objects, isElem) + if result is None: + result = (0.0,)*6 + else: + result = (result.minX, result.minY, result.minZ, result.maxX, result.maxY, result.maxZ) + return result + + ## Get measure structure specifying bounding box data of the specified object(s) + # @param IDs single source object or list of source objects or list of nodes/elements IDs + # @param isElem if @a objects is a list of IDs, @c True value in this parameters specifies that @a objects are elements, + # @c False specifies that @a objects are nodes + # @return Measure structure + # @sa BoundingBox() + def GetBoundingBox(self, IDs=None, isElem=False): + if IDs is None: + IDs = [self.mesh] + elif isinstance(IDs, tuple): + IDs = list(IDs) + if not isinstance(IDs, list): + IDs = [IDs] + if len(IDs) > 0 and isinstance(IDs[0], int): + IDs = [IDs] + srclist = [] + for o in IDs: + if isinstance(o, Mesh): + srclist.append(o.mesh) + elif hasattr(o, "_narrow"): + src = o._narrow(SMESH.SMESH_IDSource) + if src: srclist.append(src) + pass + elif isinstance(o, list): + if isElem: + srclist.append(self.editor.MakeIDSource(o, SMESH.FACE)) + else: + srclist.append(self.editor.MakeIDSource(o, SMESH.NODE)) + pass + pass + aMeasurements = self.smeshpyD.CreateMeasurements() + aMeasure = aMeasurements.BoundingBox(srclist) + aMeasurements.UnRegister() + return aMeasure + # Mesh edition (SMESH_MeshEditor functionality): # --------------------------------------------- @@ -1938,6 +2677,12 @@ class Mesh: def RemoveNodes(self, IDsOfNodes): return self.editor.RemoveNodes(IDsOfNodes) + ## Removes all orphan (free) nodes from mesh + # @return number of the removed nodes + # @ingroup l2_modif_del + def RemoveOrphanNodes(self): + return self.editor.RemoveOrphanNodes() + ## Add a node to the mesh by coordinates # @return Id of the new node # @ingroup l2_modif_add @@ -1946,12 +2691,19 @@ class Mesh: self.mesh.SetParameters(Parameters) return self.editor.AddNode( x, y, z) + ## Creates a 0D element on a node with given number. + # @param IDOfNode the ID of node for creation of the element. + # @return the Id of the new 0D element + # @ingroup l2_modif_add + def Add0DElement(self, IDOfNode): + return self.editor.Add0DElement(IDOfNode) + ## Creates a linear or quadratic edge (this is determined # by the number of given nodes). # @param IDsOfNodes the list of node IDs for creation of the element. # The order of nodes in this list should correspond to the description # of MED. \n This description is located by the following link: - # http://www.salome-platform.org/salome2/web_med_internet/logiciels/medV2.2.2_doc_html/html/modele_de_donnees.html#3. + # http://www.code-aster.org/outils/med/html/modele_de_donnees.html#3. # @return the Id of the new edge # @ingroup l2_modif_add def AddEdge(self, IDsOfNodes): @@ -1962,7 +2714,7 @@ class Mesh: # @param IDsOfNodes the list of node IDs for creation of the element. # The order of nodes in this list should correspond to the description # of MED. \n This description is located by the following link: - # http://www.salome-platform.org/salome2/web_med_internet/logiciels/medV2.2.2_doc_html/html/modele_de_donnees.html#3. + # http://www.code-aster.org/outils/med/html/modele_de_donnees.html#3. # @return the Id of the new face # @ingroup l2_modif_add def AddFace(self, IDsOfNodes): @@ -1980,7 +2732,7 @@ class Mesh: # @param IDsOfNodes the list of node IDs for creation of the element. # The order of nodes in this list should correspond to the description # of MED. \n This description is located by the following link: - # http://www.salome-platform.org/salome2/web_med_internet/logiciels/medV2.2.2_doc_html/html/modele_de_donnees.html#3. + # http://www.code-aster.org/outils/med/html/modele_de_donnees.html#3. # @return the Id of the new volumic element # @ingroup l2_modif_add def AddVolume(self, IDsOfNodes): @@ -2107,6 +2859,8 @@ class Mesh: # @param x the X coordinate of a point # @param y the Y coordinate of a point # @param z the Z coordinate of a point + # @param NodeID if specified (>0), the node with this ID is moved, + # otherwise, the node closest to point (@a x,@a y,@a z) is moved # @return the ID of a node # @ingroup l2_modif_throughp def MoveClosestNodeToPoint(self, x, y, z, NodeID): @@ -2121,10 +2875,32 @@ class Mesh: # @return the ID of a node # @ingroup l2_modif_throughp def FindNodeClosestTo(self, x, y, z): - preview = self.mesh.GetMeshEditPreviewer() - return preview.MoveClosestNodeToPoint(x, y, z, -1) + #preview = self.mesh.GetMeshEditPreviewer() + #return preview.MoveClosestNodeToPoint(x, y, z, -1) + return self.editor.FindNodeClosestTo(x, y, z) - ## Finds the node closest to a point and moves it to a point location + ## Finds the elements where a point lays IN or ON + # @param x the X coordinate of a point + # @param y the Y coordinate of a point + # @param z the Z coordinate of a point + # @param elementType type of elements to find (SMESH.ALL type + # means elements of any type excluding nodes and 0D elements) + # @param meshPart a part of mesh (group, sub-mesh) to search within + # @return list of IDs of found elements + # @ingroup l2_modif_throughp + def FindElementsByPoint(self, x, y, z, elementType = SMESH.ALL, meshPart=None): + if meshPart: + return self.editor.FindAmongElementsByPoint( meshPart, x, y, z, elementType ); + else: + return self.editor.FindElementsByPoint(x, y, z, elementType) + + # Return point state in a closed 2D mesh in terms of TopAbs_State enumeration. + # TopAbs_UNKNOWN state means that either mesh is wrong or the analysis fails. + + def GetPointState(self, x, y, z): + return self.editor.GetPointState(x, y, z) + + ## Finds the node closest to a point and moves it to a point location # @param x the X coordinate of a point # @param y the Y coordinate of a point # @param z the Z coordinate of a point @@ -2188,7 +2964,7 @@ class Mesh: IDsOfElements = self.GetElementsId() self.mesh.SetParameters(Parameters) Functor = 0 - if ( isinstance( theCriterion, SMESH._objref_NumericalFunctor ) ): + if ( isinstance( theCriterion, SMESH._objref_NumericalFunctor ) ): Functor = theCriterion else: Functor = self.smeshpyD.GetFunctor(theCriterion) @@ -2255,6 +3031,18 @@ class Mesh: def BestSplit (self, IDOfQuad, theCriterion): return self.editor.BestSplit(IDOfQuad, self.smeshpyD.GetFunctor(theCriterion)) + ## Splits volumic elements into tetrahedrons + # @param elemIDs either list of elements or mesh or group or submesh + # @param method flags passing splitting method: Hex_5Tet, Hex_6Tet, Hex_24Tet + # Hex_5Tet - split the hexahedron into 5 tetrahedrons, etc + # @ingroup l2_modif_cutquadr + def SplitVolumesIntoTetra(self, elemIDs, method=Hex_5Tet ): + if isinstance( elemIDs, Mesh ): + elemIDs = elemIDs.GetMesh() + if ( isinstance( elemIDs, list )): + elemIDs = self.editor.MakeIDSource(elemIDs, SMESH.VOLUME) + self.editor.SplitVolumesIntoTetra(elemIDs, method) + ## Splits quadrangle faces near triangular facets of volumes # # @ingroup l1_auxiliary @@ -2467,17 +3255,86 @@ class Mesh: ## Converts the mesh to quadratic, deletes old elements, replacing # them with quadratic with the same id. + # @param theForce3d new node creation method: + # 0 - the medium node lies at the geometrical entity from which the mesh element is built + # 1 - the medium node lies at the middle of the line segments connecting start and end node of a mesh element + # @param theSubMesh a group or a sub-mesh to convert; WARNING: in this case the mesh can become not conformal # @ingroup l2_modif_tofromqu - def ConvertToQuadratic(self, theForce3d): - self.editor.ConvertToQuadratic(theForce3d) + def ConvertToQuadratic(self, theForce3d, theSubMesh=None): + if theSubMesh: + self.editor.ConvertToQuadraticObject(theForce3d,theSubMesh) + else: + self.editor.ConvertToQuadratic(theForce3d) ## Converts the mesh from quadratic to ordinary, # deletes old quadratic elements, \n replacing # them with ordinary mesh elements with the same id. - # @return TRUE in case of success, FALSE otherwise. + # @param theSubMesh a group or a sub-mesh to convert; WARNING: in this case the mesh can become not conformal # @ingroup l2_modif_tofromqu - def ConvertFromQuadratic(self): - return self.editor.ConvertFromQuadratic() + def ConvertFromQuadratic(self, theSubMesh=None): + if theSubMesh: + self.editor.ConvertFromQuadraticObject(theSubMesh) + else: + return self.editor.ConvertFromQuadratic() + + ## Creates 2D mesh as skin on boundary faces of a 3D mesh + # @return TRUE if operation has been completed successfully, FALSE otherwise + # @ingroup l2_modif_edit + def Make2DMeshFrom3D(self): + return self.editor. Make2DMeshFrom3D() + + ## Creates missing boundary elements + # @param elements - elements whose boundary is to be checked: + # mesh, group, sub-mesh or list of elements + # if elements is mesh, it must be the mesh whose MakeBoundaryMesh() is called + # @param dimension - defines type of boundary elements to create: + # SMESH.BND_2DFROM3D, SMESH.BND_1DFROM3D, SMESH.BND_1DFROM2D + # SMESH.BND_1DFROM3D creates mesh edges on all borders of free facets of 3D cells + # @param groupName - a name of group to store created boundary elements in, + # "" means not to create the group + # @param meshName - a name of new mesh to store created boundary elements in, + # "" means not to create the new mesh + # @param toCopyElements - if true, the checked elements will be copied into + # the new mesh else only boundary elements will be copied into the new mesh + # @param toCopyExistingBondary - if true, not only new but also pre-existing + # boundary elements will be copied into the new mesh + # @return tuple (mesh, group) where bondary elements were added to + # @ingroup l2_modif_edit + def MakeBoundaryMesh(self, elements, dimension=SMESH.BND_2DFROM3D, groupName="", meshName="", + toCopyElements=False, toCopyExistingBondary=False): + if isinstance( elements, Mesh ): + elements = elements.GetMesh() + if ( isinstance( elements, list )): + elemType = SMESH.ALL + if elements: elemType = self.GetElementType( elements[0], iselem=True) + elements = self.editor.MakeIDSource(elements, elemType) + mesh, group = self.editor.MakeBoundaryMesh(elements,dimension,groupName,meshName, + toCopyElements,toCopyExistingBondary) + if mesh: mesh = self.smeshpyD.Mesh(mesh) + return mesh, group + + ## + # @brief Creates missing boundary elements around either the whole mesh or + # groups of 2D elements + # @param dimension - defines type of boundary elements to create + # @param groupName - a name of group to store all boundary elements in, + # "" means not to create the group + # @param meshName - a name of a new mesh, which is a copy of the initial + # mesh + created boundary elements; "" means not to create the new mesh + # @param toCopyAll - if true, the whole initial mesh will be copied into + # the new mesh else only boundary elements will be copied into the new mesh + # @param groups - groups of 2D elements to make boundary around + # @retval tuple( long, mesh, groups ) + # long - number of added boundary elements + # mesh - the mesh where elements were added to + # group - the group of boundary elements or None + # + def MakeBoundaryElements(self, dimension=SMESH.BND_2DFROM3D, groupName="", meshName="", + toCopyAll=False, groups=[]): + nb, mesh, group = self.editor.MakeBoundaryElements(dimension,groupName,meshName, + toCopyAll,groups) + if mesh: mesh = self.smeshpyD.Mesh(mesh) + return nb, mesh, group ## Renumber mesh nodes # @ingroup l2_modif_renumber @@ -2525,7 +3382,8 @@ class Mesh: return [] ## Generates new elements by rotation of the elements of object around the axis - # @param theObject object which elements should be sweeped + # @param theObject object which elements should be sweeped. + # It can be a mesh, a sub mesh or a group. # @param Axis the axis of rotation, AxisStruct or line(geom object) # @param AngleInRadians the angle of Rotation # @param NbOfSteps number of steps @@ -2560,7 +3418,8 @@ class Mesh: return [] ## Generates new elements by rotation of the elements of object around the axis - # @param theObject object which elements should be sweeped + # @param theObject object which elements should be sweeped. + # It can be a mesh, a sub mesh or a group. # @param Axis the axis of rotation, AxisStruct or line(geom object) # @param AngleInRadians the angle of Rotation # @param NbOfSteps number of steps @@ -2595,7 +3454,8 @@ class Mesh: return [] ## Generates new elements by rotation of the elements of object around the axis - # @param theObject object which elements should be sweeped + # @param theObject object which elements should be sweeped. + # It can be a mesh, a sub mesh or a group. # @param Axis the axis of rotation, AxisStruct or line(geom object) # @param AngleInRadians the angle of Rotation # @param NbOfSteps number of steps @@ -2631,12 +3491,13 @@ class Mesh: ## Generates new elements by extrusion of the elements with given ids # @param IDsOfElements the list of elements ids for extrusion - # @param StepVector vector, defining the direction and value of extrusion + # @param StepVector vector or DirStruct, defining the direction and value of extrusion for one step (the total extrusion length will be NbOfSteps * ||StepVector||) # @param NbOfSteps the number of steps # @param MakeGroups forces the generation of new groups from existing ones + # @param IsNodes is True if elements with given ids are nodes # @return the list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise # @ingroup l2_modif_extrurev - def ExtrusionSweep(self, IDsOfElements, StepVector, NbOfSteps, MakeGroups=False): + def ExtrusionSweep(self, IDsOfElements, StepVector, NbOfSteps, MakeGroups=False, IsNodes = False): if IDsOfElements == []: IDsOfElements = self.GetElementsId() if ( isinstance( StepVector, geompyDC.GEOM._objref_GEOM_Object)): @@ -2646,8 +3507,14 @@ class Mesh: Parameters = StepVectorParameters + var_separator + Parameters self.mesh.SetParameters(Parameters) if MakeGroups: - return self.editor.ExtrusionSweepMakeGroups(IDsOfElements, StepVector, NbOfSteps) - self.editor.ExtrusionSweep(IDsOfElements, StepVector, NbOfSteps) + if(IsNodes): + return self.editor.ExtrusionSweepMakeGroups0D(IDsOfElements, StepVector, NbOfSteps) + else: + return self.editor.ExtrusionSweepMakeGroups(IDsOfElements, StepVector, NbOfSteps) + if(IsNodes): + self.editor.ExtrusionSweep0D(IDsOfElements, StepVector, NbOfSteps) + else: + self.editor.ExtrusionSweep(IDsOfElements, StepVector, NbOfSteps) return [] ## Generates new elements by extrusion of the elements with given ids @@ -2672,13 +3539,15 @@ class Mesh: return [] ## Generates new elements by extrusion of the elements which belong to the object - # @param theObject the object which elements should be processed - # @param StepVector vector, defining the direction and value of extrusion + # @param theObject the object which elements should be processed. + # It can be a mesh, a sub mesh or a group. + # @param StepVector vector, defining the direction and value of extrusion for one step (the total extrusion length will be NbOfSteps * ||StepVector||) # @param NbOfSteps the number of steps # @param MakeGroups forces the generation of new groups from existing ones + # @param IsNodes is True if elements which belong to the object are nodes # @return list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise # @ingroup l2_modif_extrurev - def ExtrusionSweepObject(self, theObject, StepVector, NbOfSteps, MakeGroups=False): + def ExtrusionSweepObject(self, theObject, StepVector, NbOfSteps, MakeGroups=False, IsNodes=False): if ( isinstance( theObject, Mesh )): theObject = theObject.GetMesh() if ( isinstance( StepVector, geompyDC.GEOM._objref_GEOM_Object)): @@ -2688,13 +3557,20 @@ class Mesh: Parameters = StepVectorParameters + var_separator + Parameters self.mesh.SetParameters(Parameters) if MakeGroups: - return self.editor.ExtrusionSweepObjectMakeGroups(theObject, StepVector, NbOfSteps) - self.editor.ExtrusionSweepObject(theObject, StepVector, NbOfSteps) + if(IsNodes): + return self.editor.ExtrusionSweepObject0DMakeGroups(theObject, StepVector, NbOfSteps) + else: + return self.editor.ExtrusionSweepObjectMakeGroups(theObject, StepVector, NbOfSteps) + if(IsNodes): + self.editor.ExtrusionSweepObject0D(theObject, StepVector, NbOfSteps) + else: + self.editor.ExtrusionSweepObject(theObject, StepVector, NbOfSteps) return [] ## Generates new elements by extrusion of the elements which belong to the object - # @param theObject object which elements should be processed - # @param StepVector vector, defining the direction and value of extrusion + # @param theObject object which elements should be processed. + # It can be a mesh, a sub mesh or a group. + # @param StepVector vector, defining the direction and value of extrusion for one step (the total extrusion length will be NbOfSteps * ||StepVector||) # @param NbOfSteps the number of steps # @param MakeGroups to generate new groups from existing ones # @return list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise @@ -2714,8 +3590,9 @@ class Mesh: return [] ## Generates new elements by extrusion of the elements which belong to the object - # @param theObject object which elements should be processed - # @param StepVector vector, defining the direction and value of extrusion + # @param theObject object which elements should be processed. + # It can be a mesh, a sub mesh or a group. + # @param StepVector vector, defining the direction and value of extrusion for one step (the total extrusion length will be NbOfSteps * ||StepVector||) # @param NbOfSteps the number of steps # @param MakeGroups forces the generation of new groups from existing ones # @return list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise @@ -2734,6 +3611,56 @@ class Mesh: self.editor.ExtrusionSweepObject2D(theObject, StepVector, NbOfSteps) return [] + + + ## Generates new elements by extrusion of the given elements + # The path of extrusion must be a meshed edge. + # @param Base mesh or group, or submesh, or list of ids of elements for extrusion + # @param Path - 1D mesh or 1D sub-mesh, along which proceeds the extrusion + # @param NodeStart the start node from Path. Defines the direction of extrusion + # @param HasAngles allows the shape to be rotated around the path + # to get the resulting mesh in a helical fashion + # @param Angles list of angles in radians + # @param LinearVariation forces the computation of rotation angles as linear + # variation of the given Angles along path steps + # @param HasRefPoint allows using the reference point + # @param RefPoint the point around which the shape is rotated (the mass center of the shape by default). + # The User can specify any point as the Reference Point. + # @param MakeGroups forces the generation of new groups from existing ones + # @param ElemType type of elements for extrusion (if param Base is a mesh) + # @return list of created groups (SMESH_GroupBase) and SMESH::Extrusion_Error if MakeGroups=True, + # only SMESH::Extrusion_Error otherwise + # @ingroup l2_modif_extrurev + def ExtrusionAlongPathX(self, Base, Path, NodeStart, + HasAngles, Angles, LinearVariation, + HasRefPoint, RefPoint, MakeGroups, ElemType): + Angles,AnglesParameters = ParseAngles(Angles) + RefPoint,RefPointParameters = ParsePointStruct(RefPoint) + if ( isinstance( RefPoint, geompyDC.GEOM._objref_GEOM_Object)): + RefPoint = self.smeshpyD.GetPointStruct(RefPoint) + pass + Parameters = AnglesParameters + var_separator + RefPointParameters + self.mesh.SetParameters(Parameters) + + if (isinstance(Path, Mesh)): Path = Path.GetMesh() + + if isinstance(Base, list): + IDsOfElements = [] + if Base == []: IDsOfElements = self.GetElementsId() + else: IDsOfElements = Base + return self.editor.ExtrusionAlongPathX(IDsOfElements, Path, NodeStart, + HasAngles, Angles, LinearVariation, + HasRefPoint, RefPoint, MakeGroups, ElemType) + else: + if isinstance(Base, Mesh): Base = Base.GetMesh() + if isinstance(Base, SMESH._objref_SMESH_Mesh) or isinstance(Base, SMESH._objref_SMESH_Group) or isinstance(Base, SMESH._objref_SMESH_subMesh): + return self.editor.ExtrusionAlongPathObjX(Base, Path, NodeStart, + HasAngles, Angles, LinearVariation, + HasRefPoint, RefPoint, MakeGroups, ElemType) + else: + raise RuntimeError, "Invalid Base for ExtrusionAlongPathX" + + ## Generates new elements by extrusion of the given elements # The path of extrusion must be a meshed edge. # @param IDsOfElements ids of elements @@ -2742,7 +3669,7 @@ class Mesh: # @param NodeStart the first or the last node on the edge. Defines the direction of extrusion # @param HasAngles allows the shape to be rotated around the path # to get the resulting mesh in a helical fashion - # @param Angles list of angles + # @param Angles list of angles in radians # @param HasRefPoint allows using the reference point # @param RefPoint the point around which the shape is rotated (the mass center of the shape by default). # The User can specify any point as the Reference Point. @@ -2778,7 +3705,8 @@ class Mesh: ## Generates new elements by extrusion of the elements which belong to the object # The path of extrusion must be a meshed edge. - # @param theObject the object which elements should be processed + # @param theObject the object which elements should be processed. + # It can be a mesh, a sub mesh or a group. # @param PathMesh mesh containing a 1D sub-mesh on the edge, along which the extrusion proceeds # @param PathShape shape(edge) defines the sub-mesh for the path # @param NodeStart the first or the last node on the edge. Defines the direction of extrusion @@ -2820,7 +3748,8 @@ class Mesh: ## Generates new elements by extrusion of the elements which belong to the object # The path of extrusion must be a meshed edge. - # @param theObject the object which elements should be processed + # @param theObject the object which elements should be processed. + # It can be a mesh, a sub mesh or a group. # @param PathMesh mesh containing a 1D sub-mesh on the edge, along which the extrusion proceeds # @param PathShape shape(edge) defines the sub-mesh for the path # @param NodeStart the first or the last node on the edge. Defines the direction of extrusion @@ -2862,7 +3791,8 @@ class Mesh: ## Generates new elements by extrusion of the elements which belong to the object # The path of extrusion must be a meshed edge. - # @param theObject the object which elements should be processed + # @param theObject the object which elements should be processed. + # It can be a mesh, a sub mesh or a group. # @param PathMesh mesh containing a 1D sub-mesh on the edge, along which the extrusion proceeds # @param PathShape shape(edge) defines the sub-mesh for the path # @param NodeStart the first or the last node on the edge. Defines the direction of extrusion @@ -3056,6 +3986,51 @@ class Mesh: mesh.SetParameters(Parameters) return Mesh( self.smeshpyD, self.geompyD, mesh ) + + + ## Scales the object + # @param theObject - the object to translate (mesh, submesh, or group) + # @param thePoint - base point for scale + # @param theScaleFact - list of 1-3 scale factors for axises + # @param Copy - allows copying the translated elements + # @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 + def Scale(self, theObject, thePoint, theScaleFact, Copy, MakeGroups=False): + if ( isinstance( theObject, Mesh )): + theObject = theObject.GetMesh() + if ( isinstance( theObject, list )): + theObject = self.GetIDSource(theObject, SMESH.ALL) + + thePoint, Parameters = ParsePointStruct(thePoint) + self.mesh.SetParameters(Parameters) + + if Copy and MakeGroups: + return self.editor.ScaleMakeGroups(theObject, thePoint, theScaleFact) + self.editor.Scale(theObject, thePoint, theScaleFact, Copy) + return [] + + ## Creates a new mesh from the translated object + # @param theObject - the object to translate (mesh, submesh, or group) + # @param thePoint - base point for scale + # @param theScaleFact - list of 1-3 scale factors for axises + # @param MakeGroups - forces the generation of new groups from existing ones + # @param NewMeshName - the name of the newly created mesh + # @return instance of Mesh class + def ScaleMakeMesh(self, theObject, thePoint, theScaleFact, MakeGroups=False, NewMeshName=""): + if (isinstance(theObject, Mesh)): + theObject = theObject.GetMesh() + if ( isinstance( theObject, list )): + theObject = self.GetIDSource(theObject,SMESH.ALL) + + mesh = self.editor.ScaleMakeMesh(theObject, thePoint, theScaleFact, + MakeGroups, NewMeshName) + #mesh.SetParameters(Parameters) + return Mesh( self.smeshpyD, self.geompyD, mesh ) + + + ## Rotates the elements # @param IDsOfElements list of elements ids # @param Axis the axis of rotation (AxisStruct or geom line) @@ -3172,10 +4147,17 @@ class Mesh: ## Finds groups of ajacent nodes within Tolerance. # @param Tolerance the value of tolerance # @param SubMeshOrGroup SubMesh or Group + # @param exceptNodes list of either SubMeshes, Groups or node IDs to exclude from search # @return the list of groups of nodes # @ingroup l2_modif_trsf - def FindCoincidentNodesOnPart (self, SubMeshOrGroup, Tolerance): - return self.editor.FindCoincidentNodesOnPart(SubMeshOrGroup, Tolerance) + def FindCoincidentNodesOnPart (self, SubMeshOrGroup, Tolerance, exceptNodes=[]): + if (isinstance( SubMeshOrGroup, Mesh )): + SubMeshOrGroup = SubMeshOrGroup.GetMesh() + if not isinstance( exceptNodes, list): + exceptNodes = [ exceptNodes ] + if exceptNodes and isinstance( exceptNodes[0], int): + exceptNodes = [ self.GetIDSource( exceptNodes, SMESH.NODE)] + return self.editor.FindCoincidentNodesOnPartBut(SubMeshOrGroup, Tolerance,exceptNodes) ## Merges nodes # @param GroupsOfNodes the list of groups of nodes @@ -3188,6 +4170,8 @@ class Mesh: # @return a list of groups of equal elements # @ingroup l2_modif_trsf def FindEqualElements (self, MeshOrSubMeshOrGroup): + if ( isinstance( MeshOrSubMeshOrGroup, Mesh )): + MeshOrSubMeshOrGroup = MeshOrSubMeshOrGroup.GetMesh() return self.editor.FindEqualElements(MeshOrSubMeshOrGroup) ## Merges elements in each given group. @@ -3265,44 +4249,228 @@ class Mesh: # @ingroup l1_auxiliary def GetLastCreatedElems(self): return self.editor.GetLastCreatedElems() - - ## Creates a hole in a mesh by doubling the nodes of some particular elements + + ## Creates a hole in a mesh by doubling the nodes of some particular elements # @param theNodes identifiers of nodes to be doubled - # @param theModifiedElems identifiers of elements to be updated by the new (doubled) - # nodes. If list of element identifiers is empty then nodes are doubled but + # @param theModifiedElems identifiers of elements to be updated by the new (doubled) + # nodes. If list of element identifiers is empty then nodes are doubled but # they not assigned to elements # @return TRUE if operation has been completed successfully, FALSE otherwise # @ingroup l2_modif_edit def DoubleNodes(self, theNodes, theModifiedElems): return self.editor.DoubleNodes(theNodes, theModifiedElems) - + ## Creates a hole in a mesh by doubling the nodes of some particular elements # This method provided for convenience works as DoubleNodes() described above. - # @param theNodes identifiers of node to be doubled + # @param theNodeId identifiers of node to be doubled # @param theModifiedElems identifiers of elements to be updated # @return TRUE if operation has been completed successfully, FALSE otherwise # @ingroup l2_modif_edit def DoubleNode(self, theNodeId, theModifiedElems): return self.editor.DoubleNode(theNodeId, theModifiedElems) - + ## Creates a hole in a mesh by doubling the nodes of some particular elements # This method provided for convenience works as DoubleNodes() described above. # @param theNodes group of nodes to be doubled # @param theModifiedElems group of elements to be updated. - # @return TRUE if operation has been completed successfully, FALSE otherwise + # @param theMakeGroup forces the generation of a group containing new nodes. + # @return TRUE or a created group if operation has been completed successfully, + # FALSE or None otherwise # @ingroup l2_modif_edit - def DoubleNodeGroup(self, theNodes, theModifiedElems): + def DoubleNodeGroup(self, theNodes, theModifiedElems, theMakeGroup=False): + if theMakeGroup: + return self.editor.DoubleNodeGroupNew(theNodes, theModifiedElems) return self.editor.DoubleNodeGroup(theNodes, theModifiedElems) - + ## Creates a hole in a mesh by doubling the nodes of some particular elements # This method provided for convenience works as DoubleNodes() described above. # @param theNodes list of groups of nodes to be doubled # @param theModifiedElems list of groups of elements to be updated. + # @param theMakeGroup forces the generation of a group containing new nodes. # @return TRUE if operation has been completed successfully, FALSE otherwise # @ingroup l2_modif_edit - def DoubleNodeGroups(self, theNodes, theModifiedElems): + def DoubleNodeGroups(self, theNodes, theModifiedElems, theMakeGroup=False): + if theMakeGroup: + return self.editor.DoubleNodeGroupsNew(theNodes, theModifiedElems) return self.editor.DoubleNodeGroups(theNodes, theModifiedElems) + ## Creates a hole in a mesh by doubling the nodes of some particular elements + # @param theElems - the list of elements (edges or faces) to be replicated + # The nodes for duplication could be found from these elements + # @param theNodesNot - list of nodes to NOT replicate + # @param theAffectedElems - the list of elements (cells and edges) to which the + # replicated nodes should be associated to. + # @return TRUE if operation has been completed successfully, FALSE otherwise + # @ingroup l2_modif_edit + def DoubleNodeElem(self, theElems, theNodesNot, theAffectedElems): + return self.editor.DoubleNodeElem(theElems, theNodesNot, theAffectedElems) + + ## Creates a hole in a mesh by doubling the nodes of some particular elements + # @param theElems - the list of elements (edges or faces) to be replicated + # The nodes for duplication could be found from these elements + # @param theNodesNot - list of nodes to NOT replicate + # @param theShape - shape to detect affected elements (element which geometric center + # located on or inside shape). + # The replicated nodes should be associated to affected elements. + # @return TRUE if operation has been completed successfully, FALSE otherwise + # @ingroup l2_modif_edit + def DoubleNodeElemInRegion(self, theElems, theNodesNot, theShape): + return self.editor.DoubleNodeElemInRegion(theElems, theNodesNot, theShape) + + ## Creates a hole in a mesh by doubling the nodes of some particular elements + # This method provided for convenience works as DoubleNodes() described above. + # @param theElems - group of of elements (edges or faces) to be replicated + # @param theNodesNot - group of nodes not to replicated + # @param theAffectedElems - group of elements to which the replicated nodes + # should be associated to. + # @param theMakeGroup forces the generation of a group containing new elements. + # @return TRUE or a created group if operation has been completed successfully, + # FALSE or None otherwise + # @ingroup l2_modif_edit + def DoubleNodeElemGroup(self, theElems, theNodesNot, theAffectedElems, theMakeGroup=False): + if theMakeGroup: + return self.editor.DoubleNodeElemGroupNew(theElems, theNodesNot, theAffectedElems) + return self.editor.DoubleNodeElemGroup(theElems, theNodesNot, theAffectedElems) + + ## Creates a hole in a mesh by doubling the nodes of some particular elements + # This method provided for convenience works as DoubleNodes() described above. + # @param theElems - group of of elements (edges or faces) to be replicated + # @param theNodesNot - group of nodes not to replicated + # @param theShape - shape to detect affected elements (element which geometric center + # located on or inside shape). + # The replicated nodes should be associated to affected elements. + # @ingroup l2_modif_edit + def DoubleNodeElemGroupInRegion(self, theElems, theNodesNot, theShape): + return self.editor.DoubleNodeElemGroupInRegion(theElems, theNodesNot, theShape) + + ## Creates a hole in a mesh by doubling the nodes of some particular elements + # This method provided for convenience works as DoubleNodes() described above. + # @param theElems - list of groups of elements (edges or faces) to be replicated + # @param theNodesNot - list of groups of nodes not to replicated + # @param theAffectedElems - group of elements to which the replicated nodes + # should be associated to. + # @param theMakeGroup forces the generation of a group containing new elements. + # @return TRUE or a created group if operation has been completed successfully, + # FALSE or None otherwise + # @ingroup l2_modif_edit + def DoubleNodeElemGroups(self, theElems, theNodesNot, theAffectedElems, theMakeGroup=False): + if theMakeGroup: + return self.editor.DoubleNodeElemGroupsNew(theElems, theNodesNot, theAffectedElems) + return self.editor.DoubleNodeElemGroups(theElems, theNodesNot, theAffectedElems) + + ## Creates a hole in a mesh by doubling the nodes of some particular elements + # This method provided for convenience works as DoubleNodes() described above. + # @param theElems - list of groups of elements (edges or faces) to be replicated + # @param theNodesNot - list of groups of nodes not to replicated + # @param theShape - shape to detect affected elements (element which geometric center + # located on or inside shape). + # The replicated nodes should be associated to affected elements. + # @return TRUE if operation has been completed successfully, FALSE otherwise + # @ingroup l2_modif_edit + def DoubleNodeElemGroupsInRegion(self, theElems, theNodesNot, theShape): + return self.editor.DoubleNodeElemGroupsInRegion(theElems, theNodesNot, theShape) + + ## Double nodes on shared faces between groups of volumes and create flat elements on demand. + # The list of groups must describe a partition of the mesh volumes. + # The nodes of the internal faces at the boundaries of the groups are doubled. + # In option, the internal faces are replaced by flat elements. + # Triangles are transformed in prisms, and quadrangles in hexahedrons. + # @param theDomains - list of groups of volumes + # @param createJointElems - if TRUE, create the elements + # @return TRUE if operation has been completed successfully, FALSE otherwise + def DoubleNodesOnGroupBoundaries(self, theDomains, createJointElems ): + return self.editor.DoubleNodesOnGroupBoundaries( theDomains, createJointElems ) + + ## Double nodes on some external faces and create flat elements. + # Flat elements are mainly used by some types of mechanic calculations. + # + # Each group of the list must be constituted of faces. + # Triangles are transformed in prisms, and quadrangles in hexahedrons. + # @param theGroupsOfFaces - list of groups of faces + # @return TRUE if operation has been completed successfully, FALSE otherwise + def CreateFlatElementsOnFacesGroups(self, theGroupsOfFaces ): + return self.editor.CreateFlatElementsOnFacesGroups( theGroupsOfFaces ) + + def _valueFromFunctor(self, funcType, elemId): + fn = self.smeshpyD.GetFunctor(funcType) + fn.SetMesh(self.mesh) + if fn.GetElementType() == self.GetElementType(elemId, True): + val = fn.GetValue(elemId) + else: + val = 0 + return val + + ## Get length of 1D element. + # @param elemId mesh element ID + # @return element's length value + # @ingroup l1_measurements + def GetLength(self, elemId): + return self._valueFromFunctor(SMESH.FT_Length, elemId) + + ## Get area of 2D element. + # @param elemId mesh element ID + # @return element's area value + # @ingroup l1_measurements + def GetArea(self, elemId): + return self._valueFromFunctor(SMESH.FT_Area, elemId) + + ## Get volume of 3D element. + # @param elemId mesh element ID + # @return element's volume value + # @ingroup l1_measurements + def GetVolume(self, elemId): + return self._valueFromFunctor(SMESH.FT_Volume3D, elemId) + + ## Get maximum element length. + # @param elemId mesh element ID + # @return element's maximum length value + # @ingroup l1_measurements + def GetMaxElementLength(self, elemId): + if self.GetElementType(elemId, True) == SMESH.VOLUME: + ftype = SMESH.FT_MaxElementLength3D + else: + ftype = SMESH.FT_MaxElementLength2D + return self._valueFromFunctor(ftype, elemId) + + ## Get aspect ratio of 2D or 3D element. + # @param elemId mesh element ID + # @return element's aspect ratio value + # @ingroup l1_measurements + def GetAspectRatio(self, elemId): + if self.GetElementType(elemId, True) == SMESH.VOLUME: + ftype = SMESH.FT_AspectRatio3D + else: + ftype = SMESH.FT_AspectRatio + return self._valueFromFunctor(ftype, elemId) + + ## Get warping angle of 2D element. + # @param elemId mesh element ID + # @return element's warping angle value + # @ingroup l1_measurements + def GetWarping(self, elemId): + return self._valueFromFunctor(SMESH.FT_Warping, elemId) + + ## Get minimum angle of 2D element. + # @param elemId mesh element ID + # @return element's minimum angle value + # @ingroup l1_measurements + def GetMinimumAngle(self, elemId): + return self._valueFromFunctor(SMESH.FT_MinimumAngle, elemId) + + ## Get taper of 2D element. + # @param elemId mesh element ID + # @return element's taper value + # @ingroup l1_measurements + def GetTaper(self, elemId): + return self._valueFromFunctor(SMESH.FT_Taper, elemId) + + ## Get skew of 2D element. + # @param elemId mesh element ID + # @return element's skew value + # @ingroup l1_measurements + def GetSkew(self, elemId): + return self._valueFromFunctor(SMESH.FT_Skew, elemId) + ## The mother class to define algorithm, it is not recommended to use it directly. # # More details. @@ -3444,20 +4612,22 @@ class Mesh_Algorithm: if geom is None: raise RuntimeError, "Attemp to create " + algo + " algoritm on None shape" self.mesh = mesh - piece = mesh.geom + name = "" if not geom: - self.geom = piece + self.geom = mesh.geom else: self.geom = geom - name = GetName(geom) - if name==NO_NAME: - name = mesh.geompyD.SubShapeName(geom, piece) - mesh.geompyD.addToStudyInFather(piece, geom, name) + 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(), GetName(self.geom), True ) + TreatHypoStatus( status, algo.GetName(), name, True ) + return def CompareHyp (self, hyp, args): print "CompareHyp is not implemented for ", self.__class__.__name__, ":", hyp.GetName() @@ -3478,19 +4648,98 @@ class Mesh_Algorithm: hypo = self.mesh.smeshpyD.CreateHypothesis(hyp, so) a = "" s = "=" - i = 0 - n = len(args) - while i 10: + argStr = argStr[:7]+"..." + if argStr[0] == '[': argStr += ']' + a = a + s + argStr s = "," - i = i + 1 pass + if len(a) > 50: + a = a[:47]+"..." self.mesh.smeshpyD.SetName(hypo, hyp + a) pass + geomName="" + if self.geom: + geomName = GetName(self.geom) status = self.mesh.mesh.AddHypothesis(self.geom, hypo) - TreatHypoStatus( status, GetName(hypo), GetName(self.geom), 0 ) + TreatHypoStatus( status, GetName(hypo), geomName, 0 ) return hypo + ## Returns entry of the shape to mesh in the study + def MainShapeEntry(self): + entry = "" + if not self.mesh or not self.mesh.GetMesh(): return entry + if not self.mesh.GetMesh().HasShapeToMesh(): return entry + study = self.mesh.smeshpyD.GetCurrentStudy() + ior = salome.orb.object_to_string( self.mesh.GetShape() ) + sobj = study.FindObjectIOR(ior) + if sobj: entry = sobj.GetID() + if not entry: return "" + return entry + + ## 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=[]): + 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 ] + hyp = self.Hypothesis("ViscousLayers", + [thickness, numberOfLayers, stretchFactor, ignoreFaces]) + hyp.SetTotalThickness(thickness) + hyp.SetNumberLayers(numberOfLayers) + hyp.SetStretchFactor(stretchFactor) + hyp.SetIgnoreFaces(ignoreFaces) + 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): + 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: + raise TypeError, "Not EDGE index given" + resList.append( i ) + elif isinstance( i, geompyDC.GEOM._objref_GEOM_Object ): + if i.GetShapeType() != geompyDC.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 ): + 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: + v,e = e,v + if e.GetShapeType() != geompyDC.GEOM.EDGE or \ + v.GetShapeType() != geompyDC.GEOM.VERTEX: + raise TypeError, "A list item must be a tuple (edge 1st_vertex_of_edge)" + vFirst = FirstVertexOnCurve( e ) + tol = geompy.Tolerance( vFirst )[-1] + if geompy.MinDistance( v, vFirst ) > 1.5*tol: + resList.append( geompy.GetSubShapeID(self.mesh.geom, e )) + else: + raise TypeError, "Item must be either an edge or tuple (edge 1st_vertex_of_edge)" + return resList # Public class: Mesh_Segment # -------------------------- @@ -3560,50 +4809,73 @@ class Mesh_Segment(Mesh_Algorithm): pass hyp.SetUsePreestimatedLength( length == 0.0 ) return hyp - + ## Defines "NumberOfSegments" hypothesis to cut an edge in a fixed number of segments # @param n for the number of segments that cut an edge # @param s for the scale factor (optional) + # @param reversedEdges is a list of edges to mesh using reversed orientation. + # A list item can also be a tuple (edge 1st_vertex_of_edge) # @param UseExisting if ==true - searches for an existing hypothesis created with # the same parameters, else (default) - create a new one # @return an instance of StdMeshers_NumberOfSegments hypothesis # @ingroup l3_hypos_1dhyps - def NumberOfSegments(self, n, s=[], UseExisting=0): + def NumberOfSegments(self, n, s=[], reversedEdges=[], UseExisting=0): + if not isinstance(reversedEdges,list): #old version script, before adding reversedEdges + reversedEdges, UseExisting = [], reversedEdges + entry = self.MainShapeEntry() + reversedEdgeInd = self.ReversedEdgeIndices(reversedEdges) if s == []: - hyp = self.Hypothesis("NumberOfSegments", [n], UseExisting=UseExisting, + hyp = self.Hypothesis("NumberOfSegments", [n, reversedEdgeInd, entry], + UseExisting=UseExisting, CompareMethod=self.CompareNumberOfSegments) else: - hyp = self.Hypothesis("NumberOfSegments", [n,s], UseExisting=UseExisting, + hyp = self.Hypothesis("NumberOfSegments", [n,s, reversedEdgeInd, entry], + UseExisting=UseExisting, CompareMethod=self.CompareNumberOfSegments) hyp.SetDistrType( 1 ) hyp.SetScaleFactor(s) hyp.SetNumberOfSegments(n) + hyp.SetReversedEdges( reversedEdgeInd ) + hyp.SetObjectEntry( entry ) return hyp ## Private method ## Checks if the given "NumberOfSegments" hypothesis has the same parameters as the given arguments def CompareNumberOfSegments(self, hyp, args): if hyp.GetNumberOfSegments() == args[0]: - if len(args) == 1: - return True - else: - if hyp.GetDistrType() == 1: - if IsEqual(hyp.GetScaleFactor(), args[1]): + if len(args) == 3: + if hyp.GetReversedEdges() == args[1]: + if not args[1] or hyp.GetObjectEntry() == args[2]: return True + else: + if hyp.GetReversedEdges() == args[2]: + if not args[2] or hyp.GetObjectEntry() == args[3]: + if hyp.GetDistrType() == 1: + if IsEqual(hyp.GetScaleFactor(), args[1]): + return True return False ## Defines "Arithmetic1D" hypothesis to cut an edge in several segments with increasing arithmetic length # @param start defines the length of the first segment # @param end defines the length of the last segment + # @param reversedEdges is a list of edges to mesh using reversed orientation. + # A list item can also be a tuple (edge 1st_vertex_of_edge) # @param UseExisting if ==true - searches for an existing hypothesis created with # the same parameters, else (default) - creates a new one # @return an instance of StdMeshers_Arithmetic1D hypothesis # @ingroup l3_hypos_1dhyps - def Arithmetic1D(self, start, end, UseExisting=0): - hyp = self.Hypothesis("Arithmetic1D", [start, end], UseExisting=UseExisting, + def Arithmetic1D(self, start, end, reversedEdges=[], UseExisting=0): + if not isinstance(reversedEdges,list): #old version script, before adding reversedEdges + reversedEdges, UseExisting = [], reversedEdges + reversedEdgeInd = self.ReversedEdgeIndices(reversedEdges) + entry = self.MainShapeEntry() + hyp = self.Hypothesis("Arithmetic1D", [start, end, reversedEdgeInd, entry], + UseExisting=UseExisting, CompareMethod=self.CompareArithmetic1D) - hyp.SetLength(start, 1) - hyp.SetLength(end , 0) + hyp.SetStartLength(start) + hyp.SetEndLength(end) + hyp.SetReversedEdges( reversedEdgeInd ) + hyp.SetObjectEntry( entry ) return hyp ## Private method @@ -3611,28 +4883,82 @@ class Mesh_Segment(Mesh_Algorithm): def CompareArithmetic1D(self, hyp, args): if IsEqual(hyp.GetLength(1), args[0]): if IsEqual(hyp.GetLength(0), args[1]): - return True + if hyp.GetReversedEdges() == args[2]: + if not args[2] or hyp.GetObjectEntry() == args[3]: + return True + return False + + + ## Defines "FixedPoints1D" hypothesis to cut an edge using parameter + # on curve from 0 to 1 (additionally it is neecessary to check + # orientation of edges and create list of reversed edges if it is + # needed) and sets numbers of segments between given points (default + # values are equals 1 + # @param points defines the list of parameters on curve + # @param nbSegs defines the list of numbers of segments + # @param reversedEdges is a list of edges to mesh using reversed orientation. + # A list item can also be a tuple (edge 1st_vertex_of_edge) + # @param UseExisting if ==true - searches for an existing hypothesis created with + # the same parameters, else (default) - creates a new one + # @return an instance of StdMeshers_Arithmetic1D hypothesis + # @ingroup l3_hypos_1dhyps + def FixedPoints1D(self, points, nbSegs=[1], reversedEdges=[], UseExisting=0): + if not isinstance(reversedEdges,list): #old version script, before adding reversedEdges + reversedEdges, UseExisting = [], reversedEdges + reversedEdgeInd = self.ReversedEdgeIndices(reversedEdges) + entry = self.MainShapeEntry() + hyp = self.Hypothesis("FixedPoints1D", [points, nbSegs, reversedEdgeInd, entry], + UseExisting=UseExisting, + CompareMethod=self.CompareFixedPoints1D) + hyp.SetPoints(points) + hyp.SetNbSegments(nbSegs) + hyp.SetReversedEdges(reversedEdgeInd) + hyp.SetObjectEntry(entry) + return hyp + + ## Private method + ## Check if the given "FixedPoints1D" hypothesis has the same parameters + ## as the given arguments + def CompareFixedPoints1D(self, hyp, args): + if hyp.GetPoints() == args[0]: + if hyp.GetNbSegments() == args[1]: + if hyp.GetReversedEdges() == args[2]: + if not args[2] or hyp.GetObjectEntry() == args[3]: + return True return False + + ## Defines "StartEndLength" hypothesis to cut an edge in several segments with increasing geometric length # @param start defines the length of the first segment # @param end defines the length of the last segment + # @param reversedEdges is a list of edges to mesh using reversed orientation. + # A list item can also be a tuple (edge 1st_vertex_of_edge) # @param UseExisting if ==true - searches for an existing hypothesis created with # the same parameters, else (default) - creates a new one # @return an instance of StdMeshers_StartEndLength hypothesis # @ingroup l3_hypos_1dhyps - def StartEndLength(self, start, end, UseExisting=0): - hyp = self.Hypothesis("StartEndLength", [start, end], UseExisting=UseExisting, + def StartEndLength(self, start, end, reversedEdges=[], UseExisting=0): + if not isinstance(reversedEdges,list): #old version script, before adding reversedEdges + reversedEdges, UseExisting = [], reversedEdges + reversedEdgeInd = self.ReversedEdgeIndices(reversedEdges) + entry = self.MainShapeEntry() + hyp = self.Hypothesis("StartEndLength", [start, end, reversedEdgeInd, entry], + UseExisting=UseExisting, CompareMethod=self.CompareStartEndLength) - hyp.SetLength(start, 1) - hyp.SetLength(end , 0) + hyp.SetStartLength(start) + hyp.SetEndLength(end) + hyp.SetReversedEdges( reversedEdgeInd ) + hyp.SetObjectEntry( entry ) return hyp ## Check if the given "StartEndLength" hypothesis has the same parameters as the given arguments def CompareStartEndLength(self, hyp, args): if IsEqual(hyp.GetLength(1), args[0]): if IsEqual(hyp.GetLength(0), args[1]): - return True + if hyp.GetReversedEdges() == args[2]: + if not args[2] or hyp.GetObjectEntry() == args[3]: + return True return False ## Defines "Deflection1D" hypothesis @@ -3684,7 +5010,7 @@ class Mesh_Segment(Mesh_Algorithm): store_geom = self.geom if type(vertex) is types.IntType: if vertex == 0 or vertex == 1: - vertex = self.mesh.geompyD.SubShapeAllSorted(self.geom, geompyDC.ShapeType["VERTEX"])[vertex] + vertex = self.mesh.geompyD.ExtractShapes(self.geom, geompyDC.ShapeType["VERTEX"],True)[vertex] self.geom = vertex pass pass @@ -3694,11 +5020,9 @@ class Mesh_Segment(Mesh_Algorithm): ### 0D algorithm if self.geom is None: raise RuntimeError, "Attemp to create SegmentAroundVertex_0D algoritm on None shape" + AssureGeomPublished( self.mesh, self.geom ) name = GetName(self.geom) - if name == NO_NAME: - piece = self.mesh.geom - name = self.mesh.geompyD.SubShapeName(self.geom, piece) - self.mesh.geompyD.addToStudyInFather(piece, self.geom, name) + algo = self.FindAlgorithm("SegmentAroundVertex_0D", self.mesh.smeshpyD) if algo is None: algo = self.mesh.smeshpyD.CreateHypothesis("SegmentAroundVertex_0D", "libStdMeshersEngine.so") @@ -3794,27 +5118,24 @@ class Mesh_Triangle(Mesh_Algorithm): def __init__(self, mesh, algoType, geom=0): Mesh_Algorithm.__init__(self) - self.algoType = algoType if algoType == MEFISTO: self.Create(mesh, geom, "MEFISTO_2D") pass elif algoType == BLSURF: - import BLSURFPlugin + CheckPlugin(BLSURF) self.Create(mesh, geom, "BLSURF", "libBLSURFEngine.so") #self.SetPhysicalMesh() - PAL19680 elif algoType == NETGEN: - if noNETGENPlugin: - print "Warning: NETGENPlugin module unavailable" - pass + CheckPlugin(NETGEN) self.Create(mesh, geom, "NETGEN_2D", "libNETGENEngine.so") pass elif algoType == NETGEN_2D: - if noNETGENPlugin: - print "Warning: NETGENPlugin module unavailable" - pass + CheckPlugin(NETGEN) self.Create(mesh, geom, "NETGEN_2D_ONLY", "libNETGENEngine.so") pass + self.algoType = algoType + ## Defines "MaxElementArea" hypothesis basing on the definition of the maximum area of each triangle # @param area for the maximum area of each triangle # @param UseExisting if ==true - searches for an existing hypothesis created with the @@ -3850,113 +5171,389 @@ class Mesh_Triangle(Mesh_Algorithm): return hyp ## Sets a way to define size of mesh elements to generate. - # @param thePhysicalMesh is: DefaultSize or Custom. + # @param thePhysicalMesh is: DefaultSize, BLSURF_Custom or SizeMap. # @ingroup l3_hypos_blsurf def SetPhysicalMesh(self, thePhysicalMesh=DefaultSize): - # Parameter of BLSURF algo - self.Parameters().SetPhysicalMesh(thePhysicalMesh) + if self.Parameters(): + # Parameter of BLSURF algo + self.params.SetPhysicalMesh(thePhysicalMesh) ## Sets size of mesh elements to generate. # @ingroup l3_hypos_blsurf def SetPhySize(self, theVal): - # Parameter of BLSURF algo - self.Parameters().SetPhySize(theVal) + if self.Parameters(): + # Parameter of BLSURF algo + self.params.SetPhySize(theVal) ## Sets lower boundary of mesh element size (PhySize). # @ingroup l3_hypos_blsurf def SetPhyMin(self, theVal=-1): - # Parameter of BLSURF algo - self.Parameters().SetPhyMin(theVal) + if self.Parameters(): + # Parameter of BLSURF algo + self.params.SetPhyMin(theVal) ## Sets upper boundary of mesh element size (PhySize). # @ingroup l3_hypos_blsurf def SetPhyMax(self, theVal=-1): - # Parameter of BLSURF algo - self.Parameters().SetPhyMax(theVal) + if self.Parameters(): + # Parameter of BLSURF algo + self.params.SetPhyMax(theVal) ## Sets a way to define maximum angular deflection of mesh from CAD model. - # @param theGeometricMesh is: DefaultGeom or Custom + # @param theGeometricMesh is: 0 (None) or 1 (Custom) # @ingroup l3_hypos_blsurf def SetGeometricMesh(self, theGeometricMesh=0): - # Parameter of BLSURF algo - if self.Parameters().GetPhysicalMesh() == 0: theGeometricMesh = 1 - self.params.SetGeometricMesh(theGeometricMesh) + if self.Parameters(): + # Parameter of BLSURF algo + if self.params.GetPhysicalMesh() == 0: theGeometricMesh = 1 + self.params.SetGeometricMesh(theGeometricMesh) ## Sets angular deflection (in degrees) of a mesh face from CAD surface. # @ingroup l3_hypos_blsurf def SetAngleMeshS(self, theVal=_angleMeshS): - # Parameter of BLSURF algo - if self.Parameters().GetGeometricMesh() == 0: theVal = self._angleMeshS - self.params.SetAngleMeshS(theVal) + if self.Parameters(): + # Parameter of BLSURF algo + if self.params.GetGeometricMesh() == 0: theVal = self._angleMeshS + self.params.SetAngleMeshS(theVal) ## Sets angular deflection (in degrees) of a mesh edge from CAD curve. # @ingroup l3_hypos_blsurf def SetAngleMeshC(self, theVal=_angleMeshS): - # Parameter of BLSURF algo - if self.Parameters().GetGeometricMesh() == 0: theVal = self._angleMeshS - self.params.SetAngleMeshC(theVal) + if self.Parameters(): + # Parameter of BLSURF algo + if self.params.GetGeometricMesh() == 0: theVal = self._angleMeshS + self.params.SetAngleMeshC(theVal) ## Sets lower boundary of mesh element size computed to respect angular deflection. # @ingroup l3_hypos_blsurf def SetGeoMin(self, theVal=-1): - # Parameter of BLSURF algo - self.Parameters().SetGeoMin(theVal) + if self.Parameters(): + # Parameter of BLSURF algo + self.params.SetGeoMin(theVal) ## Sets upper boundary of mesh element size computed to respect angular deflection. # @ingroup l3_hypos_blsurf def SetGeoMax(self, theVal=-1): - # Parameter of BLSURF algo - self.Parameters().SetGeoMax(theVal) + if self.Parameters(): + # Parameter of BLSURF algo + self.params.SetGeoMax(theVal) ## Sets maximal allowed ratio between the lengths of two adjacent edges. # @ingroup l3_hypos_blsurf def SetGradation(self, theVal=_gradation): - # Parameter of BLSURF algo - if self.Parameters().GetGeometricMesh() == 0: theVal = self._gradation - self.params.SetGradation(theVal) + if self.Parameters(): + # Parameter of BLSURF algo + if self.params.GetGeometricMesh() == 0: theVal = self._gradation + self.params.SetGradation(theVal) ## Sets topology usage way. # @param way defines how mesh conformity is assured + #
  • PreProcess or PreProcessPlus - by pre-processing a CAD model
    • + #
  • PreCAD - by pre-processing with PreCAD a CAD model
    • # @ingroup l3_hypos_blsurf def SetTopology(self, way): - # Parameter of BLSURF algo - self.Parameters().SetTopology(way) + if self.Parameters(): + # Parameter of BLSURF algo + self.params.SetTopology(way) ## To respect geometrical edges or not. # @ingroup l3_hypos_blsurf def SetDecimesh(self, toIgnoreEdges=False): - # Parameter of BLSURF algo - self.Parameters().SetDecimesh(toIgnoreEdges) + if self.Parameters(): + # Parameter of BLSURF algo + self.params.SetDecimesh(toIgnoreEdges) ## Sets verbosity level in the range 0 to 100. # @ingroup l3_hypos_blsurf def SetVerbosity(self, level): - # Parameter of BLSURF algo - self.Parameters().SetVerbosity(level) + if self.Parameters(): + # Parameter of BLSURF algo + self.params.SetVerbosity(level) + + ## To optimize merges edges. + # @ingroup l3_hypos_blsurf + def SetPreCADMergeEdges(self, toMergeEdges=False): + if self.Parameters(): + # Parameter of BLSURF algo + self.params.SetPreCADMergeEdges(toMergeEdges) + + ## To remove nano edges. + # @ingroup l3_hypos_blsurf + def SetPreCADRemoveNanoEdges(self, toRemoveNanoEdges=False): + if self.Parameters(): + # Parameter of BLSURF algo + self.params.SetPreCADRemoveNanoEdges(toRemoveNanoEdges) + + ## To compute topology from scratch + # @ingroup l3_hypos_blsurf + def SetPreCADDiscardInput(self, toDiscardInput=False): + if self.Parameters(): + # Parameter of BLSURF algo + self.params.SetPreCADDiscardInput(toDiscardInput) + + ## Sets the length below which an edge is considered as nano + # for the topology processing. + # @ingroup l3_hypos_blsurf + def SetPreCADEpsNano(self, epsNano): + if self.Parameters(): + # Parameter of BLSURF algo + self.params.SetPreCADEpsNano(epsNano) ## Sets advanced option value. # @ingroup l3_hypos_blsurf def SetOptionValue(self, optionName, level): - # Parameter of BLSURF algo - self.Parameters().SetOptionValue(optionName,level) + if self.Parameters(): + # Parameter of BLSURF algo + self.params.SetOptionValue(optionName,level) + + ## Sets advanced PreCAD option value. + # Keyword arguments: + # optionName: name of the option + # optionValue: value of the option + # @ingroup l3_hypos_blsurf + def SetPreCADOptionValue(self, optionName, optionValue): + if self.Parameters(): + # Parameter of BLSURF algo + self.params.SetPreCADOptionValue(optionName,optionValue) + + ## Sets GMF file for export at computation + # @ingroup l3_hypos_blsurf + def SetGMFFile(self, fileName): + if self.Parameters(): + # Parameter of BLSURF algo + self.params.SetGMFFile(fileName) + + ## Enforced vertices (BLSURF) + + ## To get all the enforced vertices + # @ingroup l3_hypos_blsurf + def GetAllEnforcedVertices(self): + if self.Parameters(): + # Parameter of BLSURF algo + return self.params.GetAllEnforcedVertices() + + ## To get all the enforced vertices sorted by face (or group, compound) + # @ingroup l3_hypos_blsurf + def GetAllEnforcedVerticesByFace(self): + if self.Parameters(): + # Parameter of BLSURF algo + return self.params.GetAllEnforcedVerticesByFace() + + ## To get all the enforced vertices sorted by coords of input vertices + # @ingroup l3_hypos_blsurf + def GetAllEnforcedVerticesByCoords(self): + if self.Parameters(): + # Parameter of BLSURF algo + return self.params.GetAllEnforcedVerticesByCoords() + + ## To get all the coords of input vertices sorted by face (or group, compound) + # @ingroup l3_hypos_blsurf + def GetAllCoordsByFace(self): + if self.Parameters(): + # Parameter of BLSURF algo + return self.params.GetAllCoordsByFace() + + ## To get all the enforced vertices on a face (or group, compound) + # @param theFace : GEOM face (or group, compound) on which to define an enforced vertex + # @ingroup l3_hypos_blsurf + def GetEnforcedVertices(self, theFace): + if self.Parameters(): + # Parameter of BLSURF algo + AssureGeomPublished( self.mesh, theFace ) + return self.params.GetEnforcedVertices(theFace) + + ## To clear all the enforced vertices + # @ingroup l3_hypos_blsurf + def ClearAllEnforcedVertices(self): + if self.Parameters(): + # Parameter of BLSURF algo + return self.params.ClearAllEnforcedVertices() + + ## To set an enforced vertex on a face (or group, compound) given the coordinates of a point. If the point is not on the face, it will projected on it. If there is no projection, no enforced vertex is created. + # @param theFace : GEOM face (or group, compound) on which to define an enforced vertex + # @param x : x coordinate + # @param y : y coordinate + # @param z : z coordinate + # @param vertexName : name of the enforced vertex + # @param groupName : name of the group + # @ingroup l3_hypos_blsurf + def SetEnforcedVertex(self, theFace, x, y, z, vertexName = "", groupName = ""): + if self.Parameters(): + # Parameter of BLSURF algo + AssureGeomPublished( self.mesh, theFace ) + if vertexName == "": + if groupName == "": + return self.params.SetEnforcedVertex(theFace, x, y, z) + else: + return self.params.SetEnforcedVertexWithGroup(theFace, x, y, z, groupName) + else: + if groupName == "": + return self.params.SetEnforcedVertexNamed(theFace, x, y, z, vertexName) + else: + return self.params.SetEnforcedVertexNamedWithGroup(theFace, x, y, z, vertexName, groupName) + + ## To set an enforced vertex on a face (or group, compound) given a GEOM vertex, group or compound. + # @param theFace : GEOM face (or group, compound) on which to define an enforced vertex + # @param theVertex : GEOM vertex (or group, compound) to be projected on theFace. + # @param groupName : name of the group + # @ingroup l3_hypos_blsurf + def SetEnforcedVertexGeom(self, theFace, theVertex, groupName = ""): + if self.Parameters(): + # Parameter of BLSURF algo + AssureGeomPublished( self.mesh, theFace ) + AssureGeomPublished( self.mesh, theVertex ) + if groupName == "": + return self.params.SetEnforcedVertexGeom(theFace, theVertex) + else: + return self.params.SetEnforcedVertexGeomWithGroup(theFace, theVertex,groupName) + + ## To remove an enforced vertex on a given GEOM face (or group, compound) given the coordinates. + # @param theFace : GEOM face (or group, compound) on which to remove the enforced vertex + # @param x : x coordinate + # @param y : y coordinate + # @param z : z coordinate + # @ingroup l3_hypos_blsurf + def UnsetEnforcedVertex(self, theFace, x, y, z): + if self.Parameters(): + # Parameter of BLSURF algo + AssureGeomPublished( self.mesh, theFace ) + return self.params.UnsetEnforcedVertex(theFace, x, y, z) + + ## To remove an enforced vertex on a given GEOM face (or group, compound) given a GEOM vertex, group or compound. + # @param theFace : GEOM face (or group, compound) on which to remove the enforced vertex + # @param theVertex : GEOM vertex (or group, compound) to remove. + # @ingroup l3_hypos_blsurf + def UnsetEnforcedVertexGeom(self, theFace, theVertex): + if self.Parameters(): + # Parameter of BLSURF algo + AssureGeomPublished( self.mesh, theFace ) + AssureGeomPublished( self.mesh, theVertex ) + return self.params.UnsetEnforcedVertexGeom(theFace, theVertex) + + ## To remove all enforced vertices on a given face. + # @param theFace : face (or group/compound of faces) on which to remove all enforced vertices + # @ingroup l3_hypos_blsurf + def UnsetEnforcedVertices(self, theFace): + if self.Parameters(): + # Parameter of BLSURF algo + AssureGeomPublished( self.mesh, theFace ) + return self.params.UnsetEnforcedVertices(theFace) + + ## To tell BLSURF to add a node on internal vertices + # @param toEnforceInternalVertices : boolean; if True the internal vertices are added as enforced vertices + # @ingroup l3_hypos_blsurf + def SetInternalEnforcedVertexAllFaces(self, toEnforceInternalVertices): + if self.Parameters(): + # Parameter of BLSURF algo + return self.params.SetInternalEnforcedVertexAllFaces(toEnforceInternalVertices) + + ## To know if BLSURF will add a node on internal vertices + # @ingroup l3_hypos_blsurf + def GetInternalEnforcedVertexAllFaces(self): + if self.Parameters(): + # Parameter of BLSURF algo + return self.params.GetInternalEnforcedVertexAllFaces() + + ## To define a group for the nodes of internal vertices + # @param groupName : string; name of the group + # @ingroup l3_hypos_blsurf + def SetInternalEnforcedVertexAllFacesGroup(self, groupName): + if self.Parameters(): + # Parameter of BLSURF algo + return self.params.SetInternalEnforcedVertexAllFacesGroup(groupName) + + ## To get the group name of the nodes of internal vertices + # @ingroup l3_hypos_blsurf + def GetInternalEnforcedVertexAllFacesGroup(self): + if self.Parameters(): + # Parameter of BLSURF algo + return self.params.GetInternalEnforcedVertexAllFacesGroup() + + ## Attractors (BLSURF) + + ## Sets an attractor on the chosen face. The mesh size will decrease exponentially with the distance from theAttractor, following the rule h(d) = theEndSize - (theEndSize - theStartSize) * exp [ - ( d / theInfluenceDistance ) ^ 2 ] + # @param theFace : face on which the attractor will be defined + # @param theAttractor : geometrical object from which the mesh size "h" decreases exponentially + # @param theStartSize : mesh size on theAttractor + # @param theEndSize : maximum size that will be reached on theFace + # @param theInfluenceDistance : influence of the attractor ( the size grow slower on theFace if it's high) + # @param theConstantSizeDistance : distance until which the mesh size will be kept constant on theFace + # @ingroup l3_hypos_blsurf + def SetAttractorGeom(self, theFace, theAttractor, theStartSize, theEndSize, theInfluenceDistance, theConstantSizeDistance): + if self.Parameters(): + # Parameter of BLSURF algo + AssureGeomPublished( self.mesh, theFace ) + AssureGeomPublished( self.mesh, theAttractor ) + self.params.SetAttractorGeom(theFace, theAttractor, theStartSize, theEndSize, theInfluenceDistance, theConstantSizeDistance) + + ## Unsets an attractor on the chosen face. + # @param theFace : face on which the attractor has to be removed + # @ingroup l3_hypos_blsurf + def UnsetAttractorGeom(self, theFace): + if self.Parameters(): + # Parameter of BLSURF algo + AssureGeomPublished( self.mesh, theFace ) + self.params.SetAttractorGeom(theFace) + + ## Size maps (BLSURF) + + ## To set a size map on a face, edge or vertex (or group, compound) given Python function. + # If theObject is a face, the function can be: def f(u,v): return u+v + # If theObject is an edge, the function can be: def f(t): return t/2 + # If theObject is a vertex, the function can be: def f(): return 10 + # @param theObject : GEOM face, edge or vertex (or group, compound) on which to define a size map + # @param theSizeMap : Size map defined as a string + # @ingroup l3_hypos_blsurf + def SetSizeMap(self, theObject, theSizeMap): + if self.Parameters(): + # Parameter of BLSURF algo + AssureGeomPublished( self.mesh, theObject ) + return self.params.SetSizeMap(theObject, theSizeMap) + + ## To remove a size map defined on a face, edge or vertex (or group, compound) + # @param theObject : GEOM face, edge or vertex (or group, compound) on which to define a size map + # @ingroup l3_hypos_blsurf + def UnsetSizeMap(self, theObject): + if self.Parameters(): + # Parameter of BLSURF algo + AssureGeomPublished( self.mesh, theObject ) + return self.params.UnsetSizeMap(theObject) + + ## To remove all the size maps + # @ingroup l3_hypos_blsurf + def ClearSizeMaps(self): + if self.Parameters(): + # Parameter of BLSURF algo + return self.params.ClearSizeMaps() + ## Sets QuadAllowed flag. - # Only for algoType == NETGEN || NETGEN_2D || BLSURF + # Only for algoType == NETGEN(NETGEN_1D2D) || NETGEN_2D || BLSURF # @ingroup l3_hypos_netgen l3_hypos_blsurf def SetQuadAllowed(self, toAllow=True): if self.algoType == NETGEN_2D: - if toAllow: # add QuadranglePreference - self.Hypothesis("QuadranglePreference", UseExisting=1, CompareMethod=self.CompareEqualHyp) - else: # remove QuadranglePreference + if not self.params: + # use simple hyps + hasSimpleHyps = False + simpleHyps = ["QuadranglePreference","LengthFromEdges","MaxElementArea"] for hyp in self.mesh.GetHypothesisList( self.geom ): - if hyp.GetName() == "QuadranglePreference": - self.mesh.RemoveHypothesis( self.geom, hyp ) + if hyp.GetName() in simpleHyps: + hasSimpleHyps = True + if hyp.GetName() == "QuadranglePreference": + if not toAllow: # remove QuadranglePreference + self.mesh.RemoveHypothesis( self.geom, hyp ) + pass + return pass pass + if hasSimpleHyps: + if toAllow: # add QuadranglePreference + self.Hypothesis("QuadranglePreference", UseExisting=1, CompareMethod=self.CompareEqualHyp) + pass + return pass - return + pass if self.Parameters(): self.params.SetQuadAllowed(toAllow) return @@ -3965,30 +5562,25 @@ class Mesh_Triangle(Mesh_Algorithm): # # @ingroup l3_hypos_netgen def Parameters(self, which=SOLE): - if self.params: - return self.params - if self.algoType == NETGEN: - if which == SIMPLE: - self.params = self.Hypothesis("NETGEN_SimpleParameters_2D", [], + if not self.params: + if self.algoType == NETGEN: + if which == SIMPLE: + self.params = self.Hypothesis("NETGEN_SimpleParameters_2D", [], + "libNETGENEngine.so", UseExisting=0) + else: + self.params = self.Hypothesis("NETGEN_Parameters_2D", [], + "libNETGENEngine.so", UseExisting=0) + elif self.algoType == MEFISTO: + print "Mefisto algo support no multi-parameter hypothesis" + elif self.algoType == NETGEN_2D: + self.params = self.Hypothesis("NETGEN_Parameters_2D_ONLY", [], "libNETGENEngine.so", UseExisting=0) + elif self.algoType == BLSURF: + self.params = self.Hypothesis("BLSURF_Parameters", [], + "libBLSURFEngine.so", UseExisting=0) else: - self.params = self.Hypothesis("NETGEN_Parameters_2D", [], - "libNETGENEngine.so", UseExisting=0) - return self.params - elif self.algoType == MEFISTO: - print "Mefisto algo support no multi-parameter hypothesis" - return None - elif self.algoType == NETGEN_2D: - print "NETGEN_2D_ONLY algo support no multi-parameter hypothesis" - print "NETGEN_2D_ONLY uses 'MaxElementArea' and 'LengthFromEdges' ones" - return None - elif self.algoType == BLSURF: - self.params = self.Hypothesis("BLSURF_Parameters", [], - "libBLSURFEngine.so", UseExisting=0) - return self.params - else: - print "Mesh_Triangle with algo type %s does not have such a parameter, check algo type"%self.algoType - return None + print "Mesh_Triangle with algo type %s does not have such a parameter, check algo type"%self.algoType + return self.params ## Sets MaxSize # @@ -4073,30 +5665,97 @@ class Mesh_Triangle(Mesh_Algorithm): # @ingroup l3_algos_basic class Mesh_Quadrangle(Mesh_Algorithm): + params=0 + ## Private constructor. def __init__(self, mesh, geom=0): Mesh_Algorithm.__init__(self) self.Create(mesh, geom, "Quadrangle_2D") + return - ## Defines "QuadranglePreference" hypothesis, forcing construction - # of quadrangles if the number of nodes on the opposite edges is not the same - # while the total number of nodes on edges is even - # - # @ingroup l3_hypos_additi - def QuadranglePreference(self): - hyp = self.Hypothesis("QuadranglePreference", UseExisting=1, - CompareMethod=self.CompareEqualHyp) - return hyp + ## Defines "QuadrangleParameters" hypothesis + # @param quadType defines the algorithm of transition between differently descretized + # sides of a geometrical face: + # - QUAD_STANDARD - both triangles and quadrangles are possible in the transition + # area along the finer meshed sides. + # - QUAD_TRIANGLE_PREF - only triangles are built in the transition area along the + # finer meshed sides. + # - QUAD_QUADRANGLE_PREF - only quadrangles are built in the transition area along + # the finer meshed sides, iff the total quantity of segments on + # all four sides of the face is even (divisible by 2). + # - QUAD_QUADRANGLE_PREF_REVERSED - same as QUAD_QUADRANGLE_PREF but the transition + # area is located along the coarser meshed sides. + # - QUAD_REDUCED - only quadrangles are built and the transition between the sides + # is made gradually, layer by layer. This type has a limitation on + # the number of segments: one pair of opposite sides must have the + # same number of segments, the other pair must have an even difference + # between the numbers of segments on the sides. + # @param triangleVertex: vertex of a trilateral geometrical face, around which triangles + # will be created while other elements will be quadrangles. + # Vertex can be either a GEOM_Object or a vertex ID within the + # shape to mesh + # @param UseExisting: if ==true - searches for the existing hypothesis created with + # the same parameters, else (default) - creates a new one + # @ingroup l3_hypos_quad + def QuadrangleParameters(self, quadType=StdMeshers.QUAD_STANDARD, triangleVertex=0, UseExisting=0): + vertexID = triangleVertex + if isinstance( triangleVertex, geompyDC.GEOM._objref_GEOM_Object ): + vertexID = self.mesh.geompyD.GetSubShapeID( self.mesh.geom, triangleVertex ) + if not self.params: + compFun = lambda hyp,args: \ + hyp.GetQuadType() == args[0] and \ + ( hyp.GetTriaVertex()==args[1] or ( hyp.GetTriaVertex()<1 and args[1]<1)) + self.params = self.Hypothesis("QuadrangleParams", [quadType,vertexID], + UseExisting = UseExisting, CompareMethod=compFun) + pass + if self.params.GetQuadType() != quadType: + self.params.SetQuadType(quadType) + if vertexID > 0: + self.params.SetTriaVertex( vertexID ) + return self.params + + ## Defines "QuadrangleParams" hypothesis with a type of quadrangulation that only + # quadrangles are built in the transition area along the finer meshed sides, + # iff the total quantity of segments on all four sides of the face is even. + # @param reversed if True, transition area is located along the coarser meshed sides. + # @param UseExisting: if ==true - searches for the existing hypothesis created with + # the same parameters, else (default) - creates a new one + # @ingroup l3_hypos_quad + def QuadranglePreference(self, reversed=False, UseExisting=0): + if reversed: + return self.QuadrangleParameters(QUAD_QUADRANGLE_PREF_REVERSED,UseExisting=UseExisting) + return self.QuadrangleParameters(QUAD_QUADRANGLE_PREF,UseExisting=UseExisting) + + ## Defines "QuadrangleParams" hypothesis with a type of quadrangulation that only + # triangles are built in the transition area along the finer meshed sides. + # @param UseExisting: if ==true - searches for the existing hypothesis created with + # the same parameters, else (default) - creates a new one + # @ingroup l3_hypos_quad + def TrianglePreference(self, UseExisting=0): + return self.QuadrangleParameters(QUAD_TRIANGLE_PREF,UseExisting=UseExisting) + + ## Defines "QuadrangleParams" hypothesis with a type of quadrangulation that only + # quadrangles are built and the transition between the sides is made gradually, + # layer by layer. This type has a limitation on the number of segments: one pair + # of opposite sides must have the same number of segments, the other pair must + # have an even difference between the numbers of segments on the sides. + # @param UseExisting: if ==true - searches for the existing hypothesis created with + # the same parameters, else (default) - creates a new one + # @ingroup l3_hypos_quad + def Reduced(self, UseExisting=0): + return self.QuadrangleParameters(QUAD_REDUCED,UseExisting=UseExisting) + + ## Defines "QuadrangleParams" hypothesis with QUAD_STANDARD type of quadrangulation + # @param vertex: vertex of a trilateral geometrical face, around which triangles + # will be created while other elements will be quadrangles. + # Vertex can be either a GEOM_Object or a vertex ID within the + # shape to mesh + # @param UseExisting: if ==true - searches for the existing hypothesis created with + # the same parameters, else (default) - creates a new one + # @ingroup l3_hypos_quad + def TriangleVertex(self, vertex, UseExisting=0): + return self.QuadrangleParameters(QUAD_STANDARD,vertex,UseExisting) - ## Defines "TrianglePreference" hypothesis, forcing construction - # of triangles in the refinement area if the number of nodes - # on the opposite edges is not the same - # - # @ingroup l3_hypos_additi - def TrianglePreference(self): - hyp = self.Hypothesis("TrianglePreference", UseExisting=1, - CompareMethod=self.CompareEqualHyp) - return hyp # Public class: Mesh_Tetrahedron # ------------------------------ @@ -4114,22 +5773,22 @@ class Mesh_Tetrahedron(Mesh_Algorithm): Mesh_Algorithm.__init__(self) if algoType == NETGEN: + CheckPlugin(NETGEN) self.Create(mesh, geom, "NETGEN_3D", "libNETGENEngine.so") pass elif algoType == FULL_NETGEN: - if noNETGENPlugin: - print "Warning: NETGENPlugin module has not been imported." + CheckPlugin(NETGEN) self.Create(mesh, geom, "NETGEN_2D3D", "libNETGENEngine.so") pass elif algoType == GHS3D: - import GHS3DPlugin + CheckPlugin(GHS3D) self.Create(mesh, geom, "GHS3D_3D" , "libGHS3DEngine.so") pass elif algoType == GHS3DPRL: - import GHS3DPRLPlugin + CheckPlugin(GHS3DPRL) self.Create(mesh, geom, "GHS3DPRL_3D" , "libGHS3DPRLEngine.so") pass @@ -4158,33 +5817,34 @@ class Mesh_Tetrahedron(Mesh_Algorithm): # # @ingroup l3_hypos_netgen def Parameters(self, which=SOLE): - if self.params: - return self.params + if not self.params: - if self.algoType == FULL_NETGEN: - if which == SIMPLE: - self.params = self.Hypothesis("NETGEN_SimpleParameters_3D", [], - "libNETGENEngine.so", UseExisting=0) - else: - self.params = self.Hypothesis("NETGEN_Parameters", [], + if self.algoType == FULL_NETGEN: + if which == SIMPLE: + self.params = self.Hypothesis("NETGEN_SimpleParameters_3D", [], + "libNETGENEngine.so", UseExisting=0) + else: + self.params = self.Hypothesis("NETGEN_Parameters", [], + "libNETGENEngine.so", UseExisting=0) + + elif self.algoType == NETGEN: + self.params = self.Hypothesis("NETGEN_Parameters_3D", [], "libNETGENEngine.so", UseExisting=0) - return self.params - if self.algoType == GHS3D: - self.params = self.Hypothesis("GHS3D_Parameters", [], - "libGHS3DEngine.so", UseExisting=0) - return self.params + elif self.algoType == GHS3D: + self.params = self.Hypothesis("GHS3D_Parameters", [], + "libGHS3DEngine.so", UseExisting=0) - if self.algoType == GHS3DPRL: - self.params = self.Hypothesis("GHS3DPRL_Parameters", [], - "libGHS3DPRLEngine.so", UseExisting=0) - return self.params + elif self.algoType == GHS3DPRL: + self.params = self.Hypothesis("GHS3DPRL_Parameters", [], + "libGHS3DPRLEngine.so", UseExisting=0) + else: + print "Warning: %s supports no multi-parameter hypothesis"%self.algo.GetName() - print "Algo supports no multi-parameter hypothesis" - return None + return self.params ## Sets MaxSize - # Parameter of FULL_NETGEN + # Parameter of FULL_NETGEN and NETGEN # @ingroup l3_hypos_netgen def SetMaxSize(self, theSize): self.Parameters().SetMaxSize(theSize) @@ -4196,7 +5856,7 @@ class Mesh_Tetrahedron(Mesh_Algorithm): self.Parameters().SetSecondOrder(theVal) ## Sets Optimize flag - # Parameter of FULL_NETGEN + # Parameter of FULL_NETGEN and NETGEN # @ingroup l3_hypos_netgen def SetOptimize(self, theVal): self.Parameters().SetOptimize(theVal) @@ -4264,40 +5924,47 @@ class Mesh_Tetrahedron(Mesh_Algorithm): # @ingroup l3_hypos_ghs3dh def SetToMeshHoles(self, toMesh): # Parameter of GHS3D - self.Parameters().SetToMeshHoles(toMesh) + if self.Parameters(): + self.params.SetToMeshHoles(toMesh) ## Set Optimization level: - # None_Optimization, Light_Optimization, Medium_Optimization, Strong_Optimization. - # Default is Medium_Optimization + # None_Optimization, Light_Optimization, Standard_Optimization, StandardPlus_Optimization, + # Strong_Optimization. + # Default is Standard_Optimization # @ingroup l3_hypos_ghs3dh def SetOptimizationLevel(self, level): # Parameter of GHS3D - self.Parameters().SetOptimizationLevel(level) + if self.Parameters(): + self.params.SetOptimizationLevel(level) ## Maximal size of memory to be used by the algorithm (in Megabytes). # @ingroup l3_hypos_ghs3dh def SetMaximumMemory(self, MB): # Advanced parameter of GHS3D - self.Parameters().SetMaximumMemory(MB) + if self.Parameters(): + self.params.SetMaximumMemory(MB) ## Initial size of memory to be used by the algorithm (in Megabytes) in # automatic memory adjustment mode. # @ingroup l3_hypos_ghs3dh def SetInitialMemory(self, MB): # Advanced parameter of GHS3D - self.Parameters().SetInitialMemory(MB) + if self.Parameters(): + self.params.SetInitialMemory(MB) ## Path to working directory. # @ingroup l3_hypos_ghs3dh def SetWorkingDirectory(self, path): # Advanced parameter of GHS3D - self.Parameters().SetWorkingDirectory(path) + if self.Parameters(): + self.params.SetWorkingDirectory(path) ## To keep working files or remove them. Log file remains in case of errors anyway. # @ingroup l3_hypos_ghs3dh def SetKeepFiles(self, toKeep): # Advanced parameter of GHS3D and GHS3DPRL - self.Parameters().SetKeepFiles(toKeep) + if self.Parameters(): + self.params.SetKeepFiles(toKeep) ## To set verbose level [0-10].