# 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
+ d = {}
+ if hasattr(obj, "_narrow") and obj._narrow(SMESH.SMESH_IDSource):
+ 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
+
## Returns the number of nodes 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 edges in the mesh
# @return an integer value
# @ingroup l1_meshinfo
self.mesh.SetParameters(Parameters)
return self.editor.AddNode( x, y, z)
+ ## Creates a 0D element on a node with given number.
+ # @param IDOfNode the ID of node for creation of the element.
+ # @return the Id of the new 0D element
+ # @ingroup l2_modif_add
+ def Add0DElement(self, IDOfNode):
+ return self.editor.Add0DElement(IDOfNode)
+
## Creates a linear or quadratic edge (this is determined
# by the number of given nodes).
# @param IDsOfNodes the list of node IDs for creation of the element.
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
+ # @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 DoubleNodes(self, theNodes, theModifiedElems):
- return self.editor.DoubleNodes(theNodes, theModifiedElems)
+ def DoubleNodes(self, theElems, theNodesNot, theAffectedElems):
+ return self.editor.DoubleNodes(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 theNodes identifiers of node to be doubled
- # @param theModifiedElems identifiers of elements to be updated
+ # @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 DoubleNode(self, theNodeId, theModifiedElems):
- return self.editor.DoubleNode(theNodeId, theModifiedElems)
+ def DoubleNodesInRegion(self, theElems, theNodesNot, theShape):
+ return self.editor.DoubleNodesInRegion(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.
+ # @ingroup l2_modif_edit
+ def DoubleNodeGroup(self, theElems, theNodesNot, theAffectedElems):
+ return self.editor.DoubleNodeGroup(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 theNodes group of nodes to be doubled
- # @param theModifiedElems group of elements to be updated.
- # @return TRUE if operation has been completed successfully, FALSE otherwise
+ # @param 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 DoubleNodeGroup(self, theNodes, theModifiedElems):
- return self.editor.DoubleNodeGroup(theNodes, theModifiedElems)
+ def DoubleNodeGroupInRegion(self, theElems, theNodesNot, theShape):
+ return self.editor.DoubleNodeGroup(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 theNodes list of groups of nodes to be doubled
- # @param theModifiedElems list of groups of elements to be updated.
+ # @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.
+ # @return TRUE if operation has been completed successfully, FALSE otherwise
+ # @ingroup l2_modif_edit
+ def DoubleNodeGroups(self, theElems, theNodesNot, theAffectedElems):
+ return self.editor.DoubleNodeGroups(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 DoubleNodeGroups(self, theNodes, theModifiedElems):
- return self.editor.DoubleNodeGroups(theNodes, theModifiedElems)
+ def DoubleNodeGroupsInRegion(self, theElems, theNodesNot, theShape):
+ return self.editor.DoubleNodeGroupsInRegion(theElems, theNodesNot, theShape)
## The mother class to define algorithm, it is not recommended to use it directly.
#
TreatHypoStatus( status, GetName(hypo), GetName(self.geom), 0 )
return hypo
+ ## Returns entry of the shape to mesh in the study
+ def MainShapeEntry(self):
+ entry = ""
+ if not self.mesh or not self.mesh.GetMesh(): return entry
+ if not self.mesh.GetMesh().HasShapeToMesh(): return entry
+ study = self.mesh.smeshpyD.GetCurrentStudy()
+ ior = salome.orb.object_to_string( self.mesh.GetShape() )
+ sobj = study.FindObjectIOR(ior)
+ if sobj: entry = sobj.GetID()
+ if not entry: return ""
+ return entry
# Public class: Mesh_Segment
# --------------------------
## Defines "NumberOfSegments" hypothesis to cut an edge in a fixed number of segments
# @param n for the number of segments that cut an edge
# @param s for the scale factor (optional)
+ # @param reversedEdges is a list of edges to mesh using reversed orientation
# @param UseExisting if ==true - searches for an existing hypothesis created with
# the same parameters, else (default) - create a new one
# @return an instance of StdMeshers_NumberOfSegments hypothesis
# @ingroup l3_hypos_1dhyps
- def NumberOfSegments(self, n, s=[], UseExisting=0):
+ def NumberOfSegments(self, n, s=[], reversedEdges=[], UseExisting=0):
+ if not isinstance(reversedEdges,list): #old version script, before adding reversedEdges
+ reversedEdges, UseExisting = [], reversedEdges
+ entry = self.MainShapeEntry()
if s == []:
- hyp = self.Hypothesis("NumberOfSegments", [n], UseExisting=UseExisting,
+ hyp = self.Hypothesis("NumberOfSegments", [n, reversedEdges, entry],
+ UseExisting=UseExisting,
CompareMethod=self.CompareNumberOfSegments)
else:
- hyp = self.Hypothesis("NumberOfSegments", [n,s], UseExisting=UseExisting,
+ hyp = self.Hypothesis("NumberOfSegments", [n,s, reversedEdges, entry],
+ UseExisting=UseExisting,
CompareMethod=self.CompareNumberOfSegments)
hyp.SetDistrType( 1 )
hyp.SetScaleFactor(s)
hyp.SetNumberOfSegments(n)
+ hyp.SetReversedEdges( reversedEdges )
+ hyp.SetObjectEntry( entry )
return hyp
## Private method
## Checks if the given "NumberOfSegments" hypothesis has the same parameters as the given arguments
def CompareNumberOfSegments(self, hyp, args):
if hyp.GetNumberOfSegments() == args[0]:
- if len(args) == 1:
- return True
- else:
- if hyp.GetDistrType() == 1:
- if IsEqual(hyp.GetScaleFactor(), args[1]):
+ if len(args) == 3:
+ if hyp.GetReversedEdges() == args[1]:
+ if not args[1] or hyp.GetObjectEntry() == args[2]:
return True
+ else:
+ if hyp.GetReversedEdges() == args[2]:
+ if not args[2] or hyp.GetObjectEntry() == args[3]:
+ if hyp.GetDistrType() == 1:
+ if IsEqual(hyp.GetScaleFactor(), args[1]):
+ return True
return False
## Defines "Arithmetic1D" hypothesis to cut an edge in several segments with increasing arithmetic length
# @param start defines the length of the first segment
# @param end defines the length of the last segment
+ # @param reversedEdges is a list of edges to mesh using reversed orientation
# @param UseExisting if ==true - searches for an existing hypothesis created with
# the same parameters, else (default) - creates a new one
# @return an instance of StdMeshers_Arithmetic1D hypothesis
# @ingroup l3_hypos_1dhyps
- def Arithmetic1D(self, start, end, UseExisting=0):
- hyp = self.Hypothesis("Arithmetic1D", [start, end], UseExisting=UseExisting,
+ def Arithmetic1D(self, start, end, reversedEdges=[], UseExisting=0):
+ if not isinstance(reversedEdges,list): #old version script, before adding reversedEdges
+ reversedEdges, UseExisting = [], reversedEdges
+ entry = self.MainShapeEntry()
+ hyp = self.Hypothesis("Arithmetic1D", [start, end, reversedEdges, entry],
+ UseExisting=UseExisting,
CompareMethod=self.CompareArithmetic1D)
- hyp.SetLength(start, 1)
- hyp.SetLength(end , 0)
+ hyp.SetStartLength(start)
+ hyp.SetEndLength(end)
+ hyp.SetReversedEdges( reversedEdges )
+ hyp.SetObjectEntry( entry )
return hyp
## Private method
def CompareArithmetic1D(self, hyp, args):
if IsEqual(hyp.GetLength(1), args[0]):
if IsEqual(hyp.GetLength(0), args[1]):
- return True
+ if hyp.GetReversedEdges() == args[2]:
+ if not args[2] or hyp.GetObjectEntry() == args[3]:
+ return True
return False
+
+ ## Defines "FixedPoints1D" hypothesis to cut an edge using parameter
+ # on curve from 0 to 1 (additionally it is neecessary to check
+ # orientation of edges and create list of reversed edges if it is
+ # needed) and sets numbers of segments between given points (default
+ # values are equals 1
+ # @param points defines the list of parameters on curve
+ # @param nbSegs defines the list of numbers of segments
+ # @param reversedEdges is a list of edges to mesh using reversed orientation
+ # @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
+ entry = self.MainShapeEntry()
+ hyp = self.Hypothesis("FixedPoints1D", [points, nbSegs, reversedEdges, entry],
+ UseExisting=UseExisting,
+ CompareMethod=self.CompareArithmetic1D)
+ hyp.SetPoints(points)
+ hyp.SetNbSegments(nbSegs)
+ hyp.SetReversedEdges(reversedEdges)
+ hyp.SetObjectEntry(entry)
+ return hyp
+
+ ## Private method
+ ## Check if the given "FixedPoints1D" hypothesis has the same parameters
+ ## as the given arguments
+ def CompareFixedPoints1D(self, hyp, args):
+ if hyp.GetPoints() == args[0]:
+ if hyp.GetNbSegments() == args[1]:
+ if hyp.GetReversedEdges() == args[2]:
+ if not args[2] or hyp.GetObjectEntry() == args[3]:
+ return True
+ return False
+
+
+
## Defines "StartEndLength" hypothesis to cut an edge in several segments with increasing geometric length
# @param start defines the length of the first segment
# @param end defines the length of the last segment
+ # @param reversedEdges is a list of edges to mesh using reversed orientation
# @param UseExisting if ==true - searches for an existing hypothesis created with
# the same parameters, else (default) - creates a new one
# @return an instance of StdMeshers_StartEndLength hypothesis
# @ingroup l3_hypos_1dhyps
- def StartEndLength(self, start, end, UseExisting=0):
- hyp = self.Hypothesis("StartEndLength", [start, end], UseExisting=UseExisting,
+ def StartEndLength(self, start, end, reversedEdges=[], UseExisting=0):
+ if not isinstance(reversedEdges,list): #old version script, before adding reversedEdges
+ reversedEdges, UseExisting = [], reversedEdges
+ entry = self.MainShapeEntry()
+ hyp = self.Hypothesis("StartEndLength", [start, end, reversedEdges, entry],
+ UseExisting=UseExisting,
CompareMethod=self.CompareStartEndLength)
- hyp.SetLength(start, 1)
- hyp.SetLength(end , 0)
+ hyp.SetStartLength(start)
+ hyp.SetEndLength(end)
+ hyp.SetReversedEdges( reversedEdges )
+ hyp.SetObjectEntry( entry )
return hyp
## Check if the given "StartEndLength" hypothesis has the same parameters as the given arguments
def CompareStartEndLength(self, hyp, args):
if IsEqual(hyp.GetLength(1), args[0]):
if IsEqual(hyp.GetLength(0), args[1]):
- return True
+ if hyp.GetReversedEdges() == args[2]:
+ if not args[2] or hyp.GetObjectEntry() == args[3]:
+ return True
return False
## Defines "Deflection1D" hypothesis
hyp.SetFineness( fineness )
return hyp
+# Public class: Mesh_RadialQuadrangle1D2D
+# -------------------------------
+
+## Defines a Radial Quadrangle 1D2D algorithm
+# @ingroup l2_algos_radialq
+#
+class Mesh_RadialQuadrangle1D2D(Mesh_Algorithm):
+
+ ## Private constructor.
+ def __init__(self, mesh, geom=0):
+ Mesh_Algorithm.__init__(self)
+ self.Create(mesh, geom, "RadialQuadrangle_1D2D")
+
+ self.distribHyp = self.Hypothesis("LayerDistribution2D", UseExisting=0)
+ self.nbLayers = None
+
+ ## Return 2D hypothesis holding the 1D one
+ def Get2DHypothesis(self):
+ 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"):
+ #print "OwnHypothesis",hypType
+ 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
+ hyp = self.mesh.smeshpyD.CreateHypothesis(hypType, so)
+ self.mesh.smeshpyD.SetCurrentStudy( study ) # enables publishing
+ self.distribHyp.SetLayerDistribution( hyp )
+ return hyp
+
+ ## Defines "NumberOfLayers2D" 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 NumberOfLayers2D(self, n, UseExisting=0):
+ self.mesh.GetMesh().RemoveHypothesis( self.geom, self.distribHyp )
+ self.nbLayers = self.Hypothesis("NumberOfLayers2D", [n], UseExisting=UseExisting,
+ CompareMethod=self.CompareNumberOfLayers)
+ self.nbLayers.SetNumberOfLayers( n )
+ return self.nbLayers
+
+ ## Checks if the given "NumberOfLayers" hypothesis has the same parameters as the given arguments
+ def CompareNumberOfLayers(self, hyp, args):
+ return IsEqual(hyp.GetNumberOfLayers(), args[0])
+
+ ## 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
+
+
# Private class: Mesh_UseExisting
# -------------------------------
class Mesh_UseExisting(Mesh_Algorithm):