# -*- coding: iso-8859-1 -*-
-# Copyright (C) 2007-2008 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
+# Copyright (C) 2007-2010 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
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
+
# File : smesh.py
# Author : Francis KLOSS, OCC
# Module : SMESH
Hexotic = 9
BLSURF = 10
GHS3DPRL = 11
-QUARDANGLE = 0
+QUADRANGLE = 0
RADIAL_QUAD = 1
# MirrorType enumeration
PrecisionConfusion = 1e-07
+# TopAbs_State enumeration
+[TopAbs_IN, TopAbs_OUT, TopAbs_ON, TopAbs_UNKNOWN] = range(4)
+
+
## Converts an angle from degrees to radians
def DegreesToRadians(AngleInDegrees):
from math import pi
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"
# 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)
- # @param algo values are: smesh.QUARDANGLE || smesh.RADIAL_QUAD
+ # @param algo values are: smesh.QUADRANGLE || smesh.RADIAL_QUAD
# @return an instance of Mesh_Quadrangle algorithm
# @ingroup l3_algos_basic
- def Quadrangle(self, geom=0, algo=QUARDANGLE):
+ def Quadrangle(self, geom=0, algo=QUADRANGLE):
if algo==RADIAL_QUAD:
return Mesh_RadialQuadrangle1D2D(self,geom)
else:
## Computes the mesh and returns the status of the computation
+ # @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):
+ def Compute(self, geom=0, discardModifs=False):
if geom == 0 or not isinstance(geom, geompyDC.GEOM._objref_GEOM_Object):
if self.geom == 0:
geom = self.mesh.GetShapeToMesh()
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 "Mesh computation failed, exception caught:"
traceback.print_exc()
if True:#not ok:
- errors = self.smeshpyD.GetAlgoState( self.mesh, geom )
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( geompyDC.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
+ "SALOME exception", #COMPERR_SLM_EXCEPTION
+ "Unknown exception", #COMPERR_EXCEPTION
+ "Memory allocation problem", #COMPERR_MEMORY_PB
+ "Algorithm failed", #COMPERR_ALGO_FAILED
+ "Unexpected geometry"]#COMPERR_BAD_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"
reason = "For unknown reason."+\
" Revise Mesh.Compute() implementation in smeshDC.py!"
pass
- if allReasons != "":
- allReasons += "\n"
- pass
+ if allReasons != "":allReasons += "\n"
allReasons += reason
pass
if allReasons != "":
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(subshape) IOR
# Shape must be the subshape of a ShapeToMesh()
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):
def FindElementsByPoint(self, x, y, z, elementType = SMESH.ALL):
return self.editor.FindElementsByPoint(x, y, z, elementType)
+ # Return point state in a closed 2D mesh in terms of TopAbs_State enumeration.
+ # 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
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:
+ # 1 - split the hexahedron into 5 tetrahedrons
+ # 2 - split the hexahedron into 6 tetrahedrons
+ # @ingroup l2_modif_cutquadr
+ def SplitVolumesIntoTetra(self, elemIDs, method=1 ):
+ if isinstance( elemIDs, Mesh ):
+ elemIDs = elemIDs.GetMesh()
+ self.editor.SplitVolumesIntoTetra(elemIDs, method)
+
## Splits quadrangle faces near triangular facets of volumes
#
# @ingroup l1_auxiliary
mesh.SetParameters(Parameters)
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 - 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.editor.MakeIDSource(theObject)
+
+ thePoint, Parameters = ParsePointStruct(thePoint)
+ self.mesh.SetParameters(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 - 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.editor.MakeIDSource(theObject)
+
+ mesh = self.editor.ScaleMakeMesh(theObject, thePoint, theScaleFact,
+ MakeGroups, NewMeshName)
+ #mesh.SetParameters(Parameters)
+ 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)
## 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 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
# 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_additi
def TriangleVertex(self, vertex, UseExisting=0):