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 subshape, nor a valid group"
+ 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:
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):
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
# @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 Treshold the threshold value (range of ids as string, shape, numeric)
+ # @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)
def GetCriterion(self,elementType,
CritType,
Compare = FT_EqualTo,
- Treshold="",
+ Threshold="",
UnaryOp=FT_Undefined,
BinaryOp=FT_Undefined,
Tolerance=1e-07):
aCriterion.Type = self.EnumToLong(CritType)
aCriterion.Tolerance = Tolerance
- aTreshold = Treshold
+ aThreshold = Threshold
if Compare in [FT_LessThan, FT_MoreThan, FT_EqualTo]:
aCriterion.Compare = self.EnumToLong(Compare)
aCriterion.Compare = self.EnumToLong(FT_MoreThan)
elif Compare != FT_Undefined:
aCriterion.Compare = self.EnumToLong(FT_EqualTo)
- aTreshold = Compare
+ aThreshold = Compare
if CritType in [FT_BelongToGeom, FT_BelongToPlane, FT_BelongToGenSurface,
FT_BelongToCylinder, FT_LyingOnGeom]:
- # Checks the treshold
- if isinstance(aTreshold, geompyDC.GEOM._objref_GEOM_Object):
- aCriterion.ThresholdStr = GetName(aTreshold)
- aCriterion.ThresholdID = salome.ObjectToID(aTreshold)
+ # Checks the Threshold
+ if isinstance(aThreshold, geompyDC.GEOM._objref_GEOM_Object):
+ aCriterion.ThresholdStr = GetName(aThreshold)
+ aCriterion.ThresholdID = salome.ObjectToID(aThreshold)
else:
- print "Error: The treshold should be a shape."
+ 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 the treshold
- if isinstance(aTreshold, str):
- aCriterion.ThresholdStr = aTreshold
+ # Checks the Threshold
+ if isinstance(aThreshold, str):
+ aCriterion.ThresholdStr = aThreshold
else:
- print "Error: The treshold should be a string."
+ print "Error: The Threshold should be a string."
return None
elif CritType == FT_CoplanarFaces:
- # Checks the treshold
- if isinstance(aTreshold, int):
- aCriterion.ThresholdID = "%s"%aTreshold
- elif isinstance(aTreshold, str):
- ID = int(aTreshold)
+ # Checks the Threshold
+ if isinstance(aThreshold, int):
+ aCriterion.ThresholdID = "%s"%aThreshold
+ elif isinstance(aThreshold, str):
+ ID = int(aThreshold)
if ID < 1:
- raise ValueError, "Invalid ID of mesh face: '%s'"%aTreshold
- aCriterion.ThresholdID = aTreshold
+ raise ValueError, "Invalid ID of mesh face: '%s'"%aThreshold
+ aCriterion.ThresholdID = aThreshold
else:
raise ValueError,\
- "The treshold should be an ID of mesh face and not '%s'"%aTreshold
+ "The Threshold should be an ID of mesh face and not '%s'"%aThreshold
elif CritType == FT_ElemGeomType:
- # Checks the treshold
+ # Checks the Threshold
try:
- aCriterion.Threshold = self.EnumToLong(aTreshold)
- assert( aTreshold in SMESH.GeometryType._items )
+ aCriterion.Threshold = self.EnumToLong(aThreshold)
+ assert( aThreshold in SMESH.GeometryType._items )
except:
- if isinstance(aTreshold, int):
- aCriterion.Threshold = aTreshold
+ if isinstance(aThreshold, int):
+ aCriterion.Threshold = aThreshold
else:
- print "Error: The treshold should be an integer or SMESH.GeometryType."
+ print "Error: The Threshold should be an integer or SMESH.GeometryType."
return None
pass
pass
elif CritType == FT_GroupColor:
- # Checks the treshold
+ # Checks the Threshold
try:
- aCriterion.ThresholdStr = self.ColorToString(aTreshold)
+ 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_BadOrientedVolume, FT_FreeNodes,
- FT_FreeFaces, FT_LinearOrQuadratic,
+ elif CritType in [FT_FreeBorders, FT_FreeEdges, FT_FreeNodes, FT_FreeFaces,
+ FT_LinearOrQuadratic, FT_BadOrientedVolume,
FT_BareBorderFace, FT_BareBorderVolume,
- FT_OverConstrainedFace, FT_OverConstrainedVolume]:
- # At this point the treshold is unnecessary
- if aTreshold == FT_LogicalNOT:
+ 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 aTreshold in [FT_LogicalAND, FT_LogicalOR]:
- aCriterion.BinaryOp = aTreshold
+ elif aThreshold in [FT_LogicalAND, FT_LogicalOR]:
+ aCriterion.BinaryOp = aThreshold
else:
- # Check treshold
+ # Check Threshold
try:
- aTreshold = float(aTreshold)
- aCriterion.Threshold = aTreshold
+ aThreshold = float(aThreshold)
+ aCriterion.Threshold = aThreshold
except:
- print "Error: The treshold should be a number."
+ print "Error: The Threshold should be a number."
return None
- if Treshold == FT_LogicalNOT or UnaryOp == FT_LogicalNOT:
+ if Threshold == FT_LogicalNOT or UnaryOp == FT_LogicalNOT:
aCriterion.UnaryOp = self.EnumToLong(FT_LogicalNOT)
- if Treshold in [FT_LogicalAND, FT_LogicalOR]:
- aCriterion.BinaryOp = self.EnumToLong(Treshold)
+ if Threshold in [FT_LogicalAND, FT_LogicalOR]:
+ aCriterion.BinaryOp = self.EnumToLong(Threshold)
if UnaryOp in [FT_LogicalAND, FT_LogicalOR]:
aCriterion.BinaryOp = self.EnumToLong(UnaryOp)
# @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 Treshold the threshold value (range of id ids as string, shape, numeric)
+ # @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
+ # FT_LyingOnGeom, FT_CoplanarFaces and FT_EqualNodes criteria
# @return SMESH_Filter
#
# <a href="../tui_filters_page.html#tui_filters">Example of Filters usage</a>
def GetFilter(self,elementType,
CritType=FT_Undefined,
Compare=FT_EqualTo,
- Treshold="",
+ Threshold="",
UnaryOp=FT_Undefined,
Tolerance=1e-07):
- aCriterion = self.GetCriterion(elementType, CritType, Compare, Treshold, UnaryOp, FT_Undefined,Tolerance)
+ aCriterion = self.GetCriterion(elementType, CritType, Compare, Threshold, UnaryOp, FT_Undefined,Tolerance)
aFilterMgr = self.CreateFilterManager()
aFilter = aFilterMgr.CreateFilter()
aCriteria = []
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 subshape of a mesh shape
+ # @param theSubObject a sub-shape of a mesh shape
# @return True or False
# @ingroup l2_construct
def IsReadyToCompute(self, theSubObject):
## Returns errors of hypotheses definition.
# The list of errors is empty if everything is OK.
- # @param theSubObject a subshape of a mesh shape
+ # @param theSubObject a sub-shape of a mesh shape
# @return a list of errors
# @ingroup l2_construct
def GetAlgoState(self, theSubObject):
## Creates a segment discretization 1D algorithm.
# If the optional \a algo parameter is not set, this algorithm is REGULAR.
# \n If the optional \a geom parameter is not set, this algorithm is global.
- # Otherwise, this algorithm defines a submesh based on \a geom subshape.
+ # Otherwise, this algorithm defines a submesh based on \a geom sub-shape.
# @param algo the type of the required algorithm. Possible values are:
# - smesh.REGULAR,
# - smesh.PYTHON for discretization via a python function,
# - smesh.COMPOSITE for meshing a set of edges on one face side as a whole.
- # @param geom If defined is the subshape to be meshed
+ # @param geom If defined is the sub-shape to be meshed
# @return an instance of Mesh_Segment or Mesh_Segment_Python, or Mesh_CompositeSegment class
# @ingroup l3_algos_basic
def Segment(self, algo=REGULAR, geom=0):
## 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.
+ # Otherwise, this algorithm defines a submesh based on \a geom sub-shape.
# @param geom If defined the subshape is to be meshed
# @return an instance of Mesh_UseExistingElements class
# @ingroup l3_algos_basic
## 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
+ # @param geom If defined the sub-shape is to be meshed
# @return an instance of Mesh_UseExistingElements class
# @ingroup l3_algos_basic
def UseExisting2DElements(self, geom=0):
# The added nodes and segments must be bound to edges and vertices by
# SetNodeOnVertex(), SetNodeOnEdge() and SetMeshElementOnShape()
# If the optional \a geom parameter is not set, this algorithm is global.
- # \n Otherwise, this algorithm defines a submesh based on \a geom subshape.
- # @param geom the subshape to be manually meshed
+ # \n Otherwise, this algorithm defines a submesh based on \a geom sub-shape.
+ # @param geom the sub-shape to be manually meshed
# @return StdMeshers_UseExisting_1D algorithm that generates nothing
# @ingroup l3_algos_basic
def UseExistingSegments(self, geom=0):
# The added nodes and faces must be bound to geom faces by SetNodeOnFace()
# and SetMeshElementOnShape()
# If the optional \a geom parameter is not set, this algorithm is global.
- # \n Otherwise, this algorithm defines a submesh based on \a geom subshape.
- # @param geom the subshape to be manually meshed
+ # \n Otherwise, this algorithm defines a submesh based on \a geom sub-shape.
+ # @param geom the sub-shape to be manually meshed
# @return StdMeshers_UseExisting_2D algorithm that generates nothing
# @ingroup l3_algos_basic
def UseExistingFaces(self, geom=0):
## Creates a triangle 2D algorithm for faces.
# If the optional \a geom parameter is not set, this algorithm is global.
- # \n Otherwise, this algorithm defines a submesh based on \a geom subshape.
+ # \n Otherwise, this algorithm defines a submesh based on \a geom sub-shape.
# @param algo values are: smesh.MEFISTO || smesh.NETGEN_1D2D || smesh.NETGEN_2D || smesh.BLSURF
- # @param geom If defined, the subshape to be meshed (GEOM_Object)
+ # @param geom If defined, the sub-shape to be meshed (GEOM_Object)
# @return an instance of Mesh_Triangle algorithm
# @ingroup l3_algos_basic
def Triangle(self, algo=MEFISTO, geom=0):
## Creates a quadrangle 2D algorithm for faces.
# If the optional \a geom parameter is not set, this algorithm is global.
- # \n Otherwise, this algorithm defines a submesh based on \a geom subshape.
- # @param geom If defined, the subshape to be meshed (GEOM_Object)
+ # \n Otherwise, this algorithm defines a submesh based on \a geom sub-shape.
+ # @param geom If defined, the sub-shape to be meshed (GEOM_Object)
# @param algo values are: smesh.QUADRANGLE || smesh.RADIAL_QUAD
# @return an instance of Mesh_Quadrangle algorithm
# @ingroup l3_algos_basic
## Creates a tetrahedron 3D algorithm for solids.
# The parameter \a algo permits to choose the algorithm: NETGEN or GHS3D
# If the optional \a geom parameter is not set, this algorithm is global.
- # \n Otherwise, this algorithm defines a submesh based on \a geom subshape.
+ # \n Otherwise, this algorithm defines a submesh based on \a geom sub-shape.
# @param algo values are: smesh.NETGEN, smesh.GHS3D, smesh.GHS3DPRL, smesh.FULL_NETGEN
- # @param geom If defined, the subshape to be meshed (GEOM_Object)
+ # @param geom If defined, the sub-shape to be meshed (GEOM_Object)
# @return an instance of Mesh_Tetrahedron algorithm
# @ingroup l3_algos_basic
def Tetrahedron(self, algo=NETGEN, geom=0):
## Creates a hexahedron 3D algorithm for solids.
# If the optional \a geom parameter is not set, this algorithm is global.
- # \n Otherwise, this algorithm defines a submesh based on \a geom subshape.
+ # \n Otherwise, this algorithm defines a submesh based on \a geom sub-shape.
# @param algo possible values are: smesh.Hexa, smesh.Hexotic
- # @param geom If defined, the subshape to be meshed (GEOM_Object)
+ # @param geom If defined, the sub-shape to be meshed (GEOM_Object)
# @return an instance of Mesh_Hexahedron algorithm
# @ingroup l3_algos_basic
def Hexahedron(self, algo=Hexa, geom=0):
## Creates a projection 1D algorithm for edges.
# 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 to be meshed
+ # Otherwise, this algorithm defines a submesh based on \a geom sub-shape.
+ # @param geom If defined, the sub-shape to be meshed
# @return an instance of Mesh_Projection1D algorithm
# @ingroup l3_algos_proj
def Projection1D(self, geom=0):
return Mesh_Projection1D(self, geom)
+ ## Creates a projection 1D-2D algorithm for faces.
+ # If the optional \a geom parameter is not set, this algorithm is global.
+ # Otherwise, this algorithm defines a submesh based on \a geom sub-shape.
+ # @param geom If defined, the sub-shape to be meshed
+ # @return an instance of Mesh_Projection2D algorithm
+ # @ingroup l3_algos_proj
+ def Projection1D2D(self, geom=0):
+ return Mesh_Projection2D(self, geom, "Projection_1D2D")
+
## Creates a projection 2D algorithm for faces.
# 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 to be meshed
+ # Otherwise, this algorithm defines a submesh based on \a geom sub-shape.
+ # @param geom If defined, the sub-shape to be meshed
# @return an instance of Mesh_Projection2D algorithm
# @ingroup l3_algos_proj
def Projection2D(self, geom=0):
- return Mesh_Projection2D(self, geom)
+ return Mesh_Projection2D(self, geom, "Projection_2D")
## Creates a projection 3D algorithm for solids.
# 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 to be meshed
+ # Otherwise, this algorithm defines a submesh based on \a geom sub-shape.
+ # @param geom If defined, the sub-shape to be meshed
# @return an instance of Mesh_Projection3D algorithm
# @ingroup l3_algos_proj
def Projection3D(self, geom=0):
## Creates a 3D extrusion (Prism 3D) or RadialPrism 3D algorithm for solids.
# 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 to be meshed
+ # Otherwise, this algorithm defines a submesh based on \a geom sub-shape.
+ # @param geom If defined, the sub-shape to be meshed
# @return an instance of Mesh_Prism3D or Mesh_RadialPrism3D algorithm
# @ingroup l3_algos_radialp l3_algos_3dextr
def Prism(self, geom=0):
return Mesh_Prism3D(self, geom)
return Mesh_RadialPrism3D(self, geom)
+ ## Creates a "Body Fitted" 3D algorithm for solids, which generates
+ # 3D structured Cartesian mesh in the internal part of a solid shape
+ # and polyhedral volumes near the shape boundary.
+ # If the optional \a geom parameter is not set, this algorithm is global.
+ # Otherwise, this algorithm defines a submesh based on \a geom sub-shape.
+ # The algorithm does not support submeshes.
+ # Generally usage of this algorithm as a local one is useless since
+ # it does not discretize 1D and 2D sub-shapes in a usual way acceptable
+ # for other algorithms.
+ # @param geom If defined, the sub-shape to be meshed
+ # @return an instance of Mesh_Cartesian_3D algorithm
+ # @ingroup l3_algos_basic
+ def BodyFitted(self, geom=0):
+ return Mesh_Cartesian_3D(self, geom)
+
## 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
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 subshape of mesh geometry
+ # @param geom a sub-shape of mesh geometry
# @return SMESH.Hypothesis_Status
# @ingroup l2_hypotheses
def RemoveHypothesis(self, hyp, geom=0):
return status
## Gets the list of hypotheses added on a geometry
- # @param geom a subshape of mesh geometry
+ # @param geom a sub-shape of mesh geometry
# @return the sequence of SMESH_Hypothesis
# @ingroup l2_hypotheses
def GetHypothesisList(self, geom):
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
# @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 Treshold the threshold value (range of id ids as string, shape, numeric)
+ # @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
elementType,
CritType=FT_Undefined,
Compare=FT_EqualTo,
- Treshold="",
+ Threshold="",
UnaryOp=FT_Undefined,
Tolerance=1e-07):
- aCriterion = self.smeshpyD.GetCriterion(elementType, CritType, Compare, Treshold, UnaryOp, FT_Undefined,Tolerance)
+ aCriterion = self.smeshpyD.GetCriterion(elementType, CritType, Compare, Threshold, UnaryOp, FT_Undefined,Tolerance)
group = self.MakeGroupByCriterion(groupName, aCriterion)
return group
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 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 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
return self.mesh.GetElementGeomType(id)
## Returns the list of submesh elements IDs
- # @param Shape a geom object(subshape) IOR
- # Shape must be the subshape of a ShapeToMesh()
+ # @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):
return self.mesh.GetSubMeshElementsId(ShapeID)
## Returns the list of submesh nodes IDs
- # @param Shape a geom object(subshape) IOR
- # Shape must be the subshape of a ShapeToMesh()
+ # @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
return self.mesh.GetSubMeshNodesId(ShapeID, all)
## Returns type of elements on given shape
- # @param Shape a geom object(subshape) IOR
- # Shape must be a subshape of a ShapeToMesh()
+ # @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):
# @param StepVector vector or DirStruct, 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):
+ def ExtrusionSweep(self, IDsOfElements, StepVector, NbOfSteps, MakeGroups=False, IsNodes = False):
if IDsOfElements == []:
IDsOfElements = self.GetElementsId()
if ( isinstance( StepVector, geompyDC.GEOM._objref_GEOM_Object)):
Parameters = StepVectorParameters + var_separator + Parameters
self.mesh.SetParameters(Parameters)
if MakeGroups:
- return self.editor.ExtrusionSweepMakeGroups(IDsOfElements, StepVector, NbOfSteps)
- self.editor.ExtrusionSweep(IDsOfElements, StepVector, NbOfSteps)
+ 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 StepVector vector, 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):
+ def ExtrusionSweepObject(self, theObject, StepVector, NbOfSteps, MakeGroups=False, IsNodes=False):
if ( isinstance( theObject, Mesh )):
theObject = theObject.GetMesh()
if ( isinstance( StepVector, geompyDC.GEOM._objref_GEOM_Object)):
Parameters = StepVectorParameters + var_separator + Parameters
self.mesh.SetParameters(Parameters)
if MakeGroups:
- return self.editor.ExtrusionSweepObjectMakeGroups(theObject, StepVector, NbOfSteps)
- self.editor.ExtrusionSweepObject(theObject, StepVector, NbOfSteps)
+ 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
hypo = self.mesh.smeshpyD.CreateHypothesis(hyp, so)
a = ""
s = "="
- i = 0
- n = len(args)
- while i<n:
- a = a + s + str(args[i])
+ for arg in args:
+ argStr = str(arg)
+ if isinstance( arg, geompyDC.GEOM._objref_GEOM_Object ):
+ argStr = arg.GetStudyEntry()
+ if not argStr: argStr = "GEOM_Obj_%s", arg.GetEntry()
+ if len( argStr ) > 10:
+ argStr = argStr[:7]+"..."
+ if argStr[0] == '[': argStr += ']'
+ a = a + s + argStr
s = ","
- i = i + 1
pass
+ if len(a) > 50:
+ a = a[:47]+"..."
self.mesh.smeshpyD.SetName(hypo, hyp + a)
pass
geomName=""
## Transform a list of ether edges or tuples (edge 1st_vertex_of_edge)
# into a list acceptable to SetReversedEdges() of some 1D hypotheses
- # @ingroupl3_hypos_1dhyps
+ # @ingroup l3_hypos_1dhyps
def ReversedEdgeIndices(self, reverseList):
resList = []
geompy = self.mesh.geompyD
## Sets topology usage way.
# @param way defines how mesh conformity is assured <ul>
# <li>FromCAD - mesh conformity is assured by conformity of a shape</li>
- # <li>PreProcess or PreProcessPlus - by pre-processing a CAD model</li></ul>
+ # <li>PreProcess or PreProcessPlus - by pre-processing a CAD model</li>
# <li>PreCAD - by pre-processing with PreCAD a CAD model</li></ul>
# @ingroup l3_hypos_blsurf
def SetTopology(self, way):
AssureGeomPublished( self.mesh, theFace )
return self.params.UnsetEnforcedVertices(theFace)
+ ## To tell BLSURF to add a node on internal vertices
+ # @param toEnforceInternalVertices : boolean; if True the internal vertices are added as enforced vertices
+ # @ingroup l3_hypos_blsurf
+ def SetInternalEnforcedVertexAllFaces(self, toEnforceInternalVertices):
+ if self.Parameters():
+ # Parameter of BLSURF algo
+ return self.params.SetInternalEnforcedVertexAllFaces(toEnforceInternalVertices)
+
+ ## To know if BLSURF will add a node on internal vertices
+ # @ingroup l3_hypos_blsurf
+ def GetInternalEnforcedVertexAllFaces(self):
+ if self.Parameters():
+ # Parameter of BLSURF algo
+ return self.params.GetInternalEnforcedVertexAllFaces()
+
+ ## To define a group for the nodes of internal vertices
+ # @param groupName : string; name of the group
+ # @ingroup l3_hypos_blsurf
+ def SetInternalEnforcedVertexAllFacesGroup(self, groupName):
+ if self.Parameters():
+ # Parameter of BLSURF algo
+ return self.params.SetInternalEnforcedVertexAllFacesGroup(groupName)
+
+ ## To get the group name of the nodes of internal vertices
+ # @ingroup l3_hypos_blsurf
+ def GetInternalEnforcedVertexAllFacesGroup(self):
+ if self.Parameters():
+ # Parameter of BLSURF algo
+ return self.params.GetInternalEnforcedVertexAllFacesGroup()
+
## Attractors (BLSURF)
## Sets an attractor on the chosen face. The mesh size will decrease exponentially with the distance from theAttractor, following the rule h(d) = theEndSize - (theEndSize - theStartSize) * exp [ - ( d / theInfluenceDistance ) ^ 2 ]
UseExisting=0)
#UseExisting=UseExisting, CompareMethod=self.CompareSourceEdge)
hyp.SetSourceEdge( edge )
- if not mesh is None and isinstance(mesh, Mesh):
+ if isinstance(mesh, Mesh):
mesh = mesh.GetMesh()
hyp.SetSourceMesh( mesh )
hyp.SetVertexAssociation( srcV, tgtV )
class Mesh_Projection2D(Mesh_Algorithm):
## Private constructor.
- def __init__(self, mesh, geom=0):
+ def __init__(self, mesh, geom=0, algoName="Projection_2D"):
Mesh_Algorithm.__init__(self)
- self.Create(mesh, geom, "Projection_2D")
+ self.Create(mesh, geom, algoName)
## Defines "Source Face" hypothesis, specifying a meshed face, from where
# a mesh pattern is taken, and, optionally, the association of vertices
UseExisting=0)
#UseExisting=UseExisting, CompareMethod=self.CompareSourceShape3D)
hyp.SetSource3DShape( solid )
- if not mesh is None and isinstance(mesh, Mesh):
+ if isinstance(mesh, Mesh):
mesh = mesh.GetMesh()
hyp.SetSourceMesh( mesh )
if srcV1 and srcV2 and tgtV1 and tgtV2:
# @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":
+ if self.algo.GetName() != "Import_1D":
raise ValueError, "algoritm dimension mismatch"
for group in groups:
AssureGeomPublished( self.mesh, group )
return entries == entries2
return False
+# Public class: Mesh_Cartesian_3D
+# --------------------------------------
+## Defines a Body Fitting 3D algorithm
+# @ingroup l3_algos_basic
+#
+class Mesh_Cartesian_3D(Mesh_Algorithm):
+
+ def __init__(self, mesh, geom=0):
+ self.Create(mesh, geom, "Cartesian_3D")
+ self.hyp = None
+ return
+
+ ## 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:
+ self.hyp = self.Hypothesis("CartesianParameters3D",
+ [xGridDef, yGridDef, zGridDef, sizeThreshold],
+ UseExisting=UseExisting, CompareMethod=self._compareHyp)
+ 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
+
+ def _compareHyp(self,hyp,args):
+ # not implemented yet
+ return False
-# Private class: Mesh_UseExisting
+# Public class: Mesh_UseExisting
# -------------------------------
class Mesh_UseExisting(Mesh_Algorithm):
