From 03843f8a8621d66c78692a78a207b211a60e566b Mon Sep 17 00:00:00 2001 From: eap Date: Wed, 6 Dec 2006 14:54:29 +0000 Subject: [PATCH] PAL13473 (Build repetitive mesh): add corresponding classes and methods --- src/SMESH_SWIG/smesh.py | 243 +++++++++++++++++++++++++++++++++++++++- 1 file changed, 241 insertions(+), 2 deletions(-) diff --git a/src/SMESH_SWIG/smesh.py b/src/SMESH_SWIG/smesh.py index 11557a098..b4ac7108f 100644 --- a/src/SMESH_SWIG/smesh.py +++ b/src/SMESH_SWIG/smesh.py @@ -405,6 +405,8 @@ class Mesh_Algorithm: reason = "there are concurrent hypotheses on sub-shapes" elif status == HYP_BAD_SUBSHAPE : reason = "shape is neither the main one, nor its subshape, nor a valid group" + elif status == HYP_BAD_GEOMETRY: + reason = "geometry mismatches algorithm's expectation" else: return hypName = '"' + hypName + '"' @@ -804,7 +806,202 @@ class Mesh_Netgen(Mesh_Algorithm): else: hyp = self.Hypothesis("NETGEN_Parameters_2D", [], "libNETGENEngine.so") return hyp + +# Public class: Mesh_Projection1D +# ------------------------------ + +## Class to define a projection 1D algorithm +# +# More details. +class Mesh_Projection1D(Mesh_Algorithm): + + ## Private constructor. + def __init__(self, mesh, geom=0): + self.Create(mesh, geom, "Projection_1D") + + ## Define "Source Edge" hypothesis, specifying a meshed edge to + # take a mesh pattern from, and optionally association of vertices + # between the source edge and a target one (where a hipothesis is assigned to) + # @param edge to take nodes distribution from + # @param mesh to take nodes distribution from (optional) + # @param srcV is vertex of \a edge to associate with \a tgtV (optional) + # @param tgtV is vertex of \a the edge where the algorithm is assigned, + # to associate with \a srcV (optional) + def SourceEdge(self, edge, mesh=None, srcV=None, tgtV=None): + hyp = self.Hypothesis("ProjectionSource1D") + hyp.SetSourceEdge( edge ) + if not mesh is None and isinstance(mesh, Mesh): + mesh = mesh.GetMesh() + hyp.SetSourceMesh( mesh ) + hyp.SetVertexAssociation( srcV, tgtV ) + return hyp + + +# Public class: Mesh_Projection2D +# ------------------------------ + +## Class to define a projection 2D algorithm +# +# More details. +class Mesh_Projection2D(Mesh_Algorithm): + + ## Private constructor. + def __init__(self, mesh, geom=0): + self.Create(mesh, geom, "Projection_2D") + + ## Define "Source Face" hypothesis, specifying a meshed face to + # take a mesh pattern from, and optionally association of vertices + # between the source face and a target one (where a hipothesis is assigned to) + # @param face to take mesh pattern from + # @param mesh to take mesh pattern from (optional) + # @param srcV1 is vertex of \a face to associate with \a tgtV1 (optional) + # @param tgtV1 is vertex of \a the face where the algorithm is assigned, + # to associate with \a srcV1 (optional) + # @param srcV2 is vertex of \a face to associate with \a tgtV1 (optional) + # @param tgtV2 is vertex of \a the face where the algorithm is assigned, + # to associate with \a srcV2 (optional) + # + # Note: association vertices must belong to one edge of a face + def SourceFace(self, face, mesh=None, srcV1=None, tgtV1=None, srcV2=None, tgtV2=None): + hyp = self.Hypothesis("ProjectionSource2D") + hyp.SetSourceFace( face ) + if not mesh is None and isinstance(mesh, Mesh): + mesh = mesh.GetMesh() + hyp.SetSourceMesh( mesh ) + hyp.SetVertexAssociation( srcV1, srcV2, tgtV1, tgtV2 ) + return hyp + +# Public class: Mesh_Projection3D +# ------------------------------ + +## Class to define a projection 3D algorithm +# +# More details. +class Mesh_Projection3D(Mesh_Algorithm): + + ## Private constructor. + def __init__(self, mesh, geom=0): + self.Create(mesh, geom, "Projection_3D") + + ## Define "Source Shape 3D" hypothesis, specifying a meshed solid to + # take a mesh pattern from, and optionally association of vertices + # between the source solid and a target one (where a hipothesis is assigned to) + # @param solid to take mesh pattern from + # @param mesh to take mesh pattern from (optional) + # @param srcV1 is vertex of \a solid to associate with \a tgtV1 (optional) + # @param tgtV1 is vertex of \a the solid where the algorithm is assigned, + # to associate with \a srcV1 (optional) + # @param srcV2 is vertex of \a solid to associate with \a tgtV1 (optional) + # @param tgtV2 is vertex of \a the solid where the algorithm is assigned, + # to associate with \a srcV2 (optional) + # + # 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): + hyp = self.Hypothesis("ProjectionSource3D") + hyp.SetSource3DShape( solid ) + if not mesh is None and isinstance(mesh, Mesh): + mesh = mesh.GetMesh() + hyp.SetSourceMesh( mesh ) + hyp.SetVertexAssociation( srcV1, srcV2, tgtV1, tgtV2 ) + return hyp + + +# Public class: Mesh_Prism +# ------------------------ + +## Class to define a Prism 3D algorithm +# +# More details. +class Mesh_Prism3D(Mesh_Algorithm): + + ## Private constructor. + def __init__(self, mesh, geom=0): + self.Create(mesh, geom, "Prism_3D") + +# Public class: Mesh_RadialPrism +# ------------------------------- + +## Class to define a Radial Prism 3D algorithm +# +# More details. +class Mesh_RadialPrism3D(Mesh_Algorithm): + + ## Private constructor. + def __init__(self, mesh, geom=0): + self.Create(mesh, geom, "RadialPrism_3D") + self.distribHyp = self.Hypothesis( "LayerDistribution" ) + + ## Return 3D hypothesis holding the 1D one + def Get3DHypothesis(self): + return self.distribHyp + + ## Private method creating 1D hypothes and storing it in the LayerDistribution + # hypothes. Returns the created hypothes + def OwnHypothesis(self, hypType, args=[], so="libStdMeshersEngine.so"): + study = GetCurrentStudy() # prevent publishing of own 1D hypothesis + hyp = smesh.CreateHypothesis(hypType, so) + SetCurrentStudy( study ) # anable publishing + self.distribHyp.SetLayerDistribution( hyp ) + return hyp + + ## Define "NumberOfLayers" hypothesis, specifying a number of layers of + # prisms to build between the inner and outer shells + def NumberOfLayers(self, n ): + hyp = self.Hypothesis("NumberOfLayers") + hyp.SetNumberOfLayers( n ) + return hyp + + ## Define "LocalLength" hypothesis, specifying segment length + # to build between the inner and outer shells + # @param l for the length of segments + def LocalLength(self, l): + hyp = self.OwnHypothesis("LocalLength", [l]) + hyp.SetLength(l) + return hyp + ## Define "NumberOfSegments" hypothesis, specifying a number of layers of + # prisms to build between the inner and outer shells + # @param n for the number of segments + # @param s for 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 + + ## Define "Arithmetic1D" hypothesis, specifying distribution of segments + # to build between the inner and outer shells as arithmetic length increasing + # @param start for the length of the first segment + # @param end for 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 + + ## Define "StartEndLength" hypothesis, specifying distribution of segments + # to build between the inner and 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): + hyp = self.OwnHypothesis("StartEndLength", [start, end]) + hyp.SetLength(start, 1) + hyp.SetLength(end , 0) + return hyp + + ## Define "AutomaticLength" hypothesis, specifying number of segments + # to build between the inner and outer shells + # @param fineness for the fineness [0-1] + def AutomaticLength(self, fineness=0): + hyp = self.OwnHypothesis("AutomaticLength") + hyp.SetFineness( fineness ) + return hyp + + # Public class: Mesh # ================== @@ -976,7 +1173,42 @@ class Mesh: ## Deprecated, only for compatibility! def Netgen(self, is3D, geom=0): return Mesh_Netgen(self, is3D, geom) - + + ## Creates a projection 1D algorithm for edges. + # If the optional \a geom parameter is not sets, this algorithm is global. + # Otherwise, this algorithm define a submesh based on \a geom subshape. + # @param geom If defined, subshape to be meshed + def Projection1D(self, geom=0): + return Mesh_Projection1D(self, geom) + + ## Creates a projection 2D algorithm for faces. + # If the optional \a geom parameter is not sets, this algorithm is global. + # Otherwise, this algorithm define a submesh based on \a geom subshape. + # @param geom If defined, subshape to be meshed + def Projection2D(self, geom=0): + return Mesh_Projection2D(self, geom) + + ## Creates a projection 3D algorithm for solids. + # If the optional \a geom parameter is not sets, this algorithm is global. + # Otherwise, this algorithm define a submesh based on \a geom subshape. + # @param geom If defined, subshape to be meshed + def Projection3D(self, geom=0): + return Mesh_Projection3D(self, geom) + + ## Creates a Prism 3D or RadialPrism 3D algorithm for solids. + # If the optional \a geom parameter is not sets, this algorithm is global. + # Otherwise, this algorithm define a submesh based on \a geom subshape. + # @param geom If defined, subshape to be meshed + def Prism(self, geom=0): + shape = geom + if shape==0: + shape = self.geom + nbSolids = len( geompy.SubShapeAll( shape, geompy.ShapeType["SOLID"] )) + nbShells = len( geompy.SubShapeAll( shape, geompy.ShapeType["SHELL"] )) + if nbSolids == 0 or nbSolids == nbShells: + return Mesh_Prism3D(self, geom) + return Mesh_RadialPrism3D(self, geom) + ## Compute the mesh and return the status of the computation def Compute(self, geom=0): if geom == 0 or not isinstance(geom, geompy.GEOM._objref_GEOM_Object): @@ -1001,8 +1233,15 @@ class Mesh: elif err.name == MISSING_HYPO: name = '"' + err.algoName + '"' reason = glob + dim + "D algorithm " + name + " misses " + dim + "D hypothesis" - else: + elif err.name == NOT_CONFORM_MESH: reason = "Global \"Not Conform mesh allowed\" hypothesis is missing" + elif err.name == BAD_PARAM_VALUE: + name = '"' + err.algoName + '"' + reason = "Hypothesis of" + glob + dim + "D algorithm " + name +\ + " has a bad parameter value" + else: + reason = "For unknown reason."+\ + " Revise Mesh.Compute() implementation in smesh.py!" pass if allReasons != "": allReasons += "\n"