# -*- 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
import StdMeshers
import SALOME
+import SALOMEDS
# import NETGENPlugin module if possible
noNETGENPlugin = 0
Hexotic = 9
BLSURF = 10
GHS3DPRL = 11
+QUADRANGLE = 0
+RADIAL_QUAD = 1
# MirrorType enumeration
POINT = SMESH_MeshEditor.POINT
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
## Gets object name
def GetName(obj):
- ior = salome.orb.object_to_string(obj)
- sobj = salome.myStudy.FindObjectIOR(ior)
- if sobj is None:
- return NO_NAME
- else:
- attr = sobj.FindAttribute("AttributeName")[1]
- return attr.Value()
+ if obj:
+ # object not null
+ if isinstance(obj, SALOMEDS._objref_SObject):
+ # study object
+ return obj.GetName()
+ ior = salome.orb.object_to_string(obj)
+ 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):
return
hypName = '"' + hypName + '"'
geomName= '"' + geomName+ '"'
- if status < HYP_UNKNOWN_FATAL:
+ if status < HYP_UNKNOWN_FATAL and not geomName =='""':
print hypName, "was assigned to", geomName,"but", reason
- else:
+ elif not geomName == '""':
print hypName, "was not assigned to",geomName,":", reason
+ else:
+ print hypName, "was not assigned:", reason
pass
## Check meshing plugin availability
if (isinstance(algo, geompyDC.GEOM._objref_GEOM_Object)):
geom = algo
algo = MEFISTO
-
return Mesh_Triangle(self, algo, geom)
## 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)
+ # @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):
- return Mesh_Quadrangle(self, geom)
+ def Quadrangle(self, geom=0, algo=QUADRANGLE):
+ if algo==RADIAL_QUAD:
+ return Mesh_RadialQuadrangle1D2D(self,geom)
+ else:
+ return Mesh_Quadrangle(self, geom)
## Creates a tetrahedron 3D algorithm for solids.
# The parameter \a algo permits to choose the algorithm: NETGEN or GHS3D
pass
status = self.mesh.AddHypothesis(geom, hyp)
isAlgo = hyp._narrow( SMESH_Algo )
- TreatHypoStatus( status, GetName( hyp ), GetName( geom ), isAlgo )
+ hyp_name = GetName( hyp )
+ geom_name = ""
+ if geom:
+ geom_name = GetName( geom )
+ TreatHypoStatus( status, hyp_name, geom_name, isAlgo )
return status
## Unassigns a hypothesis
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)
def GetLastCreatedElems(self):
return self.editor.GetLastCreatedElems()
- ## Creates a hole in a mesh by doubling the nodes of some particular elements
+ ## 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
# The replicated nodes should be associated to affected elements.
# @ingroup l2_modif_edit
def DoubleNodeElemGroupInRegion(self, theElems, theNodesNot, theShape):
- return self.editor.DoubleNodeElemGroup(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.
raise RuntimeError, "Attemp to create " + algo + " algoritm on None shape"
self.mesh = mesh
piece = mesh.geom
+ name = ""
if not geom:
self.geom = piece
else:
self.geom = geom
- name = GetName(geom)
- if name==NO_NAME:
+ try:
+ name = GetName(geom)
+ pass
+ except:
name = mesh.geompyD.SubShapeName(geom, piece)
mesh.geompyD.addToStudyInFather(piece, geom, name)
+ pass
self.subm = mesh.mesh.GetSubMesh(geom, algo.GetName())
self.algo = algo
status = mesh.mesh.AddHypothesis(self.geom, self.algo)
- TreatHypoStatus( status, algo.GetName(), GetName(self.geom), True )
+ TreatHypoStatus( status, algo.GetName(), name, True )
def CompareHyp (self, hyp, args):
print "CompareHyp is not implemented for ", self.__class__.__name__, ":", hyp.GetName()
def FixedPoints1D(self, points, nbSegs=[1], reversedEdges=[], UseExisting=0):
if not isinstance(reversedEdges,list): #old version script, before adding reversedEdges
reversedEdges, UseExisting = [], reversedEdges
+ if reversedEdges and isinstance( reversedEdges[0], geompyDC.GEOM._objref_GEOM_Object ):
+ for i in range( len( reversedEdges )):
+ reversedEdges[i] = self.mesh.geompyD.GetSubShapeID(self.mesh.geom, reversedEdges[i] )
entry = self.MainShapeEntry()
hyp = self.Hypothesis("FixedPoints1D", [points, nbSegs, reversedEdges, entry],
UseExisting=UseExisting,
- CompareMethod=self.CompareArithmetic1D)
+ CompareMethod=self.CompareFixedPoints1D)
hyp.SetPoints(points)
hyp.SetNbSegments(nbSegs)
hyp.SetReversedEdges(reversedEdges)
### 0D algorithm
if self.geom is None:
raise RuntimeError, "Attemp to create SegmentAroundVertex_0D algoritm on None shape"
- name = GetName(self.geom)
- if name == NO_NAME:
+ try:
+ name = GetName(self.geom)
+ pass
+ except:
piece = self.mesh.geom
name = self.mesh.geompyD.SubShapeName(self.geom, piece)
self.mesh.geompyD.addToStudyInFather(piece, self.geom, name)
+ pass
algo = self.FindAlgorithm("SegmentAroundVertex_0D", self.mesh.smeshpyD)
if algo is None:
algo = self.mesh.smeshpyD.CreateHypothesis("SegmentAroundVertex_0D", "libStdMeshersEngine.so")
CompareMethod=self.CompareEqualHyp)
return hyp
+ ## Defines "QuadrangleParams" hypothesis
+ # @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
+ #
+ # @ingroup l3_hypos_additi
+ def TriangleVertex(self, vertex, UseExisting=0):
+ vertexID = vertex
+ if isinstance( vertexID, geompyDC.GEOM._objref_GEOM_Object ):
+ vertexID = self.mesh.geompyD.GetSubShapeID( self.mesh.geom, vertex )
+ hyp = self.Hypothesis("QuadrangleParams", [vertexID], UseExisting = UseExisting,
+ CompareMethod=lambda hyp,args: hyp.GetTriaVertex()==args[0])
+ hyp.SetTriaVertex( vertexID )
+ return hyp
+
+
# Public class: Mesh_Tetrahedron
# ------------------------------
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 )
Mesh_Algorithm.__init__(self)
self.Create(mesh, geom, "RadialQuadrangle_1D2D")
- self.distribHyp = self.Hypothesis("LayerDistribution2D", UseExisting=0)
+ self.distribHyp = None #self.Hypothesis("LayerDistribution2D", UseExisting=0)
self.nbLayers = None
## Return 2D hypothesis holding the 1D one
# hypothesis. Returns the created hypothesis
def OwnHypothesis(self, hypType, args=[], so="libStdMeshersEngine.so"):
#print "OwnHypothesis",hypType
- if not self.nbLayers is None:
+ 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 "NumberOfLayers2D" hypothesis, specifying the number of layers
+ ## 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 NumberOfLayers2D(self, n, UseExisting=0):
- self.mesh.GetMesh().RemoveHypothesis( self.geom, self.distribHyp )
+ def NumberOfLayers(self, n, UseExisting=0):
+ if self.distribHyp:
+ self.mesh.GetMesh().RemoveHypothesis( self.geom, self.distribHyp )
self.nbLayers = self.Hypothesis("NumberOfLayers2D", [n], UseExisting=UseExisting,
CompareMethod=self.CompareNumberOfLayers)
self.nbLayers.SetNumberOfLayers( n )