return None
pass
elif CritType in [FT_FreeBorders, FT_FreeEdges, FT_BadOrientedVolume, FT_FreeNodes,
- FT_FreeFaces, FT_LinearOrQuadratic]:
+ FT_FreeFaces, FT_LinearOrQuadratic,
+ FT_BareBorderFace, FT_BareBorderVolume,
+ FT_OverConstrainedFace, FT_OverConstrainedVolume]:
# At this point the treshold is unnecessary
if aTreshold == FT_LogicalNOT:
aCriterion.UnaryOp = self.EnumToLong(FT_LogicalNOT)
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.Destroy()
+ 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.Destroy()
+ return result
+
import omniORB
#Registering the new proxy for SMESH_Gen
omniORB.registerObjref(SMESH._objref_SMESH_Gen._NP_RepositoryId, smeshDC)
else:
return Mesh_Segment(self, geom)
+ ## Creates 1D algorithm importing segments conatined in groups of other mesh.
+ # If the optional \a geom parameter is not set, this algorithm is global.
+ # Otherwise, this algorithm defines a submesh based on \a geom subshape.
+ # @param geom If defined the subshape is to be meshed
+ # @return an instance of Mesh_UseExistingElements class
+ # @ingroup l3_algos_basic
+ def UseExisting1DElements(self, geom=0):
+ return Mesh_UseExistingElements(1,self, geom)
+
+ ## Creates 2D algorithm importing faces conatined in groups of other mesh.
+ # If the optional \a geom parameter is not set, this algorithm is global.
+ # Otherwise, this algorithm defines a submesh based on \a geom subshape.
+ # @param geom If defined the subshape is to be meshed
+ # @return an instance of Mesh_UseExistingElements class
+ # @ingroup l3_algos_basic
+ def UseExisting2DElements(self, geom=0):
+ return Mesh_UseExistingElements(2,self, geom)
+
## Enables creation of nodes and segments usable by 2D algoritms.
# The added nodes and segments must be bound to edges and vertices by
# SetNodeOnVertex(), SetNodeOnEdge() and SetMeshElementOnShape()
return Mesh_RadialPrism3D(self, geom)
## Evaluates size of prospective mesh on a shape
- # @return True or False
+ # @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, geompyDC.GEOM._objref_GEOM_Object):
if self.geom == 0:
# Get mesh measurements information:
# ------------------------------------
- def MinDistance(self, id1, id2, isElem1=False, isElem2=False):
+ ## 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
- # @param node1, node2 is nodes to measure distance
+ ## 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
- def GetMinDistance(self, id1, id2, isElem1=False, isElem2=False):
- if isinstance( id1, int):
- if (isElem1):
- id1 = self.editor.MakeIDSource([id1], SMESH.FACE)
- else:
- id1 = self.editor.MakeIDSource([id1], SMESH.NODE)
- if isinstance( id2, int):
- if (isElem2):
+ # @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.Destroy()
return aMeasure
- # @param IDsOfElements is a list of ids of elements or nodes
+ ## 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 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 Measure structure
- def GetBoundingBox(self, IDs = None, isElem=True):
- if isinstance( IDs, Mesh ):
- IDs = [ IDs.mesh ]
- elif (IDs == None):
- IDs = [ self.mesh ]
- elif isinstance( IDs, int):
- if (isElem):
- IDs = [ self.editor.MakeIDSource(IDs, SMESH.FACE) ]
- else:
- IDs = [ self.editor.MakeIDSource(IDs, SMESH.NODE) ]
- elif isinstance( IDs, list ) and isinstance( IDs[0], int):
- if (isElem):
- IDs = [ self.editor.MakeIDSource(IDs, SMESH.FACE) ]
- else:
- IDs = [ self.editor.MakeIDSource(IDs, SMESH.NODE) ]
- elif hasattr(IDs, "_narrow"):
- anIDs = IDs._narrow(SMESH.SMESH_IDSource)
- if (anIDs):
- IDs = [ anIDs ]
-
- aMeasure = None
- if isinstance(IDs, list):
- aMeasurements = self.smeshpyD.CreateMeasurements()
- aMeasure = aMeasurements.BoundingBox(IDs)
- aMeasurements.Destroy()
-
+ # @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.Destroy()
return aMeasure
# Mesh edition (SMESH_MeshEditor functionality):
## Generates new elements by extrusion of the elements with given ids
# @param IDsOfElements the list of elements ids for extrusion
- # @param StepVector vector, defining the direction and value of extrusion
+ # @param StepVector vector or DirStruct, defining the direction and value of extrusion
# @param NbOfSteps the number of steps
# @param MakeGroups forces the generation of new groups from existing ones
# @return the list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise
pass
self.mesh.smeshpyD.SetName(hypo, hyp + a)
pass
+ geomName=""
+ if self.geom:
+ geomName = GetName(self.geom)
status = self.mesh.mesh.AddHypothesis(self.geom, hypo)
- TreatHypoStatus( status, GetName(hypo), GetName(self.geom), 0 )
+ TreatHypoStatus( status, GetName(hypo), geomName, 0 )
return hypo
## Returns entry of the shape to mesh in the study
self.Parameters().SetOptionValue(optionName,level)
## Sets QuadAllowed flag.
- # Only for algoType == NETGEN || NETGEN_2D || BLSURF
+ # Only for algoType == NETGEN(NETGEN_1D2D) || NETGEN_2D || BLSURF
# @ingroup l3_hypos_netgen l3_hypos_blsurf
def SetQuadAllowed(self, toAllow=True):
if self.algoType == NETGEN_2D:
- if toAllow: # add QuadranglePreference
- self.Hypothesis("QuadranglePreference", UseExisting=1, CompareMethod=self.CompareEqualHyp)
- else: # remove QuadranglePreference
+ if not self.params:
+ # use simple hyps
+ hasSimpleHyps = False
+ simpleHyps = ["QuadranglePreference","LengthFromEdges","MaxElementArea"]
for hyp in self.mesh.GetHypothesisList( self.geom ):
- if hyp.GetName() == "QuadranglePreference":
- self.mesh.RemoveHypothesis( self.geom, hyp )
+ if hyp.GetName() in simpleHyps:
+ hasSimpleHyps = True
+ if hyp.GetName() == "QuadranglePreference":
+ if not toAllow: # remove QuadranglePreference
+ self.mesh.RemoveHypothesis( self.geom, hyp )
+ pass
+ return
pass
pass
+ if hasSimpleHyps:
+ if toAllow: # add QuadranglePreference
+ self.Hypothesis("QuadranglePreference", UseExisting=1, CompareMethod=self.CompareEqualHyp)
+ pass
+ return
pass
- return
+ pass
if self.Parameters():
self.params.SetQuadAllowed(toAllow)
return
#
# @ingroup l3_hypos_netgen
def Parameters(self, which=SOLE):
- if self.params:
- return self.params
- if self.algoType == NETGEN:
- if which == SIMPLE:
- self.params = self.Hypothesis("NETGEN_SimpleParameters_2D", [],
+ if not self.params:
+ if self.algoType == NETGEN:
+ if which == SIMPLE:
+ self.params = self.Hypothesis("NETGEN_SimpleParameters_2D", [],
+ "libNETGENEngine.so", UseExisting=0)
+ else:
+ self.params = self.Hypothesis("NETGEN_Parameters_2D", [],
+ "libNETGENEngine.so", UseExisting=0)
+ elif self.algoType == MEFISTO:
+ print "Mefisto algo support no multi-parameter hypothesis"
+ elif self.algoType == NETGEN_2D:
+ self.params = self.Hypothesis("NETGEN_Parameters_2D_ONLY", [],
"libNETGENEngine.so", UseExisting=0)
+ elif self.algoType == BLSURF:
+ self.params = self.Hypothesis("BLSURF_Parameters", [],
+ "libBLSURFEngine.so", UseExisting=0)
else:
- self.params = self.Hypothesis("NETGEN_Parameters_2D", [],
- "libNETGENEngine.so", UseExisting=0)
- return self.params
- elif self.algoType == MEFISTO:
- print "Mefisto algo support no multi-parameter hypothesis"
- return None
- elif self.algoType == NETGEN_2D:
- print "NETGEN_2D_ONLY algo support no multi-parameter hypothesis"
- print "NETGEN_2D_ONLY uses 'MaxElementArea' and 'LengthFromEdges' ones"
- return None
- elif self.algoType == BLSURF:
- self.params = self.Hypothesis("BLSURF_Parameters", [],
- "libBLSURFEngine.so", UseExisting=0)
- return self.params
- else:
- print "Mesh_Triangle with algo type %s does not have such a parameter, check algo type"%self.algoType
- return None
+ print "Mesh_Triangle with algo type %s does not have such a parameter, check algo type"%self.algoType
+ return self.params
## Sets MaxSize
#
#
# @ingroup l3_hypos_netgen
def Parameters(self, which=SOLE):
- if self.params:
- return self.params
+ if not self.params:
- if self.algoType == FULL_NETGEN:
- if which == SIMPLE:
- self.params = self.Hypothesis("NETGEN_SimpleParameters_3D", [],
- "libNETGENEngine.so", UseExisting=0)
- else:
- self.params = self.Hypothesis("NETGEN_Parameters", [],
+ if self.algoType == FULL_NETGEN:
+ if which == SIMPLE:
+ self.params = self.Hypothesis("NETGEN_SimpleParameters_3D", [],
+ "libNETGENEngine.so", UseExisting=0)
+ else:
+ self.params = self.Hypothesis("NETGEN_Parameters", [],
+ "libNETGENEngine.so", UseExisting=0)
+
+ if self.algoType == NETGEN:
+ self.params = self.Hypothesis("NETGEN_Parameters_3D", [],
"libNETGENEngine.so", UseExisting=0)
- return self.params
- if self.algoType == GHS3D:
- self.params = self.Hypothesis("GHS3D_Parameters", [],
- "libGHS3DEngine.so", UseExisting=0)
- return self.params
+ elif self.algoType == GHS3D:
+ self.params = self.Hypothesis("GHS3D_Parameters", [],
+ "libGHS3DEngine.so", UseExisting=0)
- if self.algoType == GHS3DPRL:
- self.params = self.Hypothesis("GHS3DPRL_Parameters", [],
- "libGHS3DPRLEngine.so", UseExisting=0)
- return self.params
+ elif self.algoType == GHS3DPRL:
+ self.params = self.Hypothesis("GHS3DPRL_Parameters", [],
+ "libGHS3DPRLEngine.so", UseExisting=0)
+ else:
+ print "Algo supports no multi-parameter hypothesis"
- print "Algo supports no multi-parameter hypothesis"
- return None
+ return self.params
## Sets MaxSize
- # Parameter of FULL_NETGEN
+ # Parameter of FULL_NETGEN and NETGEN
# @ingroup l3_hypos_netgen
def SetMaxSize(self, theSize):
self.Parameters().SetMaxSize(theSize)
self.Parameters().SetSecondOrder(theVal)
## Sets Optimize flag
- # Parameter of FULL_NETGEN
+ # Parameter of FULL_NETGEN and NETGEN
# @ingroup l3_hypos_netgen
def SetOptimize(self, theVal):
self.Parameters().SetOptimize(theVal)
return hyp
+# Public class: Mesh_UseExistingElements
+# --------------------------------------
+## Defines a Radial Quadrangle 1D2D algorithm
+# @ingroup l3_algos_basic
+#
+class Mesh_UseExistingElements(Mesh_Algorithm):
+
+ def __init__(self, dim, mesh, geom=0):
+ if dim == 1:
+ self.Create(mesh, geom, "Import_1D")
+ else:
+ self.Create(mesh, geom, "Import_1D2D")
+ return
+
+ ## 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):
+ if self.algo.GetName() == "Import_2D":
+ raise ValueError, "algoritm dimension mismatch"
+ hyp = self.Hypothesis("ImportSource1D", [groups, toCopyMesh, toCopyGroups],
+ UseExisting=UseExisting, CompareMethod=self._compareHyp)
+ hyp.SetSourceEdges(groups)
+ hyp.SetCopySourceMesh(toCopyMesh, toCopyGroups)
+ return hyp
+
+ ## 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):
+ if self.algo.GetName() == "Import_1D":
+ raise ValueError, "algoritm dimension mismatch"
+ hyp = self.Hypothesis("ImportSource2D", [groups, toCopyMesh, toCopyGroups],
+ UseExisting=UseExisting, CompareMethod=self._compareHyp)
+ hyp.SetSourceFaces(groups)
+ hyp.SetCopySourceMesh(toCopyMesh, toCopyGroups)
+ return hyp
+
+ def _compareHyp(self,hyp,args):
+ if hasattr( hyp, "GetSourceEdges"):
+ entries = hyp.GetSourceEdges()
+ else:
+ entries = hyp.GetSourceFaces()
+ groups = args[0]
+ toCopyMesh,toCopyGroups = hyp.GetCopySourceMesh()
+ if len(entries)==len(groups) and toCopyMesh==args[1] and toCopyGroups==args[2]:
+ entries2 = []
+ study = self.mesh.smeshpyD.GetCurrentStudy()
+ if study:
+ for g in groups:
+ ior = salome.orb.object_to_string(g)
+ sobj = study.FindObjectIOR(ior)
+ if sobj: entries2.append( sobj.GetID() )
+ pass
+ pass
+ entries.sort()
+ entries2.sort()
+ return entries == entries2
+ return False
+
+
# Private class: Mesh_UseExisting
# -------------------------------
class Mesh_UseExisting(Mesh_Algorithm):