From 1d673b7232ddec26dea8693f204d0899a16db7f6 Mon Sep 17 00:00:00 2001 From: prascle Date: Sun, 24 Feb 2013 20:57:19 +0000 Subject: [PATCH] PR: packaging: from salome.smesh import smeshBuilder --- adm_local/unix/config_files/check_SMESH.m4 | 2 +- src/SMESH_SWIG/Makefile.am | 15 +- src/SMESH_SWIG/StdMeshersBuilder.py | 1326 ++++++ src/SMESH_SWIG/__init__.py | 25 + src/SMESH_SWIG/smesh.py | 34 +- src/SMESH_SWIG/smeshBuilder.py | 4405 ++++++++++++++++++++ src/SMESH_SWIG/smesh_algorithm.py | 34 +- 7 files changed, 5803 insertions(+), 38 deletions(-) create mode 100644 src/SMESH_SWIG/StdMeshersBuilder.py create mode 100644 src/SMESH_SWIG/__init__.py create mode 100644 src/SMESH_SWIG/smeshBuilder.py diff --git a/adm_local/unix/config_files/check_SMESH.m4 b/adm_local/unix/config_files/check_SMESH.m4 index 9096571c1..0143dabe5 100644 --- a/adm_local/unix/config_files/check_SMESH.m4 +++ b/adm_local/unix/config_files/check_SMESH.m4 @@ -64,7 +64,7 @@ fi #CCRTif test -f ${SMESH_DIR}/bin/salome/libSMESH_Swig.py ; then #if test -f ${SMESH_DIR}/bin/salome/MED_Test ; then -if test -f ${SMESH_DIR}/bin/salome/smesh.py ; then +if test -f ${SMESH_DIR}/bin/salome/SMESH_test.py ; then SMesh_ok=yes AC_MSG_RESULT(Using SMesh module distribution in ${SMESH_DIR}) diff --git a/src/SMESH_SWIG/Makefile.am b/src/SMESH_SWIG/Makefile.am index fd1f9e29c..562d47e1e 100644 --- a/src/SMESH_SWIG/Makefile.am +++ b/src/SMESH_SWIG/Makefile.am @@ -27,10 +27,6 @@ include $(top_srcdir)/adm_local/unix/make_common_starter.am # Scripts to be installed. dist_salomescript_PYTHON = \ - smesh.py \ - smeshDC.py \ - smesh_algorithm.py \ - StdMeshersDC.py \ batchmode_smesh.py \ batchmode_mefisto.py \ ex00_all.py \ @@ -99,5 +95,16 @@ dist_salomescript_PYTHON = \ PAL_MESH_043_3D.py \ SMESH_reg.py +mypkgpythondir = $(salomepythondir)/salome/smesh +mypkgpython_PYTHON = \ + smesh.py \ + smeshBuilder.py \ + smesh_algorithm.py + +stdpkgpythondir = $(salomepythondir)/salome/StdMeshers +stdpkgpython_PYTHON = \ + __init__.py \ + StdMeshersBuilder.py + sharedpkgpython_PYTHON = \ SMESH_shared_modules.py diff --git a/src/SMESH_SWIG/StdMeshersBuilder.py b/src/SMESH_SWIG/StdMeshersBuilder.py new file mode 100644 index 000000000..0f330bea1 --- /dev/null +++ b/src/SMESH_SWIG/StdMeshersBuilder.py @@ -0,0 +1,1326 @@ +# Copyright (C) 2007-2012 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 StdMeshersBuilder +# Python API for the standard meshing plug-in module. + +from salome.smesh.smesh_algorithm import Mesh_Algorithm +from salome.smesh.smeshBuilder import AssureGeomPublished, IsEqual, ParseParameters +from salome.smesh.smeshBuilder import GetName, TreatHypoStatus +from salome.smesh.smeshBuilder import Mesh + +import StdMeshers + +#---------------------------- +# Mesh algo type identifiers +#---------------------------- + +## Algorithm type: Regular 1D algorithm, see StdMeshersBuilder_Segment +REGULAR = "Regular_1D" +## Algorithm type: Python 1D algorithm, see StdMeshersBuilder_Segment_Python +PYTHON = "Python_1D" +## Algorithm type: Composite segment 1D algorithm, see StdMeshersBuilder_CompositeSegment +COMPOSITE = "CompositeSegment_1D" +## Algorithm type: Triangle MEFISTO 2D algorithm, see StdMeshersBuilder_Triangle_MEFISTO +MEFISTO = "MEFISTO_2D" +## Algorithm type: Hexahedron 3D (i-j-k) algorithm, see StdMeshersBuilder_Hexahedron +Hexa = "Hexa_3D" +## Algorithm type: Quadrangle 2D algorithm, see StdMeshersBuilder_Quadrangle +QUADRANGLE = "Quadrangle_2D" +## Algorithm type: Radial Quadrangle 1D-2D algorithm, see StdMeshersBuilder_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 StdMeshersBuilder_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: + from salome.geom import geomBuilder + vertex = self.mesh.geompyD.ExtractShapes(self.geom, geomBuilder.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 StdMeshersBuilder_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 StdMeshersBuilder_CompositeSegment(StdMeshersBuilder_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 StdMeshersBuilder_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 StdMeshersBuilder_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 StdMeshersBuilder_Segment_Python class + +## Triangle MEFISTO 2D algorithm +# +# It is created by calling smesh.Mesh.Triangle(smesh.MEFISTO,geom=0) +# +# @ingroup l3_algos_basic +class StdMeshersBuilder_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 StdMeshersBuilder_Triangle_MEFISTO class + +## Defines a quadrangle 2D algorithm +# +# It is created by calling smesh.Mesh.Quadrangle(geom=0) +# +# @ingroup l3_algos_basic +class StdMeshersBuilder_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 StdMeshersBuilder_Quadrangle class + +## Defines a hexahedron 3D algorithm +# +# It is created by calling smesh.Mesh.Hexahedron(geom=0) +# +# @ingroup l3_algos_basic +class StdMeshersBuilder_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 StdMeshersBuilder_Hexahedron class + +## Defines a projection 1D algorithm +# +# It is created by calling smesh.Mesh.Projection1D(geom=0) +# +# @ingroup l3_algos_proj +class StdMeshersBuilder_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 StdMeshersBuilder_Projection1D class + +## Defines a projection 2D algorithm +# +# It is created by calling smesh.Mesh.Projection2D(geom=0) +# +# @ingroup l3_algos_proj +class StdMeshersBuilder_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 salome.smesh.smeshBuilder 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 StdMeshersBuilder_Projection2D class + +## Defines a projection 1D-2D algorithm +# +# It is created by calling smesh.Mesh.Projection1D2D(geom=0) +# +# @ingroup l3_algos_proj +class StdMeshersBuilder_Projection1D2D(StdMeshersBuilder_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): + StdMeshersBuilder_Projection2D.__init__(self, mesh, geom) + pass + + pass # end of StdMeshersBuilder_Projection1D2D class + +## Defines a projection 3D algorithm +# +# It is created by calling smesh.Mesh.Projection3D(geom=0) +# +# @ingroup l3_algos_proj +class StdMeshersBuilder_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 StdMeshersBuilder_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 StdMeshersBuilder_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 = 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 + 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 StdMeshersBuilder_Prism3D class + +## 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 StdMeshersBuilder_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 StdMeshersBuilder_RadialQuadrangle1D2D class + +## Defines a Use Existing Elements 1D algorithm +# +# It is created by calling smesh.Mesh.UseExisting1DElements(geom=0) +# +# @ingroup l3_algos_basic +class StdMeshersBuilder_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 StdMeshersBuilder_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 StdMeshersBuilder_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 StdMeshersBuilder_UseExistingElements_1D2D class + +## Defines a Body Fitting 3D algorithm +# +# It is created by calling smesh.Mesh.BodyFitted(geom=0) +# +# @ingroup l3_algos_basic +class StdMeshersBuilder_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 StdMeshersBuilder_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 StdMeshersBuilder_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 StdMeshersBuilder_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 StdMeshersBuilder_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 StdMeshersBuilder_UseExisting_2D class diff --git a/src/SMESH_SWIG/__init__.py b/src/SMESH_SWIG/__init__.py new file mode 100644 index 000000000..5f91962be --- /dev/null +++ b/src/SMESH_SWIG/__init__.py @@ -0,0 +1,25 @@ +# -*- coding: iso-8859-1 -*- +# Copyright (C) 2007-2012 CEA/DEN, EDF R&D, OPEN CASCADE +# +# Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, +# CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License. +# +# This library is 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 +# + +# File : __init__.py +# Package : StdMeshers \ No newline at end of file diff --git a/src/SMESH_SWIG/smesh.py b/src/SMESH_SWIG/smesh.py index 4a5205c55..b3b24f537 100644 --- a/src/SMESH_SWIG/smesh.py +++ b/src/SMESH_SWIG/smesh.py @@ -32,34 +32,35 @@ import salome from salome import * -import geompy +from salome.geom import geompy import SMESH, SALOMEDS -import smeshDC -#from smeshDC import * +from salome.smesh import smeshBuilder +#from smeshBuilder import * # retrieve SMESH engine in try/except block # to avoid problems in some cases, e.g. when generating documentation try: - # get instance of class smeshDC + # get instance of class smeshBuilder engineSmesh = salome.lcc.FindOrLoadComponent( "FactoryServer", "SMESH" ) - smesh = smeshDC.smeshInstance(salome.myStudy, engineSmesh) + smesh = smeshBuilder.New(salome.myStudy, engineSmesh) except: smesh = None pass # load plugins and add dynamically generated methods to Mesh class, # the same for for global variables declared by plug-ins -from smeshDC import Mesh, algoCreator +from smeshBuilder import Mesh, algoCreator for pluginName in os.environ[ "SMESH_MeshersList" ].split( ":" ): # - pluginName += "DC" + print "pluginName: ", pluginName + pluginBuilderName = pluginName + "Builder" try: - exec( "from %s import *" % pluginName ) + exec( "from salome.%s.%s import *" % (pluginName, pluginBuilderName)) except Exception, e: - print "Exception while loading %s: %s" % ( pluginName, e ) + print "Exception while loading %s: %s" % ( pluginBuilderName, e ) continue - exec( "import %s" % pluginName ) - plugin = eval( pluginName ) + exec( "from salome.%s import %s" % (pluginName, pluginBuilderName)) + plugin = eval( pluginBuilderName ) # add methods creating algorithms to Mesh for k in dir( plugin ): @@ -75,7 +76,7 @@ for pluginName in os.environ[ "SMESH_MeshersList" ].split( ":" ): pass del pluginName -# export the methods of smeshDC +# export the methods of smeshBuilder if smesh: for k in dir( smesh ): if k[0] == '_': continue @@ -100,12 +101,13 @@ smesh.SetCurrentStudy(theStudy) | with | ---- | | -import smeshDC, SMESH, SALOMEDS | -smesh = smeshDC.smeshInstance(theStudy) | +import SMESH, SALOMEDS | +from salome.smesh import smeshBuilder | +smesh = smeshBuilder.New(theStudy) | | -you also need to modify some lines where smeshDC is used instead of smesh: | +you also need to modify some lines where smeshBuilder is used instead of smesh| | -algo=smesh.xxxx ==> algo.smeshDC.xxxx | +algo=smesh.xxxx ==> algo.smeshBuilder.xxxx | | =============================================================================== """ diff --git a/src/SMESH_SWIG/smeshBuilder.py b/src/SMESH_SWIG/smeshBuilder.py new file mode 100644 index 000000000..c655fdf51 --- /dev/null +++ b/src/SMESH_SWIG/smeshBuilder.py @@ -0,0 +1,4405 @@ +# Copyright (C) 2007-2012 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 +# +# File : smeshBuilder.py +# Author : Francis KLOSS, OCC +# Module : SMESH + +## @package smeshBuilder +# Python API for SALOME %Mesh module + +## @defgroup l1_auxiliary Auxiliary methods and structures +## @defgroup l1_creating Creating meshes +## @{ +## @defgroup l2_impexp Importing and exporting meshes +## @defgroup l2_construct Constructing meshes +## @defgroup l2_algorithms Defining Algorithms +## @{ +## @defgroup l3_algos_basic Basic meshing algorithms +## @defgroup l3_algos_proj Projection Algorithms +## @defgroup l3_algos_radialp Radial Prism +## @defgroup l3_algos_segmarv Segments around Vertex +## @defgroup l3_algos_3dextr 3D extrusion meshing algorithm + +## @} +## @defgroup l2_hypotheses Defining hypotheses +## @{ +## @defgroup l3_hypos_1dhyps 1D Meshing Hypotheses +## @defgroup l3_hypos_2dhyps 2D Meshing Hypotheses +## @defgroup l3_hypos_maxvol Max Element Volume hypothesis +## @defgroup l3_hypos_quad Quadrangle Parameters hypothesis +## @defgroup l3_hypos_additi Additional Hypotheses + +## @} +## @defgroup l2_submeshes Constructing submeshes +## @defgroup l2_compounds Building Compounds +## @defgroup l2_editing Editing Meshes + +## @} +## @defgroup l1_meshinfo Mesh Information +## @defgroup l1_controls Quality controls and Filtering +## @defgroup l1_grouping Grouping elements +## @{ +## @defgroup l2_grps_create Creating groups +## @defgroup l2_grps_edit Editing groups +## @defgroup l2_grps_operon Using operations on groups +## @defgroup l2_grps_delete Deleting Groups + +## @} +## @defgroup l1_modifying Modifying meshes +## @{ +## @defgroup l2_modif_add Adding nodes and elements +## @defgroup l2_modif_del Removing nodes and elements +## @defgroup l2_modif_edit Modifying nodes and elements +## @defgroup l2_modif_renumber Renumbering nodes and elements +## @defgroup l2_modif_trsf Transforming meshes (Translation, Rotation, Symmetry, Sewing, Merging) +## @defgroup l2_modif_movenode Moving nodes +## @defgroup l2_modif_throughp Mesh through point +## @defgroup l2_modif_invdiag Diagonal inversion of elements +## @defgroup l2_modif_unitetri Uniting triangles +## @defgroup l2_modif_changori Changing orientation of elements +## @defgroup l2_modif_cutquadr Cutting quadrangles +## @defgroup l2_modif_smooth Smoothing +## @defgroup l2_modif_extrurev Extrusion and Revolution +## @defgroup l2_modif_patterns Pattern mapping +## @defgroup l2_modif_tofromqu Convert to/from Quadratic Mesh + +## @} +## @defgroup l1_measurements Measurements + +import salome +from salome.geom import geomBuilder + +import SMESH # This is necessary for back compatibility +from SMESH import * +from salome.smesh.smesh_algorithm import Mesh_Algorithm + +import SALOME +import SALOMEDS +import os + +## @addtogroup l1_auxiliary +## @{ + +# MirrorType enumeration +POINT = SMESH_MeshEditor.POINT +AXIS = SMESH_MeshEditor.AXIS +PLANE = SMESH_MeshEditor.PLANE + +# Smooth_Method enumeration +LAPLACIAN_SMOOTH = SMESH_MeshEditor.LAPLACIAN_SMOOTH +CENTROIDAL_SMOOTH = SMESH_MeshEditor.CENTROIDAL_SMOOTH + +PrecisionConfusion = 1e-07 + +# TopAbs_State enumeration +[TopAbs_IN, TopAbs_OUT, TopAbs_ON, TopAbs_UNKNOWN] = range(4) + +# Methods of splitting a hexahedron into tetrahedra +Hex_5Tet, Hex_6Tet, Hex_24Tet = 1, 2, 3 + +## Converts an angle from degrees to radians +def DegreesToRadians(AngleInDegrees): + from math import pi + return AngleInDegrees * pi / 180.0 + +import salome_notebook +notebook = salome_notebook.notebook +# Salome notebook variable separator +var_separator = ":" + +## Return list of variable values from salome notebook. +# The last argument, if is callable, is used to modify values got from notebook +def ParseParameters(*args): + Result = [] + Parameters = "" + hasVariables = False + varModifFun=None + if args and callable( args[-1] ): + args, varModifFun = args[:-1], args[-1] + for parameter in args: + + Parameters += str(parameter) + var_separator + + if isinstance(parameter,str): + # check if there is an inexistent variable name + if not notebook.isVariable(parameter): + raise ValueError, "Variable with name '" + parameter + "' doesn't exist!!!" + parameter = notebook.get(parameter) + hasVariables = True + if varModifFun: + parameter = varModifFun(parameter) + pass + pass + Result.append(parameter) + + pass + Parameters = Parameters[:-1] + Result.append( Parameters ) + Result.append( hasVariables ) + return Result + +# Parse parameters converting variables to radians +def ParseAngles(*args): + return ParseParameters( *( args + (DegreesToRadians, ))) + +# Substitute PointStruct.__init__() to create SMESH.PointStruct using notebook variables. +# Parameters are stored in PointStruct.parameters attribute +def __initPointStruct(point,*args): + point.x, point.y, point.z, point.parameters,hasVars = ParseParameters(*args) + pass +SMESH.PointStruct.__init__ = __initPointStruct + +# Substitute AxisStruct.__init__() to create SMESH.AxisStruct using notebook variables. +# Parameters are stored in AxisStruct.parameters attribute +def __initAxisStruct(ax,*args): + ax.x, ax.y, ax.z, ax.vx, ax.vy, ax.vz, ax.parameters,hasVars = ParseParameters(*args) + pass +SMESH.AxisStruct.__init__ = __initAxisStruct + + +def IsEqual(val1, val2, tol=PrecisionConfusion): + if abs(val1 - val2) < tol: + return True + return False + +NO_NAME = "NoName" + +## Gets object name +def GetName(obj): + if obj: + # object not null + if isinstance(obj, SALOMEDS._objref_SObject): + # study object + return obj.GetName() + try: + ior = salome.orb.object_to_string(obj) + except: + ior = None + if ior: + # CORBA object + studies = salome.myStudyManager.GetOpenStudies() + for sname in studies: + s = salome.myStudyManager.GetStudyByName(sname) + if not s: continue + sobj = s.FindObjectIOR(ior) + if not sobj: continue + return sobj.GetName() + if hasattr(obj, "GetName"): + # unknown CORBA object, having GetName() method + return obj.GetName() + else: + # unknown CORBA object, no GetName() method + return NO_NAME + pass + if hasattr(obj, "GetName"): + # unknown non-CORBA object, having GetName() method + return obj.GetName() + pass + raise RuntimeError, "Null or invalid object" + +## Prints error message if a hypothesis was not assigned. +def TreatHypoStatus(status, hypName, geomName, isAlgo): + if isAlgo: + hypType = "algorithm" + else: + hypType = "hypothesis" + pass + if status == HYP_UNKNOWN_FATAL : + reason = "for unknown reason" + elif status == HYP_INCOMPATIBLE : + reason = "this hypothesis mismatches the algorithm" + elif status == HYP_NOTCONFORM : + reason = "a non-conform mesh would be built" + elif status == HYP_ALREADY_EXIST : + if isAlgo: return # it does not influence anything + reason = hypType + " of the same dimension is already assigned to this shape" + elif status == HYP_BAD_DIM : + reason = hypType + " mismatches the shape" + elif status == HYP_CONCURENT : + reason = "there are concurrent hypotheses on sub-shapes" + elif status == HYP_BAD_SUBSHAPE : + reason = "the shape is neither the main one, nor its sub-shape, nor a valid group" + elif status == HYP_BAD_GEOMETRY: + reason = "geometry mismatches the expectation of the algorithm" + elif status == HYP_HIDDEN_ALGO: + reason = "it is hidden by an algorithm of an upper dimension, which generates elements of all dimensions" + elif status == HYP_HIDING_ALGO: + reason = "it hides algorithms of lower dimensions by generating elements of all dimensions" + elif status == HYP_NEED_SHAPE: + reason = "Algorithm can't work without shape" + else: + return + hypName = '"' + hypName + '"' + geomName= '"' + geomName+ '"' + if status < HYP_UNKNOWN_FATAL and not geomName =='""': + print hypName, "was assigned to", geomName,"but", reason + elif not geomName == '""': + print hypName, "was not assigned to",geomName,":", reason + else: + print hypName, "was not assigned:", reason + pass + +## 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, geomBuilder.GEOM._objref_GEOM_Object ): + return + if not geom.GetStudyEntry() and \ + mesh.smeshpyD.GetCurrentStudy(): + ## 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() != geomBuilder.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 geometrical edge by ignoring orientation +def FirstVertexOnCurve(edge): + vv = geomBuilder.SubShapeAll( edge, geomBuilder.ShapeType["VERTEX"]) + if not vv: + raise TypeError, "Given object has no vertices" + if len( vv ) == 1: return vv[0] + info = geomBuilder.KindOfShape(edge) + xyz = info[1:4] # coords of the first vertex + xyz1 = geomBuilder.PointCoordinates( vv[0] ) + xyz2 = geomBuilder.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 +## @} + + +# Warning: smeshInst is a singleton +smeshInst = None +engine = None +doLcc = False + +class smeshBuilder(object, SMESH._objref_SMESH_Gen): + + def __new__(cls): + global engine + global smeshInst + global doLcc + print "__new__", engine, smeshInst, doLcc + + if smeshInst is None: + # smesh engine is either retrieved from engine, or created + smeshInst = engine + # Following test avoids a recursive loop + if doLcc: + if smeshInst is not None: + # smesh engine not created: existing engine found + doLcc = False + if doLcc: + doLcc = False + # FindOrLoadComponent called: + # 1. CORBA resolution of server + # 2. the __new__ method is called again + print "smeshInst = lcc.FindOrLoadComponent ", engine, smeshInst, doLcc + smeshInst = salome.lcc.FindOrLoadComponent( "FactoryServer", "SMESH" ) + else: + # FindOrLoadComponent not called + if smeshInst is None: + # smeshBuilder instance is created from lcc.FindOrLoadComponent + print "smeshInst = super(smeshBuilder,cls).__new__(cls) ", engine, smeshInst, doLcc + smeshInst = super(smeshBuilder,cls).__new__(cls) + else: + # smesh engine not created: existing engine found + print "existing ", engine, smeshInst, doLcc + pass + + return smeshInst + + return smeshInst + + def __init__(self): + print "__init__" + SMESH._objref_SMESH_Gen.__init__(self) + + ## Dump component to the Python script + # This method overrides IDL function to allow default values for the parameters. + def DumpPython(self, theStudy, theIsPublished=True, theIsMultiFile=True): + return SMESH._objref_SMESH_Gen.DumpPython(self, theStudy, theIsPublished, theIsMultiFile) + + ## Set mode of DumpPython(), \a historical or \a snapshot. + # In the \a historical mode, the Python Dump script includes all commands + # performed by SMESH engine. In the \a snapshot mode, commands + # relating to objects removed from the Study are excluded from the script + # as well as commands not influencing the current state of meshes + def SetDumpPythonHistorical(self, isHistorical): + if isHistorical: val = "true" + else: val = "false" + SMESH._objref_SMESH_Gen.SetOption(self, "historical_python_dump", val) + + ## Sets the current study and Geometry component + # @ingroup l1_auxiliary + def init_smesh(self,theStudy,geompyD = None): + print "init_smesh" + self.SetCurrentStudy(theStudy,geompyD) + + ## Creates an empty Mesh. This mesh can have an underlying geometry. + # @param obj the Geometrical object on which the mesh is built. If not defined, + # the mesh will have no underlying geometry. + # @param name the name for the new mesh. + # @return an instance of Mesh class. + # @ingroup l2_construct + def Mesh(self, obj=0, name=0): + if isinstance(obj,str): + obj,name = name,obj + return Mesh(self,self.geompyD,obj,name) + + ## Returns a long value from enumeration + # @ingroup l1_controls + def EnumToLong(self,theItem): + return theItem._v + + ## Returns a string representation of the color. + # To be used with filters. + # @param c color value (SALOMEDS.Color) + # @ingroup l1_controls + def ColorToString(self,c): + val = "" + if isinstance(c, SALOMEDS.Color): + val = "%s;%s;%s" % (c.R, c.G, c.B) + elif isinstance(c, str): + val = c + else: + raise ValueError, "Color value should be of string or SALOMEDS.Color type" + return val + + ## Gets PointStruct from vertex + # @param theVertex a GEOM object(vertex) + # @return SMESH.PointStruct + # @ingroup l1_auxiliary + def GetPointStruct(self,theVertex): + [x, y, z] = self.geompyD.PointCoordinates(theVertex) + return PointStruct(x,y,z) + + ## Gets DirStruct from vector + # @param theVector a GEOM object(vector) + # @return SMESH.DirStruct + # @ingroup l1_auxiliary + def GetDirStruct(self,theVector): + vertices = self.geompyD.SubShapeAll( theVector, geomBuilder.ShapeType["VERTEX"] ) + if(len(vertices) != 2): + print "Error: vector object is incorrect." + return None + p1 = self.geompyD.PointCoordinates(vertices[0]) + p2 = self.geompyD.PointCoordinates(vertices[1]) + pnt = PointStruct(p2[0]-p1[0], p2[1]-p1[1], p2[2]-p1[2]) + dirst = DirStruct(pnt) + return dirst + + ## Makes DirStruct from a triplet + # @param x,y,z vector components + # @return SMESH.DirStruct + # @ingroup l1_auxiliary + def MakeDirStruct(self,x,y,z): + pnt = PointStruct(x,y,z) + return DirStruct(pnt) + + ## Get AxisStruct from object + # @param theObj a GEOM object (line or plane) + # @return SMESH.AxisStruct + # @ingroup l1_auxiliary + def GetAxisStruct(self,theObj): + edges = self.geompyD.SubShapeAll( theObj, geomBuilder.ShapeType["EDGE"] ) + if len(edges) > 1: + vertex1, vertex2 = self.geompyD.SubShapeAll( edges[0], geomBuilder.ShapeType["VERTEX"] ) + vertex3, vertex4 = self.geompyD.SubShapeAll( edges[1], geomBuilder.ShapeType["VERTEX"] ) + vertex1 = self.geompyD.PointCoordinates(vertex1) + vertex2 = self.geompyD.PointCoordinates(vertex2) + vertex3 = self.geompyD.PointCoordinates(vertex3) + vertex4 = self.geompyD.PointCoordinates(vertex4) + v1 = [vertex2[0]-vertex1[0], vertex2[1]-vertex1[1], vertex2[2]-vertex1[2]] + v2 = [vertex4[0]-vertex3[0], vertex4[1]-vertex3[1], vertex4[2]-vertex3[2]] + normal = [ v1[1]*v2[2]-v2[1]*v1[2], v1[2]*v2[0]-v2[2]*v1[0], v1[0]*v2[1]-v2[0]*v1[1] ] + axis = AxisStruct(vertex1[0], vertex1[1], vertex1[2], normal[0], normal[1], normal[2]) + return axis + elif len(edges) == 1: + vertex1, vertex2 = self.geompyD.SubShapeAll( edges[0], geomBuilder.ShapeType["VERTEX"] ) + p1 = self.geompyD.PointCoordinates( vertex1 ) + p2 = self.geompyD.PointCoordinates( vertex2 ) + axis = AxisStruct(p1[0], p1[1], p1[2], p2[0]-p1[0], p2[1]-p1[1], p2[2]-p1[2]) + return axis + return None + + # From SMESH_Gen interface: + # ------------------------ + + ## Sets the given name to the object + # @param obj the object to rename + # @param name a new object name + # @ingroup l1_auxiliary + def SetName(self, obj, name): + if isinstance( obj, Mesh ): + obj = obj.GetMesh() + elif isinstance( obj, Mesh_Algorithm ): + obj = obj.GetAlgorithm() + ior = salome.orb.object_to_string(obj) + SMESH._objref_SMESH_Gen.SetName(self, ior, name) + + ## Sets the current mode + # @ingroup l1_auxiliary + def SetEmbeddedMode( self,theMode ): + #self.SetEmbeddedMode(theMode) + SMESH._objref_SMESH_Gen.SetEmbeddedMode(self,theMode) + + ## Gets the current mode + # @ingroup l1_auxiliary + def IsEmbeddedMode(self): + #return self.IsEmbeddedMode() + return SMESH._objref_SMESH_Gen.IsEmbeddedMode(self) + + ## Sets the current study + # @ingroup l1_auxiliary + def SetCurrentStudy( self, theStudy, geompyD = None ): + #self.SetCurrentStudy(theStudy) + if not geompyD: + from salome.geom import geomBuilder + geompyD = geomBuilder.geom + pass + self.geompyD=geompyD + self.SetGeomEngine(geompyD) + SMESH._objref_SMESH_Gen.SetCurrentStudy(self,theStudy) + global notebook + if theStudy: + notebook = salome_notebook.NoteBook( theStudy ) + else: + notebook = salome_notebook.NoteBook( salome_notebook.PseudoStudyForNoteBook() ) + + ## Gets the current study + # @ingroup l1_auxiliary + def GetCurrentStudy(self): + #return self.GetCurrentStudy() + return SMESH._objref_SMESH_Gen.GetCurrentStudy(self) + + ## Creates a Mesh object importing data from the given UNV file + # @return an instance of Mesh class + # @ingroup l2_impexp + def CreateMeshesFromUNV( self,theFileName ): + aSmeshMesh = SMESH._objref_SMESH_Gen.CreateMeshesFromUNV(self,theFileName) + aMesh = Mesh(self, self.geompyD, aSmeshMesh) + return aMesh + + ## Creates a Mesh object(s) importing data from the given MED file + # @return a list of Mesh class instances + # @ingroup l2_impexp + def CreateMeshesFromMED( self,theFileName ): + aSmeshMeshes, aStatus = SMESH._objref_SMESH_Gen.CreateMeshesFromMED(self,theFileName) + aMeshes = [] + for iMesh in range(len(aSmeshMeshes)) : + aMesh = Mesh(self, self.geompyD, aSmeshMeshes[iMesh]) + aMeshes.append(aMesh) + return aMeshes, aStatus + + ## Creates a Mesh object(s) importing data from the given SAUV file + # @return a list of Mesh class instances + # @ingroup l2_impexp + def CreateMeshesFromSAUV( self,theFileName ): + aSmeshMeshes, aStatus = SMESH._objref_SMESH_Gen.CreateMeshesFromSAUV(self,theFileName) + aMeshes = [] + for iMesh in range(len(aSmeshMeshes)) : + aMesh = Mesh(self, self.geompyD, aSmeshMeshes[iMesh]) + aMeshes.append(aMesh) + return aMeshes, aStatus + + ## Creates a Mesh object importing data from the given STL file + # @return an instance of Mesh class + # @ingroup l2_impexp + def CreateMeshesFromSTL( self, theFileName ): + aSmeshMesh = SMESH._objref_SMESH_Gen.CreateMeshesFromSTL(self,theFileName) + 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 + + ## Creates a Mesh object importing data from the given GMF file + # @return [ an instance of Mesh class, SMESH::ComputeError ] + # @ingroup l2_impexp + def CreateMeshesFromGMF( self, theFileName ): + aSmeshMesh, error = SMESH._objref_SMESH_Gen.CreateMeshesFromGMF(self, + theFileName, + True) + if error.comment: print "*** CreateMeshesFromGMF() errors:\n", error.comment + return Mesh(self, self.geompyD, aSmeshMesh), error + + ## Concatenate the given meshes into one mesh. + # @return an instance of Mesh class + # @param meshes the meshes to combine into one mesh + # @param uniteIdenticalGroups if true, groups with same names are united, else they are renamed + # @param mergeNodesAndElements if true, equal nodes and elements aremerged + # @param mergeTolerance tolerance for merging nodes + # @param allGroups forces creation of groups of all elements + # @param name name of a new mesh + def Concatenate( self, meshes, uniteIdenticalGroups, + mergeNodesAndElements = False, mergeTolerance = 1e-5, allGroups = False, + name = ""): + if not meshes: return None + for i,m in enumerate(meshes): + if isinstance(m, Mesh): + meshes[i] = m.GetMesh() + mergeTolerance,Parameters,hasVars = ParseParameters(mergeTolerance) + meshes[0].SetParameters(Parameters) + if allGroups: + aSmeshMesh = SMESH._objref_SMESH_Gen.ConcatenateWithGroups( + self,meshes,uniteIdenticalGroups,mergeNodesAndElements,mergeTolerance) + else: + aSmeshMesh = SMESH._objref_SMESH_Gen.Concatenate( + self,meshes,uniteIdenticalGroups,mergeNodesAndElements,mergeTolerance) + aMesh = Mesh(self, self.geompyD, aSmeshMesh, name=name) + return aMesh + + ## Create a mesh by copying a part of another mesh. + # @param meshPart a part of mesh to copy, either a Mesh, a sub-mesh or a group; + # to copy nodes or elements not contained in any mesh object, + # pass result of Mesh.GetIDSource( list_of_ids, type ) as meshPart + # @param meshName a name of the new mesh + # @param toCopyGroups to create in the new mesh groups the copied elements belongs to + # @param toKeepIDs to preserve IDs of the copied elements or not + # @return an instance of Mesh class + def CopyMesh( self, meshPart, meshName, toCopyGroups=False, toKeepIDs=False): + if (isinstance( meshPart, Mesh )): + meshPart = meshPart.GetMesh() + mesh = SMESH._objref_SMESH_Gen.CopyMesh( self,meshPart,meshName,toCopyGroups,toKeepIDs ) + return Mesh(self, self.geompyD, mesh) + + ## From SMESH_Gen interface + # @return the list of integer values + # @ingroup l1_auxiliary + def GetSubShapesId( self, theMainObject, theListOfSubObjects ): + return SMESH._objref_SMESH_Gen.GetSubShapesId(self,theMainObject, theListOfSubObjects) + + ## From SMESH_Gen interface. Creates a pattern + # @return an instance of SMESH_Pattern + # + # Example of Patterns usage + # @ingroup l2_modif_patterns + def GetPattern(self): + return SMESH._objref_SMESH_Gen.GetPattern(self) + + ## Sets number of segments per diagonal of boundary box of geometry by which + # default segment length of appropriate 1D hypotheses is defined. + # Default value is 10 + # @ingroup l1_auxiliary + def SetBoundaryBoxSegmentation(self, nbSegments): + SMESH._objref_SMESH_Gen.SetBoundaryBoxSegmentation(self,nbSegments) + + # Filtering. Auxiliary functions: + # ------------------------------ + + ## Creates an empty criterion + # @return SMESH.Filter.Criterion + # @ingroup l1_controls + def GetEmptyCriterion(self): + Type = self.EnumToLong(FT_Undefined) + Compare = self.EnumToLong(FT_Undefined) + Threshold = 0 + ThresholdStr = "" + ThresholdID = "" + UnaryOp = self.EnumToLong(FT_Undefined) + BinaryOp = self.EnumToLong(FT_Undefined) + Tolerance = 1e-07 + TypeOfElement = ALL + Precision = -1 ##@1e-07 + return Filter.Criterion(Type, Compare, Threshold, ThresholdStr, ThresholdID, + UnaryOp, BinaryOp, Tolerance, TypeOfElement, Precision) + + ## Creates a criterion by the given parameters + # \n Criterion structures allow to define complex filters by combining them with logical operations (AND / OR) (see example below) + # @param elementType the type of elements(NODE, EDGE, FACE, VOLUME) + # @param CritType the type of criterion (FT_Taper, FT_Area, FT_RangeOfIds, FT_LyingOnGeom etc.) + # @param Compare belongs to {FT_LessThan, FT_MoreThan, FT_EqualTo} + # @param Threshold the threshold value (range of ids as string, shape, numeric) + # @param UnaryOp FT_LogicalNOT or FT_Undefined + # @param BinaryOp a binary logical operation FT_LogicalAND, FT_LogicalOR or + # FT_Undefined (must be for the last criterion of all criteria) + # @param Tolerance the tolerance used by FT_BelongToGeom, FT_BelongToSurface, + # FT_LyingOnGeom, FT_CoplanarFaces criteria + # @return SMESH.Filter.Criterion + # + # Example of Criteria usage + # @ingroup l1_controls + def GetCriterion(self,elementType, + CritType, + Compare = FT_EqualTo, + Threshold="", + 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) + aCriterion.Tolerance = Tolerance + + aThreshold = Threshold + + if Compare in [FT_LessThan, FT_MoreThan, FT_EqualTo]: + aCriterion.Compare = self.EnumToLong(Compare) + elif Compare == "=" or Compare == "==": + aCriterion.Compare = self.EnumToLong(FT_EqualTo) + elif Compare == "<": + aCriterion.Compare = self.EnumToLong(FT_LessThan) + elif Compare == ">": + aCriterion.Compare = self.EnumToLong(FT_MoreThan) + elif Compare != FT_Undefined: + aCriterion.Compare = self.EnumToLong(FT_EqualTo) + aThreshold = Compare + + if CritType in [FT_BelongToGeom, FT_BelongToPlane, FT_BelongToGenSurface, + FT_BelongToCylinder, FT_LyingOnGeom]: + # Checks that Threshold is GEOM object + if isinstance(aThreshold, geomBuilder.GEOM._objref_GEOM_Object): + aCriterion.ThresholdStr = GetName(aThreshold) + aCriterion.ThresholdID = aThreshold.GetStudyEntry() + if not aCriterion.ThresholdID: + name = aCriterion.ThresholdStr + if not name: + name = "%s_%s"%(aThreshold.GetShapeType(), id(aThreshold)%10000) + aCriterion.ThresholdID = self.geompyD.addToStudy( aThreshold, name ) + #raise RuntimeError, "Threshold shape must be published" + else: + print "Error: The Threshold should be a shape." + return None + if isinstance(UnaryOp,float): + aCriterion.Tolerance = UnaryOp + UnaryOp = FT_Undefined + pass + elif CritType == FT_RangeOfIds: + # Checks that Threshold is string + if isinstance(aThreshold, str): + aCriterion.ThresholdStr = aThreshold + else: + print "Error: The Threshold should be a string." + return None + elif CritType == FT_CoplanarFaces: + # Checks the Threshold + if isinstance(aThreshold, int): + aCriterion.ThresholdID = str(aThreshold) + elif isinstance(aThreshold, str): + ID = int(aThreshold) + if ID < 1: + raise ValueError, "Invalid ID of mesh face: '%s'"%aThreshold + aCriterion.ThresholdID = aThreshold + else: + raise ValueError,\ + "The Threshold should be an ID of mesh face and not '%s'"%aThreshold + elif CritType == FT_ElemGeomType: + # Checks the Threshold + try: + aCriterion.Threshold = self.EnumToLong(aThreshold) + assert( aThreshold in SMESH.GeometryType._items ) + except: + if isinstance(aThreshold, int): + aCriterion.Threshold = aThreshold + else: + print "Error: The Threshold should be an integer or SMESH.GeometryType." + return None + pass + pass + elif CritType == FT_GroupColor: + # Checks the Threshold + try: + aCriterion.ThresholdStr = self.ColorToString(aThreshold) + except: + print "Error: The threshold value should be of SALOMEDS.Color type" + return None + pass + elif CritType in [FT_FreeBorders, FT_FreeEdges, FT_FreeNodes, FT_FreeFaces, + FT_LinearOrQuadratic, FT_BadOrientedVolume, + FT_BareBorderFace, FT_BareBorderVolume, + FT_OverConstrainedFace, FT_OverConstrainedVolume, + FT_EqualNodes,FT_EqualEdges,FT_EqualFaces,FT_EqualVolumes ]: + # At this point the Threshold is unnecessary + if aThreshold == FT_LogicalNOT: + aCriterion.UnaryOp = self.EnumToLong(FT_LogicalNOT) + elif aThreshold in [FT_LogicalAND, FT_LogicalOR]: + aCriterion.BinaryOp = aThreshold + else: + # Check Threshold + try: + aThreshold = float(aThreshold) + aCriterion.Threshold = aThreshold + except: + print "Error: The Threshold should be a number." + return None + + if Threshold == FT_LogicalNOT or UnaryOp == FT_LogicalNOT: + aCriterion.UnaryOp = self.EnumToLong(FT_LogicalNOT) + + if Threshold in [FT_LogicalAND, FT_LogicalOR]: + aCriterion.BinaryOp = self.EnumToLong(Threshold) + + if UnaryOp in [FT_LogicalAND, FT_LogicalOR]: + aCriterion.BinaryOp = self.EnumToLong(UnaryOp) + + if BinaryOp in [FT_LogicalAND, FT_LogicalOR]: + aCriterion.BinaryOp = self.EnumToLong(BinaryOp) + + return aCriterion + + ## Creates a filter with the given parameters + # @param elementType the type of elements in the group + # @param CritType the type of criterion ( FT_Taper, FT_Area, FT_RangeOfIds, FT_LyingOnGeom etc. ) + # @param Compare belongs to {FT_LessThan, FT_MoreThan, FT_EqualTo} + # @param Threshold the threshold value (range of id ids as string, shape, numeric) + # @param UnaryOp FT_LogicalNOT or FT_Undefined + # @param Tolerance the tolerance used by FT_BelongToGeom, FT_BelongToSurface, + # FT_LyingOnGeom, FT_CoplanarFaces and FT_EqualNodes criteria + # @return SMESH_Filter + # + # Example of Filters usage + # @ingroup l1_controls + def GetFilter(self,elementType, + CritType=FT_Undefined, + Compare=FT_EqualTo, + Threshold="", + UnaryOp=FT_Undefined, + Tolerance=1e-07): + aCriterion = self.GetCriterion(elementType, CritType, Compare, Threshold, UnaryOp, FT_Undefined,Tolerance) + aFilterMgr = self.CreateFilterManager() + aFilter = aFilterMgr.CreateFilter() + aCriteria = [] + aCriteria.append(aCriterion) + aFilter.SetCriteria(aCriteria) + aFilterMgr.UnRegister() + return aFilter + + ## Creates a filter from criteria + # @param criteria a list of criteria + # @return SMESH_Filter + # + # Example of Filters usage + # @ingroup l1_controls + def GetFilterFromCriteria(self,criteria): + aFilterMgr = self.CreateFilterManager() + aFilter = aFilterMgr.CreateFilter() + aFilter.SetCriteria(criteria) + aFilterMgr.UnRegister() + return aFilter + + ## Creates a numerical functor by its type + # @param theCriterion FT_...; functor type + # @return SMESH_NumericalFunctor + # @ingroup l1_controls + def GetFunctor(self,theCriterion): + if isinstance( theCriterion, SMESH._objref_NumericalFunctor ): + return theCriterion + aFilterMgr = self.CreateFilterManager() + functor = None + if theCriterion == FT_AspectRatio: + functor = aFilterMgr.CreateAspectRatio() + elif theCriterion == FT_AspectRatio3D: + functor = aFilterMgr.CreateAspectRatio3D() + elif theCriterion == FT_Warping: + functor = aFilterMgr.CreateWarping() + elif theCriterion == FT_MinimumAngle: + functor = aFilterMgr.CreateMinimumAngle() + elif theCriterion == FT_Taper: + functor = aFilterMgr.CreateTaper() + elif theCriterion == FT_Skew: + functor = aFilterMgr.CreateSkew() + elif theCriterion == FT_Area: + functor = aFilterMgr.CreateArea() + elif theCriterion == FT_Volume3D: + functor = aFilterMgr.CreateVolume3D() + elif theCriterion == FT_MaxElementLength2D: + functor = aFilterMgr.CreateMaxElementLength2D() + elif theCriterion == FT_MaxElementLength3D: + functor = aFilterMgr.CreateMaxElementLength3D() + elif theCriterion == FT_MultiConnection: + functor = aFilterMgr.CreateMultiConnection() + elif theCriterion == FT_MultiConnection2D: + functor = aFilterMgr.CreateMultiConnection2D() + elif theCriterion == FT_Length: + functor = aFilterMgr.CreateLength() + elif theCriterion == FT_Length2D: + functor = aFilterMgr.CreateLength2D() + else: + print "Error: given parameter is not numerical functor type." + aFilterMgr.UnRegister() + return functor + + ## Creates hypothesis + # @param theHType mesh hypothesis type (string) + # @param theLibName mesh plug-in library name + # @return created hypothesis instance + def CreateHypothesis(self, theHType, theLibName="libStdMeshersEngine.so"): + hyp = SMESH._objref_SMESH_Gen.CreateHypothesis(self, theHType, theLibName ) + + if isinstance( hyp, SMESH._objref_SMESH_Algo ): + return hyp + + # wrap hypothesis methods + #print "HYPOTHESIS", theHType + for meth_name in dir( hyp.__class__ ): + if not meth_name.startswith("Get") and \ + not meth_name in dir ( SMESH._objref_SMESH_Hypothesis ): + method = getattr ( hyp.__class__, meth_name ) + if callable(method): + setattr( hyp, meth_name, hypMethodWrapper( hyp, method )) + + return hyp + + ## Gets the mesh statistic + # @return dictionary "element type" - "count of elements" + # @ingroup l1_meshinfo + def GetMeshInfo(self, obj): + if isinstance( obj, Mesh ): + obj = obj.GetMesh() + d = {} + if hasattr(obj, "GetMeshInfo"): + values = obj.GetMeshInfo() + for i in range(SMESH.Entity_Last._v): + if i < len(values): d[SMESH.EntityType._item(i)]=values[i] + pass + return d + + ## Get minimum distance between two objects + # + # If @a src2 is None, and @a id2 = 0, distance from @a src1 / @a id1 to the origin is computed. + # If @a src2 is None, and @a id2 != 0, it is assumed that both @a id1 and @a id2 belong to @a src1. + # + # @param src1 first source object + # @param src2 second source object + # @param id1 node/element id from the first source + # @param id2 node/element id from the second (or first) source + # @param isElem1 @c True if @a id1 is element id, @c False if it is node id + # @param isElem2 @c True if @a id2 is element id, @c False if it is node id + # @return minimum distance value + # @sa GetMinDistance() + # @ingroup l1_measurements + def MinDistance(self, src1, src2=None, id1=0, id2=0, isElem1=False, isElem2=False): + result = self.GetMinDistance(src1, src2, id1, id2, isElem1, isElem2) + if result is None: + result = 0.0 + else: + result = result.value + return result + + ## Get measure structure specifying minimum distance data between two objects + # + # If @a src2 is None, and @a id2 = 0, distance from @a src1 / @a id1 to the origin is computed. + # If @a src2 is None, and @a id2 != 0, it is assumed that both @a id1 and @a id2 belong to @a src1. + # + # @param src1 first source object + # @param src2 second source object + # @param id1 node/element id from the first source + # @param id2 node/element id from the second (or first) source + # @param isElem1 @c True if @a id1 is element id, @c False if it is node id + # @param isElem2 @c True if @a id2 is element id, @c False if it is node id + # @return Measure structure or None if input data is invalid + # @sa MinDistance() + # @ingroup l1_measurements + def GetMinDistance(self, src1, src2=None, id1=0, id2=0, isElem1=False, isElem2=False): + if isinstance(src1, Mesh): src1 = src1.mesh + if isinstance(src2, Mesh): src2 = src2.mesh + if src2 is None and id2 != 0: src2 = src1 + if not hasattr(src1, "_narrow"): return None + src1 = src1._narrow(SMESH.SMESH_IDSource) + if not src1: return None + if id1 != 0: + m = src1.GetMesh() + e = m.GetMeshEditor() + if isElem1: + src1 = e.MakeIDSource([id1], SMESH.FACE) + else: + src1 = e.MakeIDSource([id1], SMESH.NODE) + pass + if hasattr(src2, "_narrow"): + src2 = src2._narrow(SMESH.SMESH_IDSource) + if src2 and id2 != 0: + m = src2.GetMesh() + e = m.GetMeshEditor() + if isElem2: + src2 = e.MakeIDSource([id2], SMESH.FACE) + else: + src2 = e.MakeIDSource([id2], SMESH.NODE) + pass + pass + aMeasurements = self.CreateMeasurements() + result = aMeasurements.MinDistance(src1, src2) + aMeasurements.UnRegister() + return result + + ## Get bounding box of the specified object(s) + # @param objects single source object or list of source objects + # @return tuple of six values (minX, minY, minZ, maxX, maxY, maxZ) + # @sa GetBoundingBox() + # @ingroup l1_measurements + def BoundingBox(self, objects): + result = self.GetBoundingBox(objects) + if result is None: + result = (0.0,)*6 + else: + result = (result.minX, result.minY, result.minZ, result.maxX, result.maxY, result.maxZ) + return result + + ## Get measure structure specifying bounding box data of the specified object(s) + # @param objects single source object or list of source objects + # @return Measure structure + # @sa BoundingBox() + # @ingroup l1_measurements + def GetBoundingBox(self, objects): + if isinstance(objects, tuple): + objects = list(objects) + if not isinstance(objects, list): + objects = [objects] + srclist = [] + for o in objects: + if isinstance(o, Mesh): + srclist.append(o.mesh) + elif hasattr(o, "_narrow"): + src = o._narrow(SMESH.SMESH_IDSource) + if src: srclist.append(src) + pass + pass + aMeasurements = self.CreateMeasurements() + result = aMeasurements.BoundingBox(srclist) + aMeasurements.UnRegister() + return result + +import omniORB +#Registering the new proxy for SMESH_Gen +omniORB.registerObjref(SMESH._objref_SMESH_Gen._NP_RepositoryId, smeshBuilder) + + +def New( study, instance=None): + global engine + global smeshInst + global doLcc + engine = instance + if engine is None: + doLcc = True + smeshInst = smeshBuilder() + assert isinstance(smeshInst,smeshBuilder), "Smesh engine class is %s but should be smeshBuilder.smeshBuilder. Import salome.smesh.smeshBuilder before creating the instance."%smeshInst.__class__ + smeshInst.init_smesh(study) + return smeshInst + + +# Public class: Mesh +# ================== + +## This class allows defining and managing a mesh. +# It has a set of methods to build a mesh on the given geometry, including the definition of sub-meshes. +# It also has methods to define groups of mesh elements, to modify a mesh (by addition of +# new nodes and elements and by changing the existing entities), to get information +# about a mesh and to export a mesh into different formats. +class Mesh: + + geom = 0 + mesh = 0 + editor = 0 + + ## Constructor + # + # Creates a mesh on the shape \a obj (or an empty mesh if \a obj is equal to 0) and + # sets the GUI name of this mesh to \a name. + # @param smeshpyD an instance of smeshBuilder class + # @param geompyD an instance of geomBuilder class + # @param obj Shape to be meshed or SMESH_Mesh object + # @param name Study name of the mesh + # @ingroup l2_construct + def __init__(self, smeshpyD, geompyD, obj=0, name=0): + self.smeshpyD=smeshpyD + self.geompyD=geompyD + if obj is None: + obj = 0 + objHasName = False + if obj != 0: + if isinstance(obj, geomBuilder.GEOM._objref_GEOM_Object): + self.geom = obj + objHasName = True + # publish geom of mesh (issue 0021122) + if not self.geom.GetStudyEntry() and smeshpyD.GetCurrentStudy(): + objHasName = False + studyID = smeshpyD.GetCurrentStudy()._get_StudyId() + if studyID != geompyD.myStudyId: + geompyD.init_geom( smeshpyD.GetCurrentStudy()) + pass + if name: + geo_name = name + " shape" + else: + geo_name = "%s_%s to mesh"%(self.geom.GetShapeType(), id(self.geom)%100) + geompyD.addToStudy( self.geom, geo_name ) + self.mesh = self.smeshpyD.CreateMesh(self.geom) + + elif isinstance(obj, SMESH._objref_SMESH_Mesh): + self.SetMesh(obj) + else: + self.mesh = self.smeshpyD.CreateEmptyMesh() + if name: + self.smeshpyD.SetName(self.mesh, name) + elif objHasName: + self.smeshpyD.SetName(self.mesh, GetName(obj)) # + " mesh" + + if not self.geom: + self.geom = self.mesh.GetShapeToMesh() + + self.editor = self.mesh.GetMeshEditor() + self.functors = [None] * SMESH.FT_Undefined._v + + # set self to algoCreator's + for attrName in dir(self): + attr = getattr( self, attrName ) + if isinstance( attr, algoCreator ): + print "algoCreator ", attrName + setattr( self, attrName, attr.copy( self )) + + ## Initializes the Mesh object from an instance of SMESH_Mesh interface + # @param theMesh a SMESH_Mesh object + # @ingroup l2_construct + def SetMesh(self, theMesh): + if self.mesh: self.mesh.UnRegister() + self.mesh = theMesh + if self.mesh: + self.mesh.Register() + self.geom = self.mesh.GetShapeToMesh() + + ## Returns the mesh, that is an instance of SMESH_Mesh interface + # @return a SMESH_Mesh object + # @ingroup l2_construct + def GetMesh(self): + return self.mesh + + ## Gets the name of the mesh + # @return the name of the mesh as a string + # @ingroup l2_construct + def GetName(self): + name = GetName(self.GetMesh()) + return name + + ## Sets a name to the mesh + # @param name a new name of the mesh + # @ingroup l2_construct + def SetName(self, name): + self.smeshpyD.SetName(self.GetMesh(), name) + + ## Gets the subMesh object associated to a \a theSubObject geometrical object. + # The subMesh object gives access to the IDs of nodes and elements. + # @param geom a geometrical object (shape) + # @param name a name for the submesh + # @return an object of type SMESH_SubMesh, representing a part of mesh, which lies on the given shape + # @ingroup l2_submeshes + def GetSubMesh(self, geom, name): + AssureGeomPublished( self, geom, name ) + submesh = self.mesh.GetSubMesh( geom, name ) + return submesh + + ## Returns the shape associated to the mesh + # @return a GEOM_Object + # @ingroup l2_construct + def GetShape(self): + return self.geom + + ## Associates the given shape to the mesh (entails the recreation of the mesh) + # @param geom the shape to be meshed (GEOM_Object) + # @ingroup l2_construct + def SetShape(self, geom): + self.mesh = self.smeshpyD.CreateMesh(geom) + + ## Loads mesh from the study after opening the study + def Load(self): + self.mesh.Load() + + ## Returns true if the hypotheses are defined well + # @param theSubObject a sub-shape of a mesh shape + # @return True or False + # @ingroup l2_construct + def IsReadyToCompute(self, theSubObject): + return self.smeshpyD.IsReadyToCompute(self.mesh, theSubObject) + + ## Returns errors of hypotheses definition. + # The list of errors is empty if everything is OK. + # @param theSubObject a sub-shape of a mesh shape + # @return a list of errors + # @ingroup l2_construct + def GetAlgoState(self, theSubObject): + return self.smeshpyD.GetAlgoState(self.mesh, theSubObject) + + ## Returns a geometrical object on which the given element was built. + # The returned geometrical object, if not nil, is either found in the + # study or published by this method with the given name + # @param theElementID the id of the mesh element + # @param theGeomName the user-defined name of the geometrical object + # @return GEOM::GEOM_Object instance + # @ingroup l2_construct + def GetGeometryByMeshElement(self, theElementID, theGeomName): + return self.smeshpyD.GetGeometryByMeshElement( self.mesh, theElementID, theGeomName ) + + ## Returns the mesh dimension depending on the dimension of the underlying shape + # or, if the mesh is not based on any shape, basing on deimension of elements + # @return mesh dimension as an integer value [0,3] + # @ingroup l1_auxiliary + def MeshDimension(self): + if self.mesh.HasShapeToMesh(): + shells = self.geompyD.SubShapeAllIDs( self.geom, geomBuilder.ShapeType["SOLID"] ) + if len( shells ) > 0 : + return 3 + elif self.geompyD.NumberOfFaces( self.geom ) > 0 : + return 2 + elif self.geompyD.NumberOfEdges( self.geom ) > 0 : + return 1 + else: + return 0; + else: + if self.NbVolumes() > 0: return 3 + if self.NbFaces() > 0: return 2 + if self.NbEdges() > 0: return 1 + return 0 + + ## Evaluates size of prospective mesh on a shape + # @return a list where i-th element is a number of elements of i-th SMESH.EntityType + # To know predicted number of e.g. edges, inquire it this way + # Evaluate()[ EnumToLong( Entity_Edge )] + def Evaluate(self, geom=0): + if geom == 0 or not isinstance(geom, geomBuilder.GEOM._objref_GEOM_Object): + if self.geom == 0: + geom = self.mesh.GetShapeToMesh() + else: + geom = self.geom + return self.smeshpyD.Evaluate(self.mesh, geom) + + + ## Computes the mesh and returns the status of the computation + # @param geom geomtrical shape on which mesh data should be computed + # @param discardModifs if True and the mesh has been edited since + # a last total re-compute and that may prevent successful partial re-compute, + # then the mesh is cleaned before Compute() + # @return True or False + # @ingroup l2_construct + def Compute(self, geom=0, discardModifs=False): + if geom == 0 or not isinstance(geom, geomBuilder.GEOM._objref_GEOM_Object): + if self.geom == 0: + geom = self.mesh.GetShapeToMesh() + else: + geom = self.geom + ok = False + try: + if discardModifs and self.mesh.HasModificationsToDiscard(): # issue 0020693 + self.mesh.Clear() + ok = self.smeshpyD.Compute(self.mesh, geom) + except SALOME.SALOME_Exception, ex: + print "Mesh computation failed, exception caught:" + print " ", ex.details.text + except: + import traceback + print "Mesh computation failed, exception caught:" + traceback.print_exc() + if True:#not ok: + allReasons = "" + + # Treat compute errors + computeErrors = self.smeshpyD.GetComputeErrors( self.mesh, geom ) + for err in computeErrors: + shapeText = "" + if self.mesh.HasShapeToMesh(): + try: + mainIOR = salome.orb.object_to_string(geom) + for sname in salome.myStudyManager.GetOpenStudies(): + s = salome.myStudyManager.GetStudyByName(sname) + if not s: continue + mainSO = s.FindObjectIOR(mainIOR) + if not mainSO: continue + if err.subShapeID == 1: + shapeText = ' on "%s"' % mainSO.GetName() + subIt = s.NewChildIterator(mainSO) + while subIt.More(): + subSO = subIt.Value() + subIt.Next() + obj = subSO.GetObject() + if not obj: continue + go = obj._narrow( geomBuilder.GEOM._objref_GEOM_Object ) + if not go: continue + ids = go.GetSubShapeIndices() + if len(ids) == 1 and ids[0] == err.subShapeID: + shapeText = ' on "%s"' % subSO.GetName() + break + if not shapeText: + shape = self.geompyD.GetSubShape( geom, [err.subShapeID]) + if shape: + shapeText = " on %s #%s" % (shape.GetShapeType(), err.subShapeID) + else: + shapeText = " on subshape #%s" % (err.subShapeID) + except: + shapeText = " on subshape #%s" % (err.subShapeID) + errText = "" + stdErrors = ["OK", #COMPERR_OK + "Invalid input mesh", #COMPERR_BAD_INPUT_MESH + "std::exception", #COMPERR_STD_EXCEPTION + "OCC exception", #COMPERR_OCC_EXCEPTION + "..", #COMPERR_SLM_EXCEPTION + "Unknown exception", #COMPERR_EXCEPTION + "Memory allocation problem", #COMPERR_MEMORY_PB + "Algorithm failed", #COMPERR_ALGO_FAILED + "Unexpected geometry", #COMPERR_BAD_SHAPE + "Warning", #COMPERR_WARNING + "Computation cancelled",#COMPERR_CANCELED + "No mesh on sub-shape"] #COMPERR_NO_MESH_ON_SHAPE + if err.code > 0: + if err.code < len(stdErrors): errText = stdErrors[err.code] + else: + errText = "code %s" % -err.code + if errText: errText += ". " + errText += err.comment + if allReasons != "":allReasons += "\n" + allReasons += '- "%s" failed%s. Error: %s' %(err.algoName, shapeText, errText) + pass + + # Treat hyp errors + errors = self.smeshpyD.GetAlgoState( self.mesh, geom ) + for err in errors: + if err.isGlobalAlgo: + glob = "global" + else: + glob = "local" + pass + dim = err.algoDim + name = err.algoName + if len(name) == 0: + reason = '%s %sD algorithm is missing' % (glob, dim) + elif err.state == HYP_MISSING: + reason = ('%s %sD algorithm "%s" misses %sD hypothesis' + % (glob, dim, name, dim)) + elif err.state == HYP_NOTCONFORM: + reason = 'Global "Not Conform mesh allowed" hypothesis is missing' + elif err.state == HYP_BAD_PARAMETER: + reason = ('Hypothesis of %s %sD algorithm "%s" has a bad parameter value' + % ( glob, dim, name )) + elif err.state == HYP_BAD_GEOMETRY: + reason = ('%s %sD algorithm "%s" is assigned to mismatching' + 'geometry' % ( glob, dim, name )) + elif err.state == HYP_HIDDEN_ALGO: + reason = ('%s %sD algorithm "%s" is ignored due to presence of a %s ' + 'algorithm of upper dimension generating %sD mesh' + % ( glob, dim, name, glob, dim )) + else: + reason = ("For unknown reason. " + "Developer, revise Mesh.Compute() implementation in smeshBuilder.py!") + pass + if allReasons != "":allReasons += "\n" + allReasons += "- " + reason + pass + if not ok or allReasons != "": + msg = '"' + GetName(self.mesh) + '"' + if ok: msg += " has been computed with warnings" + else: msg += " has not been computed" + if allReasons != "": msg += ":" + else: msg += "." + print msg + print allReasons + pass + if salome.sg.hasDesktop() and self.mesh.GetStudyId() >= 0: + smeshgui = salome.ImportComponentGUI("SMESH") + smeshgui.Init(self.mesh.GetStudyId()) + smeshgui.SetMeshIcon( salome.ObjectToID( self.mesh ), ok, (self.NbNodes()==0) ) + salome.sg.updateObjBrowser(1) + pass + return ok + + ## Return submesh objects list in meshing order + # @return list of list of submesh objects + # @ingroup l2_construct + def GetMeshOrder(self): + return self.mesh.GetMeshOrder() + + ## Return submesh objects list in meshing order + # @return list of list of submesh objects + # @ingroup l2_construct + def SetMeshOrder(self, submeshes): + return self.mesh.SetMeshOrder(submeshes) + + ## Removes all nodes and elements + # @ingroup l2_construct + def Clear(self): + self.mesh.Clear() + if ( salome.sg.hasDesktop() and + salome.myStudyManager.GetStudyByID( self.mesh.GetStudyId() )): + smeshgui = salome.ImportComponentGUI("SMESH") + smeshgui.Init(self.mesh.GetStudyId()) + smeshgui.SetMeshIcon( salome.ObjectToID( self.mesh ), False, True ) + salome.sg.updateObjBrowser(1) + + ## Removes all nodes and elements of indicated shape + # @ingroup l2_construct + def ClearSubMesh(self, geomId): + self.mesh.ClearSubMesh(geomId) + if salome.sg.hasDesktop(): + smeshgui = salome.ImportComponentGUI("SMESH") + smeshgui.Init(self.mesh.GetStudyId()) + smeshgui.SetMeshIcon( salome.ObjectToID( self.mesh ), False, True ) + salome.sg.updateObjBrowser(1) + + ## Computes a tetrahedral mesh using AutomaticLength + MEFISTO + NETGEN + # @param fineness [0.0,1.0] defines mesh fineness + # @return True or False + # @ingroup l3_algos_basic + def AutomaticTetrahedralization(self, fineness=0): + dim = self.MeshDimension() + # assign hypotheses + self.RemoveGlobalHypotheses() + self.Segment().AutomaticLength(fineness) + if dim > 1 : + self.Triangle().LengthFromEdges() + pass + if dim > 2 : + from salome.NETGENPlugin.NETGENPluginBuilder import NETGEN + self.Tetrahedron(NETGEN) + pass + return self.Compute() + + ## Computes an hexahedral mesh using AutomaticLength + Quadrangle + Hexahedron + # @param fineness [0.0, 1.0] defines mesh fineness + # @return True or False + # @ingroup l3_algos_basic + def AutomaticHexahedralization(self, fineness=0): + dim = self.MeshDimension() + # assign the hypotheses + self.RemoveGlobalHypotheses() + self.Segment().AutomaticLength(fineness) + if dim > 1 : + self.Quadrangle() + pass + if dim > 2 : + self.Hexahedron() + pass + return self.Compute() + + ## Assigns a hypothesis + # @param hyp a hypothesis to assign + # @param geom a subhape of mesh geometry + # @return SMESH.Hypothesis_Status + # @ingroup l2_hypotheses + def AddHypothesis(self, hyp, geom=0): + if isinstance( hyp, Mesh_Algorithm ): + hyp = hyp.GetAlgorithm() + pass + if not geom: + geom = self.geom + if not geom: + geom = self.mesh.GetShapeToMesh() + pass + AssureGeomPublished( self, geom, "shape for %s" % hyp.GetName()) + status = self.mesh.AddHypothesis(geom, hyp) + isAlgo = hyp._narrow( SMESH_Algo ) + hyp_name = GetName( hyp ) + geom_name = "" + if geom: + geom_name = GetName( geom ) + TreatHypoStatus( status, hyp_name, geom_name, isAlgo ) + return status + + ## Return True if an algorithm of hypothesis is assigned to a given shape + # @param hyp a hypothesis to check + # @param geom a subhape of mesh geometry + # @return True of False + # @ingroup l2_hypotheses + def IsUsedHypothesis(self, hyp, geom): + if not hyp: # or not geom + return False + if isinstance( hyp, Mesh_Algorithm ): + hyp = hyp.GetAlgorithm() + pass + hyps = self.GetHypothesisList(geom) + for h in hyps: + if h.GetId() == hyp.GetId(): + return True + return False + + ## Unassigns a hypothesis + # @param hyp a hypothesis to unassign + # @param geom a sub-shape of mesh geometry + # @return SMESH.Hypothesis_Status + # @ingroup l2_hypotheses + def RemoveHypothesis(self, hyp, geom=0): + if isinstance( hyp, Mesh_Algorithm ): + hyp = hyp.GetAlgorithm() + pass + shape = geom + if not shape: + shape = self.geom + pass + if self.IsUsedHypothesis( hyp, shape ): + return self.mesh.RemoveHypothesis( shape, hyp ) + hypName = GetName( hyp ) + geoName = GetName( shape ) + print "WARNING: RemoveHypothesis() failed as '%s' is not assigned to '%s' shape" % ( hypName, geoName ) + return None + + ## Gets the list of hypotheses added on a geometry + # @param geom a sub-shape of mesh geometry + # @return the sequence of SMESH_Hypothesis + # @ingroup l2_hypotheses + def GetHypothesisList(self, geom): + return self.mesh.GetHypothesisList( geom ) + + ## Removes all global hypotheses + # @ingroup l2_hypotheses + def RemoveGlobalHypotheses(self): + current_hyps = self.mesh.GetHypothesisList( self.geom ) + for hyp in current_hyps: + self.mesh.RemoveHypothesis( self.geom, hyp ) + pass + pass + + ## Exports the mesh in a file in MED format and chooses the \a version of MED format + ## allowing to overwrite the file if it exists or add the exported data to its contents + # @param f is the file name + # @param auto_groups boolean parameter for creating/not creating + # the groups Group_On_All_Nodes, Group_On_All_Faces, ... ; + # the typical use is auto_groups=false. + # @param version MED format version(MED_V2_1 or MED_V2_2) + # @param overwrite boolean parameter for overwriting/not overwriting the file + # @param meshPart a part of mesh (group, sub-mesh) to export instead of the mesh + # @ingroup l2_impexp + def ExportMED(self, f, auto_groups=0, version=MED_V2_2, overwrite=1, meshPart=None): + if meshPart: + if isinstance( meshPart, list ): + meshPart = self.GetIDSource( meshPart, SMESH.ALL ) + self.mesh.ExportPartToMED( meshPart, f, auto_groups, version, overwrite ) + else: + self.mesh.ExportToMEDX(f, auto_groups, version, overwrite) + + ## Exports the mesh in a file in SAUV format + # @param f is the file name + # @param auto_groups boolean parameter for creating/not creating + # the groups Group_On_All_Nodes, Group_On_All_Faces, ... ; + # the typical use is auto_groups=false. + # @ingroup l2_impexp + def ExportSAUV(self, f, auto_groups=0): + self.mesh.ExportSAUV(f, auto_groups) + + ## Exports the mesh in a file in DAT format + # @param f the file name + # @param meshPart a part of mesh (group, sub-mesh) to export instead of the mesh + # @ingroup l2_impexp + def ExportDAT(self, f, 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, 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, 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) + + ## Exports the mesh in a file in GMF format + # @param f is the file name + # @param meshPart a part of mesh (group, sub-mesh) to export instead of the mesh + # @ingroup l2_impexp + def ExportGMF(self, f, 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.ExportGMF(meshPart, f, True) + + ## Deprecated, used only for compatibility! Please, use ExportToMEDX() method instead. + # Exports the mesh in a file in MED format and chooses the \a version of MED format + ## allowing to overwrite the file if it exists or add the exported data to its contents + # @param f the file name + # @param version values are SMESH.MED_V2_1, SMESH.MED_V2_2 + # @param opt boolean parameter for creating/not creating + # the groups Group_On_All_Nodes, Group_On_All_Faces, ... + # @param overwrite boolean parameter for overwriting/not overwriting the file + # @ingroup l2_impexp + def ExportToMED(self, f, version, opt=0, overwrite=1): + self.mesh.ExportToMEDX(f, opt, version, overwrite) + + # Operations with groups: + # ---------------------- + + ## Creates an empty mesh group + # @param elementType the type of elements in the group + # @param name the name of the mesh group + # @return SMESH_Group + # @ingroup l2_grps_create + 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 + # @param grp a geometrical group, a vertex, an edge, a face or a solid + # @param name the name of the mesh group + # @param typ the type of elements in the group. If not set, it is + # automatically detected by the type of the geometry + # @return SMESH_GroupOnGeom + # @ingroup l2_grps_create + def GroupOnGeom(self, grp, name="", typ=None): + AssureGeomPublished( self, grp, name ) + if name == "": + name = grp.GetName() + 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, geomBuilder.ShapeType["SHAPE"]) + if not sub: + raise ValueError,"_groupTypeFromShape(): empty geometric group or compound '%s'" % GetName(shape) + return self._groupTypeFromShape( sub[0] ) + else: + 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 + # @param elementType the type of elements in the group + # @param elemIDs the list of ids + # @return SMESH_Group + # @ingroup l2_grps_create + def MakeGroupByIds(self, groupName, elementType, elemIDs): + group = self.mesh.CreateGroup(elementType, groupName) + group.Add(elemIDs) + return group + + ## Creates a mesh group by the given conditions + # @param groupName the name of the mesh group + # @param elementType the type of elements in the group + # @param CritType the type of criterion( FT_Taper, FT_Area, FT_RangeOfIds, FT_LyingOnGeom etc. ) + # @param Compare belongs to {FT_LessThan, FT_MoreThan, FT_EqualTo} + # @param Threshold the threshold value (range of id ids as string, shape, numeric) + # @param UnaryOp FT_LogicalNOT or FT_Undefined + # @param Tolerance the tolerance used by FT_BelongToGeom, FT_BelongToSurface, + # FT_LyingOnGeom, FT_CoplanarFaces criteria + # @return SMESH_Group + # @ingroup l2_grps_create + def MakeGroup(self, + groupName, + elementType, + CritType=FT_Undefined, + Compare=FT_EqualTo, + Threshold="", + UnaryOp=FT_Undefined, + Tolerance=1e-07): + aCriterion = self.smeshpyD.GetCriterion(elementType, CritType, Compare, Threshold, UnaryOp, FT_Undefined,Tolerance) + group = self.MakeGroupByCriterion(groupName, aCriterion) + return group + + ## Creates a mesh group by the given criterion + # @param groupName the name of the mesh group + # @param Criterion the instance of Criterion class + # @return SMESH_Group + # @ingroup l2_grps_create + def MakeGroupByCriterion(self, groupName, Criterion): + aFilterMgr = self.smeshpyD.CreateFilterManager() + aFilter = aFilterMgr.CreateFilter() + aCriteria = [] + aCriteria.append(Criterion) + aFilter.SetCriteria(aCriteria) + group = self.MakeGroupByFilter(groupName, aFilter) + aFilterMgr.UnRegister() + return group + + ## Creates a mesh group by the given criteria (list of criteria) + # @param groupName the name of the mesh group + # @param theCriteria the list of criteria + # @return SMESH_Group + # @ingroup l2_grps_create + def MakeGroupByCriteria(self, groupName, theCriteria): + aFilterMgr = self.smeshpyD.CreateFilterManager() + aFilter = aFilterMgr.CreateFilter() + aFilter.SetCriteria(theCriteria) + group = self.MakeGroupByFilter(groupName, aFilter) + aFilterMgr.UnRegister() + return group + + ## Creates a mesh group by the given filter + # @param groupName the name of the mesh group + # @param theFilter the instance of Filter class + # @return SMESH_Group + # @ingroup l2_grps_create + def MakeGroupByFilter(self, groupName, theFilter): + group = self.CreateEmptyGroup(theFilter.GetElementType(), groupName) + theFilter.SetMesh( self.mesh ) + group.AddFrom( theFilter ) + return group + + ## Removes a group + # @ingroup l2_grps_delete + def RemoveGroup(self, group): + self.mesh.RemoveGroup(group) + + ## Removes a group with its contents + # @ingroup l2_grps_delete + def RemoveGroupWithContents(self, group): + self.mesh.RemoveGroupWithContents(group) + + ## Gets the list of groups existing in the mesh + # @return a sequence of SMESH_GroupBase + # @ingroup l2_grps_create + def GetGroups(self): + return self.mesh.GetGroups() + + ## Gets the number of groups existing in the mesh + # @return the quantity of groups as an integer value + # @ingroup l2_grps_create + def NbGroups(self): + return self.mesh.NbGroups() + + ## Gets the list of names of groups existing in the mesh + # @return list of strings + # @ingroup l2_grps_create + def GetGroupNames(self): + groups = self.GetGroups() + names = [] + for group in groups: + names.append(group.GetName()) + return names + + ## Produces a union of two groups + # A new group is created. All mesh elements that are + # present in the initial groups are added to the new one + # @return an instance of SMESH_Group + # @ingroup l2_grps_operon + def UnionGroups(self, group1, group2, name): + return self.mesh.UnionGroups(group1, group2, name) + + ## Produces a union list of groups + # New group is created. All mesh elements that are present in + # initial groups are added to the new one + # @return an instance of SMESH_Group + # @ingroup l2_grps_operon + def UnionListOfGroups(self, groups, name): + return self.mesh.UnionListOfGroups(groups, name) + + ## Prodices an intersection of two groups + # A new group is created. All mesh elements that are common + # for the two initial groups are added to the new one. + # @return an instance of SMESH_Group + # @ingroup l2_grps_operon + def IntersectGroups(self, group1, group2, name): + return self.mesh.IntersectGroups(group1, group2, name) + + ## Produces an intersection of groups + # New group is created. All mesh elements that are present in all + # initial groups simultaneously are added to the new one + # @return an instance of SMESH_Group + # @ingroup l2_grps_operon + def IntersectListOfGroups(self, groups, name): + return self.mesh.IntersectListOfGroups(groups, name) + + ## Produces a cut of two groups + # A new group is created. All mesh elements that are present in + # the main group but are not present in the tool group are added to the new one + # @return an instance of SMESH_Group + # @ingroup l2_grps_operon + def CutGroups(self, main_group, tool_group, name): + return self.mesh.CutGroups(main_group, tool_group, name) + + ## Produces a cut of groups + # A new group is created. All mesh elements that are present in main groups + # but do not present in tool groups are added to the new one + # @return an instance of SMESH_Group + # @ingroup l2_grps_operon + def CutListOfGroups(self, main_groups, tool_groups, name): + return self.mesh.CutListOfGroups(main_groups, tool_groups, name) + + ## Produces a group of elements of specified type using list of existing groups + # A new group is created. System + # 1) extracts all nodes on which groups elements are built + # 2) combines all elements of specified dimension laying on these nodes + # @return an instance of SMESH_Group + # @ingroup l2_grps_operon + def CreateDimGroup(self, groups, elem_type, name): + return self.mesh.CreateDimGroup(groups, elem_type, name) + + + ## Convert group on geom into standalone group + # @ingroup l2_grps_delete + def ConvertToStandalone(self, group): + return self.mesh.ConvertToStandalone(group) + + # Get some info about mesh: + # ------------------------ + + ## Returns the log of nodes and elements added or removed + # since the previous clear of the log. + # @param clearAfterGet log is emptied after Get (safe if concurrents access) + # @return list of log_block structures: + # commandType + # number + # coords + # indexes + # @ingroup l1_auxiliary + def GetLog(self, clearAfterGet): + return self.mesh.GetLog(clearAfterGet) + + ## Clears the log of nodes and elements added or removed since the previous + # clear. Must be used immediately after GetLog if clearAfterGet is false. + # @ingroup l1_auxiliary + def ClearLog(self): + self.mesh.ClearLog() + + ## Toggles auto color mode on the object. + # @param theAutoColor the flag which toggles auto color mode. + # @ingroup l1_auxiliary + def SetAutoColor(self, theAutoColor): + self.mesh.SetAutoColor(theAutoColor) + + ## Gets flag of object auto color mode. + # @return True or False + # @ingroup l1_auxiliary + def GetAutoColor(self): + return self.mesh.GetAutoColor() + + ## Gets the internal ID + # @return integer value, which is the internal Id of the mesh + # @ingroup l1_auxiliary + def GetId(self): + return self.mesh.GetId() + + ## Get the study Id + # @return integer value, which is the study Id of the mesh + # @ingroup l1_auxiliary + def GetStudyId(self): + return self.mesh.GetStudyId() + + ## Checks the group names for duplications. + # Consider the maximum group name length stored in MED file. + # @return True or False + # @ingroup l1_auxiliary + def HasDuplicatedGroupNamesMED(self): + return self.mesh.HasDuplicatedGroupNamesMED() + + ## Obtains the mesh editor tool + # @return an instance of SMESH_MeshEditor + # @ingroup l1_modifying + def GetMeshEditor(self): + return self.editor + + ## Wrap a list of IDs of elements or nodes into SMESH_IDSource which + # can be passed as argument to a method accepting mesh, group or sub-mesh + # @return an instance of SMESH_IDSource + # @ingroup l1_auxiliary + def GetIDSource(self, ids, elemType): + return self.editor.MakeIDSource(ids, elemType) + + ## Gets MED Mesh + # @return an instance of SALOME_MED::MESH + # @ingroup l1_auxiliary + def GetMEDMesh(self): + return self.mesh.GetMEDMesh() + + + # Get informations about mesh contents: + # ------------------------------------ + + ## Gets the mesh stattistic + # @return dictionary type element - count of elements + # @ingroup l1_meshinfo + def GetMeshInfo(self, obj = None): + if not obj: obj = self.mesh + return self.smeshpyD.GetMeshInfo(obj) + + ## Returns the number of nodes in the mesh + # @return an integer value + # @ingroup l1_meshinfo + def NbNodes(self): + return self.mesh.NbNodes() + + ## Returns the number of elements in the mesh + # @return an integer value + # @ingroup l1_meshinfo + def NbElements(self): + return self.mesh.NbElements() + + ## Returns the number of 0d elements in the mesh + # @return an integer value + # @ingroup l1_meshinfo + def Nb0DElements(self): + return self.mesh.Nb0DElements() + + ## Returns the number of ball discrete elements in the mesh + # @return an integer value + # @ingroup l1_meshinfo + def NbBalls(self): + return self.mesh.NbBalls() + + ## Returns the number of edges in the mesh + # @return an integer value + # @ingroup l1_meshinfo + def NbEdges(self): + return self.mesh.NbEdges() + + ## Returns the number of edges with the given order in the mesh + # @param elementOrder the order of elements: + # ORDER_ANY, ORDER_LINEAR or ORDER_QUADRATIC + # @return an integer value + # @ingroup l1_meshinfo + def NbEdgesOfOrder(self, elementOrder): + return self.mesh.NbEdgesOfOrder(elementOrder) + + ## Returns the number of faces in the mesh + # @return an integer value + # @ingroup l1_meshinfo + def NbFaces(self): + return self.mesh.NbFaces() + + ## Returns the number of faces with the given order in the mesh + # @param elementOrder the order of elements: + # ORDER_ANY, ORDER_LINEAR or ORDER_QUADRATIC + # @return an integer value + # @ingroup l1_meshinfo + def NbFacesOfOrder(self, elementOrder): + return self.mesh.NbFacesOfOrder(elementOrder) + + ## Returns the number of triangles in the mesh + # @return an integer value + # @ingroup l1_meshinfo + def NbTriangles(self): + return self.mesh.NbTriangles() + + ## Returns the number of triangles with the given order in the mesh + # @param elementOrder is the order of elements: + # ORDER_ANY, ORDER_LINEAR or ORDER_QUADRATIC + # @return an integer value + # @ingroup l1_meshinfo + def NbTrianglesOfOrder(self, elementOrder): + return self.mesh.NbTrianglesOfOrder(elementOrder) + + ## Returns the number of quadrangles in the mesh + # @return an integer value + # @ingroup l1_meshinfo + def NbQuadrangles(self): + return self.mesh.NbQuadrangles() + + ## Returns the number of quadrangles with the given order in the mesh + # @param elementOrder the order of elements: + # ORDER_ANY, ORDER_LINEAR or ORDER_QUADRATIC + # @return an integer value + # @ingroup l1_meshinfo + def NbQuadranglesOfOrder(self, elementOrder): + return self.mesh.NbQuadranglesOfOrder(elementOrder) + + ## Returns the number of biquadratic quadrangles in the mesh + # @return an integer value + # @ingroup l1_meshinfo + def NbBiQuadQuadrangles(self): + return self.mesh.NbBiQuadQuadrangles() + + ## Returns the number of polygons in the mesh + # @return an integer value + # @ingroup l1_meshinfo + def NbPolygons(self): + return self.mesh.NbPolygons() + + ## Returns the number of volumes in the mesh + # @return an integer value + # @ingroup l1_meshinfo + def NbVolumes(self): + return self.mesh.NbVolumes() + + ## Returns the number of volumes with the given order in the mesh + # @param elementOrder the order of elements: + # ORDER_ANY, ORDER_LINEAR or ORDER_QUADRATIC + # @return an integer value + # @ingroup l1_meshinfo + def NbVolumesOfOrder(self, elementOrder): + return self.mesh.NbVolumesOfOrder(elementOrder) + + ## Returns the number of tetrahedrons in the mesh + # @return an integer value + # @ingroup l1_meshinfo + def NbTetras(self): + return self.mesh.NbTetras() + + ## Returns the number of tetrahedrons with the given order in the mesh + # @param elementOrder the order of elements: + # ORDER_ANY, ORDER_LINEAR or ORDER_QUADRATIC + # @return an integer value + # @ingroup l1_meshinfo + def NbTetrasOfOrder(self, elementOrder): + return self.mesh.NbTetrasOfOrder(elementOrder) + + ## Returns the number of hexahedrons in the mesh + # @return an integer value + # @ingroup l1_meshinfo + def NbHexas(self): + return self.mesh.NbHexas() + + ## Returns the number of hexahedrons with the given order in the mesh + # @param elementOrder the order of elements: + # ORDER_ANY, ORDER_LINEAR or ORDER_QUADRATIC + # @return an integer value + # @ingroup l1_meshinfo + def NbHexasOfOrder(self, elementOrder): + return self.mesh.NbHexasOfOrder(elementOrder) + + ## Returns the number of triquadratic hexahedrons in the mesh + # @return an integer value + # @ingroup l1_meshinfo + def NbTriQuadraticHexas(self): + return self.mesh.NbTriQuadraticHexas() + + ## Returns the number of pyramids in the mesh + # @return an integer value + # @ingroup l1_meshinfo + def NbPyramids(self): + return self.mesh.NbPyramids() + + ## Returns the number of pyramids with the given order in the mesh + # @param elementOrder the order of elements: + # ORDER_ANY, ORDER_LINEAR or ORDER_QUADRATIC + # @return an integer value + # @ingroup l1_meshinfo + def NbPyramidsOfOrder(self, elementOrder): + return self.mesh.NbPyramidsOfOrder(elementOrder) + + ## Returns the number of prisms in the mesh + # @return an integer value + # @ingroup l1_meshinfo + def NbPrisms(self): + return self.mesh.NbPrisms() + + ## Returns the number of prisms with the given order in the mesh + # @param elementOrder the order of elements: + # ORDER_ANY, ORDER_LINEAR or ORDER_QUADRATIC + # @return an integer value + # @ingroup l1_meshinfo + def NbPrismsOfOrder(self, elementOrder): + return self.mesh.NbPrismsOfOrder(elementOrder) + + ## Returns the number of hexagonal prisms in the mesh + # @return an integer value + # @ingroup l1_meshinfo + def NbHexagonalPrisms(self): + return self.mesh.NbHexagonalPrisms() + + ## Returns the number of polyhedrons in the mesh + # @return an integer value + # @ingroup l1_meshinfo + def NbPolyhedrons(self): + return self.mesh.NbPolyhedrons() + + ## Returns the number of submeshes in the mesh + # @return an integer value + # @ingroup l1_meshinfo + def NbSubMesh(self): + return self.mesh.NbSubMesh() + + ## Returns the list of mesh elements IDs + # @return the list of integer values + # @ingroup l1_meshinfo + def GetElementsId(self): + return self.mesh.GetElementsId() + + ## Returns the list of IDs of mesh elements with the given type + # @param elementType the required type of elements (SMESH.NODE, SMESH.EDGE, SMESH.FACE or SMESH.VOLUME) + # @return list of integer values + # @ingroup l1_meshinfo + def GetElementsByType(self, elementType): + return self.mesh.GetElementsByType(elementType) + + ## Returns the list of mesh nodes IDs + # @return the list of integer values + # @ingroup l1_meshinfo + def GetNodesId(self): + return self.mesh.GetNodesId() + + # Get the information about mesh elements: + # ------------------------------------ + + ## Returns the type of mesh element + # @return the value from SMESH::ElementType enumeration + # @ingroup l1_meshinfo + def GetElementType(self, id, iselem): + return self.mesh.GetElementType(id, iselem) + + ## Returns the geometric type of mesh element + # @return the value from SMESH::EntityType enumeration + # @ingroup l1_meshinfo + def GetElementGeomType(self, id): + return self.mesh.GetElementGeomType(id) + + ## Returns the list of submesh elements IDs + # @param Shape a geom object(sub-shape) IOR + # Shape must be the sub-shape of a ShapeToMesh() + # @return the list of integer values + # @ingroup l1_meshinfo + def GetSubMeshElementsId(self, Shape): + if ( isinstance( Shape, geomBuilder.GEOM._objref_GEOM_Object)): + ShapeID = Shape.GetSubShapeIndices()[0] + else: + ShapeID = Shape + return self.mesh.GetSubMeshElementsId(ShapeID) + + ## Returns the list of submesh nodes IDs + # @param Shape a geom object(sub-shape) IOR + # Shape must be the sub-shape of a ShapeToMesh() + # @param all If true, gives all nodes of submesh elements, otherwise gives only submesh nodes + # @return the list of integer values + # @ingroup l1_meshinfo + def GetSubMeshNodesId(self, Shape, all): + if ( isinstance( Shape, geomBuilder.GEOM._objref_GEOM_Object)): + ShapeID = self.geompyD.GetSubShapeID( self.geom, Shape ) + else: + ShapeID = Shape + return self.mesh.GetSubMeshNodesId(ShapeID, all) + + ## Returns type of elements on given shape + # @param Shape a geom object(sub-shape) IOR + # Shape must be a sub-shape of a ShapeToMesh() + # @return element type + # @ingroup l1_meshinfo + def GetSubMeshElementType(self, Shape): + if ( isinstance( Shape, geomBuilder.GEOM._objref_GEOM_Object)): + ShapeID = Shape.GetSubShapeIndices()[0] + else: + ShapeID = Shape + return self.mesh.GetSubMeshElementType(ShapeID) + + ## Gets the mesh description + # @return string value + # @ingroup l1_meshinfo + def Dump(self): + return self.mesh.Dump() + + + # Get the information about nodes and elements of a mesh by its IDs: + # ----------------------------------------------------------- + + ## Gets XYZ coordinates of a node + # \n If there is no nodes for the given ID - returns an empty list + # @return a list of double precision values + # @ingroup l1_meshinfo + def GetNodeXYZ(self, id): + return self.mesh.GetNodeXYZ(id) + + ## Returns list of IDs of inverse elements for the given node + # \n If there is no node for the given ID - returns an empty list + # @return a list of integer values + # @ingroup l1_meshinfo + def GetNodeInverseElements(self, id): + return self.mesh.GetNodeInverseElements(id) + + ## @brief Returns the position of a node on the shape + # @return SMESH::NodePosition + # @ingroup l1_meshinfo + def GetNodePosition(self,NodeID): + return self.mesh.GetNodePosition(NodeID) + + ## @brief Returns the position of an element on the shape + # @return SMESH::ElementPosition + # @ingroup l1_meshinfo + def GetElementPosition(self,ElemID): + return self.mesh.GetElementPosition(ElemID) + + ## If the given element is a node, returns the ID of shape + # \n If there is no node for the given ID - returns -1 + # @return an integer value + # @ingroup l1_meshinfo + def GetShapeID(self, id): + return self.mesh.GetShapeID(id) + + ## Returns the ID of the result shape after + # FindShape() from SMESH_MeshEditor for the given element + # \n If there is no element for the given ID - returns -1 + # @return an integer value + # @ingroup l1_meshinfo + def GetShapeIDForElem(self,id): + return self.mesh.GetShapeIDForElem(id) + + ## Returns the number of nodes for the given element + # \n If there is no element for the given ID - returns -1 + # @return an integer value + # @ingroup l1_meshinfo + def GetElemNbNodes(self, id): + return self.mesh.GetElemNbNodes(id) + + ## Returns the node ID the given index for the given element + # \n If there is no element for the given ID - returns -1 + # \n If there is no node for the given index - returns -2 + # @return an integer value + # @ingroup l1_meshinfo + def GetElemNode(self, id, index): + return self.mesh.GetElemNode(id, index) + + ## Returns the IDs of nodes of the given element + # @return a list of integer values + # @ingroup l1_meshinfo + def GetElemNodes(self, id): + return self.mesh.GetElemNodes(id) + + ## Returns true if the given node is the medium node in the given quadratic element + # @ingroup l1_meshinfo + def IsMediumNode(self, elementID, nodeID): + return self.mesh.IsMediumNode(elementID, nodeID) + + ## Returns true if the given node is the medium node in one of quadratic elements + # @ingroup l1_meshinfo + def IsMediumNodeOfAnyElem(self, nodeID, elementType): + return self.mesh.IsMediumNodeOfAnyElem(nodeID, elementType) + + ## Returns the number of edges for the given element + # @ingroup l1_meshinfo + def ElemNbEdges(self, id): + return self.mesh.ElemNbEdges(id) + + ## Returns the number of faces for the given element + # @ingroup l1_meshinfo + def ElemNbFaces(self, id): + return self.mesh.ElemNbFaces(id) + + ## Returns nodes of given face (counted from zero) for given volumic element. + # @ingroup l1_meshinfo + def GetElemFaceNodes(self,elemId, faceIndex): + return self.mesh.GetElemFaceNodes(elemId, faceIndex) + + ## Returns an element based on all given nodes. + # @ingroup l1_meshinfo + def FindElementByNodes(self,nodes): + return self.mesh.FindElementByNodes(nodes) + + ## Returns true if the given element is a polygon + # @ingroup l1_meshinfo + def IsPoly(self, id): + return self.mesh.IsPoly(id) + + ## Returns true if the given element is quadratic + # @ingroup l1_meshinfo + def IsQuadratic(self, id): + return self.mesh.IsQuadratic(id) + + ## Returns diameter of a ball discrete element or zero in case of an invalid \a id + # @ingroup l1_meshinfo + def GetBallDiameter(self, id): + return self.mesh.GetBallDiameter(id) + + ## Returns XYZ coordinates of the barycenter of the given element + # \n If there is no element for the given ID - returns an empty list + # @return a list of three double values + # @ingroup l1_meshinfo + def BaryCenter(self, id): + return self.mesh.BaryCenter(id) + + ## Passes mesh elements through the given filter and return IDs of fitting elements + # @param theFilter SMESH_Filter + # @return a list of ids + # @ingroup l1_controls + def GetIdsFromFilter(self, theFilter): + theFilter.SetMesh( self.mesh ) + return theFilter.GetIDs() + + ## Verifies whether a 2D mesh element has free edges (edges connected to one face only)\n + # Returns a list of special structures (borders). + # @return a list of SMESH.FreeEdges.Border structure: edge id and ids of two its nodes. + # @ingroup l1_controls + def GetFreeBorders(self): + aFilterMgr = self.smeshpyD.CreateFilterManager() + aPredicate = aFilterMgr.CreateFreeEdges() + aPredicate.SetMesh(self.mesh) + aBorders = aPredicate.GetBorders() + aFilterMgr.UnRegister() + return aBorders + + + # Get mesh measurements information: + # ------------------------------------ + + ## Get minimum distance between two nodes, elements or distance to the origin + # @param id1 first node/element id + # @param id2 second node/element id (if 0, distance from @a id1 to the origin is computed) + # @param isElem1 @c True if @a id1 is element id, @c False if it is node id + # @param isElem2 @c True if @a id2 is element id, @c False if it is node id + # @return minimum distance value + # @sa GetMinDistance() + def MinDistance(self, id1, id2=0, isElem1=False, isElem2=False): + aMeasure = self.GetMinDistance(id1, id2, isElem1, isElem2) + return aMeasure.value + + ## Get measure structure specifying minimum distance data between two objects + # @param id1 first node/element id + # @param id2 second node/element id (if 0, distance from @a id1 to the origin is computed) + # @param isElem1 @c True if @a id1 is element id, @c False if it is node id + # @param isElem2 @c True if @a id2 is element id, @c False if it is node id + # @return Measure structure + # @sa MinDistance() + def GetMinDistance(self, id1, id2=0, isElem1=False, isElem2=False): + if isElem1: + id1 = self.editor.MakeIDSource([id1], SMESH.FACE) + else: + id1 = self.editor.MakeIDSource([id1], SMESH.NODE) + if id2 != 0: + if isElem2: + id2 = self.editor.MakeIDSource([id2], SMESH.FACE) + else: + id2 = self.editor.MakeIDSource([id2], SMESH.NODE) + pass + else: + id2 = None + + aMeasurements = self.smeshpyD.CreateMeasurements() + aMeasure = aMeasurements.MinDistance(id1, id2) + aMeasurements.UnRegister() + return aMeasure + + ## Get bounding box of the specified object(s) + # @param objects single source object or list of source objects or list of nodes/elements IDs + # @param isElem if @a objects is a list of IDs, @c True value in this parameters specifies that @a objects are elements, + # @c False specifies that @a objects are nodes + # @return tuple of six values (minX, minY, minZ, maxX, maxY, maxZ) + # @sa GetBoundingBox() + def BoundingBox(self, objects=None, isElem=False): + result = self.GetBoundingBox(objects, isElem) + if result is None: + result = (0.0,)*6 + else: + result = (result.minX, result.minY, result.minZ, result.maxX, result.maxY, result.maxZ) + return result + + ## Get measure structure specifying bounding box data of the specified object(s) + # @param IDs single source object or list of source objects or list of nodes/elements IDs + # @param isElem if @a objects is a list of IDs, @c True value in this parameters specifies that @a objects are elements, + # @c False specifies that @a objects are nodes + # @return Measure structure + # @sa BoundingBox() + def GetBoundingBox(self, IDs=None, isElem=False): + if IDs is None: + IDs = [self.mesh] + elif isinstance(IDs, tuple): + IDs = list(IDs) + if not isinstance(IDs, list): + IDs = [IDs] + if len(IDs) > 0 and isinstance(IDs[0], int): + IDs = [IDs] + srclist = [] + for o in IDs: + if isinstance(o, Mesh): + srclist.append(o.mesh) + elif hasattr(o, "_narrow"): + src = o._narrow(SMESH.SMESH_IDSource) + if src: srclist.append(src) + pass + elif isinstance(o, list): + if isElem: + srclist.append(self.editor.MakeIDSource(o, SMESH.FACE)) + else: + srclist.append(self.editor.MakeIDSource(o, SMESH.NODE)) + pass + pass + aMeasurements = self.smeshpyD.CreateMeasurements() + aMeasure = aMeasurements.BoundingBox(srclist) + aMeasurements.UnRegister() + return aMeasure + + # Mesh edition (SMESH_MeshEditor functionality): + # --------------------------------------------- + + ## Removes the elements from the mesh by ids + # @param IDsOfElements is a list of ids of elements to remove + # @return True or False + # @ingroup l2_modif_del + def RemoveElements(self, IDsOfElements): + return self.editor.RemoveElements(IDsOfElements) + + ## Removes nodes from mesh by ids + # @param IDsOfNodes is a list of ids of nodes to remove + # @return True or False + # @ingroup l2_modif_del + def RemoveNodes(self, IDsOfNodes): + return self.editor.RemoveNodes(IDsOfNodes) + + ## Removes all orphan (free) nodes from mesh + # @return number of the removed nodes + # @ingroup l2_modif_del + def RemoveOrphanNodes(self): + return self.editor.RemoveOrphanNodes() + + ## Add a node to the mesh by coordinates + # @return Id of the new node + # @ingroup l2_modif_add + def AddNode(self, x, y, z): + x,y,z,Parameters,hasVars = ParseParameters(x,y,z) + if hasVars: self.mesh.SetParameters(Parameters) + return self.editor.AddNode( x, y, z) + + ## Creates a 0D element on a node with given number. + # @param IDOfNode the ID of node for creation of the element. + # @return the Id of the new 0D element + # @ingroup l2_modif_add + def Add0DElement(self, IDOfNode): + return self.editor.Add0DElement(IDOfNode) + + ## Create 0D elements on all nodes of the given elements except those + # nodes on which a 0D element already exists. + # @param theObject an object on whose nodes 0D elements will be created. + # It can be mesh, sub-mesh, group, list of element IDs or a holder + # of nodes IDs created by calling mesh.GetIDSource( nodes, SMESH.NODE ) + # @param theGroupName optional name of a group to add 0D elements created + # and/or found on nodes of \a theObject. + # @return an object (a new group or a temporary SMESH_IDSource) holding + # IDs of new and/or found 0D elements. IDs of 0D elements + # can be retrieved from the returned object by calling GetIDs() + # @ingroup l2_modif_add + def Add0DElementsToAllNodes(self, theObject, theGroupName=""): + if isinstance( theObject, Mesh ): + theObject = theObject.GetMesh() + if isinstance( theObject, list ): + theObject = self.GetIDSource( theObject, SMESH.ALL ) + return self.editor.Create0DElementsOnAllNodes( theObject, theGroupName ) + + ## Creates a ball element on a node with given ID. + # @param IDOfNode the ID of node for creation of the element. + # @param diameter the bal diameter. + # @return the Id of the new ball element + # @ingroup l2_modif_add + def AddBall(self, IDOfNode, diameter): + return self.editor.AddBall( IDOfNode, diameter ) + + ## Creates a linear or quadratic edge (this is determined + # by the number of given nodes). + # @param IDsOfNodes the list of node IDs for creation of the element. + # The order of nodes in this list should correspond to the description + # of MED. \n This description is located by the following link: + # http://www.code-aster.org/outils/med/html/modele_de_donnees.html#3. + # @return the Id of the new edge + # @ingroup l2_modif_add + def AddEdge(self, IDsOfNodes): + return self.editor.AddEdge(IDsOfNodes) + + ## Creates a linear or quadratic face (this is determined + # by the number of given nodes). + # @param IDsOfNodes the list of node IDs for creation of the element. + # The order of nodes in this list should correspond to the description + # of MED. \n This description is located by the following link: + # http://www.code-aster.org/outils/med/html/modele_de_donnees.html#3. + # @return the Id of the new face + # @ingroup l2_modif_add + def AddFace(self, IDsOfNodes): + return self.editor.AddFace(IDsOfNodes) + + ## Adds a polygonal face to the mesh by the list of node IDs + # @param IdsOfNodes the list of node IDs for creation of the element. + # @return the Id of the new face + # @ingroup l2_modif_add + def AddPolygonalFace(self, IdsOfNodes): + return self.editor.AddPolygonalFace(IdsOfNodes) + + ## Creates both simple and quadratic volume (this is determined + # by the number of given nodes). + # @param IDsOfNodes the list of node IDs for creation of the element. + # The order of nodes in this list should correspond to the description + # of MED. \n This description is located by the following link: + # http://www.code-aster.org/outils/med/html/modele_de_donnees.html#3. + # @return the Id of the new volumic element + # @ingroup l2_modif_add + def AddVolume(self, IDsOfNodes): + return self.editor.AddVolume(IDsOfNodes) + + ## Creates a volume of many faces, giving nodes for each face. + # @param IdsOfNodes the list of node IDs for volume creation face by face. + # @param Quantities the list of integer values, Quantities[i] + # gives the quantity of nodes in face number i. + # @return the Id of the new volumic element + # @ingroup l2_modif_add + def AddPolyhedralVolume (self, IdsOfNodes, Quantities): + return self.editor.AddPolyhedralVolume(IdsOfNodes, Quantities) + + ## Creates a volume of many faces, giving the IDs of the existing faces. + # @param IdsOfFaces the list of face IDs for volume creation. + # + # Note: The created volume will refer only to the nodes + # of the given faces, not to the faces themselves. + # @return the Id of the new volumic element + # @ingroup l2_modif_add + def AddPolyhedralVolumeByFaces (self, IdsOfFaces): + return self.editor.AddPolyhedralVolumeByFaces(IdsOfFaces) + + + ## @brief Binds a node to a vertex + # @param NodeID a node ID + # @param Vertex a vertex or vertex ID + # @return True if succeed else raises an exception + # @ingroup l2_modif_add + def SetNodeOnVertex(self, NodeID, Vertex): + if ( isinstance( Vertex, geomBuilder.GEOM._objref_GEOM_Object)): + VertexID = Vertex.GetSubShapeIndices()[0] + else: + VertexID = Vertex + try: + self.editor.SetNodeOnVertex(NodeID, VertexID) + except SALOME.SALOME_Exception, inst: + raise ValueError, inst.details.text + return True + + + ## @brief Stores the node position on an edge + # @param NodeID a node ID + # @param Edge an edge or edge ID + # @param paramOnEdge a parameter on the edge where the node is located + # @return True if succeed else raises an exception + # @ingroup l2_modif_add + def SetNodeOnEdge(self, NodeID, Edge, paramOnEdge): + if ( isinstance( Edge, geomBuilder.GEOM._objref_GEOM_Object)): + EdgeID = Edge.GetSubShapeIndices()[0] + else: + EdgeID = Edge + try: + self.editor.SetNodeOnEdge(NodeID, EdgeID, paramOnEdge) + except SALOME.SALOME_Exception, inst: + raise ValueError, inst.details.text + return True + + ## @brief Stores node position on a face + # @param NodeID a node ID + # @param Face a face or face ID + # @param u U parameter on the face where the node is located + # @param v V parameter on the face where the node is located + # @return True if succeed else raises an exception + # @ingroup l2_modif_add + def SetNodeOnFace(self, NodeID, Face, u, v): + if ( isinstance( Face, geomBuilder.GEOM._objref_GEOM_Object)): + FaceID = Face.GetSubShapeIndices()[0] + else: + FaceID = Face + try: + self.editor.SetNodeOnFace(NodeID, FaceID, u, v) + except SALOME.SALOME_Exception, inst: + raise ValueError, inst.details.text + return True + + ## @brief Binds a node to a solid + # @param NodeID a node ID + # @param Solid a solid or solid ID + # @return True if succeed else raises an exception + # @ingroup l2_modif_add + def SetNodeInVolume(self, NodeID, Solid): + if ( isinstance( Solid, geomBuilder.GEOM._objref_GEOM_Object)): + SolidID = Solid.GetSubShapeIndices()[0] + else: + SolidID = Solid + try: + self.editor.SetNodeInVolume(NodeID, SolidID) + except SALOME.SALOME_Exception, inst: + raise ValueError, inst.details.text + return True + + ## @brief Bind an element to a shape + # @param ElementID an element ID + # @param Shape a shape or shape ID + # @return True if succeed else raises an exception + # @ingroup l2_modif_add + def SetMeshElementOnShape(self, ElementID, Shape): + if ( isinstance( Shape, geomBuilder.GEOM._objref_GEOM_Object)): + ShapeID = Shape.GetSubShapeIndices()[0] + else: + ShapeID = Shape + try: + self.editor.SetMeshElementOnShape(ElementID, ShapeID) + except SALOME.SALOME_Exception, inst: + raise ValueError, inst.details.text + return True + + + ## Moves the node with the given id + # @param NodeID the id of the node + # @param x a new X coordinate + # @param y a new Y coordinate + # @param z a new Z coordinate + # @return True if succeed else False + # @ingroup l2_modif_movenode + def MoveNode(self, NodeID, x, y, z): + x,y,z,Parameters,hasVars = ParseParameters(x,y,z) + if hasVars: self.mesh.SetParameters(Parameters) + return self.editor.MoveNode(NodeID, x, y, z) + + ## Finds the node closest to a point and moves it to a point location + # @param x the X coordinate of a point + # @param y the Y coordinate of a point + # @param z the Z coordinate of a point + # @param NodeID if specified (>0), the node with this ID is moved, + # otherwise, the node closest to point (@a x,@a y,@a z) is moved + # @return the ID of a node + # @ingroup l2_modif_throughp + def MoveClosestNodeToPoint(self, x, y, z, NodeID): + x,y,z,Parameters,hasVars = ParseParameters(x,y,z) + if hasVars: self.mesh.SetParameters(Parameters) + return self.editor.MoveClosestNodeToPoint(x, y, z, NodeID) + + ## Finds the node closest to a point + # @param x the X coordinate of a point + # @param y the Y coordinate of a point + # @param z the Z coordinate of a point + # @return the ID of a node + # @ingroup l2_modif_throughp + def FindNodeClosestTo(self, x, y, z): + #preview = self.mesh.GetMeshEditPreviewer() + #return preview.MoveClosestNodeToPoint(x, y, z, -1) + return self.editor.FindNodeClosestTo(x, y, z) + + ## Finds the elements where a point lays IN or ON + # @param x the X coordinate of a point + # @param y the Y coordinate of a point + # @param z the Z coordinate of a point + # @param elementType type of elements to find (SMESH.ALL type + # means elements of any type excluding nodes, discrete and 0D elements) + # @param meshPart a part of mesh (group, sub-mesh) to search within + # @return list of IDs of found elements + # @ingroup l2_modif_throughp + def FindElementsByPoint(self, x, y, z, elementType = SMESH.ALL, meshPart=None): + if meshPart: + return self.editor.FindAmongElementsByPoint( meshPart, x, y, z, elementType ); + else: + return self.editor.FindElementsByPoint(x, y, z, elementType) + + # Return point state in a closed 2D mesh in terms of TopAbs_State enumeration: + # 0-IN, 1-OUT, 2-ON, 3-UNKNOWN + # TopAbs_UNKNOWN state means that either mesh is wrong or the analysis fails. + + def GetPointState(self, x, y, z): + return self.editor.GetPointState(x, y, z) + + ## Finds the node closest to a point and moves it to a point location + # @param x the X coordinate of a point + # @param y the Y coordinate of a point + # @param z the Z coordinate of a point + # @return the ID of a moved node + # @ingroup l2_modif_throughp + def MeshToPassThroughAPoint(self, x, y, z): + return self.editor.MoveClosestNodeToPoint(x, y, z, -1) + + ## Replaces two neighbour triangles sharing Node1-Node2 link + # with the triangles built on the same 4 nodes but having other common link. + # @param NodeID1 the ID of the first node + # @param NodeID2 the ID of the second node + # @return false if proper faces were not found + # @ingroup l2_modif_invdiag + def InverseDiag(self, NodeID1, NodeID2): + return self.editor.InverseDiag(NodeID1, NodeID2) + + ## Replaces two neighbour triangles sharing Node1-Node2 link + # with a quadrangle built on the same 4 nodes. + # @param NodeID1 the ID of the first node + # @param NodeID2 the ID of the second node + # @return false if proper faces were not found + # @ingroup l2_modif_unitetri + def DeleteDiag(self, NodeID1, NodeID2): + return self.editor.DeleteDiag(NodeID1, NodeID2) + + ## Reorients elements by ids + # @param IDsOfElements if undefined reorients all mesh elements + # @return True if succeed else False + # @ingroup l2_modif_changori + def Reorient(self, IDsOfElements=None): + if IDsOfElements == None: + IDsOfElements = self.GetElementsId() + return self.editor.Reorient(IDsOfElements) + + ## Reorients all elements of the object + # @param theObject mesh, submesh or group + # @return True if succeed else False + # @ingroup l2_modif_changori + def ReorientObject(self, theObject): + if ( isinstance( theObject, Mesh )): + theObject = theObject.GetMesh() + return self.editor.ReorientObject(theObject) + + ## Reorient faces contained in \a the2DObject. + # @param the2DObject is a mesh, sub-mesh, group or list of IDs of 2D elements + # @param theDirection is a desired direction of normal of \a theFace. + # It can be either a GEOM vector or a list of coordinates [x,y,z]. + # @param theFaceOrPoint defines a face of \a the2DObject whose normal will be + # compared with theDirection. It can be either ID of face or a point + # by which the face will be found. The point can be given as either + # a GEOM vertex or a list of point coordinates. + # @return number of reoriented faces + # @ingroup l2_modif_changori + def Reorient2D(self, the2DObject, theDirection, theFaceOrPoint ): + # check the2DObject + if isinstance( the2DObject, Mesh ): + the2DObject = the2DObject.GetMesh() + if isinstance( the2DObject, list ): + the2DObject = self.GetIDSource( the2DObject, SMESH.FACE ) + # check theDirection + if isinstance( theDirection, geomBuilder.GEOM._objref_GEOM_Object): + theDirection = self.smeshpyD.GetDirStruct( theDirection ) + if isinstance( theDirection, list ): + theDirection = self.smeshpyD.MakeDirStruct( *theDirection ) + # prepare theFace and thePoint + theFace = theFaceOrPoint + thePoint = PointStruct(0,0,0) + if isinstance( theFaceOrPoint, geomBuilder.GEOM._objref_GEOM_Object): + thePoint = self.smeshpyD.GetPointStruct( theFaceOrPoint ) + theFace = -1 + if isinstance( theFaceOrPoint, list ): + thePoint = PointStruct( *theFaceOrPoint ) + theFace = -1 + if isinstance( theFaceOrPoint, PointStruct ): + thePoint = theFaceOrPoint + theFace = -1 + return self.editor.Reorient2D( the2DObject, theDirection, theFace, thePoint ) + + ## Fuses the neighbouring triangles into quadrangles. + # @param IDsOfElements The triangles to be fused, + # @param theCriterion is a numerical functor, in terms of enum SMESH.FunctorType, used to + # choose a neighbour to fuse with. + # @param MaxAngle is the maximum angle between element normals at which the fusion + # is still performed; theMaxAngle is mesured in radians. + # Also it could be a name of variable which defines angle in degrees. + # @return TRUE in case of success, FALSE otherwise. + # @ingroup l2_modif_unitetri + def TriToQuad(self, IDsOfElements, theCriterion, MaxAngle): + MaxAngle,Parameters,hasVars = ParseAngles(MaxAngle) + self.mesh.SetParameters(Parameters) + if not IDsOfElements: + IDsOfElements = self.GetElementsId() + Functor = self.smeshpyD.GetFunctor(theCriterion) + return self.editor.TriToQuad(IDsOfElements, Functor, MaxAngle) + + ## Fuses the neighbouring triangles of the object into quadrangles + # @param theObject is mesh, submesh or group + # @param theCriterion is a numerical functor, in terms of enum SMESH.FunctorType, used to + # choose a neighbour to fuse with. + # @param MaxAngle a max angle between element normals at which the fusion + # is still performed; theMaxAngle is mesured in radians. + # @return TRUE in case of success, FALSE otherwise. + # @ingroup l2_modif_unitetri + def TriToQuadObject (self, theObject, theCriterion, MaxAngle): + MaxAngle,Parameters,hasVars = ParseAngles(MaxAngle) + self.mesh.SetParameters(Parameters) + if isinstance( theObject, Mesh ): + theObject = theObject.GetMesh() + Functor = self.smeshpyD.GetFunctor(theCriterion) + return self.editor.TriToQuadObject(theObject, Functor, MaxAngle) + + ## Splits quadrangles into triangles. + # + # @param IDsOfElements the faces to be splitted. + # @param theCriterion is a numerical functor, in terms of enum SMESH.FunctorType, used to + # choose a diagonal for splitting. If @a theCriterion is None, which is a default + # value, then quadrangles will be split by the smallest diagonal. + # @return TRUE in case of success, FALSE otherwise. + # @ingroup l2_modif_cutquadr + def QuadToTri (self, IDsOfElements, theCriterion = None): + if IDsOfElements == []: + IDsOfElements = self.GetElementsId() + if theCriterion is None: + theCriterion = FT_MaxElementLength2D + Functor = self.smeshpyD.GetFunctor(theCriterion) + return self.editor.QuadToTri(IDsOfElements, Functor) + + ## Splits quadrangles into triangles. + # @param theObject the object from which the list of elements is taken, + # this is mesh, submesh or group + # @param theCriterion is a numerical functor, in terms of enum SMESH.FunctorType, used to + # choose a diagonal for splitting. If @a theCriterion is None, which is a default + # value, then quadrangles will be split by the smallest diagonal. + # @return TRUE in case of success, FALSE otherwise. + # @ingroup l2_modif_cutquadr + def QuadToTriObject (self, theObject, theCriterion = None): + if ( isinstance( theObject, Mesh )): + theObject = theObject.GetMesh() + if theCriterion is None: + theCriterion = FT_MaxElementLength2D + Functor = self.smeshpyD.GetFunctor(theCriterion) + return self.editor.QuadToTriObject(theObject, Functor) + + ## Splits quadrangles into triangles. + # @param IDsOfElements the faces to be splitted + # @param Diag13 is used to choose a diagonal for splitting. + # @return TRUE in case of success, FALSE otherwise. + # @ingroup l2_modif_cutquadr + def SplitQuad (self, IDsOfElements, Diag13): + if IDsOfElements == []: + IDsOfElements = self.GetElementsId() + return self.editor.SplitQuad(IDsOfElements, Diag13) + + ## Splits quadrangles into triangles. + # @param theObject the object from which the list of elements is taken, + # this is mesh, submesh or group + # @param Diag13 is used to choose a diagonal for splitting. + # @return TRUE in case of success, FALSE otherwise. + # @ingroup l2_modif_cutquadr + def SplitQuadObject (self, theObject, Diag13): + if ( isinstance( theObject, Mesh )): + theObject = theObject.GetMesh() + return self.editor.SplitQuadObject(theObject, Diag13) + + ## Finds a better splitting of the given quadrangle. + # @param IDOfQuad the ID of the quadrangle to be splitted. + # @param theCriterion is a numerical functor, in terms of enum SMESH.FunctorType, used to + # choose a diagonal for splitting. + # @return 1 if 1-3 diagonal is better, 2 if 2-4 + # diagonal is better, 0 if error occurs. + # @ingroup l2_modif_cutquadr + def BestSplit (self, IDOfQuad, theCriterion): + return self.editor.BestSplit(IDOfQuad, self.smeshpyD.GetFunctor(theCriterion)) + + ## Splits volumic elements into tetrahedrons + # @param elemIDs either list of elements or mesh or group or submesh + # @param method flags passing splitting method: Hex_5Tet, Hex_6Tet, Hex_24Tet + # Hex_5Tet - split the hexahedron into 5 tetrahedrons, etc + # @ingroup l2_modif_cutquadr + def SplitVolumesIntoTetra(self, elemIDs, method=Hex_5Tet ): + if isinstance( elemIDs, Mesh ): + elemIDs = elemIDs.GetMesh() + if ( isinstance( elemIDs, list )): + elemIDs = self.editor.MakeIDSource(elemIDs, SMESH.VOLUME) + self.editor.SplitVolumesIntoTetra(elemIDs, method) + + ## Splits quadrangle faces near triangular facets of volumes + # + # @ingroup l1_auxiliary + def SplitQuadsNearTriangularFacets(self): + faces_array = self.GetElementsByType(SMESH.FACE) + for face_id in faces_array: + if self.GetElemNbNodes(face_id) == 4: # quadrangle + quad_nodes = self.mesh.GetElemNodes(face_id) + node1_elems = self.GetNodeInverseElements(quad_nodes[1 -1]) + isVolumeFound = False + for node1_elem in node1_elems: + if not isVolumeFound: + if self.GetElementType(node1_elem, True) == SMESH.VOLUME: + nb_nodes = self.GetElemNbNodes(node1_elem) + if 3 < nb_nodes and nb_nodes < 7: # tetra or penta, or prism + volume_elem = node1_elem + volume_nodes = self.mesh.GetElemNodes(volume_elem) + if volume_nodes.count(quad_nodes[2 -1]) > 0: # 1,2 + if volume_nodes.count(quad_nodes[4 -1]) > 0: # 1,2,4 + isVolumeFound = True + if volume_nodes.count(quad_nodes[3 -1]) == 0: # 1,2,4 & !3 + self.SplitQuad([face_id], False) # diagonal 2-4 + elif volume_nodes.count(quad_nodes[3 -1]) > 0: # 1,2,3 & !4 + isVolumeFound = True + self.SplitQuad([face_id], True) # diagonal 1-3 + elif volume_nodes.count(quad_nodes[4 -1]) > 0: # 1,4 & !2 + if volume_nodes.count(quad_nodes[3 -1]) > 0: # 1,4,3 & !2 + isVolumeFound = True + self.SplitQuad([face_id], True) # diagonal 1-3 + + ## @brief Splits hexahedrons into tetrahedrons. + # + # This operation uses pattern mapping functionality for splitting. + # @param theObject the object from which the list of hexahedrons is taken; this is mesh, submesh or group. + # @param theNode000,theNode001 within the range [0,7]; gives the orientation of the + # pattern relatively each hexahedron: the (0,0,0) key-point of the pattern + # will be mapped into theNode000-th node of each volume, the (0,0,1) + # key-point will be mapped into theNode001-th node of each volume. + # The (0,0,0) key-point of the used pattern corresponds to a non-split corner. + # @return TRUE in case of success, FALSE otherwise. + # @ingroup l1_auxiliary + def SplitHexaToTetras (self, theObject, theNode000, theNode001): + # Pattern: 5.---------.6 + # /|#* /| + # / | #* / | + # / | # * / | + # / | # /* | + # (0,0,1) 4.---------.7 * | + # |#* |1 | # *| + # | # *.----|---#.2 + # | #/ * | / + # | /# * | / + # | / # * | / + # |/ #*|/ + # (0,0,0) 0.---------.3 + pattern_tetra = "!!! Nb of points: \n 8 \n\ + !!! Points: \n\ + 0 0 0 !- 0 \n\ + 0 1 0 !- 1 \n\ + 1 1 0 !- 2 \n\ + 1 0 0 !- 3 \n\ + 0 0 1 !- 4 \n\ + 0 1 1 !- 5 \n\ + 1 1 1 !- 6 \n\ + 1 0 1 !- 7 \n\ + !!! Indices of points of 6 tetras: \n\ + 0 3 4 1 \n\ + 7 4 3 1 \n\ + 4 7 5 1 \n\ + 6 2 5 7 \n\ + 1 5 2 7 \n\ + 2 3 1 7 \n" + + pattern = self.smeshpyD.GetPattern() + isDone = pattern.LoadFromFile(pattern_tetra) + if not isDone: + print 'Pattern.LoadFromFile :', pattern.GetErrorCode() + return isDone + + pattern.ApplyToHexahedrons(self.mesh, theObject.GetIDs(), theNode000, theNode001) + isDone = pattern.MakeMesh(self.mesh, False, False) + if not isDone: print 'Pattern.MakeMesh :', pattern.GetErrorCode() + + # split quafrangle faces near triangular facets of volumes + self.SplitQuadsNearTriangularFacets() + + return isDone + + ## @brief Split hexahedrons into prisms. + # + # Uses the pattern mapping functionality for splitting. + # @param theObject the object (mesh, submesh or group) from where the list of hexahedrons is taken; + # @param theNode000,theNode001 (within the range [0,7]) gives the orientation of the + # pattern relatively each hexahedron: keypoint (0,0,0) of the pattern + # will be mapped into the theNode000-th node of each volume, keypoint (0,0,1) + # will be mapped into the theNode001-th node of each volume. + # Edge (0,0,0)-(0,0,1) of used pattern connects two not split corners. + # @return TRUE in case of success, FALSE otherwise. + # @ingroup l1_auxiliary + def SplitHexaToPrisms (self, theObject, theNode000, theNode001): + # Pattern: 5.---------.6 + # /|# /| + # / | # / | + # / | # / | + # / | # / | + # (0,0,1) 4.---------.7 | + # | | | | + # | 1.----|----.2 + # | / * | / + # | / * | / + # | / * | / + # |/ *|/ + # (0,0,0) 0.---------.3 + pattern_prism = "!!! Nb of points: \n 8 \n\ + !!! Points: \n\ + 0 0 0 !- 0 \n\ + 0 1 0 !- 1 \n\ + 1 1 0 !- 2 \n\ + 1 0 0 !- 3 \n\ + 0 0 1 !- 4 \n\ + 0 1 1 !- 5 \n\ + 1 1 1 !- 6 \n\ + 1 0 1 !- 7 \n\ + !!! Indices of points of 2 prisms: \n\ + 0 1 3 4 5 7 \n\ + 2 3 1 6 7 5 \n" + + pattern = self.smeshpyD.GetPattern() + isDone = pattern.LoadFromFile(pattern_prism) + if not isDone: + print 'Pattern.LoadFromFile :', pattern.GetErrorCode() + return isDone + + pattern.ApplyToHexahedrons(self.mesh, theObject.GetIDs(), theNode000, theNode001) + isDone = pattern.MakeMesh(self.mesh, False, False) + if not isDone: print 'Pattern.MakeMesh :', pattern.GetErrorCode() + + # Splits quafrangle faces near triangular facets of volumes + self.SplitQuadsNearTriangularFacets() + + return isDone + + ## Smoothes elements + # @param IDsOfElements the list if ids of elements to smooth + # @param IDsOfFixedNodes the list of ids of fixed nodes. + # Note that nodes built on edges and boundary nodes are always fixed. + # @param MaxNbOfIterations the maximum number of iterations + # @param MaxAspectRatio varies in range [1.0, inf] + # @param Method is Laplacian(LAPLACIAN_SMOOTH) or Centroidal(CENTROIDAL_SMOOTH) + # @return TRUE in case of success, FALSE otherwise. + # @ingroup l2_modif_smooth + def Smooth(self, IDsOfElements, IDsOfFixedNodes, + MaxNbOfIterations, MaxAspectRatio, Method): + if IDsOfElements == []: + IDsOfElements = self.GetElementsId() + MaxNbOfIterations,MaxAspectRatio,Parameters,hasVars = ParseParameters(MaxNbOfIterations,MaxAspectRatio) + self.mesh.SetParameters(Parameters) + return self.editor.Smooth(IDsOfElements, IDsOfFixedNodes, + MaxNbOfIterations, MaxAspectRatio, Method) + + ## Smoothes elements which belong to the given object + # @param theObject the object to smooth + # @param IDsOfFixedNodes the list of ids of fixed nodes. + # Note that nodes built on edges and boundary nodes are always fixed. + # @param MaxNbOfIterations the maximum number of iterations + # @param MaxAspectRatio varies in range [1.0, inf] + # @param Method is Laplacian(LAPLACIAN_SMOOTH) or Centroidal(CENTROIDAL_SMOOTH) + # @return TRUE in case of success, FALSE otherwise. + # @ingroup l2_modif_smooth + def SmoothObject(self, theObject, IDsOfFixedNodes, + MaxNbOfIterations, MaxAspectRatio, Method): + if ( isinstance( theObject, Mesh )): + theObject = theObject.GetMesh() + return self.editor.SmoothObject(theObject, IDsOfFixedNodes, + MaxNbOfIterations, MaxAspectRatio, Method) + + ## Parametrically smoothes the given elements + # @param IDsOfElements the list if ids of elements to smooth + # @param IDsOfFixedNodes the list of ids of fixed nodes. + # Note that nodes built on edges and boundary nodes are always fixed. + # @param MaxNbOfIterations the maximum number of iterations + # @param MaxAspectRatio varies in range [1.0, inf] + # @param Method is Laplacian(LAPLACIAN_SMOOTH) or Centroidal(CENTROIDAL_SMOOTH) + # @return TRUE in case of success, FALSE otherwise. + # @ingroup l2_modif_smooth + def SmoothParametric(self, IDsOfElements, IDsOfFixedNodes, + MaxNbOfIterations, MaxAspectRatio, Method): + if IDsOfElements == []: + IDsOfElements = self.GetElementsId() + MaxNbOfIterations,MaxAspectRatio,Parameters,hasVars = ParseParameters(MaxNbOfIterations,MaxAspectRatio) + self.mesh.SetParameters(Parameters) + return self.editor.SmoothParametric(IDsOfElements, IDsOfFixedNodes, + MaxNbOfIterations, MaxAspectRatio, Method) + + ## Parametrically smoothes the elements which belong to the given object + # @param theObject the object to smooth + # @param IDsOfFixedNodes the list of ids of fixed nodes. + # Note that nodes built on edges and boundary nodes are always fixed. + # @param MaxNbOfIterations the maximum number of iterations + # @param MaxAspectRatio varies in range [1.0, inf] + # @param Method Laplacian(LAPLACIAN_SMOOTH) or Centroidal(CENTROIDAL_SMOOTH) + # @return TRUE in case of success, FALSE otherwise. + # @ingroup l2_modif_smooth + def SmoothParametricObject(self, theObject, IDsOfFixedNodes, + MaxNbOfIterations, MaxAspectRatio, Method): + if ( isinstance( theObject, Mesh )): + theObject = theObject.GetMesh() + return self.editor.SmoothParametricObject(theObject, IDsOfFixedNodes, + MaxNbOfIterations, MaxAspectRatio, Method) + + ## Converts the mesh to quadratic, deletes old elements, replacing + # them with quadratic with the same id. + # @param theForce3d new node creation method: + # 0 - the medium node lies at the geometrical entity from which the mesh element is built + # 1 - the medium node lies at the middle of the line segments connecting start and end node of a mesh element + # @param theSubMesh a group or a sub-mesh to convert; WARNING: in this case the mesh can become not conformal + # @ingroup l2_modif_tofromqu + def ConvertToQuadratic(self, theForce3d, theSubMesh=None): + if theSubMesh: + self.editor.ConvertToQuadraticObject(theForce3d,theSubMesh) + else: + self.editor.ConvertToQuadratic(theForce3d) + + ## Converts the mesh from quadratic to ordinary, + # deletes old quadratic elements, \n replacing + # them with ordinary mesh elements with the same id. + # @param theSubMesh a group or a sub-mesh to convert; WARNING: in this case the mesh can become not conformal + # @ingroup l2_modif_tofromqu + def ConvertFromQuadratic(self, theSubMesh=None): + if theSubMesh: + self.editor.ConvertFromQuadraticObject(theSubMesh) + else: + return self.editor.ConvertFromQuadratic() + + ## Creates 2D mesh as skin on boundary faces of a 3D mesh + # @return TRUE if operation has been completed successfully, FALSE otherwise + # @ingroup l2_modif_edit + def Make2DMeshFrom3D(self): + return self.editor. Make2DMeshFrom3D() + + ## Creates missing boundary elements + # @param elements - elements whose boundary is to be checked: + # mesh, group, sub-mesh or list of elements + # if elements is mesh, it must be the mesh whose MakeBoundaryMesh() is called + # @param dimension - defines type of boundary elements to create: + # SMESH.BND_2DFROM3D, SMESH.BND_1DFROM3D, SMESH.BND_1DFROM2D + # SMESH.BND_1DFROM3D creates mesh edges on all borders of free facets of 3D cells + # @param groupName - a name of group to store created boundary elements in, + # "" means not to create the group + # @param meshName - a name of new mesh to store created boundary elements in, + # "" means not to create the new mesh + # @param toCopyElements - if true, the checked elements will be copied into + # the new mesh else only boundary elements will be copied into the new mesh + # @param toCopyExistingBondary - if true, not only new but also pre-existing + # boundary elements will be copied into the new mesh + # @return tuple (mesh, group) where bondary elements were added to + # @ingroup l2_modif_edit + def MakeBoundaryMesh(self, elements, dimension=SMESH.BND_2DFROM3D, groupName="", meshName="", + toCopyElements=False, toCopyExistingBondary=False): + if isinstance( elements, Mesh ): + elements = elements.GetMesh() + if ( isinstance( elements, list )): + elemType = SMESH.ALL + if elements: elemType = self.GetElementType( elements[0], iselem=True) + elements = self.editor.MakeIDSource(elements, elemType) + mesh, group = self.editor.MakeBoundaryMesh(elements,dimension,groupName,meshName, + toCopyElements,toCopyExistingBondary) + if mesh: mesh = self.smeshpyD.Mesh(mesh) + return mesh, group + + ## + # @brief Creates missing boundary elements around either the whole mesh or + # groups of 2D elements + # @param dimension - defines type of boundary elements to create + # @param groupName - a name of group to store all boundary elements in, + # "" means not to create the group + # @param meshName - a name of a new mesh, which is a copy of the initial + # mesh + created boundary elements; "" means not to create the new mesh + # @param toCopyAll - if true, the whole initial mesh will be copied into + # the new mesh else only boundary elements will be copied into the new mesh + # @param groups - groups of 2D elements to make boundary around + # @retval tuple( long, mesh, groups ) + # long - number of added boundary elements + # mesh - the mesh where elements were added to + # group - the group of boundary elements or None + # + def MakeBoundaryElements(self, dimension=SMESH.BND_2DFROM3D, groupName="", meshName="", + toCopyAll=False, groups=[]): + nb, mesh, group = self.editor.MakeBoundaryElements(dimension,groupName,meshName, + toCopyAll,groups) + if mesh: mesh = self.smeshpyD.Mesh(mesh) + return nb, mesh, group + + ## Renumber mesh nodes + # @ingroup l2_modif_renumber + def RenumberNodes(self): + self.editor.RenumberNodes() + + ## Renumber mesh elements + # @ingroup l2_modif_renumber + def RenumberElements(self): + self.editor.RenumberElements() + + ## Generates new elements by rotation of the elements around the axis + # @param IDsOfElements the list of ids of elements to sweep + # @param Axis the axis of rotation, AxisStruct or line(geom object) + # @param AngleInRadians the angle of Rotation (in radians) or a name of variable which defines angle in degrees + # @param NbOfSteps the number of steps + # @param Tolerance tolerance + # @param MakeGroups forces the generation of new groups from existing ones + # @param TotalAngle gives meaning of AngleInRadians: if True then it is an angular size + # of all steps, else - size of each step + # @return the list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise + # @ingroup l2_modif_extrurev + def RotationSweep(self, IDsOfElements, Axis, AngleInRadians, NbOfSteps, Tolerance, + MakeGroups=False, TotalAngle=False): + if IDsOfElements == []: + IDsOfElements = self.GetElementsId() + if ( isinstance( Axis, geomBuilder.GEOM._objref_GEOM_Object)): + Axis = self.smeshpyD.GetAxisStruct(Axis) + AngleInRadians,AngleParameters,hasVars = ParseAngles(AngleInRadians) + NbOfSteps,Tolerance,Parameters,hasVars = ParseParameters(NbOfSteps,Tolerance) + Parameters = Axis.parameters + var_separator + AngleParameters + var_separator + Parameters + self.mesh.SetParameters(Parameters) + if TotalAngle and NbOfSteps: + AngleInRadians /= NbOfSteps + if MakeGroups: + return self.editor.RotationSweepMakeGroups(IDsOfElements, Axis, + AngleInRadians, NbOfSteps, Tolerance) + self.editor.RotationSweep(IDsOfElements, Axis, AngleInRadians, NbOfSteps, Tolerance) + return [] + + ## Generates new elements by rotation of the elements of object around the axis + # @param theObject object which elements should be sweeped. + # It can be a mesh, a sub mesh or a group. + # @param Axis the axis of rotation, AxisStruct or line(geom object) + # @param AngleInRadians the angle of Rotation + # @param NbOfSteps number of steps + # @param Tolerance tolerance + # @param MakeGroups forces the generation of new groups from existing ones + # @param TotalAngle gives meaning of AngleInRadians: if True then it is an angular size + # of all steps, else - size of each step + # @return the list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise + # @ingroup l2_modif_extrurev + def RotationSweepObject(self, theObject, Axis, AngleInRadians, NbOfSteps, Tolerance, + MakeGroups=False, TotalAngle=False): + if ( isinstance( theObject, Mesh )): + theObject = theObject.GetMesh() + if ( isinstance( Axis, geomBuilder.GEOM._objref_GEOM_Object)): + Axis = self.smeshpyD.GetAxisStruct(Axis) + AngleInRadians,AngleParameters,hasVars = ParseAngles(AngleInRadians) + NbOfSteps,Tolerance,Parameters,hasVars = ParseParameters(NbOfSteps,Tolerance) + Parameters = Axis.parameters + var_separator + AngleParameters + var_separator + Parameters + self.mesh.SetParameters(Parameters) + if TotalAngle and NbOfSteps: + AngleInRadians /= NbOfSteps + if MakeGroups: + return self.editor.RotationSweepObjectMakeGroups(theObject, Axis, AngleInRadians, + NbOfSteps, Tolerance) + self.editor.RotationSweepObject(theObject, Axis, AngleInRadians, NbOfSteps, Tolerance) + return [] + + ## Generates new elements by rotation of the elements of object around the axis + # @param theObject object which elements should be sweeped. + # It can be a mesh, a sub mesh or a group. + # @param Axis the axis of rotation, AxisStruct or line(geom object) + # @param AngleInRadians the angle of Rotation + # @param NbOfSteps number of steps + # @param Tolerance tolerance + # @param MakeGroups forces the generation of new groups from existing ones + # @param TotalAngle gives meaning of AngleInRadians: if True then it is an angular size + # of all steps, else - size of each step + # @return the list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise + # @ingroup l2_modif_extrurev + def RotationSweepObject1D(self, theObject, Axis, AngleInRadians, NbOfSteps, Tolerance, + MakeGroups=False, TotalAngle=False): + if ( isinstance( theObject, Mesh )): + theObject = theObject.GetMesh() + if ( isinstance( Axis, geomBuilder.GEOM._objref_GEOM_Object)): + Axis = self.smeshpyD.GetAxisStruct(Axis) + AngleInRadians,AngleParameters,hasVars = ParseAngles(AngleInRadians) + NbOfSteps,Tolerance,Parameters,hasVars = ParseParameters(NbOfSteps,Tolerance) + Parameters = Axis.parameters + var_separator + AngleParameters + var_separator + Parameters + self.mesh.SetParameters(Parameters) + if TotalAngle and NbOfSteps: + AngleInRadians /= NbOfSteps + if MakeGroups: + return self.editor.RotationSweepObject1DMakeGroups(theObject, Axis, AngleInRadians, + NbOfSteps, Tolerance) + self.editor.RotationSweepObject1D(theObject, Axis, AngleInRadians, NbOfSteps, Tolerance) + return [] + + ## Generates new elements by rotation of the elements of object around the axis + # @param theObject object which elements should be sweeped. + # It can be a mesh, a sub mesh or a group. + # @param Axis the axis of rotation, AxisStruct or line(geom object) + # @param AngleInRadians the angle of Rotation + # @param NbOfSteps number of steps + # @param Tolerance tolerance + # @param MakeGroups forces the generation of new groups from existing ones + # @param TotalAngle gives meaning of AngleInRadians: if True then it is an angular size + # of all steps, else - size of each step + # @return the list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise + # @ingroup l2_modif_extrurev + def RotationSweepObject2D(self, theObject, Axis, AngleInRadians, NbOfSteps, Tolerance, + MakeGroups=False, TotalAngle=False): + if ( isinstance( theObject, Mesh )): + theObject = theObject.GetMesh() + if ( isinstance( Axis, geomBuilder.GEOM._objref_GEOM_Object)): + Axis = self.smeshpyD.GetAxisStruct(Axis) + AngleInRadians,AngleParameters,hasVars = ParseAngles(AngleInRadians) + NbOfSteps,Tolerance,Parameters,hasVars = ParseParameters(NbOfSteps,Tolerance) + Parameters = Axis.parameters + var_separator + AngleParameters + var_separator + Parameters + self.mesh.SetParameters(Parameters) + if TotalAngle and NbOfSteps: + AngleInRadians /= NbOfSteps + if MakeGroups: + return self.editor.RotationSweepObject2DMakeGroups(theObject, Axis, AngleInRadians, + NbOfSteps, Tolerance) + self.editor.RotationSweepObject2D(theObject, Axis, AngleInRadians, NbOfSteps, Tolerance) + return [] + + ## Generates new elements by extrusion of the elements with given ids + # @param IDsOfElements the list of elements ids for extrusion + # @param StepVector vector or DirStruct or 3 vector components, defining + # the direction and value of extrusion for one step (the total extrusion + # length will be NbOfSteps * ||StepVector||) + # @param NbOfSteps the number of steps + # @param MakeGroups forces the generation of new groups from existing ones + # @param IsNodes is True if elements with given ids are nodes + # @return the list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise + # @ingroup l2_modif_extrurev + def ExtrusionSweep(self, IDsOfElements, StepVector, NbOfSteps, MakeGroups=False, IsNodes = False): + if IDsOfElements == []: + IDsOfElements = self.GetElementsId() + if isinstance( StepVector, geomBuilder.GEOM._objref_GEOM_Object): + StepVector = self.smeshpyD.GetDirStruct(StepVector) + if isinstance( StepVector, list ): + StepVector = self.smeshpyD.MakeDirStruct(*StepVector) + NbOfSteps,Parameters,hasVars = ParseParameters(NbOfSteps) + Parameters = StepVector.PS.parameters + var_separator + Parameters + self.mesh.SetParameters(Parameters) + if MakeGroups: + if(IsNodes): + return self.editor.ExtrusionSweepMakeGroups0D(IDsOfElements, StepVector, NbOfSteps) + else: + return self.editor.ExtrusionSweepMakeGroups(IDsOfElements, StepVector, NbOfSteps) + if(IsNodes): + self.editor.ExtrusionSweep0D(IDsOfElements, StepVector, NbOfSteps) + else: + self.editor.ExtrusionSweep(IDsOfElements, StepVector, NbOfSteps) + return [] + + ## Generates new elements by extrusion of the elements with given ids + # @param IDsOfElements is ids of elements + # @param StepVector vector or DirStruct or 3 vector components, defining + # the direction and value of extrusion for one step (the total extrusion + # length will be NbOfSteps * ||StepVector||) + # @param NbOfSteps the number of steps + # @param ExtrFlags sets flags for extrusion + # @param SewTolerance uses for comparing locations of nodes if flag + # EXTRUSION_FLAG_SEW is set + # @param MakeGroups forces the generation of new groups from existing ones + # @return list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise + # @ingroup l2_modif_extrurev + def AdvancedExtrusion(self, IDsOfElements, StepVector, NbOfSteps, + ExtrFlags, SewTolerance, MakeGroups=False): + if ( isinstance( StepVector, geomBuilder.GEOM._objref_GEOM_Object)): + StepVector = self.smeshpyD.GetDirStruct(StepVector) + if isinstance( StepVector, list ): + StepVector = self.smeshpyD.MakeDirStruct(*StepVector) + if MakeGroups: + return self.editor.AdvancedExtrusionMakeGroups(IDsOfElements, StepVector, NbOfSteps, + ExtrFlags, SewTolerance) + self.editor.AdvancedExtrusion(IDsOfElements, StepVector, NbOfSteps, + ExtrFlags, SewTolerance) + return [] + + ## Generates new elements by extrusion of the elements which belong to the object + # @param theObject the object which elements should be processed. + # It can be a mesh, a sub mesh or a group. + # @param StepVector vector or DirStruct or 3 vector components, defining + # the direction and value of extrusion for one step (the total extrusion + # length will be NbOfSteps * ||StepVector||) + # @param NbOfSteps the number of steps + # @param MakeGroups forces the generation of new groups from existing ones + # @param IsNodes is True if elements which belong to the object are nodes + # @return list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise + # @ingroup l2_modif_extrurev + def ExtrusionSweepObject(self, theObject, StepVector, NbOfSteps, MakeGroups=False, IsNodes=False): + if ( isinstance( theObject, Mesh )): + theObject = theObject.GetMesh() + if ( isinstance( StepVector, geomBuilder.GEOM._objref_GEOM_Object)): + StepVector = self.smeshpyD.GetDirStruct(StepVector) + if isinstance( StepVector, list ): + StepVector = self.smeshpyD.MakeDirStruct(*StepVector) + NbOfSteps,Parameters,hasVars = ParseParameters(NbOfSteps) + Parameters = StepVector.PS.parameters + var_separator + Parameters + self.mesh.SetParameters(Parameters) + if MakeGroups: + if(IsNodes): + return self.editor.ExtrusionSweepObject0DMakeGroups(theObject, StepVector, NbOfSteps) + else: + return self.editor.ExtrusionSweepObjectMakeGroups(theObject, StepVector, NbOfSteps) + if(IsNodes): + self.editor.ExtrusionSweepObject0D(theObject, StepVector, NbOfSteps) + else: + self.editor.ExtrusionSweepObject(theObject, StepVector, NbOfSteps) + return [] + + ## Generates new elements by extrusion of the elements which belong to the object + # @param theObject object which elements should be processed. + # It can be a mesh, a sub mesh or a group. + # @param StepVector vector or DirStruct or 3 vector components, defining + # the direction and value of extrusion for one step (the total extrusion + # length will be NbOfSteps * ||StepVector||) + # @param NbOfSteps the number of steps + # @param MakeGroups to generate new groups from existing ones + # @return list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise + # @ingroup l2_modif_extrurev + def ExtrusionSweepObject1D(self, theObject, StepVector, NbOfSteps, MakeGroups=False): + if ( isinstance( theObject, Mesh )): + theObject = theObject.GetMesh() + if ( isinstance( StepVector, geomBuilder.GEOM._objref_GEOM_Object)): + StepVector = self.smeshpyD.GetDirStruct(StepVector) + if isinstance( StepVector, list ): + StepVector = self.smeshpyD.MakeDirStruct(*StepVector) + NbOfSteps,Parameters,hasVars = ParseParameters(NbOfSteps) + Parameters = StepVector.PS.parameters + var_separator + Parameters + self.mesh.SetParameters(Parameters) + if MakeGroups: + return self.editor.ExtrusionSweepObject1DMakeGroups(theObject, StepVector, NbOfSteps) + self.editor.ExtrusionSweepObject1D(theObject, StepVector, NbOfSteps) + return [] + + ## Generates new elements by extrusion of the elements which belong to the object + # @param theObject object which elements should be processed. + # It can be a mesh, a sub mesh or a group. + # @param StepVector vector or DirStruct or 3 vector components, defining + # the direction and value of extrusion for one step (the total extrusion + # length will be NbOfSteps * ||StepVector||) + # @param NbOfSteps the number of steps + # @param MakeGroups forces the generation of new groups from existing ones + # @return list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise + # @ingroup l2_modif_extrurev + def ExtrusionSweepObject2D(self, theObject, StepVector, NbOfSteps, MakeGroups=False): + if ( isinstance( theObject, Mesh )): + theObject = theObject.GetMesh() + if ( isinstance( StepVector, geomBuilder.GEOM._objref_GEOM_Object)): + StepVector = self.smeshpyD.GetDirStruct(StepVector) + if isinstance( StepVector, list ): + StepVector = self.smeshpyD.MakeDirStruct(*StepVector) + NbOfSteps,Parameters,hasVars = ParseParameters(NbOfSteps) + Parameters = StepVector.PS.parameters + var_separator + Parameters + self.mesh.SetParameters(Parameters) + if MakeGroups: + return self.editor.ExtrusionSweepObject2DMakeGroups(theObject, StepVector, NbOfSteps) + self.editor.ExtrusionSweepObject2D(theObject, StepVector, NbOfSteps) + return [] + + + + ## Generates new elements by extrusion of the given elements + # The path of extrusion must be a meshed edge. + # @param Base mesh or group, or submesh, or list of ids of elements for extrusion + # @param Path - 1D mesh or 1D sub-mesh, along which proceeds the extrusion + # @param NodeStart the start node from Path. Defines the direction of extrusion + # @param HasAngles allows the shape to be rotated around the path + # to get the resulting mesh in a helical fashion + # @param Angles list of angles in radians + # @param LinearVariation forces the computation of rotation angles as linear + # variation of the given Angles along path steps + # @param HasRefPoint allows using the reference point + # @param RefPoint the point around which the shape is rotated (the mass center of the shape by default). + # The User can specify any point as the Reference Point. + # @param MakeGroups forces the generation of new groups from existing ones + # @param ElemType type of elements for extrusion (if param Base is a mesh) + # @return list of created groups (SMESH_GroupBase) and SMESH::Extrusion_Error if MakeGroups=True, + # only SMESH::Extrusion_Error otherwise + # @ingroup l2_modif_extrurev + def ExtrusionAlongPathX(self, Base, Path, NodeStart, + HasAngles, Angles, LinearVariation, + HasRefPoint, RefPoint, MakeGroups, ElemType): + if ( isinstance( RefPoint, geomBuilder.GEOM._objref_GEOM_Object)): + RefPoint = self.smeshpyD.GetPointStruct(RefPoint) + pass + Angles,AnglesParameters,hasVars = ParseAngles(Angles) + Parameters = AnglesParameters + var_separator + RefPoint.parameters + self.mesh.SetParameters(Parameters) + + if (isinstance(Path, Mesh)): Path = Path.GetMesh() + + if isinstance(Base, list): + IDsOfElements = [] + if Base == []: IDsOfElements = self.GetElementsId() + else: IDsOfElements = Base + return self.editor.ExtrusionAlongPathX(IDsOfElements, Path, NodeStart, + HasAngles, Angles, LinearVariation, + HasRefPoint, RefPoint, MakeGroups, ElemType) + else: + if isinstance(Base, Mesh): Base = Base.GetMesh() + if isinstance(Base, SMESH._objref_SMESH_Mesh) or isinstance(Base, SMESH._objref_SMESH_Group) or isinstance(Base, SMESH._objref_SMESH_subMesh): + return self.editor.ExtrusionAlongPathObjX(Base, Path, NodeStart, + HasAngles, Angles, LinearVariation, + HasRefPoint, RefPoint, MakeGroups, ElemType) + else: + raise RuntimeError, "Invalid Base for ExtrusionAlongPathX" + + + ## Generates new elements by extrusion of the given elements + # The path of extrusion must be a meshed edge. + # @param IDsOfElements ids of elements + # @param PathMesh mesh containing a 1D sub-mesh on the edge, along which proceeds the extrusion + # @param PathShape shape(edge) defines the sub-mesh for the path + # @param NodeStart the first or the last node on the edge. Defines the direction of extrusion + # @param HasAngles allows the shape to be rotated around the path + # to get the resulting mesh in a helical fashion + # @param Angles list of angles in radians + # @param HasRefPoint allows using the reference point + # @param RefPoint the point around which the shape is rotated (the mass center of the shape by default). + # The User can specify any point as the Reference Point. + # @param MakeGroups forces the generation of new groups from existing ones + # @param LinearVariation forces the computation of rotation angles as linear + # variation of the given Angles along path steps + # @return list of created groups (SMESH_GroupBase) and SMESH::Extrusion_Error if MakeGroups=True, + # only SMESH::Extrusion_Error otherwise + # @ingroup l2_modif_extrurev + def ExtrusionAlongPath(self, IDsOfElements, PathMesh, PathShape, NodeStart, + HasAngles, Angles, HasRefPoint, RefPoint, + MakeGroups=False, LinearVariation=False): + if IDsOfElements == []: + IDsOfElements = self.GetElementsId() + if ( isinstance( RefPoint, geomBuilder.GEOM._objref_GEOM_Object)): + RefPoint = self.smeshpyD.GetPointStruct(RefPoint) + pass + if ( isinstance( PathMesh, Mesh )): + PathMesh = PathMesh.GetMesh() + Angles,AnglesParameters,hasVars = ParseAngles(Angles) + Parameters = AnglesParameters + var_separator + RefPoint.parameters + self.mesh.SetParameters(Parameters) + if HasAngles and Angles and LinearVariation: + Angles = self.editor.LinearAnglesVariation( PathMesh, PathShape, Angles ) + pass + if MakeGroups: + return self.editor.ExtrusionAlongPathMakeGroups(IDsOfElements, PathMesh, + PathShape, NodeStart, HasAngles, + Angles, HasRefPoint, RefPoint) + return self.editor.ExtrusionAlongPath(IDsOfElements, PathMesh, PathShape, + NodeStart, HasAngles, Angles, HasRefPoint, RefPoint) + + ## Generates new elements by extrusion of the elements which belong to the object + # The path of extrusion must be a meshed edge. + # @param theObject the object which elements should be processed. + # It can be a mesh, a sub mesh or a group. + # @param PathMesh mesh containing a 1D sub-mesh on the edge, along which the extrusion proceeds + # @param PathShape shape(edge) defines the sub-mesh for the path + # @param NodeStart the first or the last node on the edge. Defines the direction of extrusion + # @param HasAngles allows the shape to be rotated around the path + # to get the resulting mesh in a helical fashion + # @param Angles list of angles + # @param HasRefPoint allows using the reference point + # @param RefPoint the point around which the shape is rotated (the mass center of the shape by default). + # The User can specify any point as the Reference Point. + # @param MakeGroups forces the generation of new groups from existing ones + # @param LinearVariation forces the computation of rotation angles as linear + # variation of the given Angles along path steps + # @return list of created groups (SMESH_GroupBase) and SMESH::Extrusion_Error if MakeGroups=True, + # only SMESH::Extrusion_Error otherwise + # @ingroup l2_modif_extrurev + def ExtrusionAlongPathObject(self, theObject, PathMesh, PathShape, NodeStart, + HasAngles, Angles, HasRefPoint, RefPoint, + MakeGroups=False, LinearVariation=False): + if ( isinstance( theObject, Mesh )): + theObject = theObject.GetMesh() + if ( isinstance( RefPoint, geomBuilder.GEOM._objref_GEOM_Object)): + RefPoint = self.smeshpyD.GetPointStruct(RefPoint) + if ( isinstance( PathMesh, Mesh )): + PathMesh = PathMesh.GetMesh() + Angles,AnglesParameters,hasVars = ParseAngles(Angles) + Parameters = AnglesParameters + var_separator + RefPoint.parameters + self.mesh.SetParameters(Parameters) + if HasAngles and Angles and LinearVariation: + Angles = self.editor.LinearAnglesVariation( PathMesh, PathShape, Angles ) + pass + if MakeGroups: + return self.editor.ExtrusionAlongPathObjectMakeGroups(theObject, PathMesh, + PathShape, NodeStart, HasAngles, + Angles, HasRefPoint, RefPoint) + return self.editor.ExtrusionAlongPathObject(theObject, PathMesh, PathShape, + NodeStart, HasAngles, Angles, HasRefPoint, + RefPoint) + + ## Generates new elements by extrusion of the elements which belong to the object + # The path of extrusion must be a meshed edge. + # @param theObject the object which elements should be processed. + # It can be a mesh, a sub mesh or a group. + # @param PathMesh mesh containing a 1D sub-mesh on the edge, along which the extrusion proceeds + # @param PathShape shape(edge) defines the sub-mesh for the path + # @param NodeStart the first or the last node on the edge. Defines the direction of extrusion + # @param HasAngles allows the shape to be rotated around the path + # to get the resulting mesh in a helical fashion + # @param Angles list of angles + # @param HasRefPoint allows using the reference point + # @param RefPoint the point around which the shape is rotated (the mass center of the shape by default). + # The User can specify any point as the Reference Point. + # @param MakeGroups forces the generation of new groups from existing ones + # @param LinearVariation forces the computation of rotation angles as linear + # variation of the given Angles along path steps + # @return list of created groups (SMESH_GroupBase) and SMESH::Extrusion_Error if MakeGroups=True, + # only SMESH::Extrusion_Error otherwise + # @ingroup l2_modif_extrurev + def ExtrusionAlongPathObject1D(self, theObject, PathMesh, PathShape, NodeStart, + HasAngles, Angles, HasRefPoint, RefPoint, + MakeGroups=False, LinearVariation=False): + if ( isinstance( theObject, Mesh )): + theObject = theObject.GetMesh() + if ( isinstance( RefPoint, geomBuilder.GEOM._objref_GEOM_Object)): + RefPoint = self.smeshpyD.GetPointStruct(RefPoint) + if ( isinstance( PathMesh, Mesh )): + PathMesh = PathMesh.GetMesh() + Angles,AnglesParameters,hasVars = ParseAngles(Angles) + Parameters = AnglesParameters + var_separator + RefPoint.parameters + self.mesh.SetParameters(Parameters) + if HasAngles and Angles and LinearVariation: + Angles = self.editor.LinearAnglesVariation( PathMesh, PathShape, Angles ) + pass + if MakeGroups: + return self.editor.ExtrusionAlongPathObject1DMakeGroups(theObject, PathMesh, + PathShape, NodeStart, HasAngles, + Angles, HasRefPoint, RefPoint) + return self.editor.ExtrusionAlongPathObject1D(theObject, PathMesh, PathShape, + NodeStart, HasAngles, Angles, HasRefPoint, + RefPoint) + + ## Generates new elements by extrusion of the elements which belong to the object + # The path of extrusion must be a meshed edge. + # @param theObject the object which elements should be processed. + # It can be a mesh, a sub mesh or a group. + # @param PathMesh mesh containing a 1D sub-mesh on the edge, along which the extrusion proceeds + # @param PathShape shape(edge) defines the sub-mesh for the path + # @param NodeStart the first or the last node on the edge. Defines the direction of extrusion + # @param HasAngles allows the shape to be rotated around the path + # to get the resulting mesh in a helical fashion + # @param Angles list of angles + # @param HasRefPoint allows using the reference point + # @param RefPoint the point around which the shape is rotated (the mass center of the shape by default). + # The User can specify any point as the Reference Point. + # @param MakeGroups forces the generation of new groups from existing ones + # @param LinearVariation forces the computation of rotation angles as linear + # variation of the given Angles along path steps + # @return list of created groups (SMESH_GroupBase) and SMESH::Extrusion_Error if MakeGroups=True, + # only SMESH::Extrusion_Error otherwise + # @ingroup l2_modif_extrurev + def ExtrusionAlongPathObject2D(self, theObject, PathMesh, PathShape, NodeStart, + HasAngles, Angles, HasRefPoint, RefPoint, + MakeGroups=False, LinearVariation=False): + if ( isinstance( theObject, Mesh )): + theObject = theObject.GetMesh() + if ( isinstance( RefPoint, geomBuilder.GEOM._objref_GEOM_Object)): + RefPoint = self.smeshpyD.GetPointStruct(RefPoint) + if ( isinstance( PathMesh, Mesh )): + PathMesh = PathMesh.GetMesh() + Angles,AnglesParameters,hasVars = ParseAngles(Angles) + Parameters = AnglesParameters + var_separator + RefPoint.parameters + self.mesh.SetParameters(Parameters) + if HasAngles and Angles and LinearVariation: + Angles = self.editor.LinearAnglesVariation( PathMesh, PathShape, Angles ) + pass + if MakeGroups: + return self.editor.ExtrusionAlongPathObject2DMakeGroups(theObject, PathMesh, + PathShape, NodeStart, HasAngles, + Angles, HasRefPoint, RefPoint) + return self.editor.ExtrusionAlongPathObject2D(theObject, PathMesh, PathShape, + NodeStart, HasAngles, Angles, HasRefPoint, + RefPoint) + + ## Creates a symmetrical copy of mesh elements + # @param IDsOfElements list of elements ids + # @param Mirror is AxisStruct or geom object(point, line, plane) + # @param theMirrorType is POINT, AXIS or PLANE + # If the Mirror is a geom object this parameter is unnecessary + # @param Copy allows to copy element (Copy is 1) or to replace with its mirroring (Copy is 0) + # @param MakeGroups forces the generation of new groups from existing ones (if Copy) + # @return list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise + # @ingroup l2_modif_trsf + def Mirror(self, IDsOfElements, Mirror, theMirrorType, Copy=0, MakeGroups=False): + if IDsOfElements == []: + IDsOfElements = self.GetElementsId() + if ( isinstance( Mirror, geomBuilder.GEOM._objref_GEOM_Object)): + Mirror = self.smeshpyD.GetAxisStruct(Mirror) + self.mesh.SetParameters(Mirror.parameters) + if Copy and MakeGroups: + return self.editor.MirrorMakeGroups(IDsOfElements, Mirror, theMirrorType) + self.editor.Mirror(IDsOfElements, Mirror, theMirrorType, Copy) + return [] + + ## Creates a new mesh by a symmetrical copy of mesh elements + # @param IDsOfElements the list of elements ids + # @param Mirror is AxisStruct or geom object (point, line, plane) + # @param theMirrorType is POINT, AXIS or PLANE + # If the Mirror is a geom object this parameter is unnecessary + # @param MakeGroups to generate new groups from existing ones + # @param NewMeshName a name of the new mesh to create + # @return instance of Mesh class + # @ingroup l2_modif_trsf + def MirrorMakeMesh(self, IDsOfElements, Mirror, theMirrorType, MakeGroups=0, NewMeshName=""): + if IDsOfElements == []: + IDsOfElements = self.GetElementsId() + if ( isinstance( Mirror, geomBuilder.GEOM._objref_GEOM_Object)): + Mirror = self.smeshpyD.GetAxisStruct(Mirror) + self.mesh.SetParameters(Mirror.parameters) + mesh = self.editor.MirrorMakeMesh(IDsOfElements, Mirror, theMirrorType, + MakeGroups, NewMeshName) + return Mesh(self.smeshpyD,self.geompyD,mesh) + + ## Creates a symmetrical copy of the object + # @param theObject mesh, submesh or group + # @param Mirror AxisStruct or geom object (point, line, plane) + # @param theMirrorType is POINT, AXIS or PLANE + # If the Mirror is a geom object this parameter is unnecessary + # @param Copy allows copying the element (Copy is 1) or replacing it with its mirror (Copy is 0) + # @param MakeGroups forces the generation of new groups from existing ones (if Copy) + # @return list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise + # @ingroup l2_modif_trsf + def MirrorObject (self, theObject, Mirror, theMirrorType, Copy=0, MakeGroups=False): + if ( isinstance( theObject, Mesh )): + theObject = theObject.GetMesh() + if ( isinstance( Mirror, geomBuilder.GEOM._objref_GEOM_Object)): + Mirror = self.smeshpyD.GetAxisStruct(Mirror) + self.mesh.SetParameters(Mirror.parameters) + if Copy and MakeGroups: + return self.editor.MirrorObjectMakeGroups(theObject, Mirror, theMirrorType) + self.editor.MirrorObject(theObject, Mirror, theMirrorType, Copy) + return [] + + ## Creates a new mesh by a symmetrical copy of the object + # @param theObject mesh, submesh or group + # @param Mirror AxisStruct or geom object (point, line, plane) + # @param theMirrorType POINT, AXIS or PLANE + # If the Mirror is a geom object this parameter is unnecessary + # @param MakeGroups forces the generation of new groups from existing ones + # @param NewMeshName the name of the new mesh to create + # @return instance of Mesh class + # @ingroup l2_modif_trsf + def MirrorObjectMakeMesh (self, theObject, Mirror, theMirrorType,MakeGroups=0, NewMeshName=""): + if ( isinstance( theObject, Mesh )): + theObject = theObject.GetMesh() + if (isinstance(Mirror, geomBuilder.GEOM._objref_GEOM_Object)): + Mirror = self.smeshpyD.GetAxisStruct(Mirror) + self.mesh.SetParameters(Mirror.parameters) + mesh = self.editor.MirrorObjectMakeMesh(theObject, Mirror, theMirrorType, + MakeGroups, NewMeshName) + return Mesh( self.smeshpyD,self.geompyD,mesh ) + + ## Translates the elements + # @param IDsOfElements list of elements ids + # @param Vector the direction of translation (DirStruct or vector) + # @param Copy allows copying the translated elements + # @param MakeGroups forces the generation of new groups from existing ones (if Copy) + # @return list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise + # @ingroup l2_modif_trsf + def Translate(self, IDsOfElements, Vector, Copy, MakeGroups=False): + if IDsOfElements == []: + IDsOfElements = self.GetElementsId() + if ( isinstance( Vector, geomBuilder.GEOM._objref_GEOM_Object)): + Vector = self.smeshpyD.GetDirStruct(Vector) + self.mesh.SetParameters(Vector.PS.parameters) + if Copy and MakeGroups: + return self.editor.TranslateMakeGroups(IDsOfElements, Vector) + self.editor.Translate(IDsOfElements, Vector, Copy) + return [] + + ## Creates a new mesh of translated elements + # @param IDsOfElements list of elements ids + # @param Vector the direction of translation (DirStruct or vector) + # @param MakeGroups forces the generation of new groups from existing ones + # @param NewMeshName the name of the newly created mesh + # @return instance of Mesh class + # @ingroup l2_modif_trsf + def TranslateMakeMesh(self, IDsOfElements, Vector, MakeGroups=False, NewMeshName=""): + if IDsOfElements == []: + IDsOfElements = self.GetElementsId() + if ( isinstance( Vector, geomBuilder.GEOM._objref_GEOM_Object)): + Vector = self.smeshpyD.GetDirStruct(Vector) + self.mesh.SetParameters(Vector.PS.parameters) + mesh = self.editor.TranslateMakeMesh(IDsOfElements, Vector, MakeGroups, NewMeshName) + return Mesh ( self.smeshpyD, self.geompyD, mesh ) + + ## Translates the object + # @param theObject the object to translate (mesh, submesh, or group) + # @param Vector direction of translation (DirStruct or geom vector) + # @param Copy allows copying the translated elements + # @param MakeGroups forces the generation of new groups from existing ones (if Copy) + # @return list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise + # @ingroup l2_modif_trsf + def TranslateObject(self, theObject, Vector, Copy, MakeGroups=False): + if ( isinstance( theObject, Mesh )): + theObject = theObject.GetMesh() + if ( isinstance( Vector, geomBuilder.GEOM._objref_GEOM_Object)): + Vector = self.smeshpyD.GetDirStruct(Vector) + self.mesh.SetParameters(Vector.PS.parameters) + if Copy and MakeGroups: + return self.editor.TranslateObjectMakeGroups(theObject, Vector) + self.editor.TranslateObject(theObject, Vector, Copy) + return [] + + ## Creates a new mesh from the translated object + # @param theObject the object to translate (mesh, submesh, or group) + # @param Vector the direction of translation (DirStruct or geom vector) + # @param MakeGroups forces the generation of new groups from existing ones + # @param NewMeshName the name of the newly created mesh + # @return instance of Mesh class + # @ingroup l2_modif_trsf + def TranslateObjectMakeMesh(self, theObject, Vector, MakeGroups=False, NewMeshName=""): + if (isinstance(theObject, Mesh)): + theObject = theObject.GetMesh() + if (isinstance(Vector, geomBuilder.GEOM._objref_GEOM_Object)): + Vector = self.smeshpyD.GetDirStruct(Vector) + self.mesh.SetParameters(Vector.PS.parameters) + mesh = self.editor.TranslateObjectMakeMesh(theObject, Vector, MakeGroups, NewMeshName) + return Mesh( self.smeshpyD, self.geompyD, mesh ) + + + + ## Scales the object + # @param theObject - the object to translate (mesh, submesh, or group) + # @param thePoint - base point for scale + # @param theScaleFact - list of 1-3 scale factors for axises + # @param Copy - allows copying the translated elements + # @param MakeGroups - forces the generation of new groups from existing + # ones (if Copy) + # @return list of created groups (SMESH_GroupBase) if MakeGroups=True, + # empty list otherwise + def Scale(self, theObject, thePoint, theScaleFact, Copy, MakeGroups=False): + if ( isinstance( theObject, Mesh )): + theObject = theObject.GetMesh() + if ( isinstance( theObject, list )): + theObject = self.GetIDSource(theObject, SMESH.ALL) + if ( isinstance( theScaleFact, float )): + theScaleFact = [theScaleFact] + if ( isinstance( theScaleFact, int )): + theScaleFact = [ float(theScaleFact)] + + self.mesh.SetParameters(thePoint.parameters) + + if Copy and MakeGroups: + return self.editor.ScaleMakeGroups(theObject, thePoint, theScaleFact) + self.editor.Scale(theObject, thePoint, theScaleFact, Copy) + return [] + + ## Creates a new mesh from the translated object + # @param theObject - the object to translate (mesh, submesh, or group) + # @param thePoint - base point for scale + # @param theScaleFact - list of 1-3 scale factors for axises + # @param MakeGroups - forces the generation of new groups from existing ones + # @param NewMeshName - the name of the newly created mesh + # @return instance of Mesh class + def ScaleMakeMesh(self, theObject, thePoint, theScaleFact, MakeGroups=False, NewMeshName=""): + if (isinstance(theObject, Mesh)): + theObject = theObject.GetMesh() + if ( isinstance( theObject, list )): + theObject = self.GetIDSource(theObject,SMESH.ALL) + if ( isinstance( theScaleFact, float )): + theScaleFact = [theScaleFact] + if ( isinstance( theScaleFact, int )): + theScaleFact = [ float(theScaleFact)] + + self.mesh.SetParameters(thePoint.parameters) + mesh = self.editor.ScaleMakeMesh(theObject, thePoint, theScaleFact, + MakeGroups, NewMeshName) + return Mesh( self.smeshpyD, self.geompyD, mesh ) + + + + ## Rotates the elements + # @param IDsOfElements list of elements ids + # @param Axis the axis of rotation (AxisStruct or geom line) + # @param AngleInRadians the angle of rotation (in radians) or a name of variable which defines angle in degrees + # @param Copy allows copying the rotated elements + # @param MakeGroups forces the generation of new groups from existing ones (if Copy) + # @return list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise + # @ingroup l2_modif_trsf + def Rotate (self, IDsOfElements, Axis, AngleInRadians, Copy, MakeGroups=False): + if IDsOfElements == []: + IDsOfElements = self.GetElementsId() + if ( isinstance( Axis, geomBuilder.GEOM._objref_GEOM_Object)): + Axis = self.smeshpyD.GetAxisStruct(Axis) + AngleInRadians,Parameters,hasVars = ParseAngles(AngleInRadians) + Parameters = Axis.parameters + var_separator + Parameters + self.mesh.SetParameters(Parameters) + if Copy and MakeGroups: + return self.editor.RotateMakeGroups(IDsOfElements, Axis, AngleInRadians) + self.editor.Rotate(IDsOfElements, Axis, AngleInRadians, Copy) + return [] + + ## Creates a new mesh of rotated elements + # @param IDsOfElements list of element ids + # @param Axis the axis of rotation (AxisStruct or geom line) + # @param AngleInRadians the angle of rotation (in radians) or a name of variable which defines angle in degrees + # @param MakeGroups forces the generation of new groups from existing ones + # @param NewMeshName the name of the newly created mesh + # @return instance of Mesh class + # @ingroup l2_modif_trsf + def RotateMakeMesh (self, IDsOfElements, Axis, AngleInRadians, MakeGroups=0, NewMeshName=""): + if IDsOfElements == []: + IDsOfElements = self.GetElementsId() + if ( isinstance( Axis, geomBuilder.GEOM._objref_GEOM_Object)): + Axis = self.smeshpyD.GetAxisStruct(Axis) + AngleInRadians,Parameters,hasVars = ParseAngles(AngleInRadians) + Parameters = Axis.parameters + var_separator + Parameters + self.mesh.SetParameters(Parameters) + mesh = self.editor.RotateMakeMesh(IDsOfElements, Axis, AngleInRadians, + MakeGroups, NewMeshName) + return Mesh( self.smeshpyD, self.geompyD, mesh ) + + ## Rotates the object + # @param theObject the object to rotate( mesh, submesh, or group) + # @param Axis the axis of rotation (AxisStruct or geom line) + # @param AngleInRadians the angle of rotation (in radians) or a name of variable which defines angle in degrees + # @param Copy allows copying the rotated elements + # @param MakeGroups forces the generation of new groups from existing ones (if Copy) + # @return list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise + # @ingroup l2_modif_trsf + def RotateObject (self, theObject, Axis, AngleInRadians, Copy, MakeGroups=False): + if (isinstance(theObject, Mesh)): + theObject = theObject.GetMesh() + if (isinstance(Axis, geomBuilder.GEOM._objref_GEOM_Object)): + Axis = self.smeshpyD.GetAxisStruct(Axis) + AngleInRadians,Parameters,hasVars = ParseAngles(AngleInRadians) + Parameters = Axis.parameters + ":" + Parameters + self.mesh.SetParameters(Parameters) + if Copy and MakeGroups: + return self.editor.RotateObjectMakeGroups(theObject, Axis, AngleInRadians) + self.editor.RotateObject(theObject, Axis, AngleInRadians, Copy) + return [] + + ## Creates a new mesh from the rotated object + # @param theObject the object to rotate (mesh, submesh, or group) + # @param Axis the axis of rotation (AxisStruct or geom line) + # @param AngleInRadians the angle of rotation (in radians) or a name of variable which defines angle in degrees + # @param MakeGroups forces the generation of new groups from existing ones + # @param NewMeshName the name of the newly created mesh + # @return instance of Mesh class + # @ingroup l2_modif_trsf + def RotateObjectMakeMesh(self, theObject, Axis, AngleInRadians, MakeGroups=0,NewMeshName=""): + if (isinstance( theObject, Mesh )): + theObject = theObject.GetMesh() + if (isinstance(Axis, geomBuilder.GEOM._objref_GEOM_Object)): + Axis = self.smeshpyD.GetAxisStruct(Axis) + AngleInRadians,Parameters,hasVars = ParseAngles(AngleInRadians) + Parameters = Axis.parameters + ":" + Parameters + mesh = self.editor.RotateObjectMakeMesh(theObject, Axis, AngleInRadians, + MakeGroups, NewMeshName) + self.mesh.SetParameters(Parameters) + return Mesh( self.smeshpyD, self.geompyD, mesh ) + + ## Finds groups of ajacent nodes within Tolerance. + # @param Tolerance the value of tolerance + # @return the list of groups of nodes + # @ingroup l2_modif_trsf + def FindCoincidentNodes (self, Tolerance): + return self.editor.FindCoincidentNodes(Tolerance) + + ## Finds groups of ajacent nodes within Tolerance. + # @param Tolerance the value of tolerance + # @param SubMeshOrGroup SubMesh or Group + # @param exceptNodes list of either SubMeshes, Groups or node IDs to exclude from search + # @return the list of groups of nodes + # @ingroup l2_modif_trsf + def FindCoincidentNodesOnPart (self, SubMeshOrGroup, Tolerance, exceptNodes=[]): + if (isinstance( SubMeshOrGroup, Mesh )): + SubMeshOrGroup = SubMeshOrGroup.GetMesh() + if not isinstance( exceptNodes, list): + exceptNodes = [ exceptNodes ] + if exceptNodes and isinstance( exceptNodes[0], int): + exceptNodes = [ self.GetIDSource( exceptNodes, SMESH.NODE)] + return self.editor.FindCoincidentNodesOnPartBut(SubMeshOrGroup, Tolerance,exceptNodes) + + ## Merges nodes + # @param GroupsOfNodes the list of groups of nodes + # @ingroup l2_modif_trsf + def MergeNodes (self, GroupsOfNodes): + self.editor.MergeNodes(GroupsOfNodes) + + ## Finds the elements built on the same nodes. + # @param MeshOrSubMeshOrGroup Mesh or SubMesh, or Group of elements for searching + # @return a list of groups of equal elements + # @ingroup l2_modif_trsf + def FindEqualElements (self, MeshOrSubMeshOrGroup): + if ( isinstance( MeshOrSubMeshOrGroup, Mesh )): + MeshOrSubMeshOrGroup = MeshOrSubMeshOrGroup.GetMesh() + return self.editor.FindEqualElements(MeshOrSubMeshOrGroup) + + ## Merges elements in each given group. + # @param GroupsOfElementsID groups of elements for merging + # @ingroup l2_modif_trsf + def MergeElements(self, GroupsOfElementsID): + self.editor.MergeElements(GroupsOfElementsID) + + ## Leaves one element and removes all other elements built on the same nodes. + # @ingroup l2_modif_trsf + def MergeEqualElements(self): + self.editor.MergeEqualElements() + + ## Sews free borders + # @return SMESH::Sew_Error + # @ingroup l2_modif_trsf + def SewFreeBorders (self, FirstNodeID1, SecondNodeID1, LastNodeID1, + FirstNodeID2, SecondNodeID2, LastNodeID2, + CreatePolygons, CreatePolyedrs): + return self.editor.SewFreeBorders(FirstNodeID1, SecondNodeID1, LastNodeID1, + FirstNodeID2, SecondNodeID2, LastNodeID2, + CreatePolygons, CreatePolyedrs) + + ## Sews conform free borders + # @return SMESH::Sew_Error + # @ingroup l2_modif_trsf + def SewConformFreeBorders (self, FirstNodeID1, SecondNodeID1, LastNodeID1, + FirstNodeID2, SecondNodeID2): + return self.editor.SewConformFreeBorders(FirstNodeID1, SecondNodeID1, LastNodeID1, + FirstNodeID2, SecondNodeID2) + + ## Sews border to side + # @return SMESH::Sew_Error + # @ingroup l2_modif_trsf + def SewBorderToSide (self, FirstNodeIDOnFreeBorder, SecondNodeIDOnFreeBorder, LastNodeIDOnFreeBorder, + FirstNodeIDOnSide, LastNodeIDOnSide, CreatePolygons, CreatePolyedrs): + return self.editor.SewBorderToSide(FirstNodeIDOnFreeBorder, SecondNodeIDOnFreeBorder, LastNodeIDOnFreeBorder, + FirstNodeIDOnSide, LastNodeIDOnSide, CreatePolygons, CreatePolyedrs) + + ## Sews two sides of a mesh. The nodes belonging to Side1 are + # merged with the nodes of elements of Side2. + # The number of elements in theSide1 and in theSide2 must be + # equal and they should have similar nodal connectivity. + # The nodes to merge should belong to side borders and + # the first node should be linked to the second. + # @return SMESH::Sew_Error + # @ingroup l2_modif_trsf + def SewSideElements (self, IDsOfSide1Elements, IDsOfSide2Elements, + NodeID1OfSide1ToMerge, NodeID1OfSide2ToMerge, + NodeID2OfSide1ToMerge, NodeID2OfSide2ToMerge): + return self.editor.SewSideElements(IDsOfSide1Elements, IDsOfSide2Elements, + NodeID1OfSide1ToMerge, NodeID1OfSide2ToMerge, + NodeID2OfSide1ToMerge, NodeID2OfSide2ToMerge) + + ## Sets new nodes for the given element. + # @param ide the element id + # @param newIDs nodes ids + # @return If the number of nodes does not correspond to the type of element - returns false + # @ingroup l2_modif_edit + def ChangeElemNodes(self, ide, newIDs): + return self.editor.ChangeElemNodes(ide, newIDs) + + ## If during the last operation of MeshEditor some nodes were + # created, this method returns the list of their IDs, \n + # if new nodes were not created - returns empty list + # @return the list of integer values (can be empty) + # @ingroup l1_auxiliary + def GetLastCreatedNodes(self): + return self.editor.GetLastCreatedNodes() + + ## If during the last operation of MeshEditor some elements were + # created this method returns the list of their IDs, \n + # if new elements were not created - returns empty list + # @return the list of integer values (can be empty) + # @ingroup l1_auxiliary + def GetLastCreatedElems(self): + return self.editor.GetLastCreatedElems() + + ## Creates a hole in a mesh by doubling the nodes of some particular elements + # @param theNodes identifiers of nodes to be doubled + # @param theModifiedElems identifiers of elements to be updated by the new (doubled) + # nodes. If list of element identifiers is empty then nodes are doubled but + # they not assigned to elements + # @return TRUE if operation has been completed successfully, FALSE otherwise + # @ingroup l2_modif_edit + def DoubleNodes(self, theNodes, theModifiedElems): + return self.editor.DoubleNodes(theNodes, theModifiedElems) + + ## Creates a hole in a mesh by doubling the nodes of some particular elements + # This method provided for convenience works as DoubleNodes() described above. + # @param theNodeId identifiers of node to be doubled + # @param theModifiedElems identifiers of elements to be updated + # @return TRUE if operation has been completed successfully, FALSE otherwise + # @ingroup l2_modif_edit + def DoubleNode(self, theNodeId, theModifiedElems): + return self.editor.DoubleNode(theNodeId, theModifiedElems) + + ## Creates a hole in a mesh by doubling the nodes of some particular elements + # This method provided for convenience works as DoubleNodes() described above. + # @param theNodes group of nodes to be doubled + # @param theModifiedElems group of elements to be updated. + # @param theMakeGroup forces the generation of a group containing new nodes. + # @return TRUE or a created group if operation has been completed successfully, + # FALSE or None otherwise + # @ingroup l2_modif_edit + def DoubleNodeGroup(self, theNodes, theModifiedElems, theMakeGroup=False): + if theMakeGroup: + return self.editor.DoubleNodeGroupNew(theNodes, theModifiedElems) + return self.editor.DoubleNodeGroup(theNodes, theModifiedElems) + + ## Creates a hole in a mesh by doubling the nodes of some particular elements + # This method provided for convenience works as DoubleNodes() described above. + # @param theNodes list of groups of nodes to be doubled + # @param theModifiedElems list of groups of elements to be updated. + # @param theMakeGroup forces the generation of a group containing new nodes. + # @return TRUE if operation has been completed successfully, FALSE otherwise + # @ingroup l2_modif_edit + def DoubleNodeGroups(self, theNodes, theModifiedElems, theMakeGroup=False): + if theMakeGroup: + return self.editor.DoubleNodeGroupsNew(theNodes, theModifiedElems) + return self.editor.DoubleNodeGroups(theNodes, theModifiedElems) + + ## Creates a hole in a mesh by doubling the nodes of some particular elements + # @param theElems - the list of elements (edges or faces) to be replicated + # The nodes for duplication could be found from these elements + # @param theNodesNot - list of nodes to NOT replicate + # @param theAffectedElems - the list of elements (cells and edges) to which the + # replicated nodes should be associated to. + # @return TRUE if operation has been completed successfully, FALSE otherwise + # @ingroup l2_modif_edit + def DoubleNodeElem(self, theElems, theNodesNot, theAffectedElems): + return self.editor.DoubleNodeElem(theElems, theNodesNot, theAffectedElems) + + ## Creates a hole in a mesh by doubling the nodes of some particular elements + # @param theElems - the list of elements (edges or faces) to be replicated + # The nodes for duplication could be found from these elements + # @param theNodesNot - list of nodes to NOT replicate + # @param theShape - shape to detect affected elements (element which geometric center + # located on or inside shape). + # The replicated nodes should be associated to affected elements. + # @return TRUE if operation has been completed successfully, FALSE otherwise + # @ingroup l2_modif_edit + def DoubleNodeElemInRegion(self, theElems, theNodesNot, theShape): + return self.editor.DoubleNodeElemInRegion(theElems, theNodesNot, theShape) + + ## Creates a hole in a mesh by doubling the nodes of some particular elements + # This method provided for convenience works as DoubleNodes() described above. + # @param theElems - group of of elements (edges or faces) to be replicated + # @param theNodesNot - group of nodes not to replicated + # @param theAffectedElems - group of elements to which the replicated nodes + # should be associated to. + # @param theMakeGroup forces the generation of a group containing new elements. + # @param theMakeNodeGroup forces the generation of a group containing new nodes. + # @return TRUE or created groups (one or two) if operation has been completed successfully, + # FALSE or None otherwise + # @ingroup l2_modif_edit + def DoubleNodeElemGroup(self, theElems, theNodesNot, theAffectedElems, + theMakeGroup=False, theMakeNodeGroup=False): + if theMakeGroup or theMakeNodeGroup: + twoGroups = self.editor.DoubleNodeElemGroup2New(theElems, theNodesNot, + theAffectedElems, + theMakeGroup, theMakeNodeGroup) + if theMakeGroup and theMakeNodeGroup: + return twoGroups + else: + return twoGroups[ int(theMakeNodeGroup) ] + return self.editor.DoubleNodeElemGroup(theElems, theNodesNot, theAffectedElems) + + ## Creates a hole in a mesh by doubling the nodes of some particular elements + # This method provided for convenience works as DoubleNodes() described above. + # @param theElems - group of of elements (edges or faces) to be replicated + # @param theNodesNot - group of nodes not to replicated + # @param theShape - shape to detect affected elements (element which geometric center + # located on or inside shape). + # The replicated nodes should be associated to affected elements. + # @ingroup l2_modif_edit + def DoubleNodeElemGroupInRegion(self, theElems, theNodesNot, theShape): + return self.editor.DoubleNodeElemGroupInRegion(theElems, theNodesNot, theShape) + + ## Creates a hole in a mesh by doubling the nodes of some particular elements + # This method provided for convenience works as DoubleNodes() described above. + # @param theElems - list of groups of elements (edges or faces) to be replicated + # @param theNodesNot - list of groups of nodes not to replicated + # @param theAffectedElems - group of elements to which the replicated nodes + # should be associated to. + # @param theMakeGroup forces the generation of a group containing new elements. + # @param theMakeNodeGroup forces the generation of a group containing new nodes. + # @return TRUE or created groups (one or two) if operation has been completed successfully, + # FALSE or None otherwise + # @ingroup l2_modif_edit + def DoubleNodeElemGroups(self, theElems, theNodesNot, theAffectedElems, + theMakeGroup=False, theMakeNodeGroup=False): + if theMakeGroup or theMakeNodeGroup: + twoGroups = self.editor.DoubleNodeElemGroups2New(theElems, theNodesNot, + theAffectedElems, + theMakeGroup, theMakeNodeGroup) + if theMakeGroup and theMakeNodeGroup: + return twoGroups + else: + return twoGroups[ int(theMakeNodeGroup) ] + return self.editor.DoubleNodeElemGroups(theElems, theNodesNot, theAffectedElems) + + ## Creates a hole in a mesh by doubling the nodes of some particular elements + # This method provided for convenience works as DoubleNodes() described above. + # @param theElems - list of groups of elements (edges or faces) to be replicated + # @param theNodesNot - list of groups of nodes not to replicated + # @param theShape - shape to detect affected elements (element which geometric center + # located on or inside shape). + # The replicated nodes should be associated to affected elements. + # @return TRUE if operation has been completed successfully, FALSE otherwise + # @ingroup l2_modif_edit + def DoubleNodeElemGroupsInRegion(self, theElems, theNodesNot, theShape): + return self.editor.DoubleNodeElemGroupsInRegion(theElems, theNodesNot, theShape) + + ## Identify the elements that will be affected by node duplication (actual duplication is not performed. + # This method is the first step of DoubleNodeElemGroupsInRegion. + # @param theElems - list of groups of elements (edges or faces) to be replicated + # @param theNodesNot - list of groups of nodes not to replicated + # @param theShape - shape to detect affected elements (element which geometric center + # located on or inside shape). + # The replicated nodes should be associated to affected elements. + # @return groups of affected elements + # @ingroup l2_modif_edit + def AffectedElemGroupsInRegion(self, theElems, theNodesNot, theShape): + return self.editor.AffectedElemGroupsInRegion(theElems, theNodesNot, theShape) + + ## Double nodes on shared faces between groups of volumes and create flat elements on demand. + # The list of groups must describe a partition of the mesh volumes. + # The nodes of the internal faces at the boundaries of the groups are doubled. + # In option, the internal faces are replaced by flat elements. + # Triangles are transformed in prisms, and quadrangles in hexahedrons. + # @param theDomains - list of groups of volumes + # @param createJointElems - if TRUE, create the elements + # @return TRUE if operation has been completed successfully, FALSE otherwise + def DoubleNodesOnGroupBoundaries(self, theDomains, createJointElems ): + return self.editor.DoubleNodesOnGroupBoundaries( theDomains, createJointElems ) + + ## Double nodes on some external faces and create flat elements. + # Flat elements are mainly used by some types of mechanic calculations. + # + # Each group of the list must be constituted of faces. + # Triangles are transformed in prisms, and quadrangles in hexahedrons. + # @param theGroupsOfFaces - list of groups of faces + # @return TRUE if operation has been completed successfully, FALSE otherwise + def CreateFlatElementsOnFacesGroups(self, theGroupsOfFaces ): + return self.editor.CreateFlatElementsOnFacesGroups( theGroupsOfFaces ) + + ## identify all the elements around a geom shape, get the faces delimiting the hole + # + def CreateHoleSkin(self, radius, theShape, groupName, theNodesCoords): + return self.editor.CreateHoleSkin( radius, theShape, groupName, theNodesCoords ) + + def _getFunctor(self, funcType ): + fn = self.functors[ funcType._v ] + if not fn: + fn = self.smeshpyD.GetFunctor(funcType) + fn.SetMesh(self.mesh) + self.functors[ funcType._v ] = fn + return fn + + def _valueFromFunctor(self, funcType, elemId): + fn = self._getFunctor( funcType ) + if fn.GetElementType() == self.GetElementType(elemId, True): + val = fn.GetValue(elemId) + else: + val = 0 + return val + + ## Get length of 1D element. + # @param elemId mesh element ID + # @return element's length value + # @ingroup l1_measurements + def GetLength(self, elemId): + return self._valueFromFunctor(SMESH.FT_Length, elemId) + + ## Get area of 2D element. + # @param elemId mesh element ID + # @return element's area value + # @ingroup l1_measurements + def GetArea(self, elemId): + return self._valueFromFunctor(SMESH.FT_Area, elemId) + + ## Get volume of 3D element. + # @param elemId mesh element ID + # @return element's volume value + # @ingroup l1_measurements + def GetVolume(self, elemId): + return self._valueFromFunctor(SMESH.FT_Volume3D, elemId) + + ## Get maximum element length. + # @param elemId mesh element ID + # @return element's maximum length value + # @ingroup l1_measurements + def GetMaxElementLength(self, elemId): + if self.GetElementType(elemId, True) == SMESH.VOLUME: + ftype = SMESH.FT_MaxElementLength3D + else: + ftype = SMESH.FT_MaxElementLength2D + return self._valueFromFunctor(ftype, elemId) + + ## Get aspect ratio of 2D or 3D element. + # @param elemId mesh element ID + # @return element's aspect ratio value + # @ingroup l1_measurements + def GetAspectRatio(self, elemId): + if self.GetElementType(elemId, True) == SMESH.VOLUME: + ftype = SMESH.FT_AspectRatio3D + else: + ftype = SMESH.FT_AspectRatio + return self._valueFromFunctor(ftype, elemId) + + ## Get warping angle of 2D element. + # @param elemId mesh element ID + # @return element's warping angle value + # @ingroup l1_measurements + def GetWarping(self, elemId): + return self._valueFromFunctor(SMESH.FT_Warping, elemId) + + ## Get minimum angle of 2D element. + # @param elemId mesh element ID + # @return element's minimum angle value + # @ingroup l1_measurements + def GetMinimumAngle(self, elemId): + return self._valueFromFunctor(SMESH.FT_MinimumAngle, elemId) + + ## Get taper of 2D element. + # @param elemId mesh element ID + # @return element's taper value + # @ingroup l1_measurements + def GetTaper(self, elemId): + return self._valueFromFunctor(SMESH.FT_Taper, elemId) + + ## Get skew of 2D element. + # @param elemId mesh element ID + # @return element's skew value + # @ingroup l1_measurements + def GetSkew(self, elemId): + return self._valueFromFunctor(SMESH.FT_Skew, elemId) + + pass # end of Mesh class + +## Helper class for wrapping of SMESH.SMESH_Pattern CORBA class +# +class Pattern(SMESH._objref_SMESH_Pattern): + + def ApplyToMeshFaces(self, theMesh, theFacesIDs, theNodeIndexOnKeyPoint1, theReverse): + decrFun = lambda i: i-1 + theNodeIndexOnKeyPoint1,Parameters,hasVars = ParseParameters(theNodeIndexOnKeyPoint1, decrFun) + theMesh.SetParameters(Parameters) + return SMESH._objref_SMESH_Pattern.ApplyToMeshFaces( self, theMesh, theFacesIDs, theNodeIndexOnKeyPoint1, theReverse ) + + def ApplyToHexahedrons(self, theMesh, theVolumesIDs, theNode000Index, theNode001Index): + decrFun = lambda i: i-1 + theNode000Index,theNode001Index,Parameters,hasVars = ParseParameters(theNode000Index,theNode001Index, decrFun) + theMesh.SetParameters(Parameters) + return SMESH._objref_SMESH_Pattern.ApplyToHexahedrons( self, theMesh, theVolumesIDs, theNode000Index, theNode001Index ) + +# Registering the new proxy for Pattern +omniORB.registerObjref(SMESH._objref_SMESH_Pattern._NP_RepositoryId, Pattern) + +## Private class used to bind methods creating algorithms to the class Mesh +# +class algoCreator: + def __init__(self): + self.mesh = None + self.defaultAlgoType = "" + self.algoTypeToClass = {} + + # Stores a python class of algorithm + def add(self, algoClass): + if type( algoClass ).__name__ == 'classobj' and \ + hasattr( algoClass, "algoType"): + self.algoTypeToClass[ algoClass.algoType ] = algoClass + if not self.defaultAlgoType and \ + hasattr( algoClass, "isDefault") and algoClass.isDefault: + self.defaultAlgoType = algoClass.algoType + #print "Add",algoClass.algoType, "dflt",self.defaultAlgoType + + # creates a copy of self and assign mesh to the copy + def copy(self, mesh): + other = algoCreator() + other.defaultAlgoType = self.defaultAlgoType + other.algoTypeToClass = self.algoTypeToClass + other.mesh = mesh + return other + + # creates an instance of algorithm + def __call__(self,algo="",geom=0,*args): + algoType = self.defaultAlgoType + for arg in args + (algo,geom): + if isinstance( arg, geomBuilder.GEOM._objref_GEOM_Object ): + geom = arg + if isinstance( arg, str ) and arg: + algoType = arg + if not algoType and self.algoTypeToClass: + algoType = self.algoTypeToClass.keys()[0] + if self.algoTypeToClass.has_key( algoType ): + #print "Create algo",algoType + return self.algoTypeToClass[ algoType ]( self.mesh, geom ) + raise RuntimeError, "No class found for algo type %s" % algoType + return None + +# Private class used to substitute and store variable parameters of hypotheses. +# +class hypMethodWrapper: + def __init__(self, hyp, method): + self.hyp = hyp + self.method = method + #print "REBIND:", method.__name__ + return + + # call a method of hypothesis with calling SetVarParameter() before + def __call__(self,*args): + if not args: + return self.method( self.hyp, *args ) # hypothesis method with no args + + #print "MethWrapper.__call__",self.method.__name__, args + try: + parsed = ParseParameters(*args) # replace variables with their values + self.hyp.SetVarParameter( parsed[-2], self.method.__name__ ) + result = self.method( self.hyp, *parsed[:-2] ) # call hypothesis method + except omniORB.CORBA.BAD_PARAM: # raised by hypothesis method call + # maybe there is a replaced string arg which is not variable + result = self.method( self.hyp, *args ) + except ValueError, detail: # raised by ParseParameters() + try: + result = self.method( self.hyp, *args ) + except omniORB.CORBA.BAD_PARAM: + raise ValueError, detail # wrong variable name + + return result + +for pluginName in os.environ[ "SMESH_MeshersList" ].split( ":" ): + # + print "pluginName: ", pluginName + pluginBuilderName = pluginName + "Builder" + try: + exec( "from salome.%s.%s import *" % (pluginName, pluginBuilderName)) + except Exception, e: + print "Exception while loading %s: %s" % ( pluginBuilderName, e ) + continue + exec( "from salome.%s import %s" % (pluginName, pluginBuilderName)) + plugin = eval( pluginBuilderName ) + print " plugin:" , str(plugin) + + # add methods creating algorithms to Mesh + for k in dir( plugin ): + if k[0] == '_': continue + algo = getattr( plugin, k ) + print " algo:", str(algo) + if type( algo ).__name__ == 'classobj' and hasattr( algo, "meshMethod" ): + print " meshMethod:" , str(algo.meshMethod) + if not hasattr( Mesh, algo.meshMethod ): + setattr( Mesh, algo.meshMethod, algoCreator() ) + pass + getattr( Mesh, algo.meshMethod ).add( algo ) + pass + pass + pass +del pluginName diff --git a/src/SMESH_SWIG/smesh_algorithm.py b/src/SMESH_SWIG/smesh_algorithm.py index ae06deb91..798be3ece 100644 --- a/src/SMESH_SWIG/smesh_algorithm.py +++ b/src/SMESH_SWIG/smesh_algorithm.py @@ -22,7 +22,7 @@ # This package is a part of SALOME %Mesh module Python API import salome -import geompyDC +from salome.geom import geomBuilder import SMESH ## The base class to define meshing algorithms @@ -166,7 +166,7 @@ class Mesh_Algorithm: ## Gets the name of the algorithm def GetName(self): - from smeshDC import GetName + from salome.smesh.smeshBuilder import GetName return GetName(self.algo) ## Sets the name to the algorithm @@ -190,7 +190,7 @@ class Mesh_Algorithm: ## Private method def Assign(self, algo, mesh, geom): - from smeshDC import AssureGeomPublished, TreatHypoStatus, GetName + from salome.smesh.smeshBuilder import AssureGeomPublished, TreatHypoStatus, GetName if geom is None: raise RuntimeError, "Attemp to create " + algo + " algoritm on None shape" self.mesh = mesh @@ -221,7 +221,7 @@ class Mesh_Algorithm: ## Private method def Hypothesis (self, hyp, args=[], so="libStdMeshersEngine.so", UseExisting=0, CompareMethod=""): - from smeshDC import TreatHypoStatus, GetName + from salome.smesh.smeshBuilder import TreatHypoStatus, GetName hypo = None if UseExisting: if CompareMethod == "": CompareMethod = self.CompareHyp @@ -233,7 +233,7 @@ class Mesh_Algorithm: s = "=" for arg in args: argStr = str(arg) - if isinstance( arg, geompyDC.GEOM._objref_GEOM_Object ): + if isinstance( arg, geomBuilder.GEOM._objref_GEOM_Object ): argStr = arg.GetStudyEntry() if not argStr: argStr = "GEOM_Obj_%s", arg.GetEntry() if len( argStr ) > 10: @@ -273,7 +273,7 @@ class Mesh_Algorithm: raise TypeError, "ViscousLayers are supported by 3D algorithms only" if not "ViscousLayers" in self.GetCompatibleHypothesis(): raise TypeError, "ViscousLayers are not supported by %s"%self.algo.GetName() - if ignoreFaces and isinstance( ignoreFaces[0], geompyDC.GEOM._objref_GEOM_Object ): + if ignoreFaces and isinstance( ignoreFaces[0], geomBuilder.GEOM._objref_GEOM_Object ): ignoreFaces = [ self.mesh.geompyD.GetSubShapeID(self.mesh.geom, f) for f in ignoreFaces ] hyp = self.Hypothesis("ViscousLayers", [thickness, numberOfLayers, stretchFactor, ignoreFaces]) @@ -296,7 +296,7 @@ class Mesh_Algorithm: raise TypeError, "ViscousLayers2D are supported by 2D algorithms only" if not "ViscousLayers2D" in self.GetCompatibleHypothesis(): raise TypeError, "ViscousLayers2D are not supported by %s"%self.algo.GetName() - if ignoreEdges and isinstance( ignoreEdges[0], geompyDC.GEOM._objref_GEOM_Object ): + if ignoreEdges and isinstance( ignoreEdges[0], geomBuilder.GEOM._objref_GEOM_Object ): ignoreEdges = [ self.mesh.geompyD.GetSubShapeID(self.mesh.geom, f) for f in ignoreEdges ] hyp = self.Hypothesis("ViscousLayers2D", [thickness, numberOfLayers, stretchFactor, ignoreEdges]) @@ -310,30 +310,30 @@ class Mesh_Algorithm: # into a list acceptable to SetReversedEdges() of some 1D hypotheses # @ingroup l3_hypos_1dhyps def ReversedEdgeIndices(self, reverseList): - from smeshDC import FirstVertexOnCurve + from salome.smesh.smeshBuilder import FirstVertexOnCurve 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: + if s.GetShapeType() != geomBuilder.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: + elif isinstance( i, geomBuilder.GEOM._objref_GEOM_Object ): + if i.GetShapeType() != geomBuilder.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 ): + if not isinstance( e, geomBuilder.GEOM._objref_GEOM_Object ) or \ + not isinstance( v, geomBuilder.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: + if v.GetShapeType() == geomBuilder.GEOM.EDGE and \ + e.GetShapeType() == geomBuilder.GEOM.VERTEX: v,e = e,v - if e.GetShapeType() != geompyDC.GEOM.EDGE or \ - v.GetShapeType() != geompyDC.GEOM.VERTEX: + if e.GetShapeType() != geomBuilder.GEOM.EDGE or \ + v.GetShapeType() != geomBuilder.GEOM.VERTEX: raise TypeError, "A list item must be a tuple (edge, 1st_vertex_of_edge)" vFirst = FirstVertexOnCurve( e ) tol = geompy.Tolerance( vFirst )[-1] -- 2.39.2