X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FSMESH_SWIG%2FsmeshDC.py;h=b02092b41722505f2f3a152093b574cd2d9e1eff;hb=f734fda203f27eb6158f3d8b93a2e00f9f437b62;hp=9099e7af8c972ed489a9df241363d8bc0121b70f;hpb=2c607013a23bd4e7ba07e72e0c04dee2c1209cff;p=modules%2Fsmesh.git diff --git a/src/SMESH_SWIG/smeshDC.py b/src/SMESH_SWIG/smeshDC.py index 9099e7af8..b02092b41 100644 --- a/src/SMESH_SWIG/smeshDC.py +++ b/src/SMESH_SWIG/smeshDC.py @@ -188,10 +188,10 @@ None_Optimization, Light_Optimization, Medium_Optimization, Strong_Optimization 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 @@ -490,6 +490,45 @@ def CheckPlugin(plugin): 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 ## @} @@ -666,6 +705,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 @@ -766,6 +816,8 @@ class smeshDC(SMESH._objref_SMESH_Gen): UnaryOp=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) @@ -781,7 +833,7 @@ 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 @@ -821,6 +873,7 @@ class smeshDC(SMESH._objref_SMESH_Gen): # Checks the treshold try: aCriterion.Threshold = self.EnumToLong(aTreshold) + assert( aTreshold in SMESH.GeometryType._items ) except: if isinstance(aTreshold, int): aCriterion.Threshold = aTreshold @@ -896,6 +949,19 @@ class smeshDC(SMESH._objref_SMESH_Gen): 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 # @param theCriterion FT_...; functor type # @return SMESH_NumericalFunctor @@ -940,14 +1006,14 @@ class smeshDC(SMESH._objref_SMESH_Gen): def CreateHypothesis(self, theHType, theLibName="libStdMeshersEngine.so"): return SMESH._objref_SMESH_Gen.CreateHypothesis(self, theHType, theLibName ) - ## Gets the mesh stattistic - # @return dictionary type element - count of elements + ## 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, "_narrow") and obj._narrow(SMESH.SMESH_IDSource): + 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] @@ -1151,19 +1217,7 @@ class Mesh: # @return an object of type SMESH_SubMesh, representing a part of mesh, which lies on the given shape # @ingroup l2_submeshes def GetSubMesh(self, geom, name): - if not geom.IsSame( self.geom ) and not geom.GetStudyEntry(): - ## set the study - studyID = self.smeshpyD.GetCurrentStudy()._get_StudyId() - if studyID != self.geompyD.myStudyId: - self.geompyD.init_geom( self.smeshpyD.GetCurrentStudy()) - ## get a name - if not name and geom.GetShapeType() != geompyDC.GEOM.COMPOUND: - # for all groups SubShapeName() returns "Compound_-1" - name = self.geompyD.SubShapeName(geom, self.geom) - if not name: - name = "%s_%s"%(geom.GetShapeType(), id(geom)%10000) - ## publish - self.geompyD.addToStudyInFather( self.geom, geom, name ) + AssureGeomPublished( self, geom, name ) submesh = self.mesh.GetSubMesh( geom, name ) return submesh @@ -1567,7 +1621,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): @@ -1584,7 +1638,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): @@ -1654,24 +1708,13 @@ 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 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, ... + # 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, overwrite=1): @@ -1685,29 +1728,66 @@ class Mesh: # 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): - self.mesh.ExportToMEDX(f, auto_groups, version, overwrite) + 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 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: # ---------------------- @@ -1720,6 +1800,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 @@ -1730,58 +1821,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": - try: # it raises on a compound of compounds - if len( self.geompyD.GetObjectIDs( grp )) == 0: - print "Mesh.Group: empty geometric group", GetName( grp ) - return 0 - pass - except: - pass - if grp.GetType() == 37: # GEOMImpl_Types.hxx: #define GEOM_GROUP 37 - # group - 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 - pass - pass - else: - # just a compound - for elemType, shapeType in [[VOLUME,"SOLID"],[FACE,"FACE"], - [EDGE,"EDGE"],[NODE,"VERTEX"]]: - if self.geompyD.SubShapeAll(grp,geompyDC.ShapeType[shapeType]): - typ = elemType - break - pass - pass - pass - pass - 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 @@ -2455,7 +2532,7 @@ class Mesh: return result ## Get measure structure specifying bounding box data of the specified object(s) - # @param objects single source object or list of source objects or list of nodes/elements IDs + # @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 @@ -2714,10 +2791,14 @@ class Mesh: # @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): - return self.editor.FindElementsByPoint(x, y, z, elementType) + 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. @@ -4097,6 +4178,7 @@ class Mesh: # 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, theMakeGroup=False): @@ -4427,7 +4509,7 @@ class Mesh_Algorithm: self.geom = mesh.geom else: self.geom = geom - self.AssureGeomPublished( geom ) + AssureGeomPublished( mesh, geom ) try: name = GetName(geom) pass @@ -4439,25 +4521,6 @@ class Mesh_Algorithm: TreatHypoStatus( status, algo.GetName(), name, True ) return - ## Private method. Add geom into the study if not yet there - def AssureGeomPublished(self, geom, name=''): - if not isinstance( geom, geompyDC.GEOM._objref_GEOM_Object ): - return - if not geom.IsSame( self.mesh.geom ) and not geom.GetStudyEntry(): - ## set the study - studyID = self.mesh.smeshpyD.GetCurrentStudy()._get_StudyId() - if studyID != self.mesh.geompyD.myStudyId: - self.mesh.geompyD.init_geom( self.mesh.smeshpyD.GetCurrentStudy()) - ## get a name - if not name and geom.GetShapeType() != geompyDC.GEOM.COMPOUND: - # for all groups SubShapeName() returns "Compound_-1" - name = self.mesh.geompyD.SubShapeName(geom, self.mesh.geom) - if not name: - name = "%s_%s"%(geom.GetShapeType(), id(geom)%10000) - ## publish - self.mesh.geompyD.addToStudyInFather( self.mesh.geom, geom, name ) - return - def CompareHyp (self, hyp, args): print "CompareHyp is not implemented for ", self.__class__.__name__, ":", hyp.GetName() return False @@ -4528,6 +4591,42 @@ class Mesh_Algorithm: 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 + # @ingroupl3_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 # -------------------------- @@ -4600,7 +4699,8 @@ class Mesh_Segment(Mesh_Algorithm): ## 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 + # @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 @@ -4609,20 +4709,19 @@ class Mesh_Segment(Mesh_Algorithm): if not isinstance(reversedEdges,list): #old version script, before adding reversedEdges reversedEdges, UseExisting = [], reversedEdges entry = self.MainShapeEntry() - if reversedEdges and isinstance(reversedEdges[0],geompyDC.GEOM._objref_GEOM_Object): - reversedEdges = [ self.mesh.geompyD.GetSubShapeID(self.mesh.geom, e) for e in reversedEdges ] + reversedEdgeInd = self.ReversedEdgeIndices(reversedEdges) if s == []: - hyp = self.Hypothesis("NumberOfSegments", [n, reversedEdges, entry], + hyp = self.Hypothesis("NumberOfSegments", [n, reversedEdgeInd, entry], UseExisting=UseExisting, CompareMethod=self.CompareNumberOfSegments) else: - hyp = self.Hypothesis("NumberOfSegments", [n,s, reversedEdges, entry], + hyp = self.Hypothesis("NumberOfSegments", [n,s, reversedEdgeInd, entry], UseExisting=UseExisting, CompareMethod=self.CompareNumberOfSegments) hyp.SetDistrType( 1 ) hyp.SetScaleFactor(s) hyp.SetNumberOfSegments(n) - hyp.SetReversedEdges( reversedEdges ) + hyp.SetReversedEdges( reversedEdgeInd ) hyp.SetObjectEntry( entry ) return hyp @@ -4645,7 +4744,8 @@ class Mesh_Segment(Mesh_Algorithm): ## 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 + # @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 @@ -4653,15 +4753,14 @@ class Mesh_Segment(Mesh_Algorithm): def Arithmetic1D(self, start, end, reversedEdges=[], UseExisting=0): if not isinstance(reversedEdges,list): #old version script, before adding reversedEdges reversedEdges, UseExisting = [], reversedEdges - if reversedEdges and isinstance(reversedEdges[0],geompyDC.GEOM._objref_GEOM_Object): - reversedEdges = [ self.mesh.geompyD.GetSubShapeID(self.mesh.geom, e) for e in reversedEdges ] + reversedEdgeInd = self.ReversedEdgeIndices(reversedEdges) entry = self.MainShapeEntry() - hyp = self.Hypothesis("Arithmetic1D", [start, end, reversedEdges, entry], + hyp = self.Hypothesis("Arithmetic1D", [start, end, reversedEdgeInd, entry], UseExisting=UseExisting, CompareMethod=self.CompareArithmetic1D) hyp.SetStartLength(start) hyp.SetEndLength(end) - hyp.SetReversedEdges( reversedEdges ) + hyp.SetReversedEdges( reversedEdgeInd ) hyp.SetObjectEntry( entry ) return hyp @@ -4683,7 +4782,8 @@ class Mesh_Segment(Mesh_Algorithm): # 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 + # @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 @@ -4691,15 +4791,14 @@ class Mesh_Segment(Mesh_Algorithm): def FixedPoints1D(self, points, nbSegs=[1], reversedEdges=[], UseExisting=0): if not isinstance(reversedEdges,list): #old version script, before adding reversedEdges reversedEdges, UseExisting = [], reversedEdges - if reversedEdges and isinstance(reversedEdges[0],geompyDC.GEOM._objref_GEOM_Object): - reversedEdges = [ self.mesh.geompyD.GetSubShapeID(self.mesh.geom, e) for e in reversedEdges ] + reversedEdgeInd = self.ReversedEdgeIndices(reversedEdges) entry = self.MainShapeEntry() - hyp = self.Hypothesis("FixedPoints1D", [points, nbSegs, reversedEdges, entry], + hyp = self.Hypothesis("FixedPoints1D", [points, nbSegs, reversedEdgeInd, entry], UseExisting=UseExisting, CompareMethod=self.CompareFixedPoints1D) hyp.SetPoints(points) hyp.SetNbSegments(nbSegs) - hyp.SetReversedEdges(reversedEdges) + hyp.SetReversedEdges(reversedEdgeInd) hyp.SetObjectEntry(entry) return hyp @@ -4719,7 +4818,8 @@ class Mesh_Segment(Mesh_Algorithm): ## 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 + # @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 @@ -4727,15 +4827,14 @@ class Mesh_Segment(Mesh_Algorithm): def StartEndLength(self, start, end, reversedEdges=[], UseExisting=0): if not isinstance(reversedEdges,list): #old version script, before adding reversedEdges reversedEdges, UseExisting = [], reversedEdges - if reversedEdges and isinstance(reversedEdges[0],geompyDC.GEOM._objref_GEOM_Object): - reversedEdges = [ self.mesh.geompyD.GetSubShapeID(self.mesh.geom, e) for e in reversedEdges ] + reversedEdgeInd = self.ReversedEdgeIndices(reversedEdges) entry = self.MainShapeEntry() - hyp = self.Hypothesis("StartEndLength", [start, end, reversedEdges, entry], + hyp = self.Hypothesis("StartEndLength", [start, end, reversedEdgeInd, entry], UseExisting=UseExisting, CompareMethod=self.CompareStartEndLength) hyp.SetStartLength(start) hyp.SetEndLength(end) - hyp.SetReversedEdges( reversedEdges ) + hyp.SetReversedEdges( reversedEdgeInd ) hyp.SetObjectEntry( entry ) return hyp @@ -4807,7 +4906,7 @@ class Mesh_Segment(Mesh_Algorithm): ### 0D algorithm if self.geom is None: raise RuntimeError, "Attemp to create SegmentAroundVertex_0D algoritm on None shape" - self.AssureGeomPublished( self.geom ) + AssureGeomPublished( self.mesh, self.geom ) name = GetName(self.geom) algo = self.FindAlgorithm("SegmentAroundVertex_0D", self.mesh.smeshpyD) @@ -4905,7 +5004,6 @@ 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 @@ -4922,6 +5020,8 @@ class Mesh_Triangle(Mesh_Algorithm): 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 @@ -4957,98 +5057,276 @@ 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.SetPhysicalMesh(1) #Custom - else why to set the size? - 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: 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 + #
  • 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) + + ## 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 @@ -5059,18 +5337,52 @@ class Mesh_Triangle(Mesh_Algorithm): # @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): - self.AssureGeomPublished( theFace ) - self.AssureGeomPublished( theAttractor ) - # Parameter of BLSURF algo - self.Parameters().SetAttractorGeom(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): - self.AssureGeomPublished( theFace ) - # Parameter of BLSURF algo - self.Parameters().SetAttractorGeom(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_1D2D) || NETGEN_2D || BLSURF @@ -5468,7 +5780,8 @@ 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, Standard_Optimization, StandardPlus_Optimization, @@ -5477,32 +5790,37 @@ class Mesh_Tetrahedron(Mesh_Algorithm): # @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].