# Copyright (C) 2007-2013 CEA/DEN, EDF R&D, OPEN CASCADE # # 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. # # 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 # ## # @package StdMeshersDC # Python API for the standard meshing plug-in module. from smesh_algorithm import Mesh_Algorithm from smesh import AssureGeomPublished, IsEqual, ParseParameters from smesh import GetName, TreatHypoStatus from smeshDC import Mesh import StdMeshers #---------------------------- # Mesh algo type identifiers #---------------------------- ## Algorithm type: Regular 1D algorithm, see StdMeshersDC_Segment REGULAR = "Regular_1D" ## Algorithm type: Python 1D algorithm, see StdMeshersDC_Segment_Python PYTHON = "Python_1D" ## Algorithm type: Composite segment 1D algorithm, see StdMeshersDC_CompositeSegment COMPOSITE = "CompositeSegment_1D" ## Algorithm type: Triangle MEFISTO 2D algorithm, see StdMeshersDC_Triangle_MEFISTO MEFISTO = "MEFISTO_2D" ## Algorithm type: Hexahedron 3D (i-j-k) algorithm, see StdMeshersDC_Hexahedron Hexa = "Hexa_3D" ## Algorithm type: Quadrangle 2D algorithm, see StdMeshersDC_Quadrangle QUADRANGLE = "Quadrangle_2D" ## Algorithm type: Radial Quadrangle 1D-2D algorithm, see StdMeshersDC_RadialQuadrangle1D2D RADIAL_QUAD = "RadialQuadrangle_1D2D" # import items of enum QuadType for e in StdMeshers.QuadType._items: exec('%s = StdMeshers.%s'%(e,e)) #---------------------- # Algorithms #---------------------- ## Defines segment 1D algorithm for edges discretization. # # It can be created by calling smesh.Mesh.Segment(geom=0) # # @ingroup l3_algos_basic class StdMeshersDC_Segment(Mesh_Algorithm): ## name of the dynamic method in smesh.Mesh class # @internal meshMethod = "Segment" ## type of algorithm used with helper function in smesh.Mesh class # @internal algoType = REGULAR ## flag pointing either this algorithm should be used by default in dynamic method # of smesh.Mesh class # @internal isDefault = True ## doc string of the method # @internal docHelper = "Creates segment 1D algorithm for edges" ## Private constructor. # @param mesh parent mesh object algorithm is assigned to # @param geom geometry (shape/sub-shape) algorithm is assigned to; # if it is @c 0 (default), the algorithm is assigned to the main shape def __init__(self, mesh, geom=0): Mesh_Algorithm.__init__(self) self.Create(mesh, geom, self.algoType) pass ## Defines "LocalLength" hypothesis to cut an edge in several segments with the same length # @param l for the length of segments that cut an edge # @param UseExisting if ==true - searches for an existing hypothesis created with # the same parameters, else (default) - creates a new one # @param p precision, used for calculation of the number of segments. # The precision should be a positive, meaningful value within the range [0,1]. # In general, the number of segments is calculated with the formula: # nb = ceil((edge_length / l) - p) # Function ceil rounds its argument to the higher integer. # So, p=0 means rounding of (edge_length / l) to the higher integer, # p=0.5 means rounding of (edge_length / l) to the nearest integer, # p=1 means rounding of (edge_length / l) to the lower integer. # Default value is 1e-07. # @return an instance of StdMeshers_LocalLength hypothesis # @ingroup l3_hypos_1dhyps def LocalLength(self, l, UseExisting=0, p=1e-07): comFun=lambda hyp, args: IsEqual(hyp.GetLength(), args[0]) and IsEqual(hyp.GetPrecision(), args[1]) hyp = self.Hypothesis("LocalLength", [l,p], UseExisting=UseExisting, CompareMethod=comFun) hyp.SetLength(l) hyp.SetPrecision(p) return hyp ## Defines "MaxSize" hypothesis to cut an edge into segments not longer than given value # @param length is optional maximal allowed length of segment, if it is omitted # the preestimated length is used that depends on geometry size # @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_MaxLength hypothesis # @ingroup l3_hypos_1dhyps def MaxSize(self, length=0.0, UseExisting=0): hyp = self.Hypothesis("MaxLength", [length], UseExisting=UseExisting) if length > 0.0: # set given length hyp.SetLength(length) if not UseExisting: # set preestimated length gen = self.mesh.smeshpyD initHyp = gen.GetHypothesisParameterValues("MaxLength", "libStdMeshersEngine.so", self.mesh.GetMesh(), self.mesh.GetShape(), False) # <- byMesh preHyp = initHyp._narrow(StdMeshers.StdMeshers_MaxLength) if preHyp: hyp.SetPreestimatedLength( preHyp.GetPreestimatedLength() ) pass 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=[], 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, reversedEdgeInd, entry], UseExisting=UseExisting, CompareMethod=self._compareNumberOfSegments) else: 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) == 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, reversedEdges=[], UseExisting=0): if not isinstance(reversedEdges,list): #old version script, before adding reversedEdges reversedEdges, UseExisting = [], reversedEdges reversedEdgeInd = self.ReversedEdgeIndices(reversedEdges) entry = self.MainShapeEntry() compFun = lambda hyp, args: ( IsEqual(hyp.GetLength(1), args[0]) and \ IsEqual(hyp.GetLength(0), args[1]) and \ hyp.GetReversedEdges() == args[2] and \ (not args[2] or hyp.GetObjectEntry() == args[3])) hyp = self.Hypothesis("Arithmetic1D", [start, end, reversedEdgeInd, entry], UseExisting=UseExisting, CompareMethod=compFun) hyp.SetStartLength(start) hyp.SetEndLength(end) hyp.SetReversedEdges( reversedEdgeInd ) hyp.SetObjectEntry( entry ) return hyp ## 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() compFun = lambda hyp, args: ( hyp.GetPoints() == args[0] and \ hyp.GetNbSegments() == args[1] and \ hyp.GetReversedEdges() == args[2] and \ (not args[2] or hyp.GetObjectEntry() == args[3])) hyp = self.Hypothesis("FixedPoints1D", [points, nbSegs, reversedEdgeInd, entry], UseExisting=UseExisting, CompareMethod=compFun) hyp.SetPoints(points) hyp.SetNbSegments(nbSegs) hyp.SetReversedEdges(reversedEdgeInd) hyp.SetObjectEntry(entry) return hyp ## 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, reversedEdges=[], UseExisting=0): if not isinstance(reversedEdges,list): #old version script, before adding reversedEdges reversedEdges, UseExisting = [], reversedEdges reversedEdgeInd = self.ReversedEdgeIndices(reversedEdges) entry = self.MainShapeEntry() compFun = lambda hyp, args: ( IsEqual(hyp.GetLength(1), args[0]) and \ IsEqual(hyp.GetLength(0), args[1]) and \ hyp.GetReversedEdges() == args[2] and \ (not args[2] or hyp.GetObjectEntry() == args[3])) hyp = self.Hypothesis("StartEndLength", [start, end, reversedEdgeInd, entry], UseExisting=UseExisting, CompareMethod=compFun) hyp.SetStartLength(start) hyp.SetEndLength(end) hyp.SetReversedEdges( reversedEdgeInd ) hyp.SetObjectEntry( entry ) return hyp ## Defines "Deflection1D" hypothesis # @param d for the deflection # @param UseExisting if ==true - searches for an existing hypothesis created with # the same parameters, else (default) - create a new one # @ingroup l3_hypos_1dhyps def Deflection1D(self, d, UseExisting=0): compFun = lambda hyp, args: IsEqual(hyp.GetDeflection(), args[0]) hyp = self.Hypothesis("Deflection1D", [d], UseExisting=UseExisting, CompareMethod=compFun) hyp.SetDeflection(d) return hyp ## Defines "Propagation" hypothesis that propagates all other hypotheses on all other edges that are at # the opposite side in case of quadrangular faces # @ingroup l3_hypos_additi def Propagation(self): return self.Hypothesis("Propagation", UseExisting=1, CompareMethod=self.CompareEqualHyp) ## Defines "AutomaticLength" hypothesis # @param fineness for the fineness [0-1] # @param UseExisting if ==true - searches for an existing hypothesis created with the # same parameters, else (default) - create a new one # @ingroup l3_hypos_1dhyps def AutomaticLength(self, fineness=0, UseExisting=0): compFun = lambda hyp, args: IsEqual(hyp.GetFineness(), args[0]) hyp = self.Hypothesis("AutomaticLength",[fineness],UseExisting=UseExisting, CompareMethod=compFun) hyp.SetFineness( fineness ) return hyp ## Defines "SegmentLengthAroundVertex" hypothesis # @param length for the segment length # @param vertex for the length localization: the vertex index [0,1] | vertex object. # Any other integer value means that the hypothesis will be set on the # whole 1D shape, where Mesh_Segment algorithm is assigned. # @param UseExisting if ==true - searches for an existing hypothesis created with # the same parameters, else (default) - creates a new one # @ingroup l3_algos_segmarv def LengthNearVertex(self, length, vertex=0, UseExisting=0): import types store_geom = self.geom if type(vertex) is types.IntType: if vertex == 0 or vertex == 1: import geompyDC vertex = self.mesh.geompyD.ExtractShapes(self.geom, geompyDC.ShapeType["VERTEX"],True)[vertex] self.geom = vertex pass pass else: self.geom = vertex pass # 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) algo = self.FindAlgorithm("SegmentAroundVertex_0D", self.mesh.smeshpyD) if algo is None: algo = self.mesh.smeshpyD.CreateHypothesis("SegmentAroundVertex_0D", "libStdMeshersEngine.so") pass status = self.mesh.mesh.AddHypothesis(self.geom, algo) TreatHypoStatus(status, "SegmentAroundVertex_0D", name, True) # comFun = lambda hyp, args: IsEqual(hyp.GetLength(), args[0]) hyp = self.Hypothesis("SegmentLengthAroundVertex", [length], UseExisting=UseExisting, CompareMethod=comFun) self.geom = store_geom hyp.SetLength( length ) return hyp ## Defines "QuadraticMesh" hypothesis, forcing construction of quadratic edges. # If the 2D mesher sees that all boundary edges are quadratic, # it generates quadratic faces, else it generates linear faces using # medium nodes as if they are vertices. # The 3D mesher generates quadratic volumes only if all boundary faces # are quadratic, else it fails. # # @ingroup l3_hypos_additi def QuadraticMesh(self): hyp = self.Hypothesis("QuadraticMesh", UseExisting=1, CompareMethod=self.CompareEqualHyp) return hyp pass # end of StdMeshersDC_Segment class ## Segment 1D algorithm for discretization of a set of adjacent edges as one edge. # # It is created by calling smesh.Mesh.Segment(smesh.COMPOSITE,geom=0) # # @ingroup l3_algos_basic class StdMeshersDC_CompositeSegment(StdMeshersDC_Segment): ## name of the dynamic method in smesh.Mesh class # @internal meshMethod = "Segment" ## type of algorithm used with helper function in smesh.Mesh class # @internal algoType = COMPOSITE ## flag pointing either this algorithm should be used by default in dynamic method # of smesh.Mesh class # @internal isDefault = False ## doc string of the method # @internal docHelper = "Creates segment 1D algorithm for edges" ## Private constructor. # @param mesh parent mesh object algorithm is assigned to # @param geom geometry (shape/sub-shape) algorithm is assigned to; # if it is @c 0 (default), the algorithm is assigned to the main shape def __init__(self, mesh, geom=0): self.Create(mesh, geom, self.algoType) pass pass # end of StdMeshersDC_CompositeSegment class ## Defines a segment 1D algorithm for discretization of edges with Python function # # It is created by calling smesh.Mesh.Segment(smesh.PYTHON,geom=0) # # @ingroup l3_algos_basic class StdMeshersDC_Segment_Python(Mesh_Algorithm): ## name of the dynamic method in smesh.Mesh class # @internal meshMethod = "Segment" ## type of algorithm used with helper function in smesh.Mesh class # @internal algoType = PYTHON ## doc string of the method # @internal docHelper = "Creates tetrahedron 3D algorithm for solids" ## doc string of the method # @internal docHelper = "Creates segment 1D algorithm for edges" ## Private constructor. # @param mesh parent mesh object algorithm is assigned to # @param geom geometry (shape/sub-shape) algorithm is assigned to; # if it is @c 0 (default), the algorithm is assigned to the main shape def __init__(self, mesh, geom=0): import Python1dPlugin self.Create(mesh, geom, self.algoType, "libPython1dEngine.so") pass ## Defines "PythonSplit1D" hypothesis # @param n for the number of segments that cut an edge # @param func for the python function that calculates the length of all segments # @param UseExisting if ==true - searches for the existing hypothesis created with # the same parameters, else (default) - creates a new one # @ingroup l3_hypos_1dhyps def PythonSplit1D(self, n, func, UseExisting=0): compFun = lambda hyp, args: False hyp = self.Hypothesis("PythonSplit1D", [n], "libPython1dEngine.so", UseExisting=UseExisting, CompareMethod=compFun) hyp.SetNumberOfSegments(n) hyp.SetPythonLog10RatioFunction(func) return hyp pass # end of StdMeshersDC_Segment_Python class ## Triangle MEFISTO 2D algorithm # # It is created by calling smesh.Mesh.Triangle(smesh.MEFISTO,geom=0) # # @ingroup l3_algos_basic class StdMeshersDC_Triangle_MEFISTO(Mesh_Algorithm): ## name of the dynamic method in smesh.Mesh class # @internal meshMethod = "Triangle" ## type of algorithm used with helper function in smesh.Mesh class # @internal algoType = MEFISTO ## flag pointing either this algorithm should be used by default in dynamic method # of smesh.Mesh class # @internal isDefault = True ## doc string of the method # @internal docHelper = "Creates triangle 2D algorithm for faces" ## Private constructor. # @param mesh parent mesh object algorithm is assigned to # @param geom geometry (shape/sub-shape) algorithm is assigned to; # if it is @c 0 (default), the algorithm is assigned to the main shape def __init__(self, mesh, geom=0): Mesh_Algorithm.__init__(self) self.Create(mesh, geom, self.algoType) pass ## 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 # same parameters, else (default) - creates a new one # # @ingroup l3_hypos_2dhyps def MaxElementArea(self, area, UseExisting=0): comparator = lambda hyp, args: IsEqual(hyp.GetMaxElementArea(), args[0]) hyp = self.Hypothesis("MaxElementArea", [area], UseExisting=UseExisting, CompareMethod=comparator) hyp.SetMaxElementArea(area) return hyp ## Defines "LengthFromEdges" hypothesis to build triangles # based on the length of the edges taken from the wire # # @ingroup l3_hypos_2dhyps def LengthFromEdges(self): hyp = self.Hypothesis("LengthFromEdges", UseExisting=1, CompareMethod=self.CompareEqualHyp) return hyp pass # end of StdMeshersDC_Triangle_MEFISTO class ## Defines a quadrangle 2D algorithm # # It is created by calling smesh.Mesh.Quadrangle(geom=0) # # @ingroup l3_algos_basic class StdMeshersDC_Quadrangle(Mesh_Algorithm): ## name of the dynamic method in smesh.Mesh class # @internal meshMethod = "Quadrangle" ## type of algorithm used with helper function in smesh.Mesh class # @internal algoType = QUADRANGLE ## flag pointing either this algorithm should be used by default in dynamic method # of smesh.Mesh class # @internal isDefault = True ## doc string of the method # @internal docHelper = "Creates quadrangle 2D algorithm for faces" ## hypothesis associated with algorithm # @internal params = 0 ## Private constructor. # @param mesh parent mesh object algorithm is assigned to # @param geom geometry (shape/sub-shape) algorithm is assigned to; # if it is @c 0 (default), the algorithm is assigned to the main shape def __init__(self, mesh, geom=0): Mesh_Algorithm.__init__(self) self.Create(mesh, geom, self.algoType) pass ## 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): import GEOM vertexID = triangleVertex if isinstance( triangleVertex, 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) pass # end of StdMeshersDC_Quadrangle class ## Defines a hexahedron 3D algorithm # # It is created by calling smesh.Mesh.Hexahedron(geom=0) # # @ingroup l3_algos_basic class StdMeshersDC_Hexahedron(Mesh_Algorithm): ## name of the dynamic method in smesh.Mesh class # @internal meshMethod = "Hexahedron" ## type of algorithm used with helper function in smesh.Mesh class # @internal algoType = Hexa ## flag pointing either this algorithm should be used by default in dynamic method # of smesh.Mesh class # @internal isDefault = True ## doc string of the method # @internal docHelper = "Creates hexahedron 3D algorithm for volumes" ## Private constructor. # @param mesh parent mesh object algorithm is assigned to # @param geom geometry (shape/sub-shape) algorithm is assigned to; # if it is @c 0 (default), the algorithm is assigned to the main shape def __init__(self, mesh, geom=0): Mesh_Algorithm.__init__(self) self.Create(mesh, geom, Hexa) pass pass # end of StdMeshersDC_Hexahedron class ## Defines a projection 1D algorithm # # It is created by calling smesh.Mesh.Projection1D(geom=0) # # @ingroup l3_algos_proj class StdMeshersDC_Projection1D(Mesh_Algorithm): ## name of the dynamic method in smesh.Mesh class # @internal meshMethod = "Projection1D" ## type of algorithm used with helper function in smesh.Mesh class # @internal algoType = "Projection_1D" ## flag pointing either this algorithm should be used by default in dynamic method # of smesh.Mesh class # @internal isDefault = True ## doc string of the method # @internal docHelper = "Creates projection 1D algorithm for edges" ## Private constructor. # @param mesh parent mesh object algorithm is assigned to # @param geom geometry (shape/sub-shape) algorithm is assigned to; # if it is @c 0 (default), the algorithm is assigned to the main shape def __init__(self, mesh, geom=0): Mesh_Algorithm.__init__(self) self.Create(mesh, geom, self.algoType) pass ## Defines "Source Edge" hypothesis, specifying a meshed edge, from where # a mesh pattern is taken, and, optionally, the association of vertices # between the source edge and a target edge (to which a hypothesis is assigned) # @param edge from which nodes distribution is taken # @param mesh from which nodes distribution is taken (optional) # @param srcV a vertex of \a edge to associate with \a tgtV (optional) # @param tgtV a vertex of \a the edge to which the algorithm is assigned, # to associate with \a srcV (optional) # @param UseExisting if ==true - searches for the existing hypothesis created with # the same parameters, else (default) - creates a new one def SourceEdge(self, edge, mesh=None, srcV=None, tgtV=None, UseExisting=0): AssureGeomPublished( self.mesh, edge ) AssureGeomPublished( self.mesh, srcV ) AssureGeomPublished( self.mesh, tgtV ) hyp = self.Hypothesis("ProjectionSource1D", [edge,mesh,srcV,tgtV], UseExisting=0) # it does not seem to be useful to reuse the existing "SourceEdge" hypothesis #UseExisting=UseExisting, CompareMethod=self.CompareSourceEdge) hyp.SetSourceEdge( edge ) if not mesh is None and isinstance(mesh, Mesh): mesh = mesh.GetMesh() hyp.SetSourceMesh( mesh ) hyp.SetVertexAssociation( srcV, tgtV ) return hyp pass # end of StdMeshersDC_Projection1D class ## Defines a projection 2D algorithm # # It is created by calling smesh.Mesh.Projection2D(geom=0) # # @ingroup l3_algos_proj class StdMeshersDC_Projection2D(Mesh_Algorithm): ## name of the dynamic method in smesh.Mesh class # @internal meshMethod = "Projection2D" ## type of algorithm used with helper function in smesh.Mesh class # @internal algoType = "Projection_2D" ## flag pointing either this algorithm should be used by default in dynamic method # of smesh.Mesh class # @internal isDefault = True ## doc string of the method # @internal docHelper = "Creates projection 2D algorithm for faces" ## Private constructor. # @param mesh parent mesh object algorithm is assigned to # @param geom geometry (shape/sub-shape) algorithm is assigned to; # if it is @c 0 (default), the algorithm is assigned to the main shape def __init__(self, mesh, geom=0): Mesh_Algorithm.__init__(self) self.Create(mesh, geom, self.algoType) pass ## Defines "Source Face" hypothesis, specifying a meshed face, from where # a mesh pattern is taken, and, optionally, the association of vertices # between the source face and the target face (to which a hypothesis is assigned) # @param face from which the mesh pattern is taken # @param mesh from which the mesh pattern is taken (optional) # @param srcV1 a vertex of \a face to associate with \a tgtV1 (optional) # @param tgtV1 a vertex of \a the face to which the algorithm is assigned, # to associate with \a srcV1 (optional) # @param srcV2 a vertex of \a face to associate with \a tgtV1 (optional) # @param tgtV2 a vertex of \a the face to which the algorithm is assigned, # to associate with \a srcV2 (optional) # @param UseExisting if ==true - forces the search for the existing hypothesis created with # the same parameters, else (default) - forces the creation a new one # # Note: all association vertices must belong to one edge of a face def SourceFace(self, face, mesh=None, srcV1=None, tgtV1=None, srcV2=None, tgtV2=None, UseExisting=0): from smeshDC import Mesh if isinstance(mesh, Mesh): mesh = mesh.GetMesh() for geom in [ face, srcV1, tgtV1, srcV2, tgtV2 ]: AssureGeomPublished( self.mesh, geom ) hyp = self.Hypothesis("ProjectionSource2D", [face,mesh,srcV1,tgtV1,srcV2,tgtV2], UseExisting=0) # it does not seem to be useful to reuse the existing "SourceFace" hypothesis #UseExisting=UseExisting, CompareMethod=self.CompareSourceFace) hyp.SetSourceFace( face ) hyp.SetSourceMesh( mesh ) hyp.SetVertexAssociation( srcV1, srcV2, tgtV1, tgtV2 ) return hyp pass # end of StdMeshersDC_Projection2D class ## Defines a projection 1D-2D algorithm # # It is created by calling smesh.Mesh.Projection1D2D(geom=0) # # @ingroup l3_algos_proj class StdMeshersDC_Projection1D2D(StdMeshersDC_Projection2D): ## name of the dynamic method in smesh.Mesh class # @internal meshMethod = "Projection1D2D" ## type of algorithm used with helper function in smesh.Mesh class # @internal algoType = "Projection_1D2D" ## doc string of the method # @internal docHelper = "Creates projection 1D-2D algorithm for edges and faces" ## Private constructor. # @param mesh parent mesh object algorithm is assigned to # @param geom geometry (shape/sub-shape) algorithm is assigned to; # if it is @c 0 (default), the algorithm is assigned to the main shape def __init__(self, mesh, geom=0): StdMeshersDC_Projection2D.__init__(self, mesh, geom) pass pass # end of StdMeshersDC_Projection1D2D class ## Defines a projection 3D algorithm # # It is created by calling smesh.Mesh.Projection3D(geom=0) # # @ingroup l3_algos_proj class StdMeshersDC_Projection3D(Mesh_Algorithm): ## name of the dynamic method in smesh.Mesh class # @internal meshMethod = "Projection3D" ## type of algorithm used with helper function in smesh.Mesh class # @internal algoType = "Projection_3D" ## doc string of the method # @internal docHelper = "Creates projection 3D algorithm for volumes" ## Private constructor. # @param mesh parent mesh object algorithm is assigned to # @param geom geometry (shape/sub-shape) algorithm is assigned to; # if it is @c 0 (default), the algorithm is assigned to the main shape def __init__(self, mesh, geom=0): Mesh_Algorithm.__init__(self) self.Create(mesh, geom, self.algoType) pass ## Defines the "Source Shape 3D" hypothesis, specifying a meshed solid, from where # the mesh pattern is taken, and, optionally, the association of vertices # between the source and the target solid (to which a hipothesis is assigned) # @param solid from where the mesh pattern is taken # @param mesh from where the mesh pattern is taken (optional) # @param srcV1 a vertex of \a solid to associate with \a tgtV1 (optional) # @param tgtV1 a vertex of \a the solid where the algorithm is assigned, # to associate with \a srcV1 (optional) # @param srcV2 a vertex of \a solid to associate with \a tgtV1 (optional) # @param tgtV2 a vertex of \a the solid to which the algorithm is assigned, # to associate with \a srcV2 (optional) # @param UseExisting - if ==true - searches for the existing hypothesis created with # the same parameters, else (default) - creates a new one # # Note: association vertices must belong to one edge of a solid def SourceShape3D(self, solid, mesh=0, srcV1=0, tgtV1=0, srcV2=0, tgtV2=0, UseExisting=0): for geom in [ solid, srcV1, tgtV1, srcV2, tgtV2 ]: AssureGeomPublished( self.mesh, geom ) hyp = self.Hypothesis("ProjectionSource3D", [solid,mesh,srcV1,tgtV1,srcV2,tgtV2], UseExisting=0) # seems to be not really useful to reuse existing "SourceShape3D" hypothesis #UseExisting=UseExisting, CompareMethod=self.CompareSourceShape3D) hyp.SetSource3DShape( solid ) if isinstance(mesh, Mesh): mesh = mesh.GetMesh() if mesh: hyp.SetSourceMesh( mesh ) if srcV1 and srcV2 and tgtV1 and tgtV2: hyp.SetVertexAssociation( srcV1, srcV2, tgtV1, tgtV2 ) #elif srcV1 or srcV2 or tgtV1 or tgtV2: return hyp pass # end of StdMeshersDC_Projection3D class ## Defines a Prism 3D algorithm, which is either "Extrusion 3D" or "Radial Prism" # depending on geometry # # It is created by calling smesh.Mesh.Prism(geom=0) # # @ingroup l3_algos_3dextr class StdMeshersDC_Prism3D(Mesh_Algorithm): ## name of the dynamic method in smesh.Mesh class # @internal meshMethod = "Prism" ## type of algorithm used with helper function in smesh.Mesh class # @internal algoType = "Prism_3D" ## doc string of the method # @internal docHelper = "Creates prism 3D algorithm for volumes" ## Private constructor. # @param mesh parent mesh object algorithm is assigned to # @param geom geometry (shape/sub-shape) algorithm is assigned to; # if it is @c 0 (default), the algorithm is assigned to the main shape def __init__(self, mesh, geom=0): Mesh_Algorithm.__init__(self) shape = geom if not shape: shape = mesh.geom from geompy import SubShapeAll, ShapeType nbSolids = len( SubShapeAll( shape, ShapeType["SOLID"] )) nbShells = len( SubShapeAll( shape, ShapeType["SHELL"] )) if nbSolids == 0 or nbSolids == nbShells: self.Create(mesh, geom, "Prism_3D") pass else: self.algoType = "RadialPrism_3D" self.Create(mesh, geom, "RadialPrism_3D") self.distribHyp = None #self.Hypothesis("LayerDistribution", UseExisting=0) self.nbLayers = None pass pass ## Return 3D hypothesis holding the 1D one def Get3DHypothesis(self): if self.algoType != "RadialPrism_3D": print "Prism_3D algorith doesn't support any hyposesis" return None return self.distribHyp ## Private method creating a 1D hypothesis and storing it in the LayerDistribution # hypothesis. Returns the created hypothesis def OwnHypothesis(self, hypType, args=[], so="libStdMeshersEngine.so"): if self.algoType != "RadialPrism_3D": print "Prism_3D algorith doesn't support any hyposesis" return None if not self.nbLayers is None: self.mesh.GetMesh().RemoveHypothesis( self.geom, self.nbLayers ) self.mesh.GetMesh().AddHypothesis( self.geom, self.distribHyp ) study = self.mesh.smeshpyD.GetCurrentStudy() # prevents publishing own 1D hypothesis self.mesh.smeshpyD.SetCurrentStudy( None ) hyp = self.mesh.smeshpyD.CreateHypothesis(hypType, so) self.mesh.smeshpyD.SetCurrentStudy( study ) # enables publishing if not self.distribHyp: self.distribHyp = self.Hypothesis("LayerDistribution", UseExisting=0) self.distribHyp.SetLayerDistribution( hyp ) return hyp ## Defines "NumberOfLayers" hypothesis, specifying the number of layers of # prisms to build between the inner and outer shells # @param n number of layers # @param UseExisting if ==true - searches for the existing hypothesis created with # the same parameters, else (default) - creates a new one def NumberOfLayers(self, n, UseExisting=0): if self.algoType != "RadialPrism_3D": print "Prism_3D algorith doesn't support any hyposesis" return None self.mesh.RemoveHypothesis( self.distribHyp, self.geom ) compFun = lambda hyp, args: IsEqual(hyp.GetNumberOfLayers(), args[0]) self.nbLayers = self.Hypothesis("NumberOfLayers", [n], UseExisting=UseExisting, CompareMethod=compFun) self.nbLayers.SetNumberOfLayers( n ) return self.nbLayers ## Defines "LocalLength" hypothesis, specifying the segment length # to build between the inner and the outer shells # @param l the length of segments # @param p the precision of rounding def LocalLength(self, l, p=1e-07): if self.algoType != "RadialPrism_3D": print "Prism_3D algorith doesn't support any hyposesis" return None hyp = self.OwnHypothesis("LocalLength", [l,p]) hyp.SetLength(l) hyp.SetPrecision(p) return hyp ## Defines "NumberOfSegments" hypothesis, specifying the number of layers of # prisms to build between the inner and the outer shells. # @param n the number of layers # @param s the scale factor (optional) def NumberOfSegments(self, n, s=[]): if self.algoType != "RadialPrism_3D": print "Prism_3D algorith doesn't support any hyposesis" return None if s == []: hyp = self.OwnHypothesis("NumberOfSegments", [n]) else: hyp = self.OwnHypothesis("NumberOfSegments", [n,s]) hyp.SetDistrType( 1 ) hyp.SetScaleFactor(s) hyp.SetNumberOfSegments(n) return hyp ## Defines "Arithmetic1D" hypothesis, specifying the distribution of segments # to build between the inner and the outer shells with a length that changes in arithmetic progression # @param start the length of the first segment # @param end the length of the last segment def Arithmetic1D(self, start, end ): if self.algoType != "RadialPrism_3D": print "Prism_3D algorith doesn't support any hyposesis" return None hyp = self.OwnHypothesis("Arithmetic1D", [start, end]) hyp.SetLength(start, 1) hyp.SetLength(end , 0) return hyp ## Defines "StartEndLength" hypothesis, specifying distribution of segments # to build between the inner and the outer shells as geometric length increasing # @param start for the length of the first segment # @param end for the length of the last segment def StartEndLength(self, start, end): if self.algoType != "RadialPrism_3D": print "Prism_3D algorith doesn't support any hyposesis" return None hyp = self.OwnHypothesis("StartEndLength", [start, end]) hyp.SetLength(start, 1) hyp.SetLength(end , 0) return hyp ## Defines "AutomaticLength" hypothesis, specifying the number of segments # to build between the inner and outer shells # @param fineness defines the quality of the mesh within the range [0-1] def AutomaticLength(self, fineness=0): if self.algoType != "RadialPrism_3D": print "Prism_3D algorith doesn't support any hyposesis" return None hyp = self.OwnHypothesis("AutomaticLength") hyp.SetFineness( fineness ) return hyp pass # end of StdMeshersDC_Prism3D class ## Defines a Prism 3D algorithm, which is either "Extrusion 3D" or "Radial Prism" # depending on geometry # # It is created by calling smesh.Mesh.Prism(geom=0) # # @ingroup l3_algos_3dextr class StdMeshersDC_RadialPrism3D(StdMeshersDC_Prism3D): ## name of the dynamic method in smesh.Mesh class # @internal meshMethod = "Prism" ## type of algorithm used with helper function in smesh.Mesh class # @internal algoType = "RadialPrism_3D" ## doc string of the method # @internal docHelper = "Creates prism 3D algorithm for volumes" ## Private constructor. # @param mesh parent mesh object algorithm is assigned to # @param geom geometry (shape/sub-shape) algorithm is assigned to; # if it is @c 0 (default), the algorithm is assigned to the main shape def __init__(self, mesh, geom=0): Mesh_Algorithm.__init__(self) shape = geom if not shape: shape = mesh.geom self.Create(mesh, geom, "RadialPrism_3D") self.distribHyp = None self.nbLayers = None return ## Defines a Radial Quadrangle 1D-2D algorithm # # It is created by calling smesh.Mesh.Quadrangle(smesh.RADIAL_QUAD,geom=0) # # @ingroup l2_algos_radialq class StdMeshersDC_RadialQuadrangle1D2D(Mesh_Algorithm): ## name of the dynamic method in smesh.Mesh class # @internal meshMethod = "Quadrangle" ## type of algorithm used with helper function in smesh.Mesh class # @internal algoType = RADIAL_QUAD ## doc string of the method # @internal docHelper = "Creates quadrangle 1D-2D algorithm for triangular faces" ## Private constructor. # @param mesh parent mesh object algorithm is assigned to # @param geom geometry (shape/sub-shape) algorithm is assigned to; # if it is @c 0 (default), the algorithm is assigned to the main shape def __init__(self, mesh, geom=0): Mesh_Algorithm.__init__(self) self.Create(mesh, geom, self.algoType) self.distribHyp = None #self.Hypothesis("LayerDistribution2D", UseExisting=0) self.nbLayers = None pass ## Return 2D hypothesis holding the 1D one def Get2DHypothesis(self): if not self.distribHyp: self.distribHyp = self.Hypothesis("LayerDistribution2D", UseExisting=0) return self.distribHyp ## Private method creating a 1D hypothesis and storing it in the LayerDistribution # hypothesis. Returns the created hypothesis def OwnHypothesis(self, hypType, args=[], so="libStdMeshersEngine.so"): if self.nbLayers: self.mesh.GetMesh().RemoveHypothesis( self.geom, self.nbLayers ) if self.distribHyp is None: self.distribHyp = self.Hypothesis("LayerDistribution2D", UseExisting=0) else: self.mesh.GetMesh().AddHypothesis( self.geom, self.distribHyp ) study = self.mesh.smeshpyD.GetCurrentStudy() # prevents publishing own 1D hypothesis self.mesh.smeshpyD.SetCurrentStudy( None ) hyp = self.mesh.smeshpyD.CreateHypothesis(hypType, so) self.mesh.smeshpyD.SetCurrentStudy( study ) # enables publishing self.distribHyp.SetLayerDistribution( hyp ) return hyp ## Defines "NumberOfLayers" hypothesis, specifying the number of layers # @param n number of layers # @param UseExisting if ==true - searches for the existing hypothesis created with # the same parameters, else (default) - creates a new one def NumberOfLayers(self, n, UseExisting=0): if self.distribHyp: self.mesh.GetMesh().RemoveHypothesis( self.geom, self.distribHyp ) compFun = lambda hyp, args: IsEqual(hyp.GetNumberOfLayers(), args[0]) self.nbLayers = self.Hypothesis("NumberOfLayers2D", [n], UseExisting=UseExisting, CompareMethod=compFun) self.nbLayers.SetNumberOfLayers( n ) return self.nbLayers ## Defines "LocalLength" hypothesis, specifying the segment length # @param l the length of segments # @param p the precision of rounding def LocalLength(self, l, p=1e-07): hyp = self.OwnHypothesis("LocalLength", [l,p]) hyp.SetLength(l) hyp.SetPrecision(p) return hyp ## Defines "NumberOfSegments" hypothesis, specifying the number of layers # @param n the number of layers # @param s the scale factor (optional) def NumberOfSegments(self, n, s=[]): if s == []: hyp = self.OwnHypothesis("NumberOfSegments", [n]) else: hyp = self.OwnHypothesis("NumberOfSegments", [n,s]) hyp.SetDistrType( 1 ) hyp.SetScaleFactor(s) hyp.SetNumberOfSegments(n) return hyp ## Defines "Arithmetic1D" hypothesis, specifying the distribution of segments # with a length that changes in arithmetic progression # @param start the length of the first segment # @param end the length of the last segment def Arithmetic1D(self, start, end ): hyp = self.OwnHypothesis("Arithmetic1D", [start, end]) hyp.SetLength(start, 1) hyp.SetLength(end , 0) return hyp ## Defines "StartEndLength" hypothesis, specifying distribution of segments # as geometric length increasing # @param start for the length of the first segment # @param end for the length of the last segment def StartEndLength(self, start, end): hyp = self.OwnHypothesis("StartEndLength", [start, end]) hyp.SetLength(start, 1) hyp.SetLength(end , 0) return hyp ## Defines "AutomaticLength" hypothesis, specifying the number of segments # @param fineness defines the quality of the mesh within the range [0-1] def AutomaticLength(self, fineness=0): hyp = self.OwnHypothesis("AutomaticLength") hyp.SetFineness( fineness ) return hyp pass # end of StdMeshersDC_RadialQuadrangle1D2D class ## Defines a Use Existing Elements 1D algorithm # # It is created by calling smesh.Mesh.UseExisting1DElements(geom=0) # # @ingroup l3_algos_basic class StdMeshersDC_UseExistingElements_1D(Mesh_Algorithm): ## name of the dynamic method in smesh.Mesh class # @internal meshMethod = "UseExisting1DElements" ## type of algorithm used with helper function in smesh.Mesh class # @internal algoType = "Import_1D" ## flag pointing either this algorithm should be used by default in dynamic method # of smesh.Mesh class # @internal isDefault = True ## doc string of the method # @internal docHelper = "Creates 1D algorithm for edges with reusing of existing mesh elements" ## Private constructor. # @param mesh parent mesh object algorithm is assigned to # @param geom geometry (shape/sub-shape) algorithm is assigned to; # if it is @c 0 (default), the algorithm is assigned to the main shape def __init__(self, mesh, geom=0): Mesh_Algorithm.__init__(self) self.Create(mesh, geom, self.algoType) pass ## Defines "Source edges" hypothesis, specifying groups of edges to import # @param groups list of groups of edges # @param toCopyMesh if True, the whole mesh \a groups belong to is imported # @param toCopyGroups if True, all groups of the mesh \a groups belong to are imported # @param UseExisting if ==true - searches for the existing hypothesis created with # the same parameters, else (default) - creates a new one def SourceEdges(self, groups, toCopyMesh=False, toCopyGroups=False, UseExisting=False): for group in groups: AssureGeomPublished( self.mesh, group ) compFun = lambda hyp, args: ( hyp.GetSourceEdges() == args[0] and \ hyp.GetCopySourceMesh() == args[1], args[2] ) hyp = self.Hypothesis("ImportSource1D", [groups, toCopyMesh, toCopyGroups], UseExisting=UseExisting, CompareMethod=compFun) hyp.SetSourceEdges(groups) hyp.SetCopySourceMesh(toCopyMesh, toCopyGroups) return hyp pass # end of StdMeshersDC_UseExistingElements_1D class ## Defines a Use Existing Elements 1D-2D algorithm # # It is created by calling smesh.Mesh.UseExisting2DElements(geom=0) # # @ingroup l3_algos_basic class StdMeshersDC_UseExistingElements_1D2D(Mesh_Algorithm): ## name of the dynamic method in smesh.Mesh class # @internal meshMethod = "UseExisting2DElements" ## type of algorithm used with helper function in smesh.Mesh class # @internal algoType = "Import_1D2D" ## flag pointing either this algorithm should be used by default in dynamic method # of smesh.Mesh class # @internal isDefault = True ## doc string of the method # @internal docHelper = "Creates 1D-2D algorithm for edges/faces with reusing of existing mesh elements" ## Private constructor. # @param mesh parent mesh object algorithm is assigned to # @param geom geometry (shape/sub-shape) algorithm is assigned to; # if it is @c 0 (default), the algorithm is assigned to the main shape def __init__(self, mesh, geom=0): Mesh_Algorithm.__init__(self) self.Create(mesh, geom, self.algoType) pass ## Defines "Source faces" hypothesis, specifying groups of faces to import # @param groups list of groups of faces # @param toCopyMesh if True, the whole mesh \a groups belong to is imported # @param toCopyGroups if True, all groups of the mesh \a groups belong to are imported # @param UseExisting if ==true - searches for the existing hypothesis created with # the same parameters, else (default) - creates a new one def SourceFaces(self, groups, toCopyMesh=False, toCopyGroups=False, UseExisting=False): for group in groups: AssureGeomPublished( self.mesh, group ) compFun = lambda hyp, args: ( hyp.GetSourceFaces() == args[0] and \ hyp.GetCopySourceMesh() == args[1], args[2] ) hyp = self.Hypothesis("ImportSource2D", [groups, toCopyMesh, toCopyGroups], UseExisting=UseExisting, CompareMethod=compFun) hyp.SetSourceFaces(groups) hyp.SetCopySourceMesh(toCopyMesh, toCopyGroups) return hyp pass # end of StdMeshersDC_UseExistingElements_1D2D class ## Defines a Body Fitting 3D algorithm # # It is created by calling smesh.Mesh.BodyFitted(geom=0) # # @ingroup l3_algos_basic class StdMeshersDC_Cartesian_3D(Mesh_Algorithm): ## name of the dynamic method in smesh.Mesh class # @internal meshMethod = "BodyFitted" ## type of algorithm used with helper function in smesh.Mesh class # @internal algoType = "Cartesian_3D" ## flag pointing either this algorithm should be used by default in dynamic method # of smesh.Mesh class # @internal isDefault = True ## doc string of the method # @internal docHelper = "Creates body fitting 3D algorithm for volumes" ## Private constructor. # @param mesh parent mesh object algorithm is assigned to # @param geom geometry (shape/sub-shape) algorithm is assigned to; # if it is @c 0 (default), the algorithm is assigned to the main shape def __init__(self, mesh, geom=0): self.Create(mesh, geom, self.algoType) self.hyp = None pass ## Defines "Body Fitting parameters" hypothesis # @param xGridDef is definition of the grid along the X asix. # It can be in either of two following forms: # - Explicit coordinates of nodes, e.g. [-1.5, 0.0, 3.1] or range( -100,200,10) # - Functions f(t) defining grid spacing at each point on grid axis. If there are # several functions, they must be accompanied by relative coordinates of # points dividing the whole shape into ranges where the functions apply; points # coodrinates should vary within (0.0, 1.0) range. Parameter \a t of the spacing # function f(t) varies from 0.0 to 1.0 witin a shape range. # Examples: # - "10.5" - defines a grid with a constant spacing # - [["1", "1+10*t", "11"] [0.1, 0.6]] - defines different spacing in 3 ranges. # @param yGridDef defines the grid along the Y asix the same way as \a xGridDef does # @param zGridDef defines the grid along the Z asix the same way as \a xGridDef does # @param sizeThreshold (> 1.0) defines a minimal size of a polyhedron so that # a polyhedron of size less than hexSize/sizeThreshold is not created # @param UseExisting if ==true - searches for the existing hypothesis created with # the same parameters, else (default) - creates a new one def SetGrid(self, xGridDef, yGridDef, zGridDef, sizeThreshold=4.0, UseExisting=False): if not self.hyp: compFun = lambda hyp, args: False self.hyp = self.Hypothesis("CartesianParameters3D", [xGridDef, yGridDef, zGridDef, sizeThreshold], UseExisting=UseExisting, CompareMethod=compFun) if not self.mesh.IsUsedHypothesis( self.hyp, self.geom ): self.mesh.AddHypothesis( self.hyp, self.geom ) for axis, gridDef in enumerate( [xGridDef, yGridDef, zGridDef]): if not gridDef: raise ValueError, "Empty grid definition" if isinstance( gridDef, str ): self.hyp.SetGridSpacing( [gridDef], [], axis ) elif isinstance( gridDef[0], str ): self.hyp.SetGridSpacing( gridDef, [], axis ) elif isinstance( gridDef[0], int ) or \ isinstance( gridDef[0], float ): self.hyp.SetGrid(gridDef, axis ) else: self.hyp.SetGridSpacing( gridDef[0], gridDef[1], axis ) self.hyp.SetSizeThreshold( sizeThreshold ) return self.hyp pass # end of StdMeshersDC_Cartesian_3D class ## Defines a stub 1D algorithm, which enables "manual" creation of nodes and # segments usable by 2D algoritms # # It is created by calling smesh.Mesh.UseExistingSegments(geom=0) # # @ingroup l3_algos_basic class StdMeshersDC_UseExisting_1D(Mesh_Algorithm): ## name of the dynamic method in smesh.Mesh class # @internal meshMethod = "UseExistingSegments" ## type of algorithm used with helper function in smesh.Mesh class # @internal algoType = "UseExisting_1D" ## doc string of the method # @internal docHelper = "Creates 1D algorithm for edges with reusing of existing mesh elements" ## Private constructor. # @param mesh parent mesh object algorithm is assigned to # @param geom geometry (shape/sub-shape) algorithm is assigned to; # if it is @c 0 (default), the algorithm is assigned to the main shape def __init__(self, mesh, geom=0): self.Create(mesh, geom, self.algoType) pass pass # end of StdMeshersDC_UseExisting_1D class ## Defines a stub 2D algorithm, which enables "manual" creation of nodes and # faces usable by 3D algoritms # # It is created by calling smesh.Mesh.UseExistingFaces(geom=0) # # @ingroup l3_algos_basic class StdMeshersDC_UseExisting_2D(Mesh_Algorithm): ## name of the dynamic method in smesh.Mesh class # @internal meshMethod = "UseExistingFaces" ## type of algorithm used with helper function in smesh.Mesh class # @internal algoType = "UseExisting_2D" ## doc string of the method # @internal docHelper = "Creates 2D algorithm for faces with reusing of existing mesh elements" ## Private constructor. # @param mesh parent mesh object algorithm is assigned to # @param geom geometry (shape/sub-shape) algorithm is assigned to; # if it is @c 0 (default), the algorithm is assigned to the main shape def __init__(self, mesh, geom=0): self.Create(mesh, geom, self.algoType) pass pass # end of StdMeshersDC_UseExisting_2D class