ForkMaster/smesh
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/smesh.git synced 2024-12-26 09:20:34 +05:00
Code Issues Packages Projects Releases Wiki Activity

[PY3] Removing TAB issues

Browse Source 
Via this command :
find . -name "*.py" | xargs grep -Prl "\t" | xargs python  /local00/home/J42254/Projets/SALOME/Installations/prerequisites/src/Python-352-tcl8513-tk8513/Tools/scripts/reindent.py
This commit is contained in:
Nicolas Geimer 2017-03-20 13:22:47 +01:00
parent d8428a892b
commit 84cf6c4911
25 changed files with 2734 additions and 2757 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
bin/smesh_setenv.py
View File

@ -60,14 +60,14 @@ def set_env(args):
if plugin in plugin_list: continue if plugin in plugin_list: continue
# add paths of plugin # add paths of plugin
plugin_list.append(plugin) plugin_list.append(plugin)
if not os.environ.has_key("SALOME_"+plugin+"Resources"): if not os.environ.has_key("SALOME_"+plugin+"Resources"):
resource_path = os.path.join(plugin_root,"share",salome_subdir,"resources",plugin.lower()) resource_path = os.path.join(plugin_root,"share",salome_subdir,"resources",plugin.lower())
os.environ["SALOME_"+plugin+"Resources"] = resource_path os.environ["SALOME_"+plugin+"Resources"] = resource_path
resource_path_list.append( resource_path ) resource_path_list.append( resource_path )
add_path(os.path.join(plugin_root,get_lib_dir(),python_version, "site-packages",salome_subdir), "PYTHONPATH") add_path(os.path.join(plugin_root,get_lib_dir(),python_version, "site-packages",salome_subdir), "PYTHONPATH")
add_path(os.path.join(plugin_root,get_lib_dir(),salome_subdir), "PYTHONPATH") add_path(os.path.join(plugin_root,get_lib_dir(),salome_subdir), "PYTHONPATH")
if sys.platform == "win32": if sys.platform == "win32":
add_path(os.path.join(plugin_root,get_lib_dir(),salome_subdir), "PATH") add_path(os.path.join(plugin_root,get_lib_dir(),salome_subdir), "PATH")
add_path(os.path.join(plugin_root,"bin",salome_subdir), "PYTHONPATH") add_path(os.path.join(plugin_root,"bin",salome_subdir), "PYTHONPATH")
@ -80,4 +80,3 @@ def set_env(args):
break break
os.environ["SMESH_MeshersList"] = ":".join(plugin_list) os.environ["SMESH_MeshersList"] = ":".join(plugin_list)
os.environ["SalomeAppConfig"] = os.environ["SalomeAppConfig"] + psep + psep.join(resource_path_list) os.environ["SalomeAppConfig"] = os.environ["SalomeAppConfig"] + psep + psep.join(resource_path_list)

10
src/SMESH_SWIG/SMESH_test.py
View File

@ -132,17 +132,17 @@ for a in log:
elif comType == 2: elif comType == 2:
for i in range(a.number): for i in range(a.number):
ind = a.indexes[ii] ind = a.indexes[ii]
print ind print ind
ii = ii+1 ii = ii+1
print ii print ii
i1 = a.indexes[ii] i1 = a.indexes[ii]
ii = ii+1 ii = ii+1
i2 = a.indexes[ii] i2 = a.indexes[ii]
print i2 print i2
ii = ii+1 ii = ii+1
print "ii", ii print "ii", ii
i3 = a.indexes[ii] i3 = a.indexes[ii]
print i3 print i3
#ii = ii+1 #ii = ii+1
ii = ii+1 ii = ii+1
print "AddTriangle %i - %i %i %i" % (ind, i1, i2, i3) print "AddTriangle %i - %i %i %i" % (ind, i1, i2, i3)

432
src/SMESH_SWIG/batchmode_smesh.py
View File

@ -38,16 +38,16 @@ smesh.SetCurrentStudy(myStudy)
myStudyBuilder = myStudy.NewBuilder() myStudyBuilder = myStudy.NewBuilder()
if myStudyBuilder is None: if myStudyBuilder is None:
raise RuntimeError, " Null myStudyBuilder" raise RuntimeError, " Null myStudyBuilder"
father = myStudy.FindComponent("SMESH") father = myStudy.FindComponent("SMESH")
if father is None: if father is None:
father = myStudyBuilder.NewComponent("SMESH") father = myStudyBuilder.NewComponent("SMESH")
FName = myStudyBuilder.FindOrCreateAttribute(father, "AttributeName") FName = myStudyBuilder.FindOrCreateAttribute(father, "AttributeName")
Comp = modulecatalog.GetComponent("SMESH") Comp = modulecatalog.GetComponent("SMESH")
FName.SetValue(Comp._get_componentusername()) FName.SetValue(Comp._get_componentusername())
aPixmap = myStudyBuilder.FindOrCreateAttribute(father, "AttributePixMap") aPixmap = myStudyBuilder.FindOrCreateAttribute(father, "AttributePixMap")
aPixmap.SetPixMap("ICON_OBJBROWSER_Mesh") aPixmap.SetPixMap("ICON_OBJBROWSER_Mesh")
myStudyBuilder.DefineComponentInstance(father,smesh) myStudyBuilder.DefineComponentInstance(father,smesh)
@ -55,11 +55,11 @@ mySComponentMesh = father._narrow(SALOMEDS.SComponent)
Tag_HypothesisRoot = 1 Tag_HypothesisRoot = 1
Tag_AlgorithmsRoot = 2 Tag_AlgorithmsRoot = 2
Tag_RefOnShape = 1 Tag_RefOnShape = 1
Tag_RefOnAppliedHypothesis = 2 Tag_RefOnAppliedHypothesis = 2
Tag_RefOnAppliedAlgorithms = 3 Tag_RefOnAppliedAlgorithms = 3
Tag_SubMeshOnVertex = 4 Tag_SubMeshOnVertex = 4
Tag_SubMeshOnEdge = 5 Tag_SubMeshOnEdge = 5
Tag_SubMeshOnFace = 6 Tag_SubMeshOnFace = 6
@ -70,255 +70,255 @@ Tag = {"HypothesisRoot":1,"AlgorithmsRoot":2,"RefOnShape":1,"RefOnAppliedHypothe
#------------------------------------------------------------ #------------------------------------------------------------
def Init(): def Init():
pass pass
#------------------------------------------------------------ #------------------------------------------------------------
def AddNewMesh(IOR): def AddNewMesh(IOR):
# VSR: added temporarily - objects are published automatically by the engine # VSR: added temporarily - objects are published automatically by the engine
aSO = myStudy.FindObjectIOR( IOR ) aSO = myStudy.FindObjectIOR( IOR )
if aSO is not None: if aSO is not None:
return aSO.GetID() return aSO.GetID()
# VSR ###################################################################### # VSR ######################################################################
res,HypothesisRoot = mySComponentMesh.FindSubObject ( Tag_HypothesisRoot )
if HypothesisRoot is None or res == 0:
HypothesisRoot = myStudyBuilder.NewObjectToTag(mySComponentMesh, Tag_HypothesisRoot)
aName = myStudyBuilder.FindOrCreateAttribute(HypothesisRoot, "AttributeName")
aName.SetValue("Hypotheses")
aPixmap = myStudyBuilder.FindOrCreateAttribute(HypothesisRoot, "AttributePixMap")
aPixmap.SetPixMap( "mesh_tree_hypo.png" )
aSelAttr = myStudyBuilder.FindOrCreateAttribute(HypothesisRoot, "AttributeSelectable")
aSelAttr.SetSelectable(0)
res, AlgorithmsRoot = mySComponentMesh.FindSubObject (Tag_AlgorithmsRoot) res,HypothesisRoot = mySComponentMesh.FindSubObject ( Tag_HypothesisRoot )
if AlgorithmsRoot is None or res == 0: if HypothesisRoot is None or res == 0:
AlgorithmsRoot = myStudyBuilder.NewObjectToTag (mySComponentMesh, Tag_AlgorithmsRoot) HypothesisRoot = myStudyBuilder.NewObjectToTag(mySComponentMesh, Tag_HypothesisRoot)
aName = myStudyBuilder.FindOrCreateAttribute(AlgorithmsRoot, "AttributeName") aName = myStudyBuilder.FindOrCreateAttribute(HypothesisRoot, "AttributeName")
aName.SetValue("Algorithms") aName.SetValue("Hypotheses")
aPixmap = myStudyBuilder.FindOrCreateAttribute(AlgorithmsRoot, "AttributePixMap") aPixmap = myStudyBuilder.FindOrCreateAttribute(HypothesisRoot, "AttributePixMap")
aPixmap.SetPixMap( "mesh_tree_algo.png" ) aPixmap.SetPixMap( "mesh_tree_hypo.png" )
aSelAttr = myStudyBuilder.FindOrCreateAttribute(AlgorithmsRoot, "AttributeSelectable") aSelAttr = myStudyBuilder.FindOrCreateAttribute(HypothesisRoot, "AttributeSelectable")
aSelAttr.SetSelectable(0) aSelAttr.SetSelectable(0)
HypothesisRoot = HypothesisRoot._narrow(SALOMEDS.SObject) res, AlgorithmsRoot = mySComponentMesh.FindSubObject (Tag_AlgorithmsRoot)
newMesh = myStudyBuilder.NewObject(mySComponentMesh) if AlgorithmsRoot is None or res == 0:
aPixmap = myStudyBuilder.FindOrCreateAttribute(newMesh, "AttributePixMap") AlgorithmsRoot = myStudyBuilder.NewObjectToTag (mySComponentMesh, Tag_AlgorithmsRoot)
aPixmap.SetPixMap( "mesh_tree_mesh.png" ) aName = myStudyBuilder.FindOrCreateAttribute(AlgorithmsRoot, "AttributeName")
anIOR = myStudyBuilder.FindOrCreateAttribute(newMesh, "AttributeIOR") aName.SetValue("Algorithms")
anIOR.SetValue(IOR) aPixmap = myStudyBuilder.FindOrCreateAttribute(AlgorithmsRoot, "AttributePixMap")
return newMesh.GetID() aPixmap.SetPixMap( "mesh_tree_algo.png" )
aSelAttr = myStudyBuilder.FindOrCreateAttribute(AlgorithmsRoot, "AttributeSelectable")
aSelAttr.SetSelectable(0)
#------------------------------------------------------------ HypothesisRoot = HypothesisRoot._narrow(SALOMEDS.SObject)
newMesh = myStudyBuilder.NewObject(mySComponentMesh)
aPixmap = myStudyBuilder.FindOrCreateAttribute(newMesh, "AttributePixMap")
aPixmap.SetPixMap( "mesh_tree_mesh.png" )
anIOR = myStudyBuilder.FindOrCreateAttribute(newMesh, "AttributeIOR")
anIOR.SetValue(IOR)
return newMesh.GetID()
#------------------------------------------------------------
def AddNewHypothesis(IOR): def AddNewHypothesis(IOR):
# VSR: added temporarily - objects are published automatically by the engine # VSR: added temporarily - objects are published automatically by the engine
aSO = myStudy.FindObjectIOR( IOR ) aSO = myStudy.FindObjectIOR( IOR )
if aSO is not None: if aSO is not None:
return aSO.GetID() return aSO.GetID()
# VSR ###################################################################### # VSR ######################################################################
res, HypothesisRoot = mySComponentMesh.FindSubObject (Tag_HypothesisRoot) res, HypothesisRoot = mySComponentMesh.FindSubObject (Tag_HypothesisRoot)
if HypothesisRoot is None or res == 0: if HypothesisRoot is None or res == 0:
HypothesisRoot = myStudyBuilder.NewObjectToTag (mySComponentMesh, Tag_HypothesisRoot) HypothesisRoot = myStudyBuilder.NewObjectToTag (mySComponentMesh, Tag_HypothesisRoot)
aName = myStudyBuilder.FindOrCreateAttribute(HypothesisRoot, "AttributeName") aName = myStudyBuilder.FindOrCreateAttribute(HypothesisRoot, "AttributeName")
aName.SetValue("Hypotheses") aName.SetValue("Hypotheses")
aSelAttr = myStudyBuilder.FindOrCreateAttribute(HypothesisRoot, "AttributeSelectable") aSelAttr = myStudyBuilder.FindOrCreateAttribute(HypothesisRoot, "AttributeSelectable")
aSelAttr.SetSelectable(0) aSelAttr.SetSelectable(0)
aPixmap = myStudyBuilder.FindOrCreateAttribute(HypothesisRoot, "AttributePixMap") aPixmap = myStudyBuilder.FindOrCreateAttribute(HypothesisRoot, "AttributePixMap")
aPixmap.SetPixMap( "mesh_tree_hypo.png" ) aPixmap.SetPixMap( "mesh_tree_hypo.png" )
# Add New Hypothesis # Add New Hypothesis
newHypo = myStudyBuilder.NewObject(HypothesisRoot) newHypo = myStudyBuilder.NewObject(HypothesisRoot)
aPixmap = myStudyBuilder.FindOrCreateAttribute(newHypo, "AttributePixMap") aPixmap = myStudyBuilder.FindOrCreateAttribute(newHypo, "AttributePixMap")
H = orb.string_to_object(IOR) H = orb.string_to_object(IOR)
aType = H.GetName() aType = H.GetName()
aPixmap.SetPixMap( "mesh_tree_hypo.png_" + aType ) aPixmap.SetPixMap( "mesh_tree_hypo.png_" + aType )
anIOR = myStudyBuilder.FindOrCreateAttribute(newHypo, "AttributeIOR") anIOR = myStudyBuilder.FindOrCreateAttribute(newHypo, "AttributeIOR")
anIOR.SetValue(IOR) anIOR.SetValue(IOR)
return newHypo.GetID() return newHypo.GetID()
#------------------------------------------------------------ #------------------------------------------------------------
def AddNewAlgorithms(IOR): def AddNewAlgorithms(IOR):
# VSR: added temporarily - objects are published automatically by the engine # VSR: added temporarily - objects are published automatically by the engine
aSO = myStudy.FindObjectIOR( IOR ) aSO = myStudy.FindObjectIOR( IOR )
if aSO is not None: if aSO is not None:
return aSO.GetID() return aSO.GetID()
# VSR ###################################################################### # VSR ######################################################################
res, AlgorithmsRoot = mySComponentMesh.FindSubObject (Tag_AlgorithmsRoot) res, AlgorithmsRoot = mySComponentMesh.FindSubObject (Tag_AlgorithmsRoot)
if AlgorithmsRoot is None or res == 0: if AlgorithmsRoot is None or res == 0:
AlgorithmsRoot = myStudyBuilde.NewObjectToTag (mySComponentMesh, Tag_AlgorithmsRoot) AlgorithmsRoot = myStudyBuilde.NewObjectToTag (mySComponentMesh, Tag_AlgorithmsRoot)
aName = myStudyBuilder.FindOrCreateAttribute(AlgorithmsRoot, "AttributeName") aName = myStudyBuilder.FindOrCreateAttribute(AlgorithmsRoot, "AttributeName")
aName.SetValue("Algorithms") aName.SetValue("Algorithms")
aSelAttr = myStudyBuilder.FindOrCreateAttribute(AlgorithmsRoot, "AttributeSelectable") aSelAttr = myStudyBuilder.FindOrCreateAttribute(AlgorithmsRoot, "AttributeSelectable")
aSelAttr.SetSelectable(0) aSelAttr.SetSelectable(0)
aPixmap = myStudyBuilder.FindOrCreateAttribute(AlgorithmsRoot, "AttributePixMap") aPixmap = myStudyBuilder.FindOrCreateAttribute(AlgorithmsRoot, "AttributePixMap")
aPixmap.SetPixMap( "mesh_tree_algo.png" ) aPixmap.SetPixMap( "mesh_tree_algo.png" )
# Add New Algorithms # Add New Algorithms
newHypo = myStudyBuilder.NewObject(AlgorithmsRoot) newHypo = myStudyBuilder.NewObject(AlgorithmsRoot)
aPixmap = myStudyBuilder.FindOrCreateAttribute(newHypo, "AttributePixMap") aPixmap = myStudyBuilder.FindOrCreateAttribute(newHypo, "AttributePixMap")
aPixmap = anAttr._narrow(SALOMEDS.AttributePixMap) aPixmap = anAttr._narrow(SALOMEDS.AttributePixMap)
H = orb.string_to_object(IOR) H = orb.string_to_object(IOR)
aType = H.GetName(); #QString in fact aType = H.GetName(); #QString in fact
aPixmap.SetPixMap( "mesh_tree_algo.png_" + aType ) aPixmap.SetPixMap( "mesh_tree_algo.png_" + aType )
anIOR = myStudyBuilder.FindOrCreateAttribute(newHypo, "AttributeIOR") anIOR = myStudyBuilder.FindOrCreateAttribute(newHypo, "AttributeIOR")
anIOR.SetValue(IOR) anIOR.SetValue(IOR)
return newHypo.GetID() return newHypo.GetID()
#------------------------------------------------------------ #------------------------------------------------------------
def SetShape(ShapeEntry, MeshEntry): def SetShape(ShapeEntry, MeshEntry):
SO_MorSM = myStudy.FindObjectID( MeshEntry ) SO_MorSM = myStudy.FindObjectID( MeshEntry )
SO_GeomShape = myStudy.FindObjectID( ShapeEntry ) SO_GeomShape = myStudy.FindObjectID( ShapeEntry )
if SO_MorSM is not None and SO_GeomShape is not None : if SO_MorSM is not None and SO_GeomShape is not None :
# VSR: added temporarily - shape reference is published automatically by the engine # VSR: added temporarily - shape reference is published automatically by the engine
res, Ref = SO_MorSM.FindSubObject( Tag_RefOnShape ) res, Ref = SO_MorSM.FindSubObject( Tag_RefOnShape )
if res == 1 : if res == 1 :
return return
# VSR ###################################################################### # VSR ######################################################################
SO = myStudyBuilder.NewObjectToTag (SO_MorSM, Tag_RefOnShape) SO = myStudyBuilder.NewObjectToTag (SO_MorSM, Tag_RefOnShape)
myStudyBuilder.Addreference (SO,SO_GeomShape) myStudyBuilder.Addreference (SO,SO_GeomShape)
#------------------------------------------------------------ #------------------------------------------------------------
def SetHypothesis(Mesh_Or_SubMesh_Entry, Hypothesis_Entry): def SetHypothesis(Mesh_Or_SubMesh_Entry, Hypothesis_Entry):
SO_MorSM = myStudy.FindObjectID( Mesh_Or_SubMesh_Entry ) SO_MorSM = myStudy.FindObjectID( Mesh_Or_SubMesh_Entry )
SO_Hypothesis = myStudy.FindObjectID( Hypothesis_Entry ) SO_Hypothesis = myStudy.FindObjectID( Hypothesis_Entry )
if SO_MorSM is not None and SO_Hypothesis is not None : if SO_MorSM is not None and SO_Hypothesis is not None :
#Find or Create Applied Hypothesis root #Find or Create Applied Hypothesis root
res, AHR = SO_MorSM.FindSubObject (Tag_RefOnAppliedHypothesis) res, AHR = SO_MorSM.FindSubObject (Tag_RefOnAppliedHypothesis)
if AHR is None or res == 0: if AHR is None or res == 0:
AHR = myStudyBuilder.NewObjectToTag (SO_MorSM, Tag_RefOnAppliedHypothesis) AHR = myStudyBuilder.NewObjectToTag (SO_MorSM, Tag_RefOnAppliedHypothesis)
aName = myStudyBuilder.FindOrCreateAttribute(AHR, "AttributeName") aName = myStudyBuilder.FindOrCreateAttribute(AHR, "AttributeName")
# The same name as in SMESH_Mesh_i::AddHypothesis() ################## # The same name as in SMESH_Mesh_i::AddHypothesis() ##################
aName.SetValue("Applied hypotheses") aName.SetValue("Applied hypotheses")
aSelAttr = myStudyBuilder.FindOrCreateAttribute(AHR, "AttributeSelectable") aSelAttr = myStudyBuilder.FindOrCreateAttribute(AHR, "AttributeSelectable")
aSelAttr.SetSelectable(0) aSelAttr.SetSelectable(0)
aPixmap = myStudyBuilder.FindOrCreateAttribute(AHR, "AttributePixMap") aPixmap = myStudyBuilder.FindOrCreateAttribute(AHR, "AttributePixMap")
aPixmap.SetPixMap( "mesh_tree_hypo.png" ) aPixmap.SetPixMap( "mesh_tree_hypo.png" )
# VSR: added temporarily - reference to applied hypothesis is published automatically by the engine # VSR: added temporarily - reference to applied hypothesis is published automatically by the engine
else : else :
it = myStudy.NewChildIterator(AHR) it = myStudy.NewChildIterator(AHR)
while it.More() : while it.More() :
res, Ref = it.Value().ReferencedObject() res, Ref = it.Value().ReferencedObject()
if res and Ref is not None and Ref.GetID() == Hypothesis_Entry : if res and Ref is not None and Ref.GetID() == Hypothesis_Entry :
return return
it.Next() it.Next()
# VSR ###################################################################### # VSR ######################################################################
SO = myStudyBuilder.NewObject(AHR) SO = myStudyBuilder.NewObject(AHR)
myStudyBuilder.Addreference (SO,SO_Hypothesis) myStudyBuilder.Addreference (SO,SO_Hypothesis)
#------------------------------------------------------------ #------------------------------------------------------------
def SetAlgorithms(Mesh_Or_SubMesh_Entry, Algorithms_Entry): def SetAlgorithms(Mesh_Or_SubMesh_Entry, Algorithms_Entry):
SO_MorSM = myStudy.FindObjectID( Mesh_Or_SubMesh_Entry ) SO_MorSM = myStudy.FindObjectID( Mesh_Or_SubMesh_Entry )
SO_Algorithms = myStudy.FindObjectID( Algorithms_Entry ) SO_Algorithms = myStudy.FindObjectID( Algorithms_Entry )
if SO_MorSM != None and SO_Algorithms != None : if SO_MorSM != None and SO_Algorithms != None :
#Find or Create Applied Algorithms root #Find or Create Applied Algorithms root
res, AHR = SO_MorSM.FindSubObject (Tag_RefOnAppliedAlgorithms) res, AHR = SO_MorSM.FindSubObject (Tag_RefOnAppliedAlgorithms)
if AHR is None or res == 0: if AHR is None or res == 0:
AHR = myStudyBuilder.NewObjectToTag (SO_MorSM, Tag_RefOnAppliedAlgorithms) AHR = myStudyBuilder.NewObjectToTag (SO_MorSM, Tag_RefOnAppliedAlgorithms)
aName = myStudyBuilder.FindOrCreateAttribute(AHR, "AttributeName") aName = myStudyBuilder.FindOrCreateAttribute(AHR, "AttributeName")
# The same name as in SMESH_Mesh_i::AddHypothesis() ##################
aName.SetValue("Applied algorithms")
aSelAttr = myStudyBuilder.FindOrCreateAttribute(AHR, "AttributeSelectable")
aSelAttr.SetSelectable(0)
aPixmap = myStudyBuilder.FindOrCreateAttribute(AHR, "AttributePixMap")
aPixmap.SetPixMap( "mesh_tree_algo.png" )
# VSR: added temporarily - reference to applied hypothesis is published automatically by the engine
else :
it = myStudy.NewChildIterator(AHR)
while it.More() :
res, Ref = it.Value().ReferencedObject()
if res and Ref is not None and Ref.GetID() == Algorithms_Entry :
return
it.Next()
# VSR ######################################################################
SO = myStudyBuilder.NewObject(AHR)
myStudyBuilder.Addreference (SO,SO_Algorithms)
# The same name as in SMESH_Mesh_i::AddHypothesis() ##################
aName.SetValue("Applied algorithms")
aSelAttr = myStudyBuilder.FindOrCreateAttribute(AHR, "AttributeSelectable")
aSelAttr.SetSelectable(0)
aPixmap = myStudyBuilder.FindOrCreateAttribute(AHR, "AttributePixMap")
aPixmap.SetPixMap( "mesh_tree_algo.png" )
# VSR: added temporarily - reference to applied hypothesis is published automatically by the engine
else :
it = myStudy.NewChildIterator(AHR)
while it.More() :
res, Ref = it.Value().ReferencedObject()
if res and Ref is not None and Ref.GetID() == Algorithms_Entry :
return
it.Next()
# VSR ######################################################################
SO = myStudyBuilder.NewObject(AHR)
myStudyBuilder.Addreference (SO,SO_Algorithms)
#------------------------------------------------------------ #------------------------------------------------------------
def UnSetHypothesis( Applied_Hypothesis_Entry ): def UnSetHypothesis( Applied_Hypothesis_Entry ):
SO_Applied_Hypothesis = myStudy.FindObjectID( Applied_Hypothesis_Entry ) SO_Applied_Hypothesis = myStudy.FindObjectID( Applied_Hypothesis_Entry )
if SO_Applied_Hypothesis : if SO_Applied_Hypothesis :
myStudyBuilder.RemoveObject(SO_Applied_Hypothesis) myStudyBuilder.RemoveObject(SO_Applied_Hypothesis)
#------------------------------------------------------------ #------------------------------------------------------------
def AddSubMesh ( SO_Mesh_Entry, SM_IOR, ST): def AddSubMesh ( SO_Mesh_Entry, SM_IOR, ST):
# VSR: added temporarily - objects are published automatically by the engine # VSR: added temporarily - objects are published automatically by the engine
aSO = myStudy.FindObjectIOR( SM_IOR ) aSO = myStudy.FindObjectIOR( SM_IOR )
if aSO is not None: if aSO is not None:
return aSO.GetID() return aSO.GetID()
# VSR ###################################################################### # VSR ######################################################################
SO_Mesh = myStudy.FindObjectID( SO_Mesh_Entry )
if ( SO_Mesh ) :
if ST == ShapeType["COMPSOLID"] :
Tag_Shape = Tag_SubMeshOnSolid
Name = "SubMeshes on Solid"
elif ST == ShapeType["FACE"] :
Tag_Shape = Tag_SubMeshOnFace
Name = "SubMeshes on Face"
elif ST == ShapeType["EDGE"] :
Tag_Shape = Tag_SubMeshOnEdge
Name = "SubMeshes on Edge"
elif ST == ShapeType["VERTEX"] :
Tag_Shape = Tag_SubMeshOnVertex
Name = "SubMeshes on Vertex"
else :
Tag_Shape = Tag_SubMeshOnCompound
Name = "SubMeshes on Compound"
res, SubmeshesRoot = SO_Mesh.FindSubObject (Tag_Shape)
if SubmeshesRoot is None or res == 0:
SubmeshesRoot = myStudyBuilder.NewObjectToTag (SO_Mesh, Tag_Shape)
aName = myStudyBuilder.FindOrCreateAttribute(SubmeshesRoot, "AttributeName")
aName.SetValue(Name)
aSelAttr = myStudyBuilder.FindOrCreateAttribute(SubmeshesRoot, "AttributeSelectable")
aSelAttr.SetSelectable(0)
SO = myStudyBuilder.NewObject (SubmeshesRoot)
anIOR = myStudyBuilder.FindOrCreateAttribute(SO, "AttributeIOR")
anIOR.SetValue(SM_IOR)
return SO.GetID()
return None SO_Mesh = myStudy.FindObjectID( SO_Mesh_Entry )
if ( SO_Mesh ) :
if ST == ShapeType["COMPSOLID"] :
Tag_Shape = Tag_SubMeshOnSolid
Name = "SubMeshes on Solid"
elif ST == ShapeType["FACE"] :
Tag_Shape = Tag_SubMeshOnFace
Name = "SubMeshes on Face"
elif ST == ShapeType["EDGE"] :
Tag_Shape = Tag_SubMeshOnEdge
Name = "SubMeshes on Edge"
elif ST == ShapeType["VERTEX"] :
Tag_Shape = Tag_SubMeshOnVertex
Name = "SubMeshes on Vertex"
else :
Tag_Shape = Tag_SubMeshOnCompound
Name = "SubMeshes on Compound"
res, SubmeshesRoot = SO_Mesh.FindSubObject (Tag_Shape)
if SubmeshesRoot is None or res == 0:
SubmeshesRoot = myStudyBuilder.NewObjectToTag (SO_Mesh, Tag_Shape)
aName = myStudyBuilder.FindOrCreateAttribute(SubmeshesRoot, "AttributeName")
aName.SetValue(Name)
aSelAttr = myStudyBuilder.FindOrCreateAttribute(SubmeshesRoot, "AttributeSelectable")
aSelAttr.SetSelectable(0)
SO = myStudyBuilder.NewObject (SubmeshesRoot)
anIOR = myStudyBuilder.FindOrCreateAttribute(SO, "AttributeIOR")
anIOR.SetValue(SM_IOR)
return SO.GetID()
return None
#------------------------------------------------------------ #------------------------------------------------------------
def AddSubMeshOnShape (Mesh_Entry, GeomShape_Entry, SM_IOR, ST) : def AddSubMeshOnShape (Mesh_Entry, GeomShape_Entry, SM_IOR, ST) :
# VSR: added temporarily - objects are published automatically by the engine # VSR: added temporarily - objects are published automatically by the engine
aSO = myStudy.FindObjectIOR( SM_IOR ) aSO = myStudy.FindObjectIOR( SM_IOR )
if aSO is not None: if aSO is not None:
return aSO.GetID() return aSO.GetID()
# VSR ###################################################################### # VSR ######################################################################
SO_GeomShape = myStudy.FindObjectID( GeomShape_Entry ) SO_GeomShape = myStudy.FindObjectID( GeomShape_Entry )
if SO_GeomShape != None : if SO_GeomShape != None :
SM_Entry = AddSubMesh (Mesh_Entry,SM_IOR,ST) SM_Entry = AddSubMesh (Mesh_Entry,SM_IOR,ST)
SO_SM = myStudy.FindObjectID( SM_Entry ) SO_SM = myStudy.FindObjectID( SM_Entry )
if SO_SM != None : if SO_SM != None :
SetShape (GeomShape_Entry, SM_Entry) SetShape (GeomShape_Entry, SM_Entry)
return SM_Entry return SM_Entry
return None return None
#------------------------------------------------------------ #------------------------------------------------------------
def SetName(Entry, Name): def SetName(Entry, Name):
SO = myStudy.FindObjectID( Entry ) SO = myStudy.FindObjectID( Entry )
if SO != None : if SO != None :
aName = myStudyBuilder.FindOrCreateAttribute(SO, "AttributeName") aName = myStudyBuilder.FindOrCreateAttribute(SO, "AttributeName")
aName.SetValue(Name) aName.SetValue(Name)

8
src/SMESH_SWIG/smesh.py
View File

@ -82,8 +82,8 @@ del pluginName
# export the methods of smeshBuilder # export the methods of smeshBuilder
if smesh: if smesh:
for k in dir( smesh ): for k in dir( smesh ):
if k[0] == '_': continue if k[0] == '_': continue
globals()[k] = getattr( smesh, k ) globals()[k] = getattr( smesh, k )
del k del k
pass pass
@ -95,7 +95,7 @@ smesh.py will be removed in a future version!
TODO: TODO:
The following changes in your scripts are required to avoid this message: The following changes in your scripts are required to avoid this message:
replace replace
------- -------
import smesh, SMESH import smesh, SMESH
@ -110,7 +110,7 @@ smesh = smeshBuilder.New(salome.myStudy)
you also need to modify some lines where smeshBuilder is used instead of smesh you also need to modify some lines where smeshBuilder is used instead of smesh
algo=smesh.xxxx ==> algo=smeshBuilder.xxxx algo=smesh.xxxx ==> algo=smeshBuilder.xxxx
See also SMESH User's Guide for more details See also SMESH User's Guide for more details

72
src/SMESH_SWIG/smeshBuilder.py
View File

@ -374,8 +374,8 @@ class smeshBuilder(object, SMESH._objref_SMESH_Gen):
global created global created
#print "--------------- smeshbuilder __init__ ---", created #print "--------------- smeshbuilder __init__ ---", created
if not created: if not created:
created = True created = True
SMESH._objref_SMESH_Gen.__init__(self) SMESH._objref_SMESH_Gen.__init__(self)
## Dump component to the Python script ## Dump component to the Python script
# This method overrides IDL function to allow default values for the parameters. # This method overrides IDL function to allow default values for the parameters.
@ -653,7 +653,7 @@ class smeshBuilder(object, SMESH._objref_SMESH_Gen):
def GetSubShapesId( self, theMainObject, theListOfSubObjects ): def GetSubShapesId( self, theMainObject, theListOfSubObjects ):
return SMESH._objref_SMESH_Gen.GetSubShapesId(self,theMainObject, theListOfSubObjects) return SMESH._objref_SMESH_Gen.GetSubShapesId(self,theMainObject, theListOfSubObjects)
## Create a pattern mapper. ## Create a pattern mapper.
# @return an instance of SMESH_Pattern # @return an instance of SMESH_Pattern
# #
# <a href="../tui_modifying_meshes_page.html#tui_pattern_mapping">Example of Patterns usage</a> # <a href="../tui_modifying_meshes_page.html#tui_pattern_mapping">Example of Patterns usage</a>
@ -835,7 +835,7 @@ class smeshBuilder(object, SMESH._objref_SMESH_Gen):
raise TypeError, "The Threshold should be an integer or SMESH.EntityType." raise TypeError, "The Threshold should be an integer or SMESH.EntityType."
pass pass
pass pass
elif CritType == FT_GroupColor: elif CritType == FT_GroupColor:
# Check the Threshold # Check the Threshold
try: try:
@ -1195,7 +1195,7 @@ def New( study, instance=None):
global doLcc global doLcc
engine = instance engine = instance
if engine is None: if engine is None:
doLcc = True doLcc = True
smeshInst = smeshBuilder() smeshInst = smeshBuilder()
assert isinstance(smeshInst,smeshBuilder), "Smesh engine class is %s but should be smeshBuilder.smeshBuilder. Import salome.smesh.smeshBuilder before creating the instance."%smeshInst.__class__ assert isinstance(smeshInst,smeshBuilder), "Smesh engine class is %s but should be smeshBuilder.smeshBuilder. Import salome.smesh.smeshBuilder before creating the instance."%smeshInst.__class__
smeshInst.init_smesh(study) smeshInst.init_smesh(study)
@ -1280,7 +1280,7 @@ class Mesh:
#self.mesh.UnRegister() #self.mesh.UnRegister()
pass pass
pass pass
## Initialize the Mesh object from an instance of SMESH_Mesh interface ## Initialize the Mesh object from an instance of SMESH_Mesh interface
# @param theMesh a SMESH_Mesh object # @param theMesh a SMESH_Mesh object
# @ingroup l2_construct # @ingroup l2_construct
@ -1641,7 +1641,7 @@ class Mesh:
# @ingroup l2_construct # @ingroup l2_construct
def Clear(self, refresh=False): def Clear(self, refresh=False):
self.mesh.Clear() self.mesh.Clear()
if ( salome.sg.hasDesktop() and if ( salome.sg.hasDesktop() and
salome.myStudyManager.GetStudyByID( self.mesh.GetStudyId() ) ): salome.myStudyManager.GetStudyByID( self.mesh.GetStudyId() ) ):
smeshgui = salome.ImportComponentGUI("SMESH") smeshgui = salome.ImportComponentGUI("SMESH")
smeshgui.Init(self.mesh.GetStudyId()) smeshgui.Init(self.mesh.GetStudyId())
@ -1804,7 +1804,7 @@ class Mesh:
# - 3D in the rest cases.<br> # - 3D in the rest cases.<br>
# If @a autoDimension is @c False, the space dimension is always 3. # If @a autoDimension is @c False, the space dimension is always 3.
# @param fields list of GEOM fields defined on the shape to mesh. # @param fields list of GEOM fields defined on the shape to mesh.
# @param geomAssocFields each character of this string means a need to export a # @param geomAssocFields each character of this string means a need to export a
# corresponding field; correspondence between fields and characters is following: # corresponding field; correspondence between fields and characters is following:
# - 'v' stands for "_vertices _" field; # - 'v' stands for "_vertices _" field;
# - 'e' stands for "_edges _" field; # - 'e' stands for "_edges _" field;
@ -1931,7 +1931,7 @@ class Mesh:
# ---------------------- # ----------------------
## Create an empty mesh group ## Create an empty mesh group
# @param elementType the type of elements in the group; either of # @param elementType the type of elements in the group; either of
# (SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME) # (SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME)
# @param name the name of the mesh group # @param name the name of the mesh group
# @return SMESH_Group # @return SMESH_Group
@ -1955,7 +1955,7 @@ class Mesh:
# the name is the same as the geometrical group name # the name is the same as the geometrical group name
# @param grp a geometrical group, a vertex, an edge, a face or a solid # @param grp a geometrical group, a vertex, an edge, a face or a solid
# @param name the name of the mesh group # @param name the name of the mesh group
# @param typ the type of elements in the group; either of # @param typ the type of elements in the group; either of
# (SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME). If not set, it is # (SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME). If not set, it is
# automatically detected by the type of the geometry # automatically detected by the type of the geometry
# @return SMESH_GroupOnGeom # @return SMESH_GroupOnGeom
@ -1992,7 +1992,7 @@ class Mesh:
## Create a mesh group with given \a name based on the \a filter which ## Create a mesh group with given \a name based on the \a filter which
## is a special type of group dynamically updating it's contents during ## is a special type of group dynamically updating it's contents during
## mesh modification ## mesh modification
# @param typ the type of elements in the group; either of # @param typ the type of elements in the group; either of
# (SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME). # (SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME).
# @param name the name of the mesh group # @param name the name of the mesh group
# @param filter the filter defining group contents # @param filter the filter defining group contents
@ -2003,7 +2003,7 @@ class Mesh:
## Create a mesh group by the given ids of elements ## Create a mesh group by the given ids of elements
# @param groupName the name of the mesh group # @param groupName the name of the mesh group
# @param elementType the type of elements in the group; either of # @param elementType the type of elements in the group; either of
# (SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME). # (SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME).
# @param elemIDs either the list of ids, group, sub-mesh, or filter # @param elemIDs either the list of ids, group, sub-mesh, or filter
# @return SMESH_Group # @return SMESH_Group
@ -2086,7 +2086,7 @@ class Mesh:
## Get the list of groups existing in the mesh in the order ## Get the list of groups existing in the mesh in the order
# of creation (starting from the oldest one) # of creation (starting from the oldest one)
# @param elemType type of elements the groups contain; either of # @param elemType type of elements the groups contain; either of
# (SMESH.ALL, SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME); # (SMESH.ALL, SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME);
# by default groups of elements of all types are returned # by default groups of elements of all types are returned
# @return a sequence of SMESH_GroupBase # @return a sequence of SMESH_GroupBase
@ -2121,7 +2121,7 @@ class Mesh:
## Find groups by name and type ## Find groups by name and type
# @param name name of the group of interest # @param name name of the group of interest
# @param elemType type of elements the groups contain; either of # @param elemType type of elements the groups contain; either of
# (SMESH.ALL, SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME); # (SMESH.ALL, SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME);
# by default one group of any type of elements is returned # by default one group of any type of elements is returned
# if elemType == SMESH.ALL then all groups of any type are returned # if elemType == SMESH.ALL then all groups of any type are returned
@ -2133,7 +2133,7 @@ class Mesh:
if group.GetName() == name: if group.GetName() == name:
if elemType is None: if elemType is None:
return [group] return [group]
if ( elemType == SMESH.ALL or if ( elemType == SMESH.ALL or
group.GetType() == elemType ): group.GetType() == elemType ):
groups.append( group ) groups.append( group )
return groups return groups
@ -2152,7 +2152,7 @@ class Mesh:
# @return an instance of SMESH_Group # @return an instance of SMESH_Group
# @ingroup l2_grps_operon # @ingroup l2_grps_operon
def UnionListOfGroups(self, groups, name): def UnionListOfGroups(self, groups, name):
return self.mesh.UnionListOfGroups(groups, name) return self.mesh.UnionListOfGroups(groups, name)
## Prodice an intersection of two groups. ## Prodice an intersection of two groups.
# A new group is created. All mesh elements that are common # A new group is created. All mesh elements that are common
@ -2168,7 +2168,7 @@ class Mesh:
# @return an instance of SMESH_Group # @return an instance of SMESH_Group
# @ingroup l2_grps_operon # @ingroup l2_grps_operon
def IntersectListOfGroups(self, groups, name): def IntersectListOfGroups(self, groups, name):
return self.mesh.IntersectListOfGroups(groups, name) return self.mesh.IntersectListOfGroups(groups, name)
## Produce a cut of two groups. ## Produce a cut of two groups.
# A new group is created. All mesh elements that are present in # A new group is created. All mesh elements that are present in
@ -2189,7 +2189,7 @@ class Mesh:
## ##
# Create a standalone group of entities basing on nodes of other groups. # Create a standalone group of entities basing on nodes of other groups.
# \param groups - list of reference groups, sub-meshes or filters, of any type. # \param groups - list of reference groups, sub-meshes or filters, of any type.
# \param elemType - a type of elements to include to the new group; either of # \param elemType - a type of elements to include to the new group; either of
# (SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME). # (SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME).
# \param name - a name of the new group. # \param name - a name of the new group.
# \param nbCommonNodes - a criterion of inclusion of an element to the new group # \param nbCommonNodes - a criterion of inclusion of an element to the new group
@ -2866,7 +2866,7 @@ class Mesh:
def Add0DElement( self, IDOfNode, DuplicateElements=True ): def Add0DElement( self, IDOfNode, DuplicateElements=True ):
return self.editor.Add0DElement( IDOfNode, DuplicateElements ) return self.editor.Add0DElement( IDOfNode, DuplicateElements )
## Create 0D elements on all nodes of the given elements except those ## Create 0D elements on all nodes of the given elements except those
# nodes on which a 0D element already exists. # nodes on which a 0D element already exists.
# @param theObject an object on whose nodes 0D elements will be created. # @param theObject an object on whose nodes 0D elements will be created.
# It can be mesh, sub-mesh, group, list of element IDs or a holder # It can be mesh, sub-mesh, group, list of element IDs or a holder
@ -2875,7 +2875,7 @@ class Mesh:
# and/or found on nodes of \a theObject. # and/or found on nodes of \a theObject.
# @param DuplicateElements to add one more 0D element to a node or not # @param DuplicateElements to add one more 0D element to a node or not
# @return an object (a new group or a temporary SMESH_IDSource) holding # @return an object (a new group or a temporary SMESH_IDSource) holding
# IDs of new and/or found 0D elements. IDs of 0D elements # IDs of new and/or found 0D elements. IDs of 0D elements
# can be retrieved from the returned object by calling GetIDs() # can be retrieved from the returned object by calling GetIDs()
# @ingroup l2_modif_add # @ingroup l2_modif_add
def Add0DElementsToAllNodes(self, theObject, theGroupName="", DuplicateElements=False): def Add0DElementsToAllNodes(self, theObject, theGroupName="", DuplicateElements=False):
@ -3088,7 +3088,7 @@ class Mesh:
# @param x the X coordinate of a point # @param x the X coordinate of a point
# @param y the Y coordinate of a point # @param y the Y coordinate of a point
# @param z the Z coordinate of a point # @param z the Z coordinate of a point
# @param elementType type of elements to find; either of # @param elementType type of elements to find; either of
# (SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME); SMESH.ALL type # (SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME); SMESH.ALL type
# means elements of any type excluding nodes, discrete and 0D elements. # means elements of any type excluding nodes, discrete and 0D elements.
# @param meshPart a part of mesh (group, sub-mesh) to search within # @param meshPart a part of mesh (group, sub-mesh) to search within
@ -3657,7 +3657,7 @@ class Mesh:
if error and error.comment: if error and error.comment:
print error.comment print error.comment
return error return error
## Convert the mesh from quadratic to ordinary, ## Convert the mesh from quadratic to ordinary,
# deletes old quadratic elements, \n replacing # deletes old quadratic elements, \n replacing
# them with ordinary mesh elements with the same id. # them with ordinary mesh elements with the same id.
@ -3708,13 +3708,13 @@ class Mesh:
return mesh, group return mesh, group
## ##
# @brief Create missing boundary elements around either the whole mesh or # @brief Create missing boundary elements around either the whole mesh or
# groups of elements # groups of elements
# @param dimension - defines type of boundary elements to create, either of # @param dimension - defines type of boundary elements to create, either of
# { SMESH.BND_2DFROM3D, SMESH.BND_1DFROM3D, SMESH.BND_1DFROM2D } # { SMESH.BND_2DFROM3D, SMESH.BND_1DFROM3D, SMESH.BND_1DFROM2D }
# @param groupName - a name of group to store all boundary elements in, # @param groupName - a name of group to store all boundary elements in,
# "" means not to create the group # "" means not to create the group
# @param meshName - a name of a new mesh, which is a copy of the initial # @param meshName - a name of a new mesh, which is a copy of the initial
# mesh + created boundary elements; "" means not to create the new mesh # mesh + created boundary elements; "" means not to create the new mesh
# @param toCopyAll - if true, the whole initial mesh will be copied into # @param toCopyAll - if true, the whole initial mesh will be copied into
# the new mesh else only boundary elements will be copied into the new mesh # the new mesh else only boundary elements will be copied into the new mesh
@ -4406,9 +4406,9 @@ class Mesh:
if ( isinstance( thePoint, list )): if ( isinstance( thePoint, list )):
thePoint = PointStruct( thePoint[0], thePoint[1], thePoint[2] ) thePoint = PointStruct( thePoint[0], thePoint[1], thePoint[2] )
if ( isinstance( theScaleFact, float )): if ( isinstance( theScaleFact, float )):
theScaleFact = [theScaleFact] theScaleFact = [theScaleFact]
if ( isinstance( theScaleFact, int )): if ( isinstance( theScaleFact, int )):
theScaleFact = [ float(theScaleFact)] theScaleFact = [ float(theScaleFact)]
self.mesh.SetParameters(thePoint.parameters) self.mesh.SetParameters(thePoint.parameters)
@ -4434,9 +4434,9 @@ class Mesh:
if ( isinstance( thePoint, list )): if ( isinstance( thePoint, list )):
thePoint = PointStruct( thePoint[0], thePoint[1], thePoint[2] ) thePoint = PointStruct( thePoint[0], thePoint[1], thePoint[2] )
if ( isinstance( theScaleFact, float )): if ( isinstance( theScaleFact, float )):
theScaleFact = [theScaleFact] theScaleFact = [theScaleFact]
if ( isinstance( theScaleFact, int )): if ( isinstance( theScaleFact, int )):
theScaleFact = [ float(theScaleFact)] theScaleFact = [ float(theScaleFact)]
self.mesh.SetParameters(thePoint.parameters) self.mesh.SetParameters(thePoint.parameters)
mesh = self.editor.ScaleMakeMesh(theObject, thePoint, theScaleFact, mesh = self.editor.ScaleMakeMesh(theObject, thePoint, theScaleFact,
@ -4602,7 +4602,7 @@ class Mesh:
# @ingroup l2_modif_trsf # @ingroup l2_modif_trsf
def FindCoincidentFreeBorders (self, tolerance=0.): def FindCoincidentFreeBorders (self, tolerance=0.):
return self.editor.FindCoincidentFreeBorders( tolerance ) return self.editor.FindCoincidentFreeBorders( tolerance )
## Sew FreeBorder's of each group ## Sew FreeBorder's of each group
# @param freeBorders either a SMESH.CoincidentFreeBorders structure or a list of lists # @param freeBorders either a SMESH.CoincidentFreeBorders structure or a list of lists
# where each enclosed list contains node IDs of a group of coincident free # where each enclosed list contains node IDs of a group of coincident free
@ -4711,7 +4711,7 @@ class Mesh:
def ClearLastCreated(self): def ClearLastCreated(self):
self.editor.ClearLastCreated() self.editor.ClearLastCreated()
## Create duplicates of given elements, i.e. create new elements based on the ## Create duplicates of given elements, i.e. create new elements based on the
# same nodes as the given ones. # same nodes as the given ones.
# @param theElements - container of elements to duplicate. It can be a Mesh, # @param theElements - container of elements to duplicate. It can be a Mesh,
# sub-mesh, group, filter or a list of element IDs. If \a theElements is # sub-mesh, group, filter or a list of element IDs. If \a theElements is
@ -4719,7 +4719,7 @@ class Mesh:
# @param theGroupName - a name of group to contain the generated elements. # @param theGroupName - a name of group to contain the generated elements.
# If a group with such a name already exists, the new elements # If a group with such a name already exists, the new elements
# are added to the existng group, else a new group is created. # are added to the existng group, else a new group is created.
# If \a theGroupName is empty, new elements are not added # If \a theGroupName is empty, new elements are not added
# in any group. # in any group.
# @return a group where the new elements are added. None if theGroupName == "". # @return a group where the new elements are added. None if theGroupName == "".
# @ingroup l2_modif_duplicat # @ingroup l2_modif_duplicat
@ -4892,11 +4892,11 @@ class Mesh:
# @return TRUE if operation has been completed successfully, FALSE otherwise # @return TRUE if operation has been completed successfully, FALSE otherwise
# @ingroup l2_modif_duplicat # @ingroup l2_modif_duplicat
def DoubleNodesOnGroupBoundaries(self, theDomains, createJointElems, onAllBoundaries=False ): def DoubleNodesOnGroupBoundaries(self, theDomains, createJointElems, onAllBoundaries=False ):
return self.editor.DoubleNodesOnGroupBoundaries( theDomains, createJointElems, onAllBoundaries ) return self.editor.DoubleNodesOnGroupBoundaries( theDomains, createJointElems, onAllBoundaries )
## Double nodes on some external faces and create flat elements. ## Double nodes on some external faces and create flat elements.
# Flat elements are mainly used by some types of mechanic calculations. # Flat elements are mainly used by some types of mechanic calculations.
# #
# Each group of the list must be constituted of faces. # Each group of the list must be constituted of faces.
# Triangles are transformed in prisms, and quadrangles in hexahedrons. # Triangles are transformed in prisms, and quadrangles in hexahedrons.
# @param theGroupsOfFaces - list of groups of faces # @param theGroupsOfFaces - list of groups of faces
@ -4904,7 +4904,7 @@ class Mesh:
# @ingroup l2_modif_duplicat # @ingroup l2_modif_duplicat
def CreateFlatElementsOnFacesGroups(self, theGroupsOfFaces ): def CreateFlatElementsOnFacesGroups(self, theGroupsOfFaces ):
return self.editor.CreateFlatElementsOnFacesGroups( theGroupsOfFaces ) return self.editor.CreateFlatElementsOnFacesGroups( theGroupsOfFaces )
## identify all the elements around a geom shape, get the faces delimiting the hole ## identify all the elements around a geom shape, get the faces delimiting the hole
# #
def CreateHoleSkin(self, radius, theShape, groupName, theNodesCoords): def CreateHoleSkin(self, radius, theShape, groupName, theNodesCoords):
@ -5276,8 +5276,8 @@ for pluginName in os.environ[ "SMESH_MeshersList" ].split( ":" ):
try: try:
exec( "from salome.%s.%s import *" % (pluginName, pluginBuilderName)) exec( "from salome.%s.%s import *" % (pluginName, pluginBuilderName))
except Exception, e: except Exception, e:
from salome_utils import verbose from salome_utils import verbose
if verbose(): print "Exception while loading %s: %s" % ( pluginBuilderName, e ) if verbose(): print "Exception while loading %s: %s" % ( pluginBuilderName, e )
continue continue
exec( "from salome.%s import %s" % (pluginName, pluginBuilderName)) exec( "from salome.%s import %s" % (pluginName, pluginBuilderName))
plugin = eval( pluginBuilderName ) plugin = eval( pluginBuilderName )

17
src/Tools/MacMesh/MacMesh/Alarms.py
View File

@ -18,12 +18,11 @@
# #
def Message (code) : def Message (code) :
import sys import sys
MessageString = { 1 : lambda x: "Successfully created \n", MessageString = { 1 : lambda x: "Successfully created \n",
2 : lambda x: "Fatal: Incorrect input \n", 2 : lambda x: "Fatal: Incorrect input \n",
3 : lambda x: "Fatal: Overlapping objects detected \n", 3 : lambda x: "Fatal: Overlapping objects detected \n",
4 : lambda x: "Fatal: Incompatible object type with neighbouring objects" }[code](str(code)) 4 : lambda x: "Fatal: Incompatible object type with neighbouring objects" }[code](str(code))
print MessageString print MessageString
#if code > 1 : sys.exit() #if code > 1 : sys.exit()
return 1 return 1

288
src/Tools/MacMesh/MacMesh/CentralUnrefine.py
View File

@ -31,157 +31,157 @@ sys.path.append(CWD)
from MacObject import * from MacObject import *
import Config, GenFunctions import Config, GenFunctions
def CentralUnrefine (X0 , Y0 , DX , DY , Orientation, **args ) : def CentralUnrefine (X0 , Y0 , DX , DY , Orientation, **args ) :
DirPar = {'SN' : lambda : ['NW', 'NE', 'EW', 'NW', 'SN', 'SN', 'NE', 'WE'], DirPar = {'SN' : lambda : ['NW', 'NE', 'EW', 'NW', 'SN', 'SN', 'NE', 'WE'],
'NS' : lambda : ['SE', 'SW', 'WE', 'SE', 'NS', 'NS', 'SW', 'EW'], 'NS' : lambda : ['SE', 'SW', 'WE', 'SE', 'NS', 'NS', 'SW', 'EW'],
'EW' : lambda : ['NW', 'SW', 'SN', 'NW', 'EW', 'EW', 'SW', 'NS'], 'EW' : lambda : ['NW', 'SW', 'SN', 'NW', 'EW', 'EW', 'SW', 'NS'],
'WE' : lambda : ['SE', 'NE', 'NS', 'SE', 'WE', 'WE', 'NE', 'SN'], }[Orientation]() 'WE' : lambda : ['SE', 'NE', 'NS', 'SE', 'WE', 'WE', 'NE', 'SN'], }[Orientation]()
CoefVer = {'SN' : lambda : 1., CoefVer = {'SN' : lambda : 1.,
'NS' : lambda : -1., 'NS' : lambda : -1.,
'EW' : lambda : 0., 'EW' : lambda : 0.,
'WE' : lambda : 0., }[Orientation]() 'WE' : lambda : 0., }[Orientation]()
CoefHor = {'SN' : lambda : 0., CoefHor = {'SN' : lambda : 0.,
'NS' : lambda : 0., 'NS' : lambda : 0.,
'EW' : lambda : -1., 'EW' : lambda : -1.,
'WE' : lambda : 1., }[Orientation]() 'WE' : lambda : 1., }[Orientation]()
MacObject('CompBoxF',[(X0+CoefHor*DX/2,Y0+CoefVer*DY/2),(DX,DY)],['auto'],publish=0) MacObject('CompBoxF',[(X0+CoefHor*DX/2,Y0+CoefVer*DY/2),(DX,DY)],['auto'],publish=0)
ToLook1 = {'SN' : lambda : 2, ToLook1 = {'SN' : lambda : 2,
'NS' : lambda : 3, 'NS' : lambda : 3,
'EW' : lambda : 1, 'EW' : lambda : 1,
'WE' : lambda : 0, }[Orientation]() 'WE' : lambda : 0, }[Orientation]()
ToLook2 = {'SN' : lambda : 0, ToLook2 = {'SN' : lambda : 0,
'NS' : lambda : 0, 'NS' : lambda : 0,
'EW' : lambda : 2, 'EW' : lambda : 2,
'WE' : lambda : 2, }[Orientation]() 'WE' : lambda : 2, }[Orientation]()
ToLook3 = {'SN' : lambda : [0,1,2,3],
'NS' : lambda : [1,0,3,2],
'EW' : lambda : [3,2,1,0],
'WE' : lambda : [2,3,0,1], }[Orientation]()
if args.__contains__('groups') :
GroupNames = args['groups']
else : GroupNames = [None, None, None, None, None, None]
ExistingSegments = Config.ListObj[-1].DirectionalMeshParams[ToLook1]
ObjIDs = Config.Connections[-1][ToLook1]
RemoveLastObj()
ExtensionSegments = math.ceil(ExistingSegments/12.)*12.
Dmin = 1.E50
Dmax = -1.E50
for ObjID in ObjIDs :
Boundaries = Config.ListObj[ObjID].Boundaries()
if Boundaries[ToLook2] < Dmin : Dmin = Boundaries[ToLook2]
if Boundaries[ToLook2+1] > Dmax : Dmax = Boundaries[ToLook2+1]
dx = 0
if ExtensionSegments > ExistingSegments :
dn = (ExtensionSegments-ExistingSegments)/2.
dx = dn*(Dmax-Dmin)/ExistingSegments
#MacObject('CompBoxF',[(X0-CoefHor*dx/2+CoefVer*(-X0+Dmin-dx/2),Y0-CoefVer*dx/2+CoefHor*(-Y0+Dmin-dx/2)),(dx,dx)],[(dn,dn)],publish=0)
#MacObject('CompBoxF',[(X0-CoefHor*dx/2+CoefVer*(-X0+Dmax+dx/2),Y0-CoefVer*dx/2+CoefHor*(-Y0+Dmax+dx/2)),(dx,dx)],[(dn,dn)],publish=0)
BoxSide = (Dmax-Dmin+2*dx)/2.
Obj = []
Obj.append(MacObject('BoxAng32',[(X0+CoefHor*(BoxSide/2)+CoefVer*(-BoxSide/2),Y0+CoefVer*(BoxSide/2)+CoefHor*(-BoxSide/2)),(BoxSide,BoxSide)],[int(ExtensionSegments/6),DirPar[0]],groups=GroupArray(ToLook3[0],GroupNames[0])))
Obj.append(MacObject('BoxAng32',[(X0+CoefHor*(BoxSide/2)+CoefVer*(BoxSide/2),Y0+CoefVer*(BoxSide/2)+CoefHor*(BoxSide/2)),(BoxSide,BoxSide)],[int(ExtensionSegments/6),DirPar[1]],groups=GroupArray(ToLook3[0],GroupNames[0])))
NLevOpt = 0 ToLook3 = {'SN' : lambda : [0,1,2,3],
for NLevels in range (1,100) : 'NS' : lambda : [1,0,3,2],
DX1 = abs(CoefVer)*BoxSide*2.**(NLevels+1)+abs(CoefHor)*BoxSide*2.**(NLevels) 'EW' : lambda : [3,2,1,0],
DY1 = abs(CoefHor)*BoxSide*2.**(NLevels+1)+abs(CoefVer)*BoxSide*2.**(NLevels) 'WE' : lambda : [2,3,0,1], }[Orientation]()
if DX1 > DX or DY1 > DY :
NLevOpt = NLevels-1
DXinner = DX1/2.
DYinner = DY1/2.
break
dummyArray = [DXinner,DYinner,DYinner,DXinner]
D1inner = dummyArray[ToLook2] # = DXinner for SN and NS orientations
D2inner = dummyArray[ToLook2+1] # = DYinner for SN and NS orientations
dummyArray = [DX,DY,DY,DX]
D1 = dummyArray[ToLook2] # = DX for SN and NS orientations
D2 = dummyArray[ToLook2+1] # = DY for SN and NS orientations
if D1inner < D1 :
GN0a = GroupArray(ToLook3[0],GroupNames[1])
GN0b = GroupArray(ToLook3[0],GroupNames[2])
GN01 = GroupArray(ToLook3[0],GroupNames[1])
GN02 = GroupArray(ToLook3[0],GroupNames[2])
if D2inner < D2 :
GN10 = [None,None,None,None]
GN11 = [None,None,None,None]
GN20 = [None,None,None,None]
else :
GN10 = GroupArray(ToLook3[1],GroupNames[3])
GN11 = GroupArray(ToLook3[1],GroupNames[3])
GN20 = GroupArray(ToLook3[1],GroupNames[3])
else :
GN0a = GroupArray(ToLook3[0],GroupNames[1])
GN0b = GroupArray(ToLook3[0],GroupNames[2])
GN01 = GroupArray([ToLook3[0],ToLook3[2]],[GroupNames[1],GroupNames[4]])
GN02 = GroupArray([ToLook3[0],ToLook3[3]],[GroupNames[2],GroupNames[5]])
if D2inner < D2 :
GN10 = GroupArray(ToLook3[2],GroupNames[4])
GN11 = GroupArray(ToLook3[3],GroupNames[5])
GN20 = [None,None,None,None]
else :
GN10 = GroupArray([ToLook3[1],ToLook3[2]],[GroupNames[3],GroupNames[4]])
GN11 = GroupArray([ToLook3[1],ToLook3[3]],[GroupNames[3],GroupNames[5]])
GN20 = GroupArray(ToLook3[1],GroupNames[3])
for N in range (1,NLevOpt+1):
n=N-1
D = BoxSide*(2.**n)
if N < NLevOpt :
Obj.append(MacObject('Box42' ,[(X0+D*(CoefHor*1/2-CoefVer*3/2) , Y0+D*(CoefVer*1/2-CoefHor*3/2) ) , (D,D)],['auto',DirPar[2]], groups=GN0a))
Obj.append(MacObject('BoxAng32',[(X0+D*(CoefHor*3/2-CoefVer*3/2) , Y0+D*(CoefVer*3/2-CoefHor*3/2) ) , (D,D)],['auto',DirPar[3]]))
Obj.append(MacObject('Box42' ,[(X0+D*(CoefHor*3/2-CoefVer*1/2) , Y0+D*(CoefVer*3/2-CoefHor*1/2) ) , (D,D)],['auto',DirPar[4]]))
Obj.append(MacObject('Box42' ,[(X0+D*(CoefHor*3/2+CoefVer*1/2) , Y0+D*(CoefHor*1/2+CoefVer*3/2) ) , (D,D)],['auto',DirPar[5]]))
Obj.append(MacObject('BoxAng32',[(X0+D*(CoefVer*3/2+CoefHor*3/2) , Y0+D*(CoefVer*3/2+CoefHor*3/2) ) , (D,D)],['auto',DirPar[6]]))
Obj.append(MacObject('Box42' ,[(X0+D*(CoefVer*3/2+CoefHor*1/2) , Y0+D*(CoefHor*3/2+CoefVer*1/2) ) , (D,D)],['auto',DirPar[7]], groups=GN0b))
else :
Obj.append(MacObject('Box42' ,[(X0+D*(CoefHor*1/2-CoefVer*3/2) , Y0+D*(CoefVer*1/2-CoefHor*3/2) ) , (D,D)],['auto',DirPar[2]], groups=GN01))
Obj.append(MacObject('BoxAng32',[(X0+D*(CoefHor*3/2-CoefVer*3/2) , Y0+D*(CoefVer*3/2-CoefHor*3/2) ) , (D,D)],['auto',DirPar[3]], groups=GN10))
Obj.append(MacObject('Box42' ,[(X0+D*(CoefHor*3/2-CoefVer*1/2) , Y0+D*(CoefVer*3/2-CoefHor*1/2) ) , (D,D)],['auto',DirPar[4]], groups=GN20))
Obj.append(MacObject('Box42' ,[(X0+D*(CoefHor*3/2+CoefVer*1/2) , Y0+D*(CoefHor*1/2+CoefVer*3/2) ) , (D,D)],['auto',DirPar[5]], groups=GN20))
Obj.append(MacObject('BoxAng32',[(X0+D*(CoefVer*3/2+CoefHor*3/2) , Y0+D*(CoefVer*3/2+CoefHor*3/2) ) , (D,D)],['auto',DirPar[6]], groups=GN11))
Obj.append(MacObject('Box42' ,[(X0+D*(CoefVer*3/2+CoefHor*1/2) , Y0+D*(CoefHor*3/2+CoefVer*1/2) ) , (D,D)],['auto',DirPar[7]], groups=GN02))
if args.__contains__('groups') :
if CoefVer and DX>DXinner : GroupNames = args['groups']
Obj.append(MacObject('CompBoxF',[(X0-CoefVer*0.25*(DX+DXinner),Y0+CoefVer*DYinner/2),((DX-DXinner)/2,DYinner)],['auto'], groups = GroupArray([ToLook3[0],ToLook3[2]],[GroupNames[1],GroupNames[4]]))) else : GroupNames = [None, None, None, None, None, None]
Obj.append(MacObject('CompBoxF',[(X0+CoefVer*0.25*(DX+DXinner),Y0+CoefVer*DYinner/2),((DX-DXinner)/2,DYinner)],['auto'], groups = GroupArray([ToLook3[0],ToLook3[3]],[GroupNames[2],GroupNames[5]])))
if DY>DYinner : ExistingSegments = Config.ListObj[-1].DirectionalMeshParams[ToLook1]
Obj.append(MacObject('CompBoxF',[(X0-CoefVer*0.25*(DX+DXinner),Y0+CoefVer*(DY+DYinner)/2.),((DX-DXinner)/2,DY-DYinner)],['auto'], groups = GroupArray([ToLook3[1],ToLook3[2]],[GroupNames[3],GroupNames[4]]))) ObjIDs = Config.Connections[-1][ToLook1]
Obj.append(MacObject('CompBoxF',[(X0+CoefVer*0.25*(DX+DXinner),Y0+CoefVer*(DY+DYinner)/2.),((DX-DXinner)/2,DY-DYinner)],['auto'], groups = GroupArray([ToLook3[1],ToLook3[3]],[GroupNames[3],GroupNames[5]]))) RemoveLastObj()
Obj.append(MacObject('CompBoxF',[(X0,Y0+CoefVer*(DY+DYinner)/2.),(DXinner,DY-DYinner)],['auto'], groups = GroupArray(ToLook3[1],GroupNames[3])))
elif CoefHor and DY>DYinner : ExtensionSegments = math.ceil(ExistingSegments/12.)*12.
Obj.append(MacObject('CompBoxF',[(X0+CoefHor*DXinner/2,Y0-CoefHor*0.25*(DY+DYinner)),(DXinner,(DY-DYinner)/2)],['auto'], groups = GroupArray([ToLook3[0],ToLook3[2]],[GroupNames[1],GroupNames[4]]))) Dmin = 1.E50
Obj.append(MacObject('CompBoxF',[(X0+CoefHor*DXinner/2,Y0+CoefHor*0.25*(DY+DYinner)),(DXinner,(DY-DYinner)/2)],['auto'], groups = GroupArray([ToLook3[0],ToLook3[3]],[GroupNames[2],GroupNames[5]]))) Dmax = -1.E50
if DX>DXinner : for ObjID in ObjIDs :
Obj.append(MacObject('CompBoxF',[(X0+CoefHor*(DX+DXinner)/2.,Y0-CoefHor*0.25*(DY+DYinner)),(DX-DXinner,(DY-DYinner)/2)],['auto'], groups = GroupArray([ToLook3[1],ToLook3[2]],[GroupNames[3],GroupNames[4]]))) Boundaries = Config.ListObj[ObjID].Boundaries()
Obj.append(MacObject('CompBoxF',[(X0+CoefHor*(DX+DXinner)/2.,Y0+CoefHor*0.25*(DY+DYinner)),(DX-DXinner,(DY-DYinner)/2)],['auto'], groups = GroupArray([ToLook3[1],ToLook3[3]],[GroupNames[3],GroupNames[5]]))) if Boundaries[ToLook2] < Dmin : Dmin = Boundaries[ToLook2]
Obj.append(MacObject('CompBoxF',[(X0+CoefHor*(DX+DXinner)/2.,Y0),(DX-DXinner,DYinner)],['auto'], groups = GroupArray(ToLook3[1],GroupNames[3]))) if Boundaries[ToLook2+1] > Dmax : Dmax = Boundaries[ToLook2+1]
return Obj dx = 0
if ExtensionSegments > ExistingSegments :
dn = (ExtensionSegments-ExistingSegments)/2.
dx = dn*(Dmax-Dmin)/ExistingSegments
#MacObject('CompBoxF',[(X0-CoefHor*dx/2+CoefVer*(-X0+Dmin-dx/2),Y0-CoefVer*dx/2+CoefHor*(-Y0+Dmin-dx/2)),(dx,dx)],[(dn,dn)],publish=0)
#MacObject('CompBoxF',[(X0-CoefHor*dx/2+CoefVer*(-X0+Dmax+dx/2),Y0-CoefVer*dx/2+CoefHor*(-Y0+Dmax+dx/2)),(dx,dx)],[(dn,dn)],publish=0)
BoxSide = (Dmax-Dmin+2*dx)/2.
Obj = []
Obj.append(MacObject('BoxAng32',[(X0+CoefHor*(BoxSide/2)+CoefVer*(-BoxSide/2),Y0+CoefVer*(BoxSide/2)+CoefHor*(-BoxSide/2)),(BoxSide,BoxSide)],[int(ExtensionSegments/6),DirPar[0]],groups=GroupArray(ToLook3[0],GroupNames[0])))
Obj.append(MacObject('BoxAng32',[(X0+CoefHor*(BoxSide/2)+CoefVer*(BoxSide/2),Y0+CoefVer*(BoxSide/2)+CoefHor*(BoxSide/2)),(BoxSide,BoxSide)],[int(ExtensionSegments/6),DirPar[1]],groups=GroupArray(ToLook3[0],GroupNames[0])))
NLevOpt = 0
for NLevels in range (1,100) :
DX1 = abs(CoefVer)*BoxSide*2.**(NLevels+1)+abs(CoefHor)*BoxSide*2.**(NLevels)
DY1 = abs(CoefHor)*BoxSide*2.**(NLevels+1)+abs(CoefVer)*BoxSide*2.**(NLevels)
if DX1 > DX or DY1 > DY :
NLevOpt = NLevels-1
DXinner = DX1/2.
DYinner = DY1/2.
break
dummyArray = [DXinner,DYinner,DYinner,DXinner]
D1inner = dummyArray[ToLook2] # = DXinner for SN and NS orientations
D2inner = dummyArray[ToLook2+1] # = DYinner for SN and NS orientations
dummyArray = [DX,DY,DY,DX]
D1 = dummyArray[ToLook2] # = DX for SN and NS orientations
D2 = dummyArray[ToLook2+1] # = DY for SN and NS orientations
if D1inner < D1 :
GN0a = GroupArray(ToLook3[0],GroupNames[1])
GN0b = GroupArray(ToLook3[0],GroupNames[2])
GN01 = GroupArray(ToLook3[0],GroupNames[1])
GN02 = GroupArray(ToLook3[0],GroupNames[2])
if D2inner < D2 :
GN10 = [None,None,None,None]
GN11 = [None,None,None,None]
GN20 = [None,None,None,None]
else :
GN10 = GroupArray(ToLook3[1],GroupNames[3])
GN11 = GroupArray(ToLook3[1],GroupNames[3])
GN20 = GroupArray(ToLook3[1],GroupNames[3])
else :
GN0a = GroupArray(ToLook3[0],GroupNames[1])
GN0b = GroupArray(ToLook3[0],GroupNames[2])
GN01 = GroupArray([ToLook3[0],ToLook3[2]],[GroupNames[1],GroupNames[4]])
GN02 = GroupArray([ToLook3[0],ToLook3[3]],[GroupNames[2],GroupNames[5]])
if D2inner < D2 :
GN10 = GroupArray(ToLook3[2],GroupNames[4])
GN11 = GroupArray(ToLook3[3],GroupNames[5])
GN20 = [None,None,None,None]
else :
GN10 = GroupArray([ToLook3[1],ToLook3[2]],[GroupNames[3],GroupNames[4]])
GN11 = GroupArray([ToLook3[1],ToLook3[3]],[GroupNames[3],GroupNames[5]])
GN20 = GroupArray(ToLook3[1],GroupNames[3])
for N in range (1,NLevOpt+1):
n=N-1
D = BoxSide*(2.**n)
if N < NLevOpt :
Obj.append(MacObject('Box42' ,[(X0+D*(CoefHor*1/2-CoefVer*3/2) , Y0+D*(CoefVer*1/2-CoefHor*3/2) ) , (D,D)],['auto',DirPar[2]], groups=GN0a))
Obj.append(MacObject('BoxAng32',[(X0+D*(CoefHor*3/2-CoefVer*3/2) , Y0+D*(CoefVer*3/2-CoefHor*3/2) ) , (D,D)],['auto',DirPar[3]]))
Obj.append(MacObject('Box42' ,[(X0+D*(CoefHor*3/2-CoefVer*1/2) , Y0+D*(CoefVer*3/2-CoefHor*1/2) ) , (D,D)],['auto',DirPar[4]]))
Obj.append(MacObject('Box42' ,[(X0+D*(CoefHor*3/2+CoefVer*1/2) , Y0+D*(CoefHor*1/2+CoefVer*3/2) ) , (D,D)],['auto',DirPar[5]]))
Obj.append(MacObject('BoxAng32',[(X0+D*(CoefVer*3/2+CoefHor*3/2) , Y0+D*(CoefVer*3/2+CoefHor*3/2) ) , (D,D)],['auto',DirPar[6]]))
Obj.append(MacObject('Box42' ,[(X0+D*(CoefVer*3/2+CoefHor*1/2) , Y0+D*(CoefHor*3/2+CoefVer*1/2) ) , (D,D)],['auto',DirPar[7]], groups=GN0b))
else :
Obj.append(MacObject('Box42' ,[(X0+D*(CoefHor*1/2-CoefVer*3/2) , Y0+D*(CoefVer*1/2-CoefHor*3/2) ) , (D,D)],['auto',DirPar[2]], groups=GN01))
Obj.append(MacObject('BoxAng32',[(X0+D*(CoefHor*3/2-CoefVer*3/2) , Y0+D*(CoefVer*3/2-CoefHor*3/2) ) , (D,D)],['auto',DirPar[3]], groups=GN10))
Obj.append(MacObject('Box42' ,[(X0+D*(CoefHor*3/2-CoefVer*1/2) , Y0+D*(CoefVer*3/2-CoefHor*1/2) ) , (D,D)],['auto',DirPar[4]], groups=GN20))
Obj.append(MacObject('Box42' ,[(X0+D*(CoefHor*3/2+CoefVer*1/2) , Y0+D*(CoefHor*1/2+CoefVer*3/2) ) , (D,D)],['auto',DirPar[5]], groups=GN20))
Obj.append(MacObject('BoxAng32',[(X0+D*(CoefVer*3/2+CoefHor*3/2) , Y0+D*(CoefVer*3/2+CoefHor*3/2) ) , (D,D)],['auto',DirPar[6]], groups=GN11))
Obj.append(MacObject('Box42' ,[(X0+D*(CoefVer*3/2+CoefHor*1/2) , Y0+D*(CoefHor*3/2+CoefVer*1/2) ) , (D,D)],['auto',DirPar[7]], groups=GN02))
if CoefVer and DX>DXinner :
Obj.append(MacObject('CompBoxF',[(X0-CoefVer*0.25*(DX+DXinner),Y0+CoefVer*DYinner/2),((DX-DXinner)/2,DYinner)],['auto'], groups = GroupArray([ToLook3[0],ToLook3[2]],[GroupNames[1],GroupNames[4]])))
Obj.append(MacObject('CompBoxF',[(X0+CoefVer*0.25*(DX+DXinner),Y0+CoefVer*DYinner/2),((DX-DXinner)/2,DYinner)],['auto'], groups = GroupArray([ToLook3[0],ToLook3[3]],[GroupNames[2],GroupNames[5]])))
if DY>DYinner :
Obj.append(MacObject('CompBoxF',[(X0-CoefVer*0.25*(DX+DXinner),Y0+CoefVer*(DY+DYinner)/2.),((DX-DXinner)/2,DY-DYinner)],['auto'], groups = GroupArray([ToLook3[1],ToLook3[2]],[GroupNames[3],GroupNames[4]])))
Obj.append(MacObject('CompBoxF',[(X0+CoefVer*0.25*(DX+DXinner),Y0+CoefVer*(DY+DYinner)/2.),((DX-DXinner)/2,DY-DYinner)],['auto'], groups = GroupArray([ToLook3[1],ToLook3[3]],[GroupNames[3],GroupNames[5]])))
Obj.append(MacObject('CompBoxF',[(X0,Y0+CoefVer*(DY+DYinner)/2.),(DXinner,DY-DYinner)],['auto'], groups = GroupArray(ToLook3[1],GroupNames[3])))
elif CoefHor and DY>DYinner :
Obj.append(MacObject('CompBoxF',[(X0+CoefHor*DXinner/2,Y0-CoefHor*0.25*(DY+DYinner)),(DXinner,(DY-DYinner)/2)],['auto'], groups = GroupArray([ToLook3[0],ToLook3[2]],[GroupNames[1],GroupNames[4]])))
Obj.append(MacObject('CompBoxF',[(X0+CoefHor*DXinner/2,Y0+CoefHor*0.25*(DY+DYinner)),(DXinner,(DY-DYinner)/2)],['auto'], groups = GroupArray([ToLook3[0],ToLook3[3]],[GroupNames[2],GroupNames[5]])))
if DX>DXinner :
Obj.append(MacObject('CompBoxF',[(X0+CoefHor*(DX+DXinner)/2.,Y0-CoefHor*0.25*(DY+DYinner)),(DX-DXinner,(DY-DYinner)/2)],['auto'], groups = GroupArray([ToLook3[1],ToLook3[2]],[GroupNames[3],GroupNames[4]])))
Obj.append(MacObject('CompBoxF',[(X0+CoefHor*(DX+DXinner)/2.,Y0+CoefHor*0.25*(DY+DYinner)),(DX-DXinner,(DY-DYinner)/2)],['auto'], groups = GroupArray([ToLook3[1],ToLook3[3]],[GroupNames[3],GroupNames[5]])))
Obj.append(MacObject('CompBoxF',[(X0+CoefHor*(DX+DXinner)/2.,Y0),(DX-DXinner,DYinner)],['auto'], groups = GroupArray(ToLook3[1],GroupNames[3])))
return Obj
def RemoveLastObj() :
Config.ListObj = Config.ListObj[:-1]
Config.Connections = Config.Connections[:-1]
def RemoveLastObj() :
Config.ListObj = Config.ListObj[:-1]
Config.Connections = Config.Connections[:-1]
def GroupArray(indices, GroupNames) : def GroupArray(indices, GroupNames) :
if type(indices) is int : if type(indices) is int :
indices = [indices] indices = [indices]
GroupNames = [GroupNames] GroupNames = [GroupNames]
Output = [None,None,None,None] Output = [None,None,None,None]
for i, ind in enumerate(indices) : for i, ind in enumerate(indices) :
Output[ind] = GroupNames[i] Output[ind] = GroupNames[i]
return Output return Output

291
src/Tools/MacMesh/MacMesh/CompositeBox.py
View File

@ -27,159 +27,156 @@ sys.path.append(CWD)
from MacObject import * from MacObject import *
import Config, GenFunctions import Config, GenFunctions
def CompositeBox (X0 , Y0 , DX , DY , **args ) : def CompositeBox (X0 , Y0 , DX , DY , **args ) :
if args.__contains__('groups') : if args.__contains__('groups') :
GroupNames = args['groups'] GroupNames = args['groups']
else : GroupNames = [None, None, None, None] else : GroupNames = [None, None, None, None]
# Create a full Box just to inherit, globally, the mesh parameters of bounding objects # Create a full Box just to inherit, globally, the mesh parameters of bounding objects
MacObject('CompBoxF',[(X0,Y0),(DX,DY)],['auto'],publish=0) MacObject('CompBoxF',[(X0,Y0),(DX,DY)],['auto'],publish=0)
# Save the existing number of segments on each direction # Save the existing number of segments on each direction
ExistingSegments = Config.ListObj[-1].DirectionalMeshParams ExistingSegments = Config.ListObj[-1].DirectionalMeshParams
# Sort the connection list for the full Box # Sort the connection list for the full Box
ObjIDLists = SortObjLists(Config.Connections[-1],X0 , Y0 , DX , DY ) ObjIDLists = SortObjLists(Config.Connections[-1],X0 , Y0 , DX , DY )
RemoveLastObj() RemoveLastObj()
print "ObjIDLists: ", ObjIDLists print "ObjIDLists: ", ObjIDLists
RealSegments = [] RealSegments = []
Direction = [] Direction = []
flag = 0 flag = 0
if not(args.__contains__('recursive')) : Config.Count = 0 if not(args.__contains__('recursive')) : Config.Count = 0
print "Config.Count : ", Config.Count print "Config.Count : ", Config.Count
Config.Criterion = GetCriterion(ObjIDLists) Config.Criterion = GetCriterion(ObjIDLists)
for index, ObjList in enumerate(ObjIDLists) : for index, ObjList in enumerate(ObjIDLists) :
if not (ObjList[0] == -1 or Config.Count >= Config.Criterion): if not (ObjList[0] == -1 or Config.Count >= Config.Criterion):
if len(ObjList)>1 : flag = 1 if len(ObjList)>1 : flag = 1
else : flag = 0 else : flag = 0
for ObjID in ObjList: for ObjID in ObjList:
ToLook0 = [2,2,0,0][index] ToLook0 = [2,2,0,0][index]
ToLook1 = [3,2,1,0][index] ToLook1 = [3,2,1,0][index]
CommonSide = FindCommonSide(Config.ListObj[ObjID].DirBoundaries(ToLook1),[X0-DX/2.,X0+DX/2.,Y0-DY/2.,Y0+DY/2.][ToLook0:ToLook0+2]) CommonSide = FindCommonSide(Config.ListObj[ObjID].DirBoundaries(ToLook1),[X0-DX/2.,X0+DX/2.,Y0-DY/2.,Y0+DY/2.][ToLook0:ToLook0+2])
ToLook2 = [1,0,3,2][index] ToLook2 = [1,0,3,2][index]
RealSegments.append(Config.ListObj[ObjID].DirectionalMeshParams[ToLook2]*IntLen(CommonSide)/IntLen(Config.ListObj[ObjID].DirBoundaries(ToLook1))) RealSegments.append(Config.ListObj[ObjID].DirectionalMeshParams[ToLook2]*IntLen(CommonSide)/IntLen(Config.ListObj[ObjID].DirBoundaries(ToLook1)))
Direction.append(ToLook0/2) Direction.append(ToLook0/2)
if flag and Config.Count < Config.Criterion: if flag and Config.Count < Config.Criterion:
if index < 2 : if index < 2 :
if abs(CommonSide[0] - (Y0-DY/2.))<1e-7 : SouthGR = GroupNames[0] if abs(CommonSide[0] - (Y0-DY/2.))<1e-7 : SouthGR = GroupNames[0]
else : SouthGR = None else : SouthGR = None
if abs(CommonSide[1] - (Y0+DY/2.))<1e-7 : NorthGR = GroupNames[1] if abs(CommonSide[1] - (Y0+DY/2.))<1e-7 : NorthGR = GroupNames[1]
else : NorthGR = None else : NorthGR = None
CompositeBox (X0, CommonSide[0]+IntLen(CommonSide)/2., DX,IntLen(CommonSide), recursive=1, groups = [SouthGR,NorthGR]+GroupNames[2:4]) CompositeBox (X0, CommonSide[0]+IntLen(CommonSide)/2., DX,IntLen(CommonSide), recursive=1, groups = [SouthGR,NorthGR]+GroupNames[2:4])
else : else :
if abs(CommonSide[0] - (X0-DX/2.))<1e-7 : EastGR = GroupNames[2] if abs(CommonSide[0] - (X0-DX/2.))<1e-7 : EastGR = GroupNames[2]
else : EastGR = None else : EastGR = None
if abs(CommonSide[1] - (X0+DX/2.))<1e-7 : WestGR = GroupNames[3] if abs(CommonSide[1] - (X0+DX/2.))<1e-7 : WestGR = GroupNames[3]
else : WestGR = None else : WestGR = None
CompositeBox (CommonSide[0]+IntLen(CommonSide)/2., Y0, IntLen(CommonSide),DY, recursive=1, groups = GroupNames[0:2]+[EastGR,WestGR]) CompositeBox (CommonSide[0]+IntLen(CommonSide)/2., Y0, IntLen(CommonSide),DY, recursive=1, groups = GroupNames[0:2]+[EastGR,WestGR])
if Config.Count >= Config.Criterion :
break
if flag == 0 and Config.Count < Config.Criterion:
#print "Dir : ", Direction
#print "RealSegments : ", RealSegments
#Xind = Direction.index(0)
#Yind = Direction.index(1)
#MacObject('CompBoxF',[(X0,Y0),(DX,DY)] ,[(RealSegments[Xind],RealSegments[Yind])], groups = GroupNames)
MacObject('CompBoxF',[(X0,Y0),(DX,DY)] ,['auto'], groups = GroupNames)
Config.Count += 1
if Config.Count >= Config.Criterion :
break
if flag == 0 and Config.Count < Config.Criterion:
#print "Dir : ", Direction
#print "RealSegments : ", RealSegments
#Xind = Direction.index(0)
#Yind = Direction.index(1)
#MacObject('CompBoxF',[(X0,Y0),(DX,DY)] ,[(RealSegments[Xind],RealSegments[Yind])], groups = GroupNames)
MacObject('CompBoxF',[(X0,Y0),(DX,DY)] ,['auto'], groups = GroupNames)
Config.Count += 1
def FindCommonSide (Int1, Int2) : def FindCommonSide (Int1, Int2) :
if abs(min(Int1[1],Int2[1])-max(Int1[0],Int2[0])) < 1e-5: return [0,0] if abs(min(Int1[1],Int2[1])-max(Int1[0],Int2[0])) < 1e-5: return [0,0]
else : return [max(Int1[0],Int2[0]), min(Int1[1],Int2[1])] else : return [max(Int1[0],Int2[0]), min(Int1[1],Int2[1])]
def IntLen (Interval) : def IntLen (Interval) :
return abs(Interval[1]-Interval[0]) return abs(Interval[1]-Interval[0])
def RemoveLastObj() : def RemoveLastObj() :
Config.ListObj = Config.ListObj[:-1] Config.ListObj = Config.ListObj[:-1]
Config.Connections = Config.Connections[:-1] Config.Connections = Config.Connections[:-1]
def GetCriterion (ObjListIDs): def GetCriterion (ObjListIDs):
return max(Config.Criterion, max(len(ObjListIDs[0]),len(ObjListIDs[1]))*max(len(ObjListIDs[2]),len(ObjListIDs[3]))) return max(Config.Criterion, max(len(ObjListIDs[0]),len(ObjListIDs[1]))*max(len(ObjListIDs[2]),len(ObjListIDs[3])))
def SortObjLists (List,X0,Y0,DX,DY) : def SortObjLists (List,X0,Y0,DX,DY) :
""" """
This function sorts the list of neighbouring objects on each side, according to their intersection This function sorts the list of neighbouring objects on each side, according to their intersection
with the object being created. From South to North and from East to West with the object being created. From South to North and from East to West
""" """
Output = List Output = List
# First find the directions where no neighbour exists # First find the directions where no neighbour exists
# Important : Here we assume that exactly two directions have no neighbours !!! # Important : Here we assume that exactly two directions have no neighbours !!!
# Should we change this to allow a more general case ???? # Should we change this to allow a more general case ????
dummy = IndexMultiOcc(List,(-1,)) dummy = IndexMultiOcc(List,(-1,))
# dummy[0] is either 0, meaning there is no neighbour on X- (West) # dummy[0] is either 0, meaning there is no neighbour on X- (West)
# or 1, meaning there is no neighbour on X+ (East) # or 1, meaning there is no neighbour on X+ (East)
# Similarly dummy[1] can be either 2 or 3 (South and North respectively) # Similarly dummy[1] can be either 2 or 3 (South and North respectively)
# In order to get back to the formalism of groups (SNWE) # In order to get back to the formalism of groups (SNWE)
# => we do the following to define Sense of no neighbours and then the Direction list # => we do the following to define Sense of no neighbours and then the Direction list
# is calculated as to include uniquely the directions where we DO have neighbours # is calculated as to include uniquely the directions where we DO have neighbours
if len(dummy) == 1 : if len(dummy) == 1 :
# This adds a second direction where neighbours are not regarded, it is either 0 or 2 # This adds a second direction where neighbours are not regarded, it is either 0 or 2
dummy.append(2*(dummy[0]+2<4)) dummy.append(2*(dummy[0]+2<4))
print("Careful, you have neighbours on 3 or more sides of the box, we will not check if on two parallel sides the boxes are compatible !!!") print("Careful, you have neighbours on 3 or more sides of the box, we will not check if on two parallel sides the boxes are compatible !!!")
if len(dummy) == 2 or len(dummy) == 1 : if len(dummy) == 2 or len(dummy) == 1 :
# Sense contains : Vertical then Horizontal # Sense contains : Vertical then Horizontal
Sense = [dummy[1]%2,dummy[0]] Sense = [dummy[1]%2,dummy[0]]
DirList = [[1,0][dummy[0]],[3,2][dummy[1]%2]] DirList = [[1,0][dummy[0]],[3,2][dummy[1]%2]]
for index,Direction in enumerate(DirList) : for index,Direction in enumerate(DirList) :
ObjList = List[Direction] ObjList = List[Direction]
RankMin = [] RankMin = []
ToLook0 = [2,2,0,0][Direction] ToLook0 = [2,2,0,0][Direction]
ToLook1 = [3,2,1,0][Direction] ToLook1 = [3,2,1,0][Direction]
for index1,ObjID in enumerate(ObjList) : for index1,ObjID in enumerate(ObjList) :
RankMin.append([-1.,1.][Sense[index]] * FindCommonSide(Config.ListObj[ObjID].DirBoundaries(ToLook1),[X0-DX/2.,X0+DX/2.,Y0-DY/2.,Y0+DY/2.][ToLook0:ToLook0+2])[Sense[index]]) RankMin.append([-1.,1.][Sense[index]] * FindCommonSide(Config.ListObj[ObjID].DirBoundaries(ToLook1),[X0-DX/2.,X0+DX/2.,Y0-DY/2.,Y0+DY/2.][ToLook0:ToLook0+2])[Sense[index]])
Output[Direction] = SortList(ObjList,RankMin) Output[Direction] = SortList(ObjList,RankMin)
elif len(dummy) == 3 : elif len(dummy) == 3 :
# We find the direction where we do have neighbours and then we sort the object list along it # We find the direction where we do have neighbours and then we sort the object list along it
Sense = dummy[0]%2 Sense = dummy[0]%2
Direction = [ i not in dummy for i in range(4) ].index(True) Direction = [ i not in dummy for i in range(4) ].index(True)
ObjList = List[Direction] ObjList = List[Direction]
RankMin = [] RankMin = []
ToLook0 = [2,2,0,0][Direction] ToLook0 = [2,2,0,0][Direction]
ToLook1 = [3,2,1,0][Direction] ToLook1 = [3,2,1,0][Direction]
for index1,ObjID in enumerate(ObjList) : for index1,ObjID in enumerate(ObjList) :
RankMin.append([-1.,1.][Sense] * FindCommonSide(Config.ListObj[ObjID].DirBoundaries(ToLook1),[X0-DX/2.,X0+DX/2.,Y0-DY/2.,Y0+DY/2.][ToLook0:ToLook0+2])[Sense]) RankMin.append([-1.,1.][Sense] * FindCommonSide(Config.ListObj[ObjID].DirBoundaries(ToLook1),[X0-DX/2.,X0+DX/2.,Y0-DY/2.,Y0+DY/2.][ToLook0:ToLook0+2])[Sense])
Output[Direction] = SortList(ObjList,RankMin) Output[Direction] = SortList(ObjList,RankMin)
else : else :
print ("Error : the composite box being created has no neighbours, how on earth do you want us to inherit its mesh parameters!!!") print ("Error : the composite box being created has no neighbours, how on earth do you want us to inherit its mesh parameters!!!")
return Output return Output
def IndexMultiOcc (Array,Element) : def IndexMultiOcc (Array,Element) :
""" """
This functions returns the occurrences indices of Element in Array. This functions returns the occurrences indices of Element in Array.
As opposed to Array.index(Element) method, this allows determining As opposed to Array.index(Element) method, this allows determining
multiple entries rather than just the first one! multiple entries rather than just the first one!
""" """
Output = [] Output = []
try : Array.index(Element) try : Array.index(Element)
except ValueError : print "No more occurrences" except ValueError : print "No more occurrences"
else : Output.append(Array.index(Element)) else : Output.append(Array.index(Element))
if not(Output == []) and len(Array) > 1 : if not(Output == []) and len(Array) > 1 :
for index, ArrElem in enumerate(Array[Output[0]+1:]) : for index, ArrElem in enumerate(Array[Output[0]+1:]) :
if ArrElem == Element : Output.append(index+Output[0]+1) if ArrElem == Element : Output.append(index+Output[0]+1)
return Output return Output
def SortList (ValList, CritList): def SortList (ValList, CritList):
Output = [] Output = []
SortedCritList = copy.copy(CritList) SortedCritList = copy.copy(CritList)
SortedCritList.sort() SortedCritList.sort()
for i in range(0,len(ValList)): for i in range(0,len(ValList)):
index = CritList.index(SortedCritList[i]) index = CritList.index(SortedCritList[i])
Output.append(ValList[index]) Output.append(ValList[index])
return Output return Output

417
src/Tools/MacMesh/MacMesh/CompositeBoxF.py
View File

@ -27,224 +27,223 @@ sys.path.append(CWD)
from MacObject import * from MacObject import *
import Config, GenFunctions import Config, GenFunctions
def CompositeBoxF (Pt1 , Pt2 , Pt3 , Pt4 , **args ) : def CompositeBoxF (Pt1 , Pt2 , Pt3 , Pt4 , **args ) :
[Pt1 , Pt2 , Pt3 , Pt4] = GenFunctions.SortPoints([Pt1 , Pt2 , Pt3 , Pt4]) [Pt1 , Pt2 , Pt3 , Pt4] = GenFunctions.SortPoints([Pt1 , Pt2 , Pt3 , Pt4])
if args.__contains__('groups') : if args.__contains__('groups') :
GroupNames = args['groups'] GroupNames = args['groups']
else : GroupNames = [None, None, None, None] else : GroupNames = [None, None, None, None]
# Create a full NonOrtho box just to inherit, globally, the mesh parameters of bounding objects # Create a full NonOrtho box just to inherit, globally, the mesh parameters of bounding objects
dummy = MacObject('NonOrtho',[Pt1,Pt2,Pt3,Pt4],['auto'],publish=0) dummy = MacObject('NonOrtho',[Pt1,Pt2,Pt3,Pt4],['auto'],publish=0)
# Save the existing number of segments on each direction # Save the existing number of segments on each direction
ExistingSeg0 = Config.ListObj[-1].DirectionalMeshParams ExistingSeg0 = Config.ListObj[-1].DirectionalMeshParams
Convention = [2,3,0,1] Convention = [2,3,0,1]
ExistingSegments = [ExistingSeg0[Convention[i]] for i in range(4)] ExistingSegments = [ExistingSeg0[Convention[i]] for i in range(4)]
# Save Boundary lengths on each direction # Save Boundary lengths on each direction
BoundaryLengths = [IntLen(dummy.DirBoundaries(i)) for i in range(4) ] BoundaryLengths = [IntLen(dummy.DirBoundaries(i)) for i in range(4) ]
# Calculate global mesh element size on each direction # Calculate global mesh element size on each direction
GlobalDelta = [1.*BoundaryLengths[i]/ExistingSegments[i] for i in range(4) ] GlobalDelta = [1.*BoundaryLengths[i]/ExistingSegments[i] for i in range(4) ]
print "GlobalDelta :",GlobalDelta print "GlobalDelta :",GlobalDelta
# Sort the connection list for the full Box # Sort the connection list for the full Box
[(X0,Y0),(DX,DY)] = dummy.GeoPar [(X0,Y0),(DX,DY)] = dummy.GeoPar
ObjIDLists = SortObjLists(Config.Connections[-1],X0 , Y0 , DX , DY ) ObjIDLists = SortObjLists(Config.Connections[-1],X0 , Y0 , DX , DY )
[Xmin,Xmax,Ymin,Ymax] = dummy.Boundaries() # Used for groups determination [Xmin,Xmax,Ymin,Ymax] = dummy.Boundaries() # Used for groups determination
RemoveLastObj() RemoveLastObj()
RealSegments = []
Direction = []
flag = 0
if not(args.__contains__('recursive')) :
Config.Count = 0
Config.Criterion = GetCriterion(ObjIDLists) RealSegments = []
for index, ObjList in enumerate(ObjIDLists) : Direction = []
if not (ObjList[0] == -1 or Config.Count >= Config.Criterion): flag = 0
if not(args.__contains__('recursive')) : if not(args.__contains__('recursive')) :
Config.DirIndex = index Config.Count = 0
if index > 1 : Config.RefPts = [Pt2, Pt3]
elif index == 0 : Config.RefPts = [Pt1, Pt2] Config.Criterion = GetCriterion(ObjIDLists)
else : Config.RefPts = [Pt4, Pt3] for index, ObjList in enumerate(ObjIDLists) :
if not (ObjList[0] == -1 or Config.Count >= Config.Criterion):
if len(ObjList)>1 : flag = 1 if not(args.__contains__('recursive')) :
else : flag = 0 Config.DirIndex = index
for ObjID in ObjList: if index > 1 : Config.RefPts = [Pt2, Pt3]
ToLook0 = [2,3,0,1][index] elif index == 0 : Config.RefPts = [Pt1, Pt2]
ToLook1 = [3,2,1,0][index] else : Config.RefPts = [Pt4, Pt3]
CommonSide = FindCommonSide(Config.ListObj[ObjID].DirBoundaries(ToLook1),dummy.DirBoundaries(ToLook0))
ToLook2 = [1,0,3,2][index] if len(ObjList)>1 : flag = 1
RealSegments = Config.ListObj[ObjID].DirectionalMeshParams[ToLook2]*IntLen(CommonSide)/IntLen(Config.ListObj[ObjID].DirBoundaries(ToLook1)) else : flag = 0
LocalDelta = 1.*IntLen(CommonSide)/RealSegments for ObjID in ObjList:
print "Direction:", ["West","East","South","North"][ToLook2] ToLook0 = [2,3,0,1][index]
print "IntLen(CommonSide):",IntLen(CommonSide) ToLook1 = [3,2,1,0][index]
print "RealSegments:",RealSegments CommonSide = FindCommonSide(Config.ListObj[ObjID].DirBoundaries(ToLook1),dummy.DirBoundaries(ToLook0))
print "LocalDelta:",LocalDelta ToLook2 = [1,0,3,2][index]
if flag and Config.Count < Config.Criterion: RealSegments = Config.ListObj[ObjID].DirectionalMeshParams[ToLook2]*IntLen(CommonSide)/IntLen(Config.ListObj[ObjID].DirBoundaries(ToLook1))
if index ==0 : LocalDelta = 1.*IntLen(CommonSide)/RealSegments
if abs(CommonSide[0] - Ymin)<1e-7 : SouthGR = GroupNames[0] print "Direction:", ["West","East","South","North"][ToLook2]
else : SouthGR = None print "IntLen(CommonSide):",IntLen(CommonSide)
if abs(CommonSide[1] - Ymax)<1e-7 : NorthGR = GroupNames[1] print "RealSegments:",RealSegments
else : NorthGR = None print "LocalDelta:",LocalDelta
if flag and Config.Count < Config.Criterion:
NDelta = Config.ListObj[ObjID].DirectionalMeshParams[ToLook2]* (LocalDelta-GlobalDelta[Convention[index]]) if index ==0 :
[Pt1,Pt2] = Config.RefPts if abs(CommonSide[0] - Ymin)<1e-7 : SouthGR = GroupNames[0]
Coef = [1.,-1.][index] else : SouthGR = None
Vref1 = [Coef*(Pt2[0]-Pt1[0]),Coef*(Pt2[1]-Pt1[1])] if abs(CommonSide[1] - Ymax)<1e-7 : NorthGR = GroupNames[1]
Vref2 = NormalizeVector([Pt2[0]-Pt3[0],Pt2[1]-Pt3[1]]) else : NorthGR = None
Ptref = Config.ListObj[ObjID].PtCoor[[2,3][index]]
NewPt = ExtrapPoint (Ptref,Vref1,Vref2,NDelta) NDelta = Config.ListObj[ObjID].DirectionalMeshParams[ToLook2]* (LocalDelta-GlobalDelta[Convention[index]])
CompositeBoxF (Pt1, Pt2, NewPt, Ptref, recursive=1, groups = [SouthGR,NorthGR]+GroupNames[2:4]) [Pt1,Pt2] = Config.RefPts
elif index == 1: Coef = [1.,-1.][index]
if abs(CommonSide[0] - Ymin)<1e-7 : SouthGR = GroupNames[0] Vref1 = [Coef*(Pt2[0]-Pt1[0]),Coef*(Pt2[1]-Pt1[1])]
else : SouthGR = None Vref2 = NormalizeVector([Pt2[0]-Pt3[0],Pt2[1]-Pt3[1]])
if abs(CommonSide[1] - Ymax)<1e-7 : NorthGR = GroupNames[1] Ptref = Config.ListObj[ObjID].PtCoor[[2,3][index]]
else : NorthGR = None NewPt = ExtrapPoint (Ptref,Vref1,Vref2,NDelta)
CompositeBoxF (Pt1, Pt2, NewPt, Ptref, recursive=1, groups = [SouthGR,NorthGR]+GroupNames[2:4])
NDelta = Config.ListObj[ObjID].DirectionalMeshParams[ToLook2]* (LocalDelta-GlobalDelta[Convention[index]]) elif index == 1:
[Pt4,Pt3] = Config.RefPts if abs(CommonSide[0] - Ymin)<1e-7 : SouthGR = GroupNames[0]
Coef = 1. else : SouthGR = None
Vref1 = [Coef*(Pt4[0]-Pt3[0]),Coef*(Pt4[1]-Pt3[1])] if abs(CommonSide[1] - Ymax)<1e-7 : NorthGR = GroupNames[1]
Vref2 = NormalizeVector([Pt1[0]-Pt4[0],Pt1[1]-Pt4[1]]) else : NorthGR = None
Ptref = Config.ListObj[ObjID].PtCoor[0]
NewPt = ExtrapPoint (Ptref,Vref1,Vref2,NDelta) NDelta = Config.ListObj[ObjID].DirectionalMeshParams[ToLook2]* (LocalDelta-GlobalDelta[Convention[index]])
CompositeBoxF (NewPt, Ptref, Pt3, Pt4, recursive=1, groups = [SouthGR,NorthGR]+GroupNames[2:4]) [Pt4,Pt3] = Config.RefPts
else : Coef = 1.
if abs(CommonSide[0] - Xmin)<1e-7 : WestGR = GroupNames[2] Vref1 = [Coef*(Pt4[0]-Pt3[0]),Coef*(Pt4[1]-Pt3[1])]
else : WestGR = None Vref2 = NormalizeVector([Pt1[0]-Pt4[0],Pt1[1]-Pt4[1]])
if abs(CommonSide[1] - Xmax)<1e-7 : EastGR = GroupNames[3] Ptref = Config.ListObj[ObjID].PtCoor[0]
else : EastGR = None NewPt = ExtrapPoint (Ptref,Vref1,Vref2,NDelta)
CompositeBoxF (NewPt, Ptref, Pt3, Pt4, recursive=1, groups = [SouthGR,NorthGR]+GroupNames[2:4])
NDelta = Config.ListObj[ObjID].DirectionalMeshParams[ToLook2]* (LocalDelta-GlobalDelta[Convention[index]]) else :
[Pt2,Pt3] = Config.RefPts if abs(CommonSide[0] - Xmin)<1e-7 : WestGR = GroupNames[2]
Coef = [1.,-1.][index-2] else : WestGR = None
Vref1 = [Coef*(Pt3[0]-Pt2[0]),Coef*(Pt3[1]-Pt2[1])] if abs(CommonSide[1] - Xmax)<1e-7 : EastGR = GroupNames[3]
Vref2 = NormalizeVector([Pt3[0]-Pt4[0],Pt3[1]-Pt4[1]]) else : EastGR = None
Ptref = Config.ListObj[ObjID].PtCoor[[3,0][index-2]]
NewPt = ExtrapPoint (Ptref,Vref1,Vref2,NDelta) NDelta = Config.ListObj[ObjID].DirectionalMeshParams[ToLook2]* (LocalDelta-GlobalDelta[Convention[index]])
CompositeBoxF (Ptref, Pt2, Pt3, NewPt, recursive=1, groups = GroupNames[0:2] + [WestGR,EastGR]) [Pt2,Pt3] = Config.RefPts
Coef = [1.,-1.][index-2]
Vref1 = [Coef*(Pt3[0]-Pt2[0]),Coef*(Pt3[1]-Pt2[1])]
Vref2 = NormalizeVector([Pt3[0]-Pt4[0],Pt3[1]-Pt4[1]])
Ptref = Config.ListObj[ObjID].PtCoor[[3,0][index-2]]
NewPt = ExtrapPoint (Ptref,Vref1,Vref2,NDelta)
CompositeBoxF (Ptref, Pt2, Pt3, NewPt, recursive=1, groups = GroupNames[0:2] + [WestGR,EastGR])
if Config.Count >= Config.Criterion :
break
if flag == 0 and Config.Count < Config.Criterion:
print "Creating NonOrtho object with the points:", Pt1,Pt2,Pt3,Pt4
MacObject('NonOrtho',[Pt1,Pt2,Pt3,Pt4] ,['auto'], groups = GroupNames)
Config.Count += 1
if Config.DirIndex > 1 : Config.RefPts = [Pt1, Pt4]
elif Config.DirIndex==0 : Config.RefPts = [Pt4, Pt3]
else : Config.RefPts = [Pt1, Pt2]
if Config.Count >= Config.Criterion :
break
if flag == 0 and Config.Count < Config.Criterion:
print "Creating NonOrtho object with the points:", Pt1,Pt2,Pt3,Pt4
MacObject('NonOrtho',[Pt1,Pt2,Pt3,Pt4] ,['auto'], groups = GroupNames)
Config.Count += 1
if Config.DirIndex > 1 : Config.RefPts = [Pt1, Pt4]
elif Config.DirIndex==0 : Config.RefPts = [Pt4, Pt3]
else : Config.RefPts = [Pt1, Pt2]
def FindCommonSide (Int1, Int2) : def FindCommonSide (Int1, Int2) :
if max(Int1[0],Int2[0])<min(Int1[1],Int2[1]): return [max(Int1[0],Int2[0]), min(Int1[1],Int2[1])] if max(Int1[0],Int2[0])<min(Int1[1],Int2[1]): return [max(Int1[0],Int2[0]), min(Int1[1],Int2[1])]
else : else :
print "Can not find interval intersection, returning [0,0]..." print "Can not find interval intersection, returning [0,0]..."
return [0,0] return [0,0]
def IntLen (Interval) : def IntLen (Interval) :
return float(abs(Interval[1]-Interval[0])) return float(abs(Interval[1]-Interval[0]))
def RemoveLastObj() : def RemoveLastObj() :
Config.ListObj = Config.ListObj[:-1] Config.ListObj = Config.ListObj[:-1]
Config.Connections = Config.Connections[:-1] Config.Connections = Config.Connections[:-1]
def NormalizeVector(V): def NormalizeVector(V):
Magnitude = math.sqrt(GenFunctions.DotProd(V,V)) Magnitude = math.sqrt(GenFunctions.DotProd(V,V))
return [ V[i]/Magnitude for i in range(len(V))] return [ V[i]/Magnitude for i in range(len(V))]
def GetCriterion (ObjListIDs): def GetCriterion (ObjListIDs):
return max(Config.Criterion, max(len(ObjListIDs[0]),len(ObjListIDs[1]))*max(len(ObjListIDs[2]),len(ObjListIDs[3]))) return max(Config.Criterion, max(len(ObjListIDs[0]),len(ObjListIDs[1]))*max(len(ObjListIDs[2]),len(ObjListIDs[3])))
def SortObjLists (List,X0,Y0,DX,DY) : def SortObjLists (List,X0,Y0,DX,DY) :
""" """
This function sorts the list of neighbouring objects on each side, according to their intersection This function sorts the list of neighbouring objects on each side, according to their intersection
with the object being created. From South to North and from East to West with the object being created. From South to North and from East to West
""" """
Output = List Output = List
# First find the directions where no neighbour exists # First find the directions where no neighbour exists
# Important : Here we assume that exactly two directions have no neighbours !!! # Important : Here we assume that exactly two directions have no neighbours !!!
# Should we change this to allow a more general case ???? # Should we change this to allow a more general case ????
dummy = IndexMultiOcc(List,(-1,)) dummy = IndexMultiOcc(List,(-1,))
# dummy[0] is either 0, meaning there is no neighbour on X- (West) # dummy[0] is either 0, meaning there is no neighbour on X- (West)
# or 1, meaning there is no neighbour on X+ (East) # or 1, meaning there is no neighbour on X+ (East)
# Similarly dummy[1] can be either 2 or 3 (South and North respectively) # Similarly dummy[1] can be either 2 or 3 (South and North respectively)
# In order to get back to the formalism of groups (SNWE) # In order to get back to the formalism of groups (SNWE)
# => we do the following to define Sense of no neighbours and then the Direction list # => we do the following to define Sense of no neighbours and then the Direction list
# is calculated as to include uniquely the directions where we DO have neighbours # is calculated as to include uniquely the directions where we DO have neighbours
if len(dummy) == 1 : if len(dummy) == 1 :
# This adds a second direction where neighbours are not regarded, it is either 0 or 2 # This adds a second direction where neighbours are not regarded, it is either 0 or 2
dummy.append(2*(dummy[0]+2<4)) dummy.append(2*(dummy[0]+2<4))
print("Careful, you have neighbours on 3 or more sides of the box, we will not check if on two parallel sides the boxes are compatible !!!") print("Careful, you have neighbours on 3 or more sides of the box, we will not check if on two parallel sides the boxes are compatible !!!")
if len(dummy) == 2 or len(dummy) == 1 : if len(dummy) == 2 or len(dummy) == 1 :
# Sense contains : Vertical then Horizontal # Sense contains : Vertical then Horizontal
Sense = [dummy[1]%2,dummy[0]] Sense = [dummy[1]%2,dummy[0]]
DirList = [[1,0][dummy[0]],[3,2][dummy[1]%2]] DirList = [[1,0][dummy[0]],[3,2][dummy[1]%2]]
for index,Direction in enumerate(DirList) : for index,Direction in enumerate(DirList) :
ObjList = List[Direction] ObjList = List[Direction]
RankMin = [] RankMin = []
ToLook0 = [2,2,0,0][Direction] ToLook0 = [2,2,0,0][Direction]
ToLook1 = [3,2,1,0][Direction] ToLook1 = [3,2,1,0][Direction]
for index1,ObjID in enumerate(ObjList) : for index1,ObjID in enumerate(ObjList) :
RankMin.append([-1.,1.][Sense[index]] * FindCommonSide(Config.ListObj[ObjID].DirBoundaries(ToLook1),[X0-DX/2.,X0+DX/2.,Y0-DY/2.,Y0+DY/2.][ToLook0:ToLook0+2])[Sense[index]]) RankMin.append([-1.,1.][Sense[index]] * FindCommonSide(Config.ListObj[ObjID].DirBoundaries(ToLook1),[X0-DX/2.,X0+DX/2.,Y0-DY/2.,Y0+DY/2.][ToLook0:ToLook0+2])[Sense[index]])
Output[Direction] = SortList(ObjList,RankMin) Output[Direction] = SortList(ObjList,RankMin)
elif len(dummy) == 3 : elif len(dummy) == 3 :
# We find the direction where we do have neighbours and then we sort the object list along it # We find the direction where we do have neighbours and then we sort the object list along it
Sense = dummy[0]%2 Sense = dummy[0]%2
Direction = [ i not in dummy for i in range(4) ].index(True) Direction = [ i not in dummy for i in range(4) ].index(True)
ObjList = List[Direction] ObjList = List[Direction]
RankMin = [] RankMin = []
ToLook0 = [2,2,0,0][Direction] ToLook0 = [2,2,0,0][Direction]
ToLook1 = [3,2,1,0][Direction] ToLook1 = [3,2,1,0][Direction]
for index1,ObjID in enumerate(ObjList) : for index1,ObjID in enumerate(ObjList) :
RankMin.append([-1.,1.][Sense] * FindCommonSide(Config.ListObj[ObjID].DirBoundaries(ToLook1),[X0-DX/2.,X0+DX/2.,Y0-DY/2.,Y0+DY/2.][ToLook0:ToLook0+2])[Sense]) RankMin.append([-1.,1.][Sense] * FindCommonSide(Config.ListObj[ObjID].DirBoundaries(ToLook1),[X0-DX/2.,X0+DX/2.,Y0-DY/2.,Y0+DY/2.][ToLook0:ToLook0+2])[Sense])
Output[Direction] = SortList(ObjList,RankMin) Output[Direction] = SortList(ObjList,RankMin)
else : else :
print ("Error : the composite box being created has no neighbours, how on earth do you want us to inherit its mesh parameters!!!") print ("Error : the composite box being created has no neighbours, how on earth do you want us to inherit its mesh parameters!!!")
return Output return Output
def IndexMultiOcc (Array,Element) : def IndexMultiOcc (Array,Element) :
""" """
This functions returns the occurrences indices of Element in Array. This functions returns the occurrences indices of Element in Array.
As opposed to Array.index(Element) method, this allows determining As opposed to Array.index(Element) method, this allows determining
multiple entries rather than just the first one! multiple entries rather than just the first one!
""" """
Output = [] Output = []
try : Array.index(Element) try : Array.index(Element)
except ValueError : print "No more occurrences" except ValueError : print "No more occurrences"
else : Output.append(Array.index(Element)) else : Output.append(Array.index(Element))
if not(Output == []) and len(Array) > 1 : if not(Output == []) and len(Array) > 1 :
for index, ArrElem in enumerate(Array[Output[0]+1:]) : for index, ArrElem in enumerate(Array[Output[0]+1:]) :
if ArrElem == Element : Output.append(index+Output[0]+1) if ArrElem == Element : Output.append(index+Output[0]+1)
return Output return Output
def SortList (ValList, CritList): def SortList (ValList, CritList):
Output = [] Output = []
SortedCritList = copy.copy(CritList) SortedCritList = copy.copy(CritList)
SortedCritList.sort() SortedCritList.sort()
for i in range(0,len(ValList)): for i in range(0,len(ValList)):
index = CritList.index(SortedCritList[i]) index = CritList.index(SortedCritList[i])
Output.append(ValList[index]) Output.append(ValList[index])
return Output return Output
def ExtrapPoint (Ptref,Vref1,Vref2,Delta): def ExtrapPoint (Ptref,Vref1,Vref2,Delta):
""" """
This function allows determining the absolute coordinates of an extrapolation point This function allows determining the absolute coordinates of an extrapolation point
as shown in the following : as shown in the following :
ExtrapPoint x---Vref2->--------o ExtrapPoint x---Vref2->--------o
/ delta_glob |Vref1 / delta_glob |Vref1
/ | / |
Ptref x---------------------+ Ptref x---------------------+
delta_loc * Nseg delta_loc * Nseg
Delta = (delta_loc - delta_glob) * Nseg Delta = (delta_loc - delta_glob) * Nseg
""" """
X = Ptref[0] + Vref1[0] + Delta*Vref2[0] X = Ptref[0] + Vref1[0] + Delta*Vref2[0]
Y = Ptref[1] + Vref1[1] + Delta*Vref2[1] Y = Ptref[1] + Vref1[1] + Delta*Vref2[1]
return (X,Y,) return (X,Y,)

352
src/Tools/MacMesh/MacMesh/CutnGroup.py
View File

@ -28,199 +28,199 @@ geompy = geomBuilder.New( Config.theStudy )
def Go(GeoObj, CutPlnLst, OutLvlLst, PrefixLst, Publish): def Go(GeoObj, CutPlnLst, OutLvlLst, PrefixLst, Publish):
""" """
This function cuts any geometry (with infinite trim !) into several subgeometries that are cleanly saved inside the navigation tree. (Check GoTrim for the same functionality with custom trim size) This function cuts any geometry (with infinite trim !) into several subgeometries that are cleanly saved inside the navigation tree. (Check GoTrim for the same functionality with custom trim size)
- GeoObj is the geometrical object to be cut and grouped - GeoObj is the geometrical object to be cut and grouped
- CutPlnLst is a list of plane definitions. Each plane is a 6-tuple (contains 6 values). The first three represent the coordinates of the origin point and the second three represent the coordinates of the normal vector to the plane - CutPlnLst is a list of plane definitions. Each plane is a 6-tuple (contains 6 values). The first three represent the coordinates of the origin point and the second three represent the coordinates of the normal vector to the plane
Example 1: [(0,0,0,1,0,0)]: cut along a plane passing through the origin and normal to the x-axis Example 1: [(0,0,0,1,0,0)]: cut along a plane passing through the origin and normal to the x-axis
Example 2: [(0,0,0,1,0,0),(50,0,0,0,1,0)]: in addition to the first plane cut, cut through a plane passing by (50,0,0) and normal to the y axis. Example 2: [(0,0,0,1,0,0),(50,0,0,0,1,0)]: in addition to the first plane cut, cut through a plane passing by (50,0,0) and normal to the y axis.
Note that the plane size us determined automatically from the size of the geometry in question (using a very big trim size = 100 x length of geometry!) Note that the plane size us determined automatically from the size of the geometry in question (using a very big trim size = 100 x length of geometry!)
- OutLvlLst is a list containing integers that represent the inner sectioning level with respect to the original geometry type - OutLvlLst is a list containing integers that represent the inner sectioning level with respect to the original geometry type
A value of 1 means that the section will provide elements of one level lower than the original type. For example a solid sectioned at level 1 will produce faces. A Face sectioned at level 1 will produce edges. A value of 1 means that the section will provide elements of one level lower than the original type. For example a solid sectioned at level 1 will produce faces. A Face sectioned at level 1 will produce edges.
A value of 2 means that a deeper sectioning will be applied. A solid sectioned with level 2 will give faces and edges. A face will give edges and vertices. An edge will give only vertices A value of 2 means that a deeper sectioning will be applied. A solid sectioned with level 2 will give faces and edges. A face will give edges and vertices. An edge will give only vertices
The number of elements in this list should be (this is verified in the code) equal to the number of elements in the plane cut list. This is logical. The number of elements in this list should be (this is verified in the code) equal to the number of elements in the plane cut list. This is logical.
Example 1: [1] Example 1: [1]
Example 2: [1, 2], This means that the cut over the second plane will produce two types of elements unlike the first cut which will only output the first level objects. Example 2: [1, 2], This means that the cut over the second plane will produce two types of elements unlike the first cut which will only output the first level objects.
- PrefixLst is a list of strings that contains the naming Prefixes that are used by the script to generate the subshape names. This is very useful for relating the results to the sectioning requested. - PrefixLst is a list of strings that contains the naming Prefixes that are used by the script to generate the subshape names. This is very useful for relating the results to the sectioning requested.
Example 1: ['Entry'] Example 1: ['Entry']
Example 2: ['Entry','Exit'] The resulting groups from the sectioning with plane no.1 will then be saved as "Entry_FACE" and/or "Entry_EDGE" according to the original geometry object type and the cutting level Example 2: ['Entry','Exit'] The resulting groups from the sectioning with plane no.1 will then be saved as "Entry_FACE" and/or "Entry_EDGE" according to the original geometry object type and the cutting level
Imagine that we have a solid called ExampleSolid, an example command will be:
CutnGroup.Go(ExampleSolid,[(0,0,0,1,0,0),(50,0,0,0,1,0)],[1, 2],['Entry','Exit'])
"""
NumCuts = CheckInput(CutPlnLst, OutLvlLst, PrefixLst, 1) Imagine that we have a solid called ExampleSolid, an example command will be:
OrigType = FindStandType(GeoObj,0) CutnGroup.Go(ExampleSolid,[(0,0,0,1,0,0),(50,0,0,0,1,0)],[1, 2],['Entry','Exit'])
InvDictionary = dict((v,k) for k, v in geompy.ShapeType.iteritems()) # Give geometry type name as a function of standard type numbering, ex: 4=FACE, 6=EDGE, 7=VERTEX """
TrimSize = geompy.BasicProperties(GeoObj)[0]*100
CutPlane = [] ; Sections = [] ; Parts = []
if NumCuts:
for i in range(0, NumCuts): # Loop over the cutting planes to create them one by one
CutPlane.append(CreatePlane(CutPlnLst[i],TrimSize))
OutFather = geompy.MakePartition([GeoObj],CutPlane, [], [],FindStandType(GeoObj,1), 0, [], 0) #Creating the partition object
if Publish: geompy.addToStudy(OutFather,'SectionedObject')
for i in range(0, NumCuts):
for j in range(OrigType+1+2, OrigType+1+2*(OutLvlLst[i]+1),2):
if j == 8 : j = 7; # Exception for the vertex case (=7)
PossSubShapesID = geompy.SubShapeAllIDs(OutFather,j) # List of subshape IDs than correspond to the required cutting level (section type : face/wire/vertex)
PossSubShapes = geompy.ExtractShapes(OutFather,j) # and the corresponding objects
Accepted = []
for k in range(0,len(PossSubShapesID)): # Loop over all the subshapes checking if they belong to the cutting plane! if yes add them to current list
if IsOnPlane(PossSubShapes[k], CutPlnLst[i], 1e-7):
Accepted.append(PossSubShapesID[k])
if Accepted : # If some element is found, save it as a group with the prescribed Prefix
dummyObj = geompy.CreateGroup(OutFather, j)
geompy.UnionIDs(dummyObj, Accepted)
Sections.append(dummyObj)
if Publish:geompy.addToStudyInFather(OutFather, dummyObj, PrefixLst[i]+"_"+InvDictionary[j][0:2])
else :
print "Warning: For the section no.", i, ", No intersection of type " + InvDictionary[j] + " was found. Hence, no corresponding groups were created"
SubShapesID = geompy.SubShapeAllIDs(OutFather,OrigType+1) # Saving also the groups corresponding to the sectioned item of the same type: ex. A solid into n sub-solids due to the sections
for i in range(0,len(SubShapesID)):
dummyObj = geompy.CreateGroup(OutFather, OrigType+1)
geompy.UnionIDs(dummyObj, [SubShapesID[i]])
Parts.append(dummyObj)
if Publish: geompy.addToStudyInFather(OutFather, dummyObj, "SB"+"_"+InvDictionary[OrigType+1][0:3]+"_"+str(i+1))
return OutFather, Sections, Parts NumCuts = CheckInput(CutPlnLst, OutLvlLst, PrefixLst, 1)
else: OrigType = FindStandType(GeoObj,0)
print("Fatal error, the routine cannot continue any further, check your input variables") InvDictionary = dict((v,k) for k, v in geompy.ShapeType.iteritems()) # Give geometry type name as a function of standard type numbering, ex: 4=FACE, 6=EDGE, 7=VERTEX
return -1 TrimSize = geompy.BasicProperties(GeoObj)[0]*100
CutPlane = [] ; Sections = [] ; Parts = []
if NumCuts:
for i in range(0, NumCuts): # Loop over the cutting planes to create them one by one
CutPlane.append(CreatePlane(CutPlnLst[i],TrimSize))
OutFather = geompy.MakePartition([GeoObj],CutPlane, [], [],FindStandType(GeoObj,1), 0, [], 0) #Creating the partition object
if Publish: geompy.addToStudy(OutFather,'SectionedObject')
for i in range(0, NumCuts):
for j in range(OrigType+1+2, OrigType+1+2*(OutLvlLst[i]+1),2):
if j == 8 : j = 7; # Exception for the vertex case (=7)
PossSubShapesID = geompy.SubShapeAllIDs(OutFather,j) # List of subshape IDs than correspond to the required cutting level (section type : face/wire/vertex)
PossSubShapes = geompy.ExtractShapes(OutFather,j) # and the corresponding objects
Accepted = []
for k in range(0,len(PossSubShapesID)): # Loop over all the subshapes checking if they belong to the cutting plane! if yes add them to current list
if IsOnPlane(PossSubShapes[k], CutPlnLst[i], 1e-7):
Accepted.append(PossSubShapesID[k])
if Accepted : # If some element is found, save it as a group with the prescribed Prefix
dummyObj = geompy.CreateGroup(OutFather, j)
geompy.UnionIDs(dummyObj, Accepted)
Sections.append(dummyObj)
if Publish:geompy.addToStudyInFather(OutFather, dummyObj, PrefixLst[i]+"_"+InvDictionary[j][0:2])
else :
print "Warning: For the section no.", i, ", No intersection of type " + InvDictionary[j] + " was found. Hence, no corresponding groups were created"
SubShapesID = geompy.SubShapeAllIDs(OutFather,OrigType+1) # Saving also the groups corresponding to the sectioned item of the same type: ex. A solid into n sub-solids due to the sections
for i in range(0,len(SubShapesID)):
dummyObj = geompy.CreateGroup(OutFather, OrigType+1)
geompy.UnionIDs(dummyObj, [SubShapesID[i]])
Parts.append(dummyObj)
if Publish: geompy.addToStudyInFather(OutFather, dummyObj, "SB"+"_"+InvDictionary[OrigType+1][0:3]+"_"+str(i+1))
return OutFather, Sections, Parts
else:
print("Fatal error, the routine cannot continue any further, check your input variables")
return -1
def GoTrim(GeoObj, CutPlnLst, OutLvlLst, PrefixLst, Publish): def GoTrim(GeoObj, CutPlnLst, OutLvlLst, PrefixLst, Publish):
""" """
This function cuts any geometry into several subgeometries that are cleanly saved inside the navigation tree with a fully customizable trim size. This function cuts any geometry into several subgeometries that are cleanly saved inside the navigation tree with a fully customizable trim size.
- GeoObj is the geometrical object to be cut and grouped - GeoObj is the geometrical object to be cut and grouped
- CutPlnLst is a list of plane definitions. Each plane is a 7-tuple (contains 7 values). The first three represent the coordinates of the origin point and the second three represent the coordinates of the normal vector to the plane, the last value corresponds to the trim size of the planes - CutPlnLst is a list of plane definitions. Each plane is a 7-tuple (contains 7 values). The first three represent the coordinates of the origin point and the second three represent the coordinates of the normal vector to the plane, the last value corresponds to the trim size of the planes
Example 1: [(0,0,0,1,0,0,5)]: cut along a plane passing through the origin and normal to the x-axis with a trim size of 5 Example 1: [(0,0,0,1,0,0,5)]: cut along a plane passing through the origin and normal to the x-axis with a trim size of 5
Example 2: [(0,0,0,1,0,0,5),(50,0,0,0,1,0,10)]: in addition to the first plane cut, cut through a plane passing by (50,0,0) and normal to the y axis with a trim size of 10 Example 2: [(0,0,0,1,0,0,5),(50,0,0,0,1,0,10)]: in addition to the first plane cut, cut through a plane passing by (50,0,0) and normal to the y axis with a trim size of 10
- OutLvlLst is a list containing integers that represent the inner sectioning level with respect to the original geometry type - OutLvlLst is a list containing integers that represent the inner sectioning level with respect to the original geometry type
A value of 1 means that the section will provide elements of one level lower than the original type. For example a solid sectioned at level 1 will produce faces. A Face sectioned at level 1 will produce edges. A value of 1 means that the section will provide elements of one level lower than the original type. For example a solid sectioned at level 1 will produce faces. A Face sectioned at level 1 will produce edges.
A value of 2 means that a deeper sectioning will be applied. A solid sectioned with level 2 will give faces and edges. A face will give edges and vertices. An edge will give only vertices A value of 2 means that a deeper sectioning will be applied. A solid sectioned with level 2 will give faces and edges. A face will give edges and vertices. An edge will give only vertices
The number of elements in this list should be (this is verified in the code) equal to the number of elements in the plane cut list. This is logical. The number of elements in this list should be (this is verified in the code) equal to the number of elements in the plane cut list. This is logical.
Example 1: [1] Example 1: [1]
Example 2: [1, 2], This means that the cut over the second plane will produce two types of elements unlike the first cut which will only output the first level objects. Example 2: [1, 2], This means that the cut over the second plane will produce two types of elements unlike the first cut which will only output the first level objects.
- PrefixLst is a list of strings that contains the naming Prefixes that are used by the script to generate the subshape names. This is very useful for relating the results to the sectioning requested. - PrefixLst is a list of strings that contains the naming Prefixes that are used by the script to generate the subshape names. This is very useful for relating the results to the sectioning requested.
Example 1: ['Entry'] Example 1: ['Entry']
Example 2: ['Entry','Exit'] The resulting groups from the sectioning with plane no.1 will then be saved as "Entry_FACE" and/or "Entry_EDGE" according to the original geometry object type and the cutting level Example 2: ['Entry','Exit'] The resulting groups from the sectioning with plane no.1 will then be saved as "Entry_FACE" and/or "Entry_EDGE" according to the original geometry object type and the cutting level
Imagine that we have a solid called ExampleSolid, an example command will be:
CutnGroup.Go(ExampleSolid,[(0,0,0,1,0,0,5),(50,0,0,0,1,0,10)],[1, 2],['Entry','Exit'])
"""
NumCuts = CheckInput(CutPlnLst, OutLvlLst, PrefixLst, 0) Imagine that we have a solid called ExampleSolid, an example command will be:
OrigType = FindStandType(GeoObj,0) CutnGroup.Go(ExampleSolid,[(0,0,0,1,0,0,5),(50,0,0,0,1,0,10)],[1, 2],['Entry','Exit'])
InvDictionary = dict((v,k) for k, v in geompy.ShapeType.iteritems()) # Give geometry type name as a function of standard type numbering, ex: 4=FACE, 6=EDGE, 7=VERTEX """
CutPlane = [] ; Sections = [] ; Parts = []
if NumCuts:
for i in range(0, NumCuts): # Loop over the cutting planes to create them one by one
CutPlane.append(CreatePlane(CutPlnLst[i][0:6],CutPlnLst[i][6]))
OutFather = geompy.MakePartition([GeoObj],CutPlane, [], [],FindStandType(GeoObj,1), 0, [], 0) #Creating the partition object
if Publish: geompy.addToStudy(OutFather,'SectionedObject')
for i in range(0, NumCuts):
for j in range(OrigType+1+2, OrigType+1+2*(OutLvlLst[i]+1),2):
if j == 8 : j = 7; # Exception for the vertex case (=7)
PossSubShapesID = geompy.SubShapeAllIDs(OutFather,j) # List of subshape IDs than correspond to the required cutting level (section type : face/wire/vertex)
PossSubShapes = geompy.ExtractShapes(OutFather,j) # and the corresponding objects
Accepted = []
for k in range(0,len(PossSubShapesID)): # Loop over all the subshapes checking if they belong to the cutting plane WITH THE TRIM SIZE CONDITION! if yes add them to current list
if IsOnPlane(PossSubShapes[k], CutPlnLst[i], 1e-7) and Distance2Pt(geompy.PointCoordinates(geompy.MakeCDG(PossSubShapes[k])),CutPlnLst[i][0:3])<=CutPlnLst[i][-1]:
Accepted.append(PossSubShapesID[k])
if Accepted : # If some element is found, save it as a group with the prescribed Prefix
dummyObj = geompy.CreateGroup(OutFather, j)
geompy.UnionIDs(dummyObj, Accepted)
Sections.append(dummyObj)
if Publish: geompy.addToStudyInFather(OutFather, dummyObj, PrefixLst[i]+"_"+InvDictionary[j][0:2])
else :
print "Warning: For the section no.", i, ", No intersection of type " + InvDictionary[j] + " was found. Hence, no corresponding groups were created"
SubShapesID = geompy.SubShapeAllIDs(OutFather,OrigType+1) # Saving also the groups corresponding to the sectioned item of the same type: ex. A solid into n sub-solids due to the sections
for i in range(0,len(SubShapesID)):
dummyObj = geompy.CreateGroup(OutFather, OrigType+1)
geompy.UnionIDs(dummyObj, [SubShapesID[i]])
Parts.append(dummyObj)
if Publish: geompy.addToStudyInFather(OutFather, dummyObj, "SB"+"_"+InvDictionary[OrigType+1][0:3]+"_"+str(i+1))
return OutFather, Sections, Parts NumCuts = CheckInput(CutPlnLst, OutLvlLst, PrefixLst, 0)
else: OrigType = FindStandType(GeoObj,0)
print("Fatal error, the routine cannot continue any further, check your input variables") InvDictionary = dict((v,k) for k, v in geompy.ShapeType.iteritems()) # Give geometry type name as a function of standard type numbering, ex: 4=FACE, 6=EDGE, 7=VERTEX
return -1 CutPlane = [] ; Sections = [] ; Parts = []
if NumCuts:
for i in range(0, NumCuts): # Loop over the cutting planes to create them one by one
CutPlane.append(CreatePlane(CutPlnLst[i][0:6],CutPlnLst[i][6]))
OutFather = geompy.MakePartition([GeoObj],CutPlane, [], [],FindStandType(GeoObj,1), 0, [], 0) #Creating the partition object
if Publish: geompy.addToStudy(OutFather,'SectionedObject')
for i in range(0, NumCuts):
for j in range(OrigType+1+2, OrigType+1+2*(OutLvlLst[i]+1),2):
if j == 8 : j = 7; # Exception for the vertex case (=7)
PossSubShapesID = geompy.SubShapeAllIDs(OutFather,j) # List of subshape IDs than correspond to the required cutting level (section type : face/wire/vertex)
PossSubShapes = geompy.ExtractShapes(OutFather,j) # and the corresponding objects
Accepted = []
for k in range(0,len(PossSubShapesID)): # Loop over all the subshapes checking if they belong to the cutting plane WITH THE TRIM SIZE CONDITION! if yes add them to current list
if IsOnPlane(PossSubShapes[k], CutPlnLst[i], 1e-7) and Distance2Pt(geompy.PointCoordinates(geompy.MakeCDG(PossSubShapes[k])),CutPlnLst[i][0:3])<=CutPlnLst[i][-1]:
Accepted.append(PossSubShapesID[k])
if Accepted : # If some element is found, save it as a group with the prescribed Prefix
dummyObj = geompy.CreateGroup(OutFather, j)
geompy.UnionIDs(dummyObj, Accepted)
Sections.append(dummyObj)
if Publish: geompy.addToStudyInFather(OutFather, dummyObj, PrefixLst[i]+"_"+InvDictionary[j][0:2])
else :
print "Warning: For the section no.", i, ", No intersection of type " + InvDictionary[j] + " was found. Hence, no corresponding groups were created"
SubShapesID = geompy.SubShapeAllIDs(OutFather,OrigType+1) # Saving also the groups corresponding to the sectioned item of the same type: ex. A solid into n sub-solids due to the sections
for i in range(0,len(SubShapesID)):
dummyObj = geompy.CreateGroup(OutFather, OrigType+1)
geompy.UnionIDs(dummyObj, [SubShapesID[i]])
Parts.append(dummyObj)
if Publish: geompy.addToStudyInFather(OutFather, dummyObj, "SB"+"_"+InvDictionary[OrigType+1][0:3]+"_"+str(i+1))
return OutFather, Sections, Parts
else:
print("Fatal error, the routine cannot continue any further, check your input variables")
return -1
def FindStandType(GeoObj, method): def FindStandType(GeoObj, method):
""" """
Find the standard index for the Geometrical object/compound type input, see dictionary in geompy.ShapeType Find the standard index for the Geometrical object/compound type input, see dictionary in geompy.ShapeType
""" """
TopType = GeoObj.GetMaxShapeType().__str__() TopType = GeoObj.GetMaxShapeType().__str__()
UnModType = geompy.ShapeType[TopType] UnModType = geompy.ShapeType[TopType]
if method == 0 : if method == 0 :
StandType = UnModType-int(not(UnModType%2)) # So that wires and edges and considered the same, faces and shells, and so on StandType = UnModType-int(not(UnModType%2)) # So that wires and edges and considered the same, faces and shells, and so on
else : else :
StandType = UnModType StandType = UnModType
return(StandType) return(StandType)
def CreatePlane(CutPlnVar,Trim): def CreatePlane(CutPlnVar,Trim):
""" """
Creates a temporary point and vector in salome in order to build the sectioning planes needed Creates a temporary point and vector in salome in order to build the sectioning planes needed
""" """
Temp_Vtx = geompy.MakeVertex(CutPlnVar[0], CutPlnVar[1], CutPlnVar[2]) Temp_Vtx = geompy.MakeVertex(CutPlnVar[0], CutPlnVar[1], CutPlnVar[2])
Temp_Vec = geompy.MakeVectorDXDYDZ(CutPlnVar[3], CutPlnVar[4], CutPlnVar[5]) Temp_Vec = geompy.MakeVectorDXDYDZ(CutPlnVar[3], CutPlnVar[4], CutPlnVar[5])
CutPlane = geompy.MakePlane(Temp_Vtx, Temp_Vec, Trim) CutPlane = geompy.MakePlane(Temp_Vtx, Temp_Vec, Trim)
return(CutPlane) return(CutPlane)
def CheckInput(CutPlnLst, OutLvlLst, PrefixLst, AutoTrim): def CheckInput(CutPlnLst, OutLvlLst, PrefixLst, AutoTrim):
""" """
Checks the user input specifically if all needed parameters are provided Checks the user input specifically if all needed parameters are provided
""" """
if not ((len(CutPlnLst) == len(OutLvlLst)) and (len(CutPlnLst) == len(PrefixLst))): if not ((len(CutPlnLst) == len(OutLvlLst)) and (len(CutPlnLst) == len(PrefixLst))):
print("Missing information about one or more of the cut planes") print("Missing information about one or more of the cut planes")
return 0 return 0
elif not ((len(CutPlnLst[0]) == 6+int(not AutoTrim))): elif not ((len(CutPlnLst[0]) == 6+int(not AutoTrim))):
print("For each cutting plane you need to specify 6 parameters = 2 x 3 coordinates") print("For each cutting plane you need to specify 6 parameters = 2 x 3 coordinates")
return 0 return 0
else: else:
return len(CutPlnLst) return len(CutPlnLst)
def IsOnPlane(GeoSubObj, CutPlnVar, tolerance): def IsOnPlane(GeoSubObj, CutPlnVar, tolerance):
""" """
Checks whether a geometry (vertex, segment, or face) belongs *completely* to the plane defined as a point and a normal vector Checks whether a geometry (vertex, segment, or face) belongs *completely* to the plane defined as a point and a normal vector
""" """
# lambda function that represents the plane equation, function = 0 <=> Pt defined with Coor belongs to plane # lambda function that represents the plane equation, function = 0 <=> Pt defined with Coor belongs to plane
PlaneEq = lambda Coor: CutPlnVar[3]*(Coor[0]-CutPlnVar[0])+CutPlnVar[4]*(Coor[1]-CutPlnVar[1])+CutPlnVar[5]*(Coor[2]-CutPlnVar[2]) PlaneEq = lambda Coor: CutPlnVar[3]*(Coor[0]-CutPlnVar[0])+CutPlnVar[4]*(Coor[1]-CutPlnVar[1])+CutPlnVar[5]*(Coor[2]-CutPlnVar[2])
OrigType = FindStandType(GeoSubObj,0) OrigType = FindStandType(GeoSubObj,0)
if (OrigType >= 7): # Vertex if (OrigType >= 7): # Vertex
NonTrimDecision = abs(PlaneEq(geompy.PointCoordinates(GeoSubObj))) < tolerance NonTrimDecision = abs(PlaneEq(geompy.PointCoordinates(GeoSubObj))) < tolerance
if len(CutPlnVar) == 6 : return NonTrimDecision # No trim condition used if len(CutPlnVar) == 6 : return NonTrimDecision # No trim condition used
else : return (NonTrimDecision and Distance2Pt(CutPlnVar[0:3],geompy.PointCoordinates(GeoSubObj))<=CutPlnVar[6]/2) else : return (NonTrimDecision and Distance2Pt(CutPlnVar[0:3],geompy.PointCoordinates(GeoSubObj))<=CutPlnVar[6]/2)
elif (OrigType >= 5): # Line, decompose into two points then call recursively IsOnPlane function! elif (OrigType >= 5): # Line, decompose into two points then call recursively IsOnPlane function!
Verdict = True Verdict = True
for i in range(0,2): for i in range(0,2):
Verdict = Verdict and IsOnPlane(geompy.GetVertexByIndex(GeoSubObj,i), CutPlnVar, tolerance) Verdict = Verdict and IsOnPlane(geompy.GetVertexByIndex(GeoSubObj,i), CutPlnVar, tolerance)
return Verdict return Verdict
elif (OrigType >= 3): # Face, decompose into three points then call recursively IsOnPlane function! elif (OrigType >= 3): # Face, decompose into three points then call recursively IsOnPlane function!
if IsOnPlane(geompy.MakeCDG(GeoSubObj),CutPlnVar, tolerance) : # Center of gravity belongs to plane, check if normal is parallel to plane if IsOnPlane(geompy.MakeCDG(GeoSubObj),CutPlnVar, tolerance) : # Center of gravity belongs to plane, check if normal is parallel to plane
NormalP1Coor = geompy.PointCoordinates(geompy.GetVertexByIndex(geompy.GetNormal(GeoSubObj),0)) NormalP1Coor = geompy.PointCoordinates(geompy.GetVertexByIndex(geompy.GetNormal(GeoSubObj),0))
NormalP2Coor = geompy.PointCoordinates(geompy.GetVertexByIndex(geompy.GetNormal(GeoSubObj),1)) NormalP2Coor = geompy.PointCoordinates(geompy.GetVertexByIndex(geompy.GetNormal(GeoSubObj),1))
Normal = [NormalP1Coor[0]-NormalP2Coor[0], NormalP1Coor[1]-NormalP2Coor[1], NormalP1Coor[2]-NormalP2Coor[2]] Normal = [NormalP1Coor[0]-NormalP2Coor[0], NormalP1Coor[1]-NormalP2Coor[1], NormalP1Coor[2]-NormalP2Coor[2]]
CrossP = CrossProd(CutPlnVar[3:6],Normal) # Checks whether normals (of section plane and of face) are parallel or not CrossP = CrossProd(CutPlnVar[3:6],Normal) # Checks whether normals (of section plane and of face) are parallel or not
if (abs(CrossP[0])<tolerance and abs(CrossP[1])<tolerance and abs(CrossP[2])<tolerance): # meaning zero cross product => parallel if (abs(CrossP[0])<tolerance and abs(CrossP[1])<tolerance and abs(CrossP[2])<tolerance): # meaning zero cross product => parallel
return True return True
else : else :
return False return False
else : else :
return False return False
def CrossProd(V1,V2): def CrossProd(V1,V2):
""" """
Determines the cross product of two 3D vectors Determines the cross product of two 3D vectors
""" """
return ([V1[1]*V2[2]-V1[2]*V2[1], V1[2]*V2[0]-V1[0]*V2[2], V1[0]*V2[1]-V1[1]*V2[0]]) return ([V1[1]*V2[2]-V1[2]*V2[1], V1[2]*V2[0]-V1[0]*V2[2], V1[0]*V2[1]-V1[1]*V2[0]])
def Distance2Pt(P1,P2): def Distance2Pt(P1,P2):
""" """
Returns the distance between two points Returns the distance between two points
""" """
return (math.sqrt((P1[0]-P2[0])**2+(P1[1]-P2[1])**2+(P1[2]-P2[2])**2)) return (math.sqrt((P1[0]-P2[0])**2+(P1[1]-P2[1])**2+(P1[2]-P2[2])**2))

152
src/Tools/MacMesh/MacMesh/Cylinder.py
View File

@ -19,7 +19,7 @@
# This is an automation of the cylinder-box object, defined with the coordinates of its center, its radius, and the box's # This is an automation of the cylinder-box object, defined with the coordinates of its center, its radius, and the box's
# boundary size. # boundary size.
# The pitch ratio is calculated automatically from the minimum of the box dimensions on x and y. # The pitch ratio is calculated automatically from the minimum of the box dimensions on x and y.
# This functions can take a groups input containing the group names of 4 sides in addition to the internal circular boundary # This functions can take a groups input containing the group names of 4 sides in addition to the internal circular boundary
@ -33,83 +33,83 @@ sys.path.append(CWD)
from MacObject import * from MacObject import *
import Config, GenFunctions import Config, GenFunctions
def Cylinder (X0 , Y0 , D , DX , DY , LocalMeshing , **args) : def Cylinder (X0 , Y0 , D , DX , DY , LocalMeshing , **args) :
if args.__contains__('DLocal') : DLocal = float(args['DLocal']) if args.__contains__('DLocal') : DLocal = float(args['DLocal'])
else : DLocal = float(min(DX,DY)) else : DLocal = float(min(DX,DY))
# K is the pitch ratio # K is the pitch ratio
K = float(D)/(DLocal-D) K = float(D)/(DLocal-D)
print "A local pitch ratio of K =", K ," will be used. " print "A local pitch ratio of K =", K ," will be used. "
NumCuts = 2*GenFunctions.QuarCylParam(K) NumCuts = 2*GenFunctions.QuarCylParam(K)
InternalMeshing = int(math.ceil(math.pi*D/(4*NumCuts*LocalMeshing))) InternalMeshing = int(math.ceil(math.pi*D/(4*NumCuts*LocalMeshing)))
if InternalMeshing == 0 : InternalMeshing = 1 # This sets a minimum meshing condition in order to avoid an error. The user is notified of the value considered for the local meshing if InternalMeshing == 0 : InternalMeshing = 1 # This sets a minimum meshing condition in order to avoid an error. The user is notified of the value considered for the local meshing
print "Possible Local meshing is :", math.pi*D/(4*NumCuts*InternalMeshing), "\nThis value is returned by this function for your convenience.\n" print "Possible Local meshing is :", math.pi*D/(4*NumCuts*InternalMeshing), "\nThis value is returned by this function for your convenience.\n"
if args.__contains__('groups') : if args.__contains__('groups') :
GroupNames = args['groups'] GroupNames = args['groups']
else : GroupNames = [None, None, None, None, None] else : GroupNames = [None, None, None, None, None]
if DY == DLocal : if DY == DLocal :
if DX == DLocal: if DX == DLocal:
GN1 = [None,GroupNames[1],None,GroupNames[3],GroupNames[4]] GN1 = [None,GroupNames[1],None,GroupNames[3],GroupNames[4]]
GN2 = [None,GroupNames[1],GroupNames[2],None,GroupNames[4]] GN2 = [None,GroupNames[1],GroupNames[2],None,GroupNames[4]]
GN3 = [GroupNames[0],None,GroupNames[2],None,GroupNames[4]] GN3 = [GroupNames[0],None,GroupNames[2],None,GroupNames[4]]
GN4 = [GroupNames[0],None,None,GroupNames[3],GroupNames[4]] GN4 = [GroupNames[0],None,None,GroupNames[3],GroupNames[4]]
else :
GN1 = [None,GroupNames[1],None,None,GroupNames[4]]
GN2 = [None,GroupNames[1],None,None,GroupNames[4]]
GN3 = [GroupNames[0],None,None,None,GroupNames[4]]
GN4 = [GroupNames[0],None,None,None,GroupNames[4]]
GN5 = [GroupNames[0],GroupNames[1],None,GroupNames[3]]
GN6 = [GroupNames[0],GroupNames[1],GroupNames[2],None]
else : else :
if DX == DLocal: GN1 = [None,GroupNames[1],None,None,GroupNames[4]]
GN1 = [None,None,None,GroupNames[3],GroupNames[4]] GN2 = [None,GroupNames[1],None,None,GroupNames[4]]
GN2 = [None,None,GroupNames[2],None,GroupNames[4]] GN3 = [GroupNames[0],None,None,None,GroupNames[4]]
GN3 = [None,None,GroupNames[2],None,GroupNames[4]] GN4 = [GroupNames[0],None,None,None,GroupNames[4]]
GN4 = [None,None,None,GroupNames[3],GroupNames[4]]
GN7 = [GroupNames[0],None,GroupNames[2],GroupNames[3]]
GN8 = [None,GroupNames[1],GroupNames[2],GroupNames[3]]
else :
GN1 = [None,None,None,None,GroupNames[4]]
GN2 = [None,None,None,None,GroupNames[4]]
GN3 = [None,None,None,None,GroupNames[4]]
GN4 = [None,None,None,None,GroupNames[4]]
GN5 = [None,None,None,GroupNames[3]]
GN6 = [None,None,GroupNames[2],None]
GN9 = [GroupNames[0],None,None,GroupNames[3]]
GN10 = [GroupNames[0],None,None,None]
GN11 = [GroupNames[0],None,GroupNames[2],None]
GN12 = [None,GroupNames[1],None,GroupNames[3]]
GN13 = [None,GroupNames[1],None,None]
GN14 = [None,GroupNames[1],GroupNames[2],None]
Obj = []
Obj.append(MacObject('QuartCyl',[(X0+DLocal/4.,Y0+DLocal/4.),(DLocal/2.,DLocal/2.)],[InternalMeshing,'NE',K], groups = GN1)) GN5 = [GroupNames[0],GroupNames[1],None,GroupNames[3]]
Obj.append(MacObject('QuartCyl',[(X0-DLocal/4.,Y0+DLocal/4.),(DLocal/2.,DLocal/2.)],['auto','NW',K], groups = GN2)) GN6 = [GroupNames[0],GroupNames[1],GroupNames[2],None]
Obj.append(MacObject('QuartCyl',[(X0-DLocal/4.,Y0-DLocal/4.),(DLocal/2.,DLocal/2.)],['auto','SW',K], groups = GN3)) else :
Obj.append(MacObject('QuartCyl',[(X0+DLocal/4.,Y0-DLocal/4.),(DLocal/2.,DLocal/2.)],['auto','SE',K], groups = GN4)) if DX == DLocal:
GN1 = [None,None,None,GroupNames[3],GroupNames[4]]
GN2 = [None,None,GroupNames[2],None,GroupNames[4]]
GN3 = [None,None,GroupNames[2],None,GroupNames[4]]
GN4 = [None,None,None,GroupNames[3],GroupNames[4]]
GN7 = [GroupNames[0],None,GroupNames[2],GroupNames[3]]
GN8 = [None,GroupNames[1],GroupNames[2],GroupNames[3]]
else :
GN1 = [None,None,None,None,GroupNames[4]]
GN2 = [None,None,None,None,GroupNames[4]]
GN3 = [None,None,None,None,GroupNames[4]]
GN4 = [None,None,None,None,GroupNames[4]]
if DX > DLocal : GN5 = [None,None,None,GroupNames[3]]
dX = (DX - DLocal)/2. GN6 = [None,None,GroupNames[2],None]
Obj.append(MacObject('CompBoxF',[(X0+DLocal/2.+dX/2.,Y0),(dX,DLocal)],['auto'], groups = GN5))
Obj.append(MacObject('CompBoxF',[(X0-DLocal/2.-dX/2.,Y0),(dX,DLocal)],['auto'], groups = GN6))
if DY > DLocal : GN9 = [GroupNames[0],None,None,GroupNames[3]]
dY = (DY - DLocal)/2. GN10 = [GroupNames[0],None,None,None]
if DX > DLocal : GN11 = [GroupNames[0],None,GroupNames[2],None]
Obj.append(MacObject('CompBoxF',[(X0+DLocal/2.+dX/2.,Y0-DLocal/2.-dY/2.),(dX,dY)],['auto'], groups = GN9))
Obj.append(MacObject('CompBoxF',[(X0,Y0-DLocal/2.-dY/2.),(DLocal,dY)],['auto'], groups = GN10)) GN12 = [None,GroupNames[1],None,GroupNames[3]]
Obj.append(MacObject('CompBoxF',[(X0-DLocal/2.-dX/2.,Y0-DLocal/2.-dY/2.),(dX,dY)],['auto'], groups = GN11)) GN13 = [None,GroupNames[1],None,None]
Obj.append(MacObject('CompBoxF',[(X0+DLocal/2.+dX/2.,Y0+DLocal/2.+dY/2.),(dX,dY)],['auto'], groups = GN12)) GN14 = [None,GroupNames[1],GroupNames[2],None]
Obj.append(MacObject('CompBoxF',[(X0,Y0+DLocal/2.+dY/2.),(DLocal,dY)],['auto'], groups = GN13))
Obj.append(MacObject('CompBoxF',[(X0-DLocal/2.-dX/2.,Y0+DLocal/2.+dY/2.),(dX,dY)],['auto'], groups = GN14)) Obj = []
else:
Obj.append(MacObject('CompBoxF',[(X0,Y0-DLocal/2.-dY/2.),(DLocal,dY)],['auto'], groups = GN7)) Obj.append(MacObject('QuartCyl',[(X0+DLocal/4.,Y0+DLocal/4.),(DLocal/2.,DLocal/2.)],[InternalMeshing,'NE',K], groups = GN1))
Obj.append(MacObject('CompBoxF',[(X0,Y0+DLocal/2.+dY/2.),(DLocal,dY)],['auto'], groups = GN8)) Obj.append(MacObject('QuartCyl',[(X0-DLocal/4.,Y0+DLocal/4.),(DLocal/2.,DLocal/2.)],['auto','NW',K], groups = GN2))
Obj.append(MacObject('QuartCyl',[(X0-DLocal/4.,Y0-DLocal/4.),(DLocal/2.,DLocal/2.)],['auto','SW',K], groups = GN3))
return Obj Obj.append(MacObject('QuartCyl',[(X0+DLocal/4.,Y0-DLocal/4.),(DLocal/2.,DLocal/2.)],['auto','SE',K], groups = GN4))
if DX > DLocal :
dX = (DX - DLocal)/2.
Obj.append(MacObject('CompBoxF',[(X0+DLocal/2.+dX/2.,Y0),(dX,DLocal)],['auto'], groups = GN5))
Obj.append(MacObject('CompBoxF',[(X0-DLocal/2.-dX/2.,Y0),(dX,DLocal)],['auto'], groups = GN6))
if DY > DLocal :
dY = (DY - DLocal)/2.
if DX > DLocal :
Obj.append(MacObject('CompBoxF',[(X0+DLocal/2.+dX/2.,Y0-DLocal/2.-dY/2.),(dX,dY)],['auto'], groups = GN9))
Obj.append(MacObject('CompBoxF',[(X0,Y0-DLocal/2.-dY/2.),(DLocal,dY)],['auto'], groups = GN10))
Obj.append(MacObject('CompBoxF',[(X0-DLocal/2.-dX/2.,Y0-DLocal/2.-dY/2.),(dX,dY)],['auto'], groups = GN11))
Obj.append(MacObject('CompBoxF',[(X0+DLocal/2.+dX/2.,Y0+DLocal/2.+dY/2.),(dX,dY)],['auto'], groups = GN12))
Obj.append(MacObject('CompBoxF',[(X0,Y0+DLocal/2.+dY/2.),(DLocal,dY)],['auto'], groups = GN13))
Obj.append(MacObject('CompBoxF',[(X0-DLocal/2.-dX/2.,Y0+DLocal/2.+dY/2.),(dX,dY)],['auto'], groups = GN14))
else:
Obj.append(MacObject('CompBoxF',[(X0,Y0-DLocal/2.-dY/2.),(DLocal,dY)],['auto'], groups = GN7))
Obj.append(MacObject('CompBoxF',[(X0,Y0+DLocal/2.+dY/2.),(DLocal,dY)],['auto'], groups = GN8))
return Obj

1369
src/Tools/MacMesh/MacMesh/GenFunctions.py
View File

File diff suppressed because it is too large Load Diff

532
src/Tools/MacMesh/MacMesh/MacObject.py
View File

@ -20,281 +20,279 @@
class MacObject: class MacObject:
""" """
This represents a python class definition which contains This represents a python class definition which contains
all necessary information about the macro object being created all necessary information about the macro object being created
in Salome in Salome
""" """
def __init__( self, ObjectType, GeoParameters, MeshParameters, **args ): def __init__( self, ObjectType, GeoParameters, MeshParameters, **args ):
""" """
Initializes the macro object to be created, saves parameters inside of it, checks for neighboring objects, Initializes the macro object to be created, saves parameters inside of it, checks for neighboring objects,
determines meshing parameters if necessary and finally launches the generation process. determines meshing parameters if necessary and finally launches the generation process.
""" """
import Config,GenFunctions import Config,GenFunctions
if Config.debug : print "Initializing object No. " + str(len(Config.ListObj)+1) if Config.debug : print "Initializing object No. " + str(len(Config.ListObj)+1)
if 'publish' in args : if 'publish' in args :
if args['publish']==0 : Config.publish = 0 if args['publish']==0 : Config.publish = 0
else : Config.publish = 1 else : Config.publish = 1
else : Config.publish = 1 else : Config.publish = 1
if 'groups' in args :
self.GroupNames = args['groups']
for group in args['groups'] :
if not(group in Config.Groups) and group : Config.Groups.append(group)
else : self.GroupNames = [None, None, None, None]
if ObjectType == 'NonOrtho':
if not(len(GeoParameters)==4): print "Error: trying to construct a non-ortho object but the 4 constitutive vertices are not given!"
else :
Xmin = min([GeoParameters[i][0] for i in range(4)])
Xmax = max([GeoParameters[i][0] for i in range(4)])
Ymin = min([GeoParameters[i][1] for i in range(4)])
Ymax = max([GeoParameters[i][1] for i in range(4)])
self.GeoPar = [(0.5*(Xmin+Xmax),0.5*(Ymin+Ymax)),(Xmax-Xmin,Ymax-Ymin)]
self.PtCoor = GenFunctions.SortPoints(GeoParameters)
else:
self.GeoPar = GeoParameters
[Xmin,Ymin,Xmax,Ymax] = [ self.GeoPar[0][0]-0.5*self.GeoPar[1][0], self.GeoPar[0][1]-0.5*self.GeoPar[1][1] ] + [ self.GeoPar[0][0]+0.5*self.GeoPar[1][0], self.GeoPar[0][1]+0.5*self.GeoPar[1][1] ]
self.PtCoor = [(Xmin,Ymin),(Xmax,Ymin),(Xmax,Ymax),(Xmin,Ymax)]
self.Type = ObjectType
self.LowBound = [ self.GeoPar[0][0]-0.5*self.GeoPar[1][0], self.GeoPar[0][1]-0.5*self.GeoPar[1][1] ]
self.UpperBound = [ self.GeoPar[0][0]+0.5*self.GeoPar[1][0], self.GeoPar[0][1]+0.5*self.GeoPar[1][1] ]
self.MeshPar = MeshParameters
self.GeoChildren = []
self.GeoChildrenNames = []
self.Mesh = []
self.MeshGroups = []
self.CheckInterfaces()
if 'auto' in MeshParameters : self.AutoParam()
if not(self.MeshPar[0]<0): self.Generate()
else :
Config.ListObj.append(self)
print("Aborting object creation\n ")
def Generate(self) : if 'groups' in args :
""" self.GroupNames = args['groups']
This method generates the geometrical object with the corresponding mesh once all verifications (CheckInterfaces and AutoParam) for group in args['groups'] :
have been accomplished if not(group in Config.Groups) and group : Config.Groups.append(group)
""" else : self.GroupNames = [None, None, None, None]
import GenFunctions, Alarms, Config
self = {'Box11' : lambda : GenFunctions.Box11(self),
'Box42' : lambda : GenFunctions.Box42(self),
'BoxAng32' : lambda : GenFunctions.BoxAng32(self),
'CompBox' : lambda : GenFunctions.CompBox(self),
'CompBoxF' : lambda : GenFunctions.CompBoxF(self),
'NonOrtho' : lambda : GenFunctions.NonOrtho(self),
'QuartCyl' : lambda : GenFunctions.QuartCyl(self) }[self.Type]()
if Config.debug : Alarms.Message(self.status) # notification on the result of the generation algorithm if ObjectType == 'NonOrtho':
if not(len(GeoParameters)==4): print "Error: trying to construct a non-ortho object but the 4 constitutive vertices are not given!"
else :
Xmin = min([GeoParameters[i][0] for i in range(4)])
Xmax = max([GeoParameters[i][0] for i in range(4)])
Ymin = min([GeoParameters[i][1] for i in range(4)])
Ymax = max([GeoParameters[i][1] for i in range(4)])
self.GeoPar = [(0.5*(Xmin+Xmax),0.5*(Ymin+Ymax)),(Xmax-Xmin,Ymax-Ymin)]
self.PtCoor = GenFunctions.SortPoints(GeoParameters)
else:
self.GeoPar = GeoParameters
[Xmin,Ymin,Xmax,Ymax] = [ self.GeoPar[0][0]-0.5*self.GeoPar[1][0], self.GeoPar[0][1]-0.5*self.GeoPar[1][1] ] + [ self.GeoPar[0][0]+0.5*self.GeoPar[1][0], self.GeoPar[0][1]+0.5*self.GeoPar[1][1] ]
self.PtCoor = [(Xmin,Ymin),(Xmax,Ymin),(Xmax,Ymax),(Xmin,Ymax)]
def CheckInterfaces(self): self.Type = ObjectType
""" self.LowBound = [ self.GeoPar[0][0]-0.5*self.GeoPar[1][0], self.GeoPar[0][1]-0.5*self.GeoPar[1][1] ]
This method searches for neighbours for the object being created and saves them inside the Config.Connections self.UpperBound = [ self.GeoPar[0][0]+0.5*self.GeoPar[1][0], self.GeoPar[0][1]+0.5*self.GeoPar[1][1] ]
array. This array contains 4 entries per object corresponding to West, East, South, and North neighbours. self.MeshPar = MeshParameters
Note that an object may have more than one neighbour for a given direction. self.GeoChildren = []
""" self.GeoChildrenNames = []
import Alarms, Config self.Mesh = []
from GenFunctions import AddIfDifferent self.MeshGroups = []
from CompositeBox import FindCommonSide self.CheckInterfaces()
if 'auto' in MeshParameters : self.AutoParam()
Config.Connections.append([(-1,),(-1,),(-1,),(-1,)]) if not(self.MeshPar[0]<0): self.Generate()
itemID = len(Config.ListObj) else :
# In all cases except non ortho, PrincipleBoxes is unitary and contains the box in question Config.ListObj.append(self)
# In the non-ortho case it contains all possible combinations of boxes with 3 vertices print("Aborting object creation\n ")
PrincipleBoxes = self.PrincipleBoxes()
for i, TestObj in enumerate(Config.ListObj):
SecondaryBoxes = TestObj.PrincipleBoxes()
ConnX = 0
ConnY = 0
for Box0 in PrincipleBoxes:
for Box1 in SecondaryBoxes:
# Along X
CenterDis = abs(Box1[0][0]-Box0[0][0])
Extension = 0.5*(Box1[1][0]+Box0[1][0])
if CenterDis - Extension < -1e-7 :
ConnX = -1
elif CenterDis - Extension < 1e-7 :
if not(FindCommonSide(self.DirBoundaries(2),TestObj.DirBoundaries(3))==[0,0]) and Box1[0][0] < Box0[0][0] : ConnX = 1
elif not(FindCommonSide(self.DirBoundaries(3),TestObj.DirBoundaries(2))==[0,0]) and Box1[0][0] >= Box0[0][0]: ConnX = 2
else : ConnX = 0
# Along Y
CenterDis = abs(Box1[0][1]-Box0[0][1])
Extension = 0.5*(Box1[1][1]+Box0[1][1])
if CenterDis - Extension < -1e-7 :
ConnY = -1
elif CenterDis - Extension < 1e-7 :
if not(FindCommonSide(self.DirBoundaries(0),TestObj.DirBoundaries(1))==[0,0]) and Box1[0][1] < Box0[0][1] : ConnY = 1
elif not(FindCommonSide(self.DirBoundaries(1),TestObj.DirBoundaries(0))==[0,0]) and Box1[0][1] >= Box0[0][1]: ConnY = 2
else : ConnY = 0
if not (ConnX*ConnY == 0) : def Generate(self) :
if max(ConnX,ConnY) == -1 and not('NonOrtho' in [self.Type,TestObj.Type]) : Alarms.Message(3) """
else: This method generates the geometrical object with the corresponding mesh once all verifications (CheckInterfaces and AutoParam)
if ConnX == 1 and ConnY == -1: have been accomplished
if Config.Connections[i][1] == (-1,) : Config.Connections[i][1] = (itemID,) """
else : Config.Connections[i][1] = AddIfDifferent(Config.Connections[i][1],itemID) import GenFunctions, Alarms, Config
if Config.Connections[itemID][0] == (-1,) : Config.Connections[itemID][0] = (i,) self = {'Box11' : lambda : GenFunctions.Box11(self),
else : Config.Connections[itemID][0] = AddIfDifferent(Config.Connections[itemID][0],i) 'Box42' : lambda : GenFunctions.Box42(self),
elif ConnX == 2 and ConnY == -1: 'BoxAng32' : lambda : GenFunctions.BoxAng32(self),
if Config.Connections[i][0] == (-1,) : Config.Connections[i][0] = (itemID,) 'CompBox' : lambda : GenFunctions.CompBox(self),
else : Config.Connections[i][0] = AddIfDifferent(Config.Connections[i][0],itemID) 'CompBoxF' : lambda : GenFunctions.CompBoxF(self),
if Config.Connections[itemID][1] == (-1,) : Config.Connections[itemID][1] = (i,) 'NonOrtho' : lambda : GenFunctions.NonOrtho(self),
else : Config.Connections[itemID][1] = AddIfDifferent(Config.Connections[itemID][1],i) 'QuartCyl' : lambda : GenFunctions.QuartCyl(self) }[self.Type]()
elif ConnY == 1 and ConnX == -1:
if Config.Connections[i][3] == (-1,) : Config.Connections[i][3] = (itemID,)
else : Config.Connections[i][3] = AddIfDifferent(Config.Connections[i][3],itemID)
if Config.Connections[itemID][2] == (-1,) : Config.Connections[itemID][2] = (i,)
else : Config.Connections[itemID][2] = AddIfDifferent(Config.Connections[itemID][2],i)
elif ConnY ==2 and ConnX == -1:
if Config.Connections[i][2] == (-1,) : Config.Connections[i][2] = (itemID,)
else : Config.Connections[i][2] = AddIfDifferent(Config.Connections[i][2],itemID)
if Config.Connections[itemID][3] == (-1,) : Config.Connections[itemID][3] = (i,)
else : Config.Connections[itemID][3] = AddIfDifferent(Config.Connections[itemID][3],i)
def AutoParam (self): if Config.debug : Alarms.Message(self.status) # notification on the result of the generation algorithm
"""
This method is called only if the 'auto' keyword is used inside the meshing algorithm. It is based on the
connection results per object and tries to find the correct parameters for obtaining a final compatible mesh
between the objects already present and the one being created. If this is not possible, the method gives an error
message.
"""
import Alarms, Config, GenFunctions, CompositeBox
MeshPar = [0,0,0,0] # initialize the mesh parameter value to be used to -1
[(X0,Y0),(DX,DY)] = self.GeoPar
ObjectsInvolved = []
for i, Conn in enumerate(Config.Connections[-1]):
if not ( Conn == (-1,) ): # Meaning that there is one or more neighbors on this direction
for ObjID in Conn :
ToLook0 = [2,3,0,1][i]
ToLook1 = [3,2,1,0][i]
CommonSide = CompositeBox.FindCommonSide(Config.ListObj[ObjID].DirBoundaries(ToLook1),self.DirBoundaries(ToLook0))
#print "Common Side is:", CommonSide
ToLook2 = [1,0,3,2][i]
#print "Full Side is:", CompositeBox.IntLen(Config.ListObj[ObjID].DirBoundaries(ToLook1))
#print "Full Segments on this direction are:", Config.ListObj[ObjID].DirectionalMeshParams[ToLook2]
RealSegments = round(Config.ListObj[ObjID].DirectionalMeshParams[ToLook2]*CompositeBox.IntLen(CommonSide)/CompositeBox.IntLen(Config.ListObj[ObjID].DirBoundaries(ToLook1)))
#print "RealSegments :", RealSegments
MeshPar[i] = MeshPar[i] + RealSegments
ObjectsInvolved.append(ObjID+1)
self.DirectionalMeshParams = MeshPar
self.MeshPar[0] = GenFunctions.CompatibilityTest(self)
if self.MeshPar[0] < 0 :
Alarms.Message(4)
if self.MeshPar[0] == -1 : print ("Problem encountered with object(s) no. "+str(ObjectsInvolved))
elif self.MeshPar[0] == -2 : print ("This object has no neighbours !!!")
def Boundaries (self): def CheckInterfaces(self):
""" """
This method returns the global boundaries of the MacObject. [Xmin,Xmax,Ymin,Ymax] This method searches for neighbours for the object being created and saves them inside the Config.Connections
""" array. This array contains 4 entries per object corresponding to West, East, South, and North neighbours.
Xmin = min([self.DirBoundaries(i)[0] for i in [0,1]]) Note that an object may have more than one neighbour for a given direction.
Xmax = max([self.DirBoundaries(i)[1] for i in [0,1]]) """
Ymin = min([self.DirBoundaries(i)[0] for i in [2,3]]) import Alarms, Config
Ymax = max([self.DirBoundaries(i)[1] for i in [2,3]]) from GenFunctions import AddIfDifferent
from CompositeBox import FindCommonSide
return [Xmin,Xmax,Ymin,Ymax]
def DirBoundaries (self, Direction):
"""
This method returns a single interval giving [Xmin,Xmax] or [Ymin,Ymax] according to the required direction.
This works particularly well for nonorthogonal objects.
Direction : [0,1,2,3] <=> [South, North, West, East]
"""
PtCoor = self.PtCoor
PtCoor.append(self.PtCoor[0])
if type(Direction) is str :
Dir = { 'South' : lambda : 0,
'North' : lambda : 1,
'West' : lambda : 2,
'East' : lambda : 3,}[Direction]()
else : Dir = int(Direction)
PtIndex = [0,2,3,1][Dir]
DirIndex = [0,0,1,1][Dir]
return sorted([PtCoor[PtIndex][DirIndex],PtCoor[PtIndex+1][DirIndex]])
def DirVectors (self, Direction):
"""
This method returns for a given object, the real vectors which define a given direction
The interest in using this method is for non-orthogonal objects where the sides can be
deviated from the orthogonal basis vectors
"""
if type(Direction) is str :
Dir = { 'South' : lambda : 0,
'North' : lambda : 1,
'West' : lambda : 2,
'East' : lambda : 3,}[Direction]()
else : Dir = int(Direction)
PtCoor = self.PtCoor
PtCoor.append(self.PtCoor[0])
PtIndex = [0,2,3,1][Dir]
return [PtCoor[PtIndex+1][0]-PtCoor[PtIndex][0],PtCoor[PtIndex+1][1]-PtCoor[PtIndex][1],0.]
def GetBorder (self, Criterion):
import GenFunctions, Config
from salome.geom import geomBuilder Config.Connections.append([(-1,),(-1,),(-1,),(-1,)])
geompy = geomBuilder.New( Config.theStudy ) itemID = len(Config.ListObj)
# In all cases except non ortho, PrincipleBoxes is unitary and contains the box in question
if type(Criterion) is str : # In the non-ortho case it contains all possible combinations of boxes with 3 vertices
Crit = {'South' : lambda : 0, PrincipleBoxes = self.PrincipleBoxes()
'North' : lambda : 1, for i, TestObj in enumerate(Config.ListObj):
'West' : lambda : 2, SecondaryBoxes = TestObj.PrincipleBoxes()
'East' : lambda : 3,}[Criterion]() ConnX = 0
else : Crit = int(Criterion) ConnY = 0
for Box0 in PrincipleBoxes:
AcceptedObj = [] for Box1 in SecondaryBoxes:
if Crit < 4 : # Along X
Boundaries = self.Boundaries() CenterDis = abs(Box1[0][0]-Box0[0][0])
Research = {0 : lambda : [self.DirVectors(0),1,Boundaries[2]], Extension = 0.5*(Box1[1][0]+Box0[1][0])
1 : lambda : [self.DirVectors(1),1,Boundaries[3]], if CenterDis - Extension < -1e-7 :
2 : lambda : [self.DirVectors(2),0,Boundaries[0]], ConnX = -1
3 : lambda : [self.DirVectors(3),0,Boundaries[1]], }[Crit]() elif CenterDis - Extension < 1e-7 :
if not(FindCommonSide(self.DirBoundaries(2),TestObj.DirBoundaries(3))==[0,0]) and Box1[0][0] < Box0[0][0] : ConnX = 1
for i,ElemObj in enumerate(self.GeoChildren): elif not(FindCommonSide(self.DirBoundaries(3),TestObj.DirBoundaries(2))==[0,0]) and Box1[0][0] >= Box0[0][0]: ConnX = 2
EdgeIDs = geompy.ExtractShapes(ElemObj,6)# List of Edge IDs belonging to ElemObj else : ConnX = 0
for Edge in EdgeIDs:
if GenFunctions.IsParallel(Edge,Research[0]):
if abs( geompy.PointCoordinates(geompy.GetVertexByIndex(Edge,0))[Research[1]] - Research[2] )< 1e-6 or abs( geompy.PointCoordinates(geompy.GetVertexByIndex(Edge,1))[Research[1]] - Research[2] )< 1e-6 :
AcceptedObj.append(Edge)
else :
CenterSrchPar = {'NE' : lambda : [-1., -1.],
'NW' : lambda : [ 1., -1.],
'SW' : lambda : [ 1., 1.],
'SE' : lambda : [-1., 1.], }[self.MeshPar[1]]()
Radius = self.GeoPar[1][1]*float(self.MeshPar[2])/(self.MeshPar[2]+1)
Center = (self.GeoPar[0][0]+CenterSrchPar[0]*self.GeoPar[1][0]/2.,self.GeoPar[0][1]+CenterSrchPar[1]*self.GeoPar[1][1]/2.,0.)
for i,ElemObj in enumerate(self.GeoChildren):
EdgeIDs = geompy.ExtractShapes(ElemObj,6)# List of Edge IDs belonging to ElemObj
for Edge in EdgeIDs:
if GenFunctions.IsOnCircle(Edge,Center,Radius):
AcceptedObj.append(Edge)
return AcceptedObj
def PrincipleBoxes (self): # Along Y
""" CenterDis = abs(Box1[0][1]-Box0[0][1])
This function returns all possible combination rectangular shape objects that can contain at least 3 of the principle vertices Extension = 0.5*(Box1[1][1]+Box0[1][1])
constituting the MacObject. This is indispensable for the Non-ortho types and shall return a number of 24 possible combinations if CenterDis - Extension < -1e-7 :
""" ConnY = -1
from itertools import combinations elif CenterDis - Extension < 1e-7 :
Boxes = [] if not(FindCommonSide(self.DirBoundaries(0),TestObj.DirBoundaries(1))==[0,0]) and Box1[0][1] < Box0[0][1] : ConnY = 1
if self.Type == 'NonOrtho': elif not(FindCommonSide(self.DirBoundaries(1),TestObj.DirBoundaries(0))==[0,0]) and Box1[0][1] >= Box0[0][1]: ConnY = 2
for combi in combinations(range(4),3): else : ConnY = 0
Xmin = min([self.PtCoor[i][0] for i in combi])
Xmax = max([self.PtCoor[i][0] for i in combi]) if not (ConnX*ConnY == 0) :
Ymin = min([self.PtCoor[i][1] for i in combi]) if max(ConnX,ConnY) == -1 and not('NonOrtho' in [self.Type,TestObj.Type]) : Alarms.Message(3)
Ymax = max([self.PtCoor[i][1] for i in combi]) else:
Boxes.append([(0.5*(Xmin+Xmax),0.5*(Ymin+Ymax)),(Xmax-Xmin,Ymax-Ymin)]) if ConnX == 1 and ConnY == -1:
else : if Config.Connections[i][1] == (-1,) : Config.Connections[i][1] = (itemID,)
Boxes = [self.GeoPar] else : Config.Connections[i][1] = AddIfDifferent(Config.Connections[i][1],itemID)
if Config.Connections[itemID][0] == (-1,) : Config.Connections[itemID][0] = (i,)
return Boxes else : Config.Connections[itemID][0] = AddIfDifferent(Config.Connections[itemID][0],i)
elif ConnX == 2 and ConnY == -1:
if Config.Connections[i][0] == (-1,) : Config.Connections[i][0] = (itemID,)
else : Config.Connections[i][0] = AddIfDifferent(Config.Connections[i][0],itemID)
if Config.Connections[itemID][1] == (-1,) : Config.Connections[itemID][1] = (i,)
else : Config.Connections[itemID][1] = AddIfDifferent(Config.Connections[itemID][1],i)
elif ConnY == 1 and ConnX == -1:
if Config.Connections[i][3] == (-1,) : Config.Connections[i][3] = (itemID,)
else : Config.Connections[i][3] = AddIfDifferent(Config.Connections[i][3],itemID)
if Config.Connections[itemID][2] == (-1,) : Config.Connections[itemID][2] = (i,)
else : Config.Connections[itemID][2] = AddIfDifferent(Config.Connections[itemID][2],i)
elif ConnY ==2 and ConnX == -1:
if Config.Connections[i][2] == (-1,) : Config.Connections[i][2] = (itemID,)
else : Config.Connections[i][2] = AddIfDifferent(Config.Connections[i][2],itemID)
if Config.Connections[itemID][3] == (-1,) : Config.Connections[itemID][3] = (i,)
else : Config.Connections[itemID][3] = AddIfDifferent(Config.Connections[itemID][3],i)
def AutoParam (self):
"""
This method is called only if the 'auto' keyword is used inside the meshing algorithm. It is based on the
connection results per object and tries to find the correct parameters for obtaining a final compatible mesh
between the objects already present and the one being created. If this is not possible, the method gives an error
message.
"""
import Alarms, Config, GenFunctions, CompositeBox
MeshPar = [0,0,0,0] # initialize the mesh parameter value to be used to -1
[(X0,Y0),(DX,DY)] = self.GeoPar
ObjectsInvolved = []
for i, Conn in enumerate(Config.Connections[-1]):
if not ( Conn == (-1,) ): # Meaning that there is one or more neighbors on this direction
for ObjID in Conn :
ToLook0 = [2,3,0,1][i]
ToLook1 = [3,2,1,0][i]
CommonSide = CompositeBox.FindCommonSide(Config.ListObj[ObjID].DirBoundaries(ToLook1),self.DirBoundaries(ToLook0))
#print "Common Side is:", CommonSide
ToLook2 = [1,0,3,2][i]
#print "Full Side is:", CompositeBox.IntLen(Config.ListObj[ObjID].DirBoundaries(ToLook1))
#print "Full Segments on this direction are:", Config.ListObj[ObjID].DirectionalMeshParams[ToLook2]
RealSegments = round(Config.ListObj[ObjID].DirectionalMeshParams[ToLook2]*CompositeBox.IntLen(CommonSide)/CompositeBox.IntLen(Config.ListObj[ObjID].DirBoundaries(ToLook1)))
#print "RealSegments :", RealSegments
MeshPar[i] = MeshPar[i] + RealSegments
ObjectsInvolved.append(ObjID+1)
self.DirectionalMeshParams = MeshPar
self.MeshPar[0] = GenFunctions.CompatibilityTest(self)
if self.MeshPar[0] < 0 :
Alarms.Message(4)
if self.MeshPar[0] == -1 : print ("Problem encountered with object(s) no. "+str(ObjectsInvolved))
elif self.MeshPar[0] == -2 : print ("This object has no neighbours !!!")
def Boundaries (self):
"""
This method returns the global boundaries of the MacObject. [Xmin,Xmax,Ymin,Ymax]
"""
Xmin = min([self.DirBoundaries(i)[0] for i in [0,1]])
Xmax = max([self.DirBoundaries(i)[1] for i in [0,1]])
Ymin = min([self.DirBoundaries(i)[0] for i in [2,3]])
Ymax = max([self.DirBoundaries(i)[1] for i in [2,3]])
return [Xmin,Xmax,Ymin,Ymax]
def DirBoundaries (self, Direction):
"""
This method returns a single interval giving [Xmin,Xmax] or [Ymin,Ymax] according to the required direction.
This works particularly well for nonorthogonal objects.
Direction : [0,1,2,3] <=> [South, North, West, East]
"""
PtCoor = self.PtCoor
PtCoor.append(self.PtCoor[0])
if type(Direction) is str :
Dir = { 'South' : lambda : 0,
'North' : lambda : 1,
'West' : lambda : 2,
'East' : lambda : 3,}[Direction]()
else : Dir = int(Direction)
PtIndex = [0,2,3,1][Dir]
DirIndex = [0,0,1,1][Dir]
return sorted([PtCoor[PtIndex][DirIndex],PtCoor[PtIndex+1][DirIndex]])
def DirVectors (self, Direction):
"""
This method returns for a given object, the real vectors which define a given direction
The interest in using this method is for non-orthogonal objects where the sides can be
deviated from the orthogonal basis vectors
"""
if type(Direction) is str :
Dir = { 'South' : lambda : 0,
'North' : lambda : 1,
'West' : lambda : 2,
'East' : lambda : 3,}[Direction]()
else : Dir = int(Direction)
PtCoor = self.PtCoor
PtCoor.append(self.PtCoor[0])
PtIndex = [0,2,3,1][Dir]
return [PtCoor[PtIndex+1][0]-PtCoor[PtIndex][0],PtCoor[PtIndex+1][1]-PtCoor[PtIndex][1],0.]
def GetBorder (self, Criterion):
import GenFunctions, Config
from salome.geom import geomBuilder
geompy = geomBuilder.New( Config.theStudy )
if type(Criterion) is str :
Crit = {'South' : lambda : 0,
'North' : lambda : 1,
'West' : lambda : 2,
'East' : lambda : 3,}[Criterion]()
else : Crit = int(Criterion)
AcceptedObj = []
if Crit < 4 :
Boundaries = self.Boundaries()
Research = {0 : lambda : [self.DirVectors(0),1,Boundaries[2]],
1 : lambda : [self.DirVectors(1),1,Boundaries[3]],
2 : lambda : [self.DirVectors(2),0,Boundaries[0]],
3 : lambda : [self.DirVectors(3),0,Boundaries[1]], }[Crit]()
for i,ElemObj in enumerate(self.GeoChildren):
EdgeIDs = geompy.ExtractShapes(ElemObj,6)# List of Edge IDs belonging to ElemObj
for Edge in EdgeIDs:
if GenFunctions.IsParallel(Edge,Research[0]):
if abs( geompy.PointCoordinates(geompy.GetVertexByIndex(Edge,0))[Research[1]] - Research[2] )< 1e-6 or abs( geompy.PointCoordinates(geompy.GetVertexByIndex(Edge,1))[Research[1]] - Research[2] )< 1e-6 :
AcceptedObj.append(Edge)
else :
CenterSrchPar = {'NE' : lambda : [-1., -1.],
'NW' : lambda : [ 1., -1.],
'SW' : lambda : [ 1., 1.],
'SE' : lambda : [-1., 1.], }[self.MeshPar[1]]()
Radius = self.GeoPar[1][1]*float(self.MeshPar[2])/(self.MeshPar[2]+1)
Center = (self.GeoPar[0][0]+CenterSrchPar[0]*self.GeoPar[1][0]/2.,self.GeoPar[0][1]+CenterSrchPar[1]*self.GeoPar[1][1]/2.,0.)
for i,ElemObj in enumerate(self.GeoChildren):
EdgeIDs = geompy.ExtractShapes(ElemObj,6)# List of Edge IDs belonging to ElemObj
for Edge in EdgeIDs:
if GenFunctions.IsOnCircle(Edge,Center,Radius):
AcceptedObj.append(Edge)
return AcceptedObj
def PrincipleBoxes (self):
"""
This function returns all possible combination rectangular shape objects that can contain at least 3 of the principle vertices
constituting the MacObject. This is indispensable for the Non-ortho types and shall return a number of 24 possible combinations
"""
from itertools import combinations
Boxes = []
if self.Type == 'NonOrtho':
for combi in combinations(range(4),3):
Xmin = min([self.PtCoor[i][0] for i in combi])
Xmax = max([self.PtCoor[i][0] for i in combi])
Ymin = min([self.PtCoor[i][1] for i in combi])
Ymax = max([self.PtCoor[i][1] for i in combi])
Boxes.append([(0.5*(Xmin+Xmax),0.5*(Ymin+Ymax)),(Xmax-Xmin,Ymax-Ymin)])
else :
Boxes = [self.GeoPar]
return Boxes

387
src/Tools/MacMesh/MacMesh/PublishGroups.py
View File

@ -17,7 +17,7 @@
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
# #
# #
import SMESH import SMESH
import math import math
import Config import Config
@ -31,217 +31,216 @@ smesh = smeshBuilder.New( Config.theStudy )
########################################################################################################## ##########################################################################################################
def PublishGroups (): def PublishGroups ():
aFilterManager = smesh.CreateFilterManager() aFilterManager = smesh.CreateFilterManager()
# Building geometric and mesh compounds and groups ############################################## # Building geometric and mesh compounds and groups ##############################################
if Config.debug : print "Searching for geometric groups and publishing final compound" if Config.debug : print "Searching for geometric groups and publishing final compound"
TempGEOList = []
TempMESHList = []
for MacroObj in Config.ListObj :
TempGEOList += MacroObj.GeoChildren
TempMESHList += MacroObj.Mesh
FinalCompound = geompy.MakeCompound(TempGEOList)
geompy.addToStudy (FinalCompound,Config.StudyName)
MeshCompound = smesh.Concatenate(TempMESHList, 1, 1, 1e-5)
MeshCompound.SetName(Config.StudyName)
GroupGEO = []
for group in Config.Groups :
# Geometric groups definition
TempGEOList = [] TempGEOList = []
TempMESHList = [] TempNames = []
for MacroObj in Config.ListObj :
for MacroObj in Config.ListObj : if group in MacroObj.GroupNames :
TempGEOList += MacroObj.GeoChildren Occurences = IndexMultiOcc(MacroObj.GroupNames, group)
TempMESHList += MacroObj.Mesh for Occ in Occurences :
TempGEOList += MacroObj.GetBorder(Occ)
FinalCompound = geompy.MakeCompound(TempGEOList) GroupGEO.append(geompy.MakeCompound(TempGEOList))
geompy.addToStudy (FinalCompound,Config.StudyName) geompy.addToStudyInFather(FinalCompound,GroupGEO[-1],'GR_'+group)
MeshCompound = smesh.Concatenate(TempMESHList, 1, 1, 1e-5)
MeshCompound.SetName(Config.StudyName) # Mesh groups definition
Criterion = smesh.GetCriterion(SMESH.EDGE, SMESH.FT_BelongToGeom,'=',GroupGEO[-1],Tolerance=1e-06)
GroupGEO = [] #Criterion = smesh.Filter.Criterion(18,39,0,'GR_'+group,'GR_'+group,39,39,1e-06,smesh.EDGE,7)
for group in Config.Groups : MeshCompound.MakeGroupByCriterion(group,Criterion)
# Geometric groups definition StudyBuilder = Config.theStudy.NewBuilder()
TempGEOList = [] for MeshObj in TempMESHList:
TempNames = [] SO = Config.theStudy.FindObjectIOR(Config.theStudy.ConvertObjectToIOR(MeshObj))
for MacroObj in Config.ListObj : if SO is not None: StudyBuilder.RemoveObjectWithChildren(SO)
if group in MacroObj.GroupNames :
Occurences = IndexMultiOcc(MacroObj.GroupNames, group) return MeshCompound
for Occ in Occurences :
TempGEOList += MacroObj.GetBorder(Occ)
GroupGEO.append(geompy.MakeCompound(TempGEOList))
geompy.addToStudyInFather(FinalCompound,GroupGEO[-1],'GR_'+group)
# Mesh groups definition
Criterion = smesh.GetCriterion(SMESH.EDGE, SMESH.FT_BelongToGeom,'=',GroupGEO[-1],Tolerance=1e-06)
#Criterion = smesh.Filter.Criterion(18,39,0,'GR_'+group,'GR_'+group,39,39,1e-06,smesh.EDGE,7)
MeshCompound.MakeGroupByCriterion(group,Criterion)
StudyBuilder = Config.theStudy.NewBuilder()
for MeshObj in TempMESHList:
SO = Config.theStudy.FindObjectIOR(Config.theStudy.ConvertObjectToIOR(MeshObj))
if SO is not None: StudyBuilder.RemoveObjectWithChildren(SO)
return MeshCompound
def IndexMultiOcc (Array,Element) : def IndexMultiOcc (Array,Element) :
""" """
This function returns the occurrences indices of Element in Array. This function returns the occurrences indices of Element in Array.
As opposed to Array.index(Element) method, this allows determining As opposed to Array.index(Element) method, this allows determining
multiple entries rather than just the first one! multiple entries rather than just the first one!
""" """
Output = [] Output = []
try : Array.index(Element) try : Array.index(Element)
except ValueError : print "No more occurrences" except ValueError : print "No more occurrences"
else : Output.append(Array.index(Element)) else : Output.append(Array.index(Element))
if not(Output == [-1]) and len(Array) > 1 : if not(Output == [-1]) and len(Array) > 1 :
for index, ArrElem in enumerate(Array[Output[0]+1:]) : for index, ArrElem in enumerate(Array[Output[0]+1:]) :
if ArrElem is Element : Output.append(index+Output[0]+1) if ArrElem is Element : Output.append(index+Output[0]+1)
return Output return Output
def Publish (ObjToPublish): def Publish (ObjToPublish):
for i,GeoObj in enumerate(ObjToPublish) : geompy.addToStudy(GeoObj,"Sub_"+str(i)) for i,GeoObj in enumerate(ObjToPublish) : geompy.addToStudy(GeoObj,"Sub_"+str(i))
def RevolveMesh(MainMesh,**args): def RevolveMesh(MainMesh,**args):
""" """
This function premits to revolute and scale a 2D mesh while transforming the edge This function premits to revolute and scale a 2D mesh while transforming the edge
groups into face groups. Moreover, the function automatically creates the face groups groups into face groups. Moreover, the function automatically creates the face groups
corresponding to the symmetry lower and upper faces corresponding to the symmetry lower and upper faces
Facultatif arguments are : Facultatif arguments are :
- Center [X,Y,Z], origin being the default - Center [X,Y,Z], origin being the default
- Direction [VX,VY,VZ], x-axis being the default - Direction [VX,VY,VZ], x-axis being the default
- AngleDeg or AngleRad : ALPHA, 10 degrees being the default - AngleDeg or AngleRad : ALPHA, 10 degrees being the default
- Scale : BETA, no scaling being default - Scale : BETA, no scaling being default
""" """
################################################################################ ################################################################################
# Reading input arguments and proceeding to defaults if necessary # Reading input arguments and proceeding to defaults if necessary
################################################################################ ################################################################################
if 'Center' in args : CenterCoor = [float(Coor) for Coor in args['Center']] if 'Center' in args : CenterCoor = [float(Coor) for Coor in args['Center']]
else : else :
print "\nThe coordinates of the center of revolution were not given\nThe origin is used by default." print "\nThe coordinates of the center of revolution were not given\nThe origin is used by default."
CenterCoor = [0.,0.,0.] CenterCoor = [0.,0.,0.]
if 'Direction' in args : Direction = [float(Dir) for Dir in args['Direction']]
else :
print "\nThe axis vector of revolution was not given\nThe x-axis is used by default."
Direction = [1.,0.,0.]
if 'AngleDeg' in args : Angle = float(args['AngleDeg'])*math.pi/180.
elif 'AngleRad' in args : Angle = float(args['AngleRad'])
else :
print "\nThe revolution angle was not given\nAn angle of 10 degrees is used by default."
Angle = 10.*math.pi/180.
if 'Scale' in args : Scale = float(args['Scale'])
else : Scale = 1.
# Creating the lower face group LOFAC if 'Direction' in args : Direction = [float(Dir) for Dir in args['Direction']]
LOFAC = MainMesh.CreateEmptyGroup( SMESH.FACE, 'LOFAC' ) else :
LOFAC.AddFrom(MainMesh.GetMesh()) print "\nThe axis vector of revolution was not given\nThe x-axis is used by default."
Direction = [1.,0.,0.]
GR_Names = MainMesh.GetGroupNames() if 'AngleDeg' in args : Angle = float(args['AngleDeg'])*math.pi/180.
GRs = MainMesh.GetGroups() elif 'AngleRad' in args : Angle = float(args['AngleRad'])
Rev3DMeshGroups = MainMesh.RotationSweepObject2D( MainMesh, SMESH.AxisStruct( CenterCoor[0], CenterCoor[1], CenterCoor[2], Direction[0], Direction[1], Direction[2] ), Angle, 1, 1e-05 ,True) else :
print "\nThe revolution angle was not given\nAn angle of 10 degrees is used by default."
Angle = 10.*math.pi/180.
# Adding an EDGE suffix to the edge groups (to be deleted eventually by the user...) if 'Scale' in args : Scale = float(args['Scale'])
for GR in GRs: else : Scale = 1.
CurrentName = GR.GetName()
if CurrentName in GR_Names and not(CurrentName=='LOFAC'): # Meaning that this is an old edge group
GR.SetName(CurrentName+'_EDGE')
# Removing the _rotated prefix from the rotated FACE groups
for GR in Rev3DMeshGroups:
CurrentName = GR.GetName()
if CurrentName.endswith( "_rotated"):
if CurrentName.startswith( 'LOFAC_' ):
GR.SetName('VOL')
else:
GR.SetName(CurrentName[:-8])
elif CurrentName == 'LOFAC_top':
GR.SetName('HIFAC')
#Index = [ GR_Names[i] in CurrentName for i in range(0,len(GR_Names)) ].index(True)
#GR.SetName(GR_Names[Index])
# Creating the upper face group HIFAC # Creating the lower face group LOFAC
ALLFAC = MainMesh.CreateEmptyGroup( SMESH.FACE, 'ALLFAC' ) LOFAC = MainMesh.CreateEmptyGroup( SMESH.FACE, 'LOFAC' )
ALLFAC.AddFrom(MainMesh.GetMesh()) LOFAC.AddFrom(MainMesh.GetMesh())
GR_Names = MainMesh.GetGroupNames()
GRs = MainMesh.GetGroups()
Rev3DMeshGroups = MainMesh.RotationSweepObject2D( MainMesh, SMESH.AxisStruct( CenterCoor[0], CenterCoor[1], CenterCoor[2], Direction[0], Direction[1], Direction[2] ), Angle, 1, 1e-05 ,True)
# Adding an EDGE suffix to the edge groups (to be deleted eventually by the user...)
for GR in GRs:
CurrentName = GR.GetName()
if CurrentName in GR_Names and not(CurrentName=='LOFAC'): # Meaning that this is an old edge group
GR.SetName(CurrentName+'_EDGE')
# Removing the _rotated prefix from the rotated FACE groups
for GR in Rev3DMeshGroups:
CurrentName = GR.GetName()
if CurrentName.endswith( "_rotated"):
if CurrentName.startswith( 'LOFAC_' ):
GR.SetName('VOL')
else:
GR.SetName(CurrentName[:-8])
elif CurrentName == 'LOFAC_top':
GR.SetName('HIFAC')
#Index = [ GR_Names[i] in CurrentName for i in range(0,len(GR_Names)) ].index(True)
#GR.SetName(GR_Names[Index])
# Creating the upper face group HIFAC
ALLFAC = MainMesh.CreateEmptyGroup( SMESH.FACE, 'ALLFAC' )
ALLFAC.AddFrom(MainMesh.GetMesh())
#HIFAC = MainMesh.GetMesh().CutListOfGroups( [ ALLFAC ], [LOFAC] + [ MeshGroup for MeshGroup in Rev3DMeshGroups if not(MeshGroup.GetName()=='VOL') ], 'HIFAC' )
#HIFAC = MainMesh.GetMesh().CutListOfGroups( [ ALLFAC ], [LOFAC] + [ MeshGroup for MeshGroup in Rev3DMeshGroups if ( not(MeshGroup.GetName()=='VOL') and MeshGroup.GetType() == SMESH.FACE )], 'HIFAC' )
# Scaling down the mesh to meter units
if not(Scale==1.):
MeshEditor = MainMesh.GetMeshEditor()
MeshEditor.Scale( MainMesh.GetMesh(), SMESH.PointStruct( 0, 0, 0 ) ,[ Scale, Scale, Scale ], 0 )
#HIFAC = MainMesh.GetMesh().CutListOfGroups( [ ALLFAC ], [LOFAC] + [ MeshGroup for MeshGroup in Rev3DMeshGroups if not(MeshGroup.GetName()=='VOL') ], 'HIFAC' )
#HIFAC = MainMesh.GetMesh().CutListOfGroups( [ ALLFAC ], [LOFAC] + [ MeshGroup for MeshGroup in Rev3DMeshGroups if ( not(MeshGroup.GetName()=='VOL') and MeshGroup.GetType() == SMESH.FACE )], 'HIFAC' )
# Scaling down the mesh to meter units
if not(Scale==1.):
MeshEditor = MainMesh.GetMeshEditor()
MeshEditor.Scale( MainMesh.GetMesh(), SMESH.PointStruct( 0, 0, 0 ) ,[ Scale, Scale, Scale ], 0 )
def ExtrudeMesh(MainMesh,**args): def ExtrudeMesh(MainMesh,**args):
""" """
This function premits to extrude and scale a 2D mesh while transforming the edge This function premits to extrude and scale a 2D mesh while transforming the edge
groups into face groups. Moreover, the function automatically creates the face groups groups into face groups. Moreover, the function automatically creates the face groups
corresponding to the symmetry lower and upper faces corresponding to the symmetry lower and upper faces
Facultatif arguments are : Facultatif arguments are :
- Direction [VX,VY,VZ], z-axis being default - Direction [VX,VY,VZ], z-axis being default
- Distance : D, default is 1 - Distance : D, default is 1
- NSteps : the object will be extruded by NSteps*Distance, default is Nsteps = 1 - NSteps : the object will be extruded by NSteps*Distance, default is Nsteps = 1
- Scale : BETA, no scaling being default - Scale : BETA, no scaling being default
""" """
################################################################################ ################################################################################
# Reading input arguments and proceeding to defaults if necessary # Reading input arguments and proceeding to defaults if necessary
################################################################################ ################################################################################
if 'Distance' in args : Distance = float(args['Distance']) if 'Distance' in args : Distance = float(args['Distance'])
else : else :
print "\nThe extrusion distance was not given\nA default value of 1 is used." print "\nThe extrusion distance was not given\nA default value of 1 is used."
Distance = 1. Distance = 1.
if 'Direction' in args : Direction = NormalizeVector([float(Dir) for Dir in args['Direction']],Distance)
else :
print "\nThe extrusion vector of revolution was not given\nThe z-axis is used by default."
Direction = NormalizeVector([0.,0.,1.],Distance)
if 'Scale' in args : Scale = float(args['Scale'])
else : Scale = 1.
if 'NSteps' in args : NSteps = int(args['NSteps'])
else : NSteps = 1
# Creating the lower face group LOFAC
LOFAC = MainMesh.CreateEmptyGroup( SMESH.FACE, 'LOFAC' )
LOFAC.AddFrom(MainMesh.GetMesh())
GR_Names = MainMesh.GetGroupNames() if 'Direction' in args : Direction = NormalizeVector([float(Dir) for Dir in args['Direction']],Distance)
GRs = MainMesh.GetGroups() else :
Ext3DMeshGroups = MainMesh.ExtrusionSweepObject2D(MainMesh,SMESH.DirStruct(SMESH.PointStruct(Direction[0],Direction[1],Direction[2])), NSteps, True) print "\nThe extrusion vector of revolution was not given\nThe z-axis is used by default."
Direction = NormalizeVector([0.,0.,1.],Distance)
# Adding an EDGE suffix to the edge groups (to be deleted eventually by the user...) if 'Scale' in args : Scale = float(args['Scale'])
for GR in GRs: else : Scale = 1.
CurrentName = GR.GetName()
if CurrentName in GR_Names and not(CurrentName=='LOFAC'): # Meaning that this is an old edge group
GR.SetName(CurrentName+'_EDGE')
# Removing the _extruded suffix from the extruded FACE groups if 'NSteps' in args : NSteps = int(args['NSteps'])
for GR in Ext3DMeshGroups: else : NSteps = 1
CurrentName = GR.GetName()
if CurrentName.endswith( "_extruded"):
if CurrentName.startswith( 'LOFAC_' ):
GR.SetName('VOL')
else:
GR.SetName(CurrentName[:-9])
elif CurrentName == 'LOFAC_top':
GR.SetName('HIFAC')
# Creating the upper face group HIFAC # Creating the lower face group LOFAC
ALLFAC = MainMesh.CreateEmptyGroup( SMESH.FACE, 'ALLFAC' ) LOFAC = MainMesh.CreateEmptyGroup( SMESH.FACE, 'LOFAC' )
ALLFAC.AddFrom(MainMesh.GetMesh()) LOFAC.AddFrom(MainMesh.GetMesh())
GR_Names = MainMesh.GetGroupNames()
GRs = MainMesh.GetGroups()
Ext3DMeshGroups = MainMesh.ExtrusionSweepObject2D(MainMesh,SMESH.DirStruct(SMESH.PointStruct(Direction[0],Direction[1],Direction[2])), NSteps, True)
# Adding an EDGE suffix to the edge groups (to be deleted eventually by the user...)
for GR in GRs:
CurrentName = GR.GetName()
if CurrentName in GR_Names and not(CurrentName=='LOFAC'): # Meaning that this is an old edge group
GR.SetName(CurrentName+'_EDGE')
# Removing the _extruded suffix from the extruded FACE groups
for GR in Ext3DMeshGroups:
CurrentName = GR.GetName()
if CurrentName.endswith( "_extruded"):
if CurrentName.startswith( 'LOFAC_' ):
GR.SetName('VOL')
else:
GR.SetName(CurrentName[:-9])
elif CurrentName == 'LOFAC_top':
GR.SetName('HIFAC')
# Creating the upper face group HIFAC
ALLFAC = MainMesh.CreateEmptyGroup( SMESH.FACE, 'ALLFAC' )
ALLFAC.AddFrom(MainMesh.GetMesh())
#HIFAC = MainMesh.GetMesh().CutListOfGroups( [ ALLFAC ], [LOFAC] + [ MeshGroup for MeshGroup in Ext3DMeshGroups if not(MeshGroup.GetName()=='VOL') ], 'HIFAC' )
# Scaling down the mesh to meter units
if not(Scale==1.):
MeshEditor = MainMesh.GetMeshEditor()
MeshEditor.Scale( MainMesh.GetMesh(), SMESH.PointStruct( 0, 0, 0 ) ,[ Scale, Scale, Scale ], 0 )
#HIFAC = MainMesh.GetMesh().CutListOfGroups( [ ALLFAC ], [LOFAC] + [ MeshGroup for MeshGroup in Ext3DMeshGroups if not(MeshGroup.GetName()=='VOL') ], 'HIFAC' )
# Scaling down the mesh to meter units
if not(Scale==1.):
MeshEditor = MainMesh.GetMeshEditor()
MeshEditor.Scale( MainMesh.GetMesh(), SMESH.PointStruct( 0, 0, 0 ) ,[ Scale, Scale, Scale ], 0 )
def NormalizeVector (V,Norm): def NormalizeVector (V,Norm):
""" """
This function returns a normalized vector (magnitude = Norm), parallel to the entered one This function returns a normalized vector (magnitude = Norm), parallel to the entered one
""" """
V = [float(Coor) for Coor in V] V = [float(Coor) for Coor in V]
Norm = float(Norm) Norm = float(Norm)
MagV = math.sqrt(V[0]*V[0]+V[1]*V[1]+V[2]*V[2]) MagV = math.sqrt(V[0]*V[0]+V[1]*V[1]+V[2]*V[2])
return [Coor*Norm/MagV for Coor in V] return [Coor*Norm/MagV for Coor in V]

404
src/Tools/MacMesh/MacMesh/SharpAngle.py
View File

@ -21,11 +21,11 @@
# This is an automation of the sharp angle object, with a corner at (X0,Y0), side length : Extension and a fine local meshing : LocalMeshing # This is an automation of the sharp angle object, with a corner at (X0,Y0), side length : Extension and a fine local meshing : LocalMeshing
# The corner orientation is defined as NE (North-East) , NW (North-West), SE, or SW. The object's "arm" is 8/14 of Extension # The corner orientation is defined as NE (North-East) , NW (North-West), SE, or SW. The object's "arm" is 8/14 of Extension
# | | 8 6 # | | 8 6
# ------- --------- # ------- ---------
# ----> | | <---- # ----> | | <----
# | NW NE | oo # | NW NE | oo
# _____| |_____ # _____| |_____
import sys, math, commands import sys, math, commands
CWD = commands.getoutput('pwd') CWD = commands.getoutput('pwd')
@ -35,213 +35,213 @@ from MacObject import *
from CompositeBox import * from CompositeBox import *
import Config, GenFunctions import Config, GenFunctions
def SharpAngleOut (X0 , Y0 , DX , DY , DLocal, LocalMeshing , CornerOrientation , NLevels, **args) : def SharpAngleOut (X0 , Y0 , DX , DY , DLocal, LocalMeshing , CornerOrientation , NLevels, **args) :
if DLocal == 'auto' : DLocal = float(min(DX,DY)) if DLocal == 'auto' : DLocal = float(min(DX,DY))
BoxSide = DLocal/(2.**(NLevels+1)) BoxSide = DLocal/(2.**(NLevels+1))
InternalMeshing = int(math.ceil(BoxSide/(3*LocalMeshing))) InternalMeshing = int(math.ceil(BoxSide/(3*LocalMeshing)))
InternalMeshing = InternalMeshing+InternalMeshing%2 # An even number is needed, otherwise the objects would not be compatible once created InternalMeshing = InternalMeshing+InternalMeshing%2 # An even number is needed, otherwise the objects would not be compatible once created
if InternalMeshing == 0 : InternalMeshing = 2 # This sets a minimum meshing condition in order to avoid an error. The user is notified of the value considered for the local meshing if InternalMeshing == 0 : InternalMeshing = 2 # This sets a minimum meshing condition in order to avoid an error. The user is notified of the value considered for the local meshing
print "Possible Local meshing is :", BoxSide/(3*InternalMeshing), "\nThis value is returned by this function for your convenience" print "Possible Local meshing is :", BoxSide/(3*InternalMeshing), "\nThis value is returned by this function for your convenience"
DirPar = {'NE' : lambda : ['NE', 'NW', 'SE', 'EW', 'NW', 'SN', 'SN', 'NE', 'WE', 'WE', 'SE', 'NS'], DirPar = {'NE' : lambda : ['NE', 'NW', 'SE', 'EW', 'NW', 'SN', 'SN', 'NE', 'WE', 'WE', 'SE', 'NS'],
'NW' : lambda : ['NW', 'NE', 'SW', 'WE', 'NE', 'SN', 'SN', 'NW', 'EW', 'EW', 'SW', 'NS'], 'NW' : lambda : ['NW', 'NE', 'SW', 'WE', 'NE', 'SN', 'SN', 'NW', 'EW', 'EW', 'SW', 'NS'],
'SE' : lambda : ['SE', 'SW', 'NE', 'EW', 'SW', 'NS', 'NS', 'SE', 'WE', 'WE', 'NE', 'SN'], 'SE' : lambda : ['SE', 'SW', 'NE', 'EW', 'SW', 'NS', 'NS', 'SE', 'WE', 'WE', 'NE', 'SN'],
'SW' : lambda : ['SW', 'SE', 'NW', 'WE', 'SE', 'NS', 'NS', 'SW', 'EW', 'EW', 'NW', 'SN'], }[CornerOrientation]() 'SW' : lambda : ['SW', 'SE', 'NW', 'WE', 'SE', 'NS', 'NS', 'SW', 'EW', 'EW', 'NW', 'SN'], }[CornerOrientation]()
CoefVer = {'NE' : lambda : 1, CoefVer = {'NE' : lambda : 1,
'NW' : lambda : 1, 'NW' : lambda : 1,
'SE' : lambda : -1, 'SE' : lambda : -1,
'SW' : lambda : -1, }[CornerOrientation]() 'SW' : lambda : -1, }[CornerOrientation]()
CoefHor = {'NE' : lambda : 1, CoefHor = {'NE' : lambda : 1,
'NW' : lambda : -1, 'NW' : lambda : -1,
'SE' : lambda : 1, 'SE' : lambda : 1,
'SW' : lambda : -1, }[CornerOrientation]() 'SW' : lambda : -1, }[CornerOrientation]()
ToLook = {'NE' : lambda : [0,2,1,3], ToLook = {'NE' : lambda : [0,2,1,3],
'NW' : lambda : [0,3,1,2], 'NW' : lambda : [0,3,1,2],
'SE' : lambda : [1,2,0,3], 'SE' : lambda : [1,2,0,3],
'SW' : lambda : [1,3,0,2], }[CornerOrientation]() 'SW' : lambda : [1,3,0,2], }[CornerOrientation]()
if args.__contains__('groups') : if args.__contains__('groups') :
GroupNames = args['groups'] GroupNames = args['groups']
else : GroupNames = [None, None, None, None, None, None] else : GroupNames = [None, None, None, None, None, None]
GN00 = GroupArray(ToLook[0],GroupNames[0]) GN00 = GroupArray(ToLook[0],GroupNames[0])
GN01 = GroupArray(ToLook[1],GroupNames[1]) GN01 = GroupArray(ToLook[1],GroupNames[1])
GN1 = GroupArray([ToLook[0],ToLook[1]],[GroupNames[0],GroupNames[5]]) GN1 = GroupArray([ToLook[0],ToLook[1]],[GroupNames[0],GroupNames[5]])
GN7 = GroupArray([ToLook[0],ToLook[1]],[GroupNames[4],GroupNames[1]]) GN7 = GroupArray([ToLook[0],ToLook[1]],[GroupNames[4],GroupNames[1]])
if DY == DLocal : if DY == DLocal :
GN2 = GroupArray([ToLook[1],ToLook[2]],[GroupNames[5],GroupNames[2]]) GN2 = GroupArray([ToLook[1],ToLook[2]],[GroupNames[5],GroupNames[2]])
GN3 = GroupArray(ToLook[2],GroupNames[2]) GN3 = GroupArray(ToLook[2],GroupNames[2])
if DX == DLocal: if DX == DLocal:
GN4 = GroupArray([ToLook[2],ToLook[3]],[GroupNames[2],GroupNames[3]]) GN4 = GroupArray([ToLook[2],ToLook[3]],[GroupNames[2],GroupNames[3]])
GN5 = GroupArray(ToLook[3],GroupNames[3]) GN5 = GroupArray(ToLook[3],GroupNames[3])
GN6 = GroupArray([ToLook[3],ToLook[0]],[GroupNames[3],GroupNames[4]]) GN6 = GroupArray([ToLook[3],ToLook[0]],[GroupNames[3],GroupNames[4]])
else :
GN4 = GroupArray(ToLook[2],GroupNames[2])
GN5 = [None,None,None,None]
GN6 = GroupArray(ToLook[0],GroupNames[4])
GN21 = GroupArray([ToLook[3],ToLook[0],ToLook[2]],[GroupNames[3],GroupNames[4],GroupNames[2]])
else : else :
GN2 = GroupArray(ToLook[1],GroupNames[5]) GN4 = GroupArray(ToLook[2],GroupNames[2])
GN3 = [None,None,None,None] GN5 = [None,None,None,None]
if DX == DLocal: GN6 = GroupArray(ToLook[0],GroupNames[4])
GN4 = GroupArray(ToLook[3],GroupNames[3]) GN21 = GroupArray([ToLook[3],ToLook[0],ToLook[2]],[GroupNames[3],GroupNames[4],GroupNames[2]])
GN5 = GroupArray(ToLook[3],GroupNames[3]) else :
GN6 = GroupArray([ToLook[3],ToLook[0]],[GroupNames[3],GroupNames[4]]) GN2 = GroupArray(ToLook[1],GroupNames[5])
GN22 = GroupArray([ToLook[1],ToLook[2],ToLook[3]],[GroupNames[5],GroupNames[2],GroupNames[3]]) GN3 = [None,None,None,None]
else : if DX == DLocal:
GN4 = [None,None,None,None] GN4 = GroupArray(ToLook[3],GroupNames[3])
GN5 = [None,None,None,None] GN5 = GroupArray(ToLook[3],GroupNames[3])
GN6 = GroupArray(ToLook[0],GroupNames[4]) GN6 = GroupArray([ToLook[3],ToLook[0]],[GroupNames[3],GroupNames[4]])
GN21 = GroupArray([ToLook[3],ToLook[0]],[GroupNames[3],GroupNames[4]]) GN22 = GroupArray([ToLook[1],ToLook[2],ToLook[3]],[GroupNames[5],GroupNames[2],GroupNames[3]])
GN22 = GroupArray([ToLook[1],ToLook[2]],[GroupNames[5],GroupNames[2]])
GN23 = GroupArray([ToLook[2],ToLook[3]],[GroupNames[2],GroupNames[3]])
Obj = []
Obj.append(MacObject('BoxAng32',[(X0+CoefHor*BoxSide/2,Y0+CoefVer*BoxSide/2),(BoxSide,BoxSide)],[InternalMeshing,DirPar[0]]))
Obj.append(MacObject('BoxAng32',[(X0-CoefHor*BoxSide/2,Y0+CoefVer*BoxSide/2),(BoxSide,BoxSide)],['auto',DirPar[1]], groups = GroupArray(ToLook[0],GroupNames[0])))
Obj.append(MacObject('BoxAng32',[(X0+CoefHor*BoxSide/2,Y0-CoefVer*BoxSide/2),(BoxSide,BoxSide)],['auto',DirPar[2]], groups = GroupArray(ToLook[1],GroupNames[1])))
for N in range (1,NLevels+1):
n = N-1
if N < NLevels :
Obj.append(MacObject('Box42',[(X0-CoefHor*BoxSide*(2**n)*3/2,Y0+CoefVer*(2**n)*BoxSide/2),((2**n)*BoxSide,(2**n)*BoxSide)],['auto',DirPar[3]] , groups = GN00))
Obj.append(MacObject('BoxAng32',[(X0-CoefHor*(2**n)*BoxSide*3/2,Y0+CoefVer*(2**n)*BoxSide*3/2),((2**n)*BoxSide,(2**n)*BoxSide)],['auto',DirPar[4]] ))
Obj.append(MacObject('Box42',[(X0-CoefHor*(2**n)*BoxSide/2,Y0+CoefVer*(2**n)*BoxSide*3/2),((2**n)*BoxSide,(2**n)*BoxSide)],['auto',DirPar[5]] ))
Obj.append(MacObject('Box42',[(X0+CoefHor*(2**n)*BoxSide/2,Y0+CoefVer*(2**n)*BoxSide*3/2),((2**n)*BoxSide,(2**n)*BoxSide)],['auto',DirPar[6]] ))
Obj.append(MacObject('BoxAng32',[(X0+CoefHor*(2**n)*BoxSide*3/2,Y0+CoefVer*(2**n)*BoxSide*3/2),((2**n)*BoxSide,(2**n)*BoxSide)],['auto',DirPar[7]] ))
Obj.append(MacObject('Box42',[(X0+CoefHor*(2**n)*BoxSide*3/2,Y0+CoefVer*(2**n)*BoxSide/2),((2**n)*BoxSide,(2**n)*BoxSide)],['auto',DirPar[8]] ))
Obj.append(MacObject('Box42',[(X0+CoefHor*(2**n)*BoxSide*3/2,Y0-CoefVer*(2**n)*BoxSide/2),((2**n)*BoxSide,(2**n)*BoxSide)],['auto',DirPar[9]] ))
Obj.append(MacObject('BoxAng32',[(X0+CoefHor*(2**n)*BoxSide*3/2,Y0-CoefVer*(2**n)*BoxSide*3/2),((2**n)*BoxSide,(2**n)*BoxSide)],['auto',DirPar[10]] ))
Obj.append(MacObject('Box42',[(X0+CoefHor*(2**n)*BoxSide/2,Y0-CoefVer*(2**n)*BoxSide*3/2),((2**n)*BoxSide,(2**n)*BoxSide)],['auto',DirPar[11]] , groups = GN01))
else :
Obj.append(MacObject('Box42',[(X0-CoefHor*BoxSide*(2**n)*3/2,Y0+CoefVer*(2**n)*BoxSide/2),((2**n)*BoxSide,(2**n)*BoxSide)],['auto',DirPar[3]] , groups = GN1))
Obj.append(MacObject('BoxAng32',[(X0-CoefHor*(2**n)*BoxSide*3/2,Y0+CoefVer*(2**n)*BoxSide*3/2),((2**n)*BoxSide,(2**n)*BoxSide)],['auto',DirPar[4]] , groups = GN2))
Obj.append(MacObject('Box42',[(X0-CoefHor*(2**n)*BoxSide/2,Y0+CoefVer*(2**n)*BoxSide*3/2),((2**n)*BoxSide,(2**n)*BoxSide)],['auto',DirPar[5]] , groups = GN3))
Obj.append(MacObject('Box42',[(X0+CoefHor*(2**n)*BoxSide/2,Y0+CoefVer*(2**n)*BoxSide*3/2),((2**n)*BoxSide,(2**n)*BoxSide)],['auto',DirPar[6]] , groups = GN3))
Obj.append(MacObject('BoxAng32',[(X0+CoefHor*(2**n)*BoxSide*3/2,Y0+CoefVer*(2**n)*BoxSide*3/2),((2**n)*BoxSide,(2**n)*BoxSide)],['auto',DirPar[7]] , groups = GN4))
Obj.append(MacObject('Box42',[(X0+CoefHor*(2**n)*BoxSide*3/2,Y0+CoefVer*(2**n)*BoxSide/2),((2**n)*BoxSide,(2**n)*BoxSide)],['auto',DirPar[8]] , groups = GN5))
Obj.append(MacObject('Box42',[(X0+CoefHor*(2**n)*BoxSide*3/2,Y0-CoefVer*(2**n)*BoxSide/2),((2**n)*BoxSide,(2**n)*BoxSide)],['auto',DirPar[9]] , groups = GN5))
Obj.append(MacObject('BoxAng32',[(X0+CoefHor*(2**n)*BoxSide*3/2,Y0-CoefVer*(2**n)*BoxSide*3/2),((2**n)*BoxSide,(2**n)*BoxSide)],['auto',DirPar[10]], groups = GN6))
Obj.append(MacObject('Box42',[(X0+CoefHor*(2**n)*BoxSide/2,Y0-CoefVer*(2**n)*BoxSide*3/2),((2**n)*BoxSide,(2**n)*BoxSide)],['auto',DirPar[11]] , groups = GN7))
OuterMeshing = (3/2)*InternalMeshing*2**(NLevels-1)
OuterSegLength = (DLocal/OuterMeshing)
if DX > DLocal :
dX = DX - DLocal
Obj.append(MacObject('CompBoxF',[(X0+CoefHor*(DX)/2.,Y0),(dX,DLocal)],['auto'], groups = GN21))
if DY > DLocal :
dY = DY - DLocal
if DX > DLocal :
Obj.append(MacObject('CompBoxF',[(X0+CoefHor*DX/2.,Y0+CoefVer*(DY)/2.),(DX-DLocal,dY)],['auto'], groups = GN23))
Obj.append(MacObject('CompBoxF',[(X0,Y0+CoefVer*(DY)/2.),(DLocal,dY)],['auto'], groups = GN22))
return Obj
def SharpAngleIn (X0 , Y0 , DX , DY , DLocal, LocalMeshing , CornerOrientation , NLevels, **args) :
if DLocal == 'auto' : DLocal = float(min(DX,DY))
BoxSide = DLocal/(2.**(NLevels))
InternalMeshing = int(math.ceil(BoxSide/(3*LocalMeshing)))
InternalMeshing = InternalMeshing+InternalMeshing%2 # An even number is needed, otherwise the objects would not be compatible once created
if InternalMeshing == 0 : InternalMeshing = 2 # This sets a minimum meshing condition in order to avoid an error. The user is notified of the value considered for the local meshing
print "Possible Local meshing is :", BoxSide/(3*InternalMeshing), "\nThis value is returned by this function for your convenience..."
DirPar = {'NE' : lambda : ['NE', 'SN', 'NE', 'WE'],
'NW' : lambda : ['NW', 'SN', 'NW', 'EW'],
'SE' : lambda : ['SE', 'NS', 'SE', 'WE'],
'SW' : lambda : ['SW', 'NS', 'SW', 'EW'], }[CornerOrientation]()
CoefVer = {'NE' : lambda : 1,
'NW' : lambda : 1,
'SE' : lambda : -1,
'SW' : lambda : -1, }[CornerOrientation]()
CoefHor = {'NE' : lambda : 1,
'NW' : lambda : -1,
'SE' : lambda : 1,
'SW' : lambda : -1, }[CornerOrientation]()
ToLook = {'NE' : lambda : [0,2,1,3],
'NW' : lambda : [0,3,1,2],
'SE' : lambda : [1,2,0,3],
'SW' : lambda : [1,3,0,2], }[CornerOrientation]()
if args.__contains__('groups') :
GroupNames = args['groups']
else : GroupNames = [None, None, None, None]
GN01 = GroupArray([ToLook[0],ToLook[1]],[GroupNames[ToLook[0]],GroupNames[ToLook[1]]])
GN02 = GroupArray(ToLook[1],GroupNames[ToLook[1]])
GN03 = [None, None, None, None]
GN04 = GroupArray(ToLook[0],GroupNames[ToLook[0]])
if DY == DLocal :
GN05 = GroupArray([ToLook[1],ToLook[2]],[GroupNames[ToLook[1]],GroupNames[ToLook[2]]])
GN08 = GroupArray([ToLook[0],ToLook[2],ToLook[3]],[GroupNames[ToLook[0]],GroupNames[ToLook[2]],GroupNames[ToLook[3]]])
if DX == DLocal:
GN06 = GroupArray([ToLook[2],ToLook[3]],[GroupNames[ToLook[2]],GroupNames[ToLook[3]]])
GN07 = GroupArray([ToLook[0],ToLook[3]],[GroupNames[ToLook[0]],GroupNames[ToLook[3]]])
else :
GN06 = GroupArray(ToLook[2],GroupNames[ToLook[2]])
GN07 = GroupArray(ToLook[0],GroupNames[ToLook[0]])
else : else :
GN05 = GroupArray(ToLook[1],GroupNames[ToLook[1]]) GN4 = [None,None,None,None]
if DX == DLocal : GN5 = [None,None,None,None]
GN06 = GroupArray(ToLook[3],GroupNames[ToLook[3]]) GN6 = GroupArray(ToLook[0],GroupNames[4])
GN07 = GroupArray([ToLook[0],ToLook[3]],[GroupNames[ToLook[0]],GroupNames[ToLook[3]]]) GN21 = GroupArray([ToLook[3],ToLook[0]],[GroupNames[3],GroupNames[4]])
GN10 = GroupArray([ToLook[1],ToLook[2],ToLook[3]],[GroupNames[ToLook[1]],GroupNames[ToLook[2]],GroupNames[ToLook[3]]]) GN22 = GroupArray([ToLook[1],ToLook[2]],[GroupNames[5],GroupNames[2]])
else : GN23 = GroupArray([ToLook[2],ToLook[3]],[GroupNames[2],GroupNames[3]])
GN06 = [None, None, None, None]
GN07 = GroupArray(ToLook[0],GroupNames[ToLook[0]])
GN08 = GroupArray([ToLook[0],ToLook[3]],[GroupNames[ToLook[0]],GroupNames[ToLook[3]]])
GN09 = GroupArray([ToLook[2],ToLook[3]],[GroupNames[ToLook[2]],GroupNames[ToLook[3]]])
GN10 = GroupArray([ToLook[1],ToLook[2]],[GroupNames[ToLook[1]],GroupNames[ToLook[2]]])
Obj = []
Obj.append(MacObject('BoxAng32',[(X0+CoefHor*BoxSide/2,Y0+CoefVer*BoxSide/2),(BoxSide,BoxSide)],[InternalMeshing,DirPar[0]],groups = GN01)) Obj = []
for N in range (1,NLevels+1):
n = N-1
if N < NLevels :
Obj.append(MacObject('Box42',[(X0+CoefHor*(2**n)*BoxSide/2,Y0+CoefVer*(2**n)*BoxSide*3/2),((2**n)*BoxSide,(2**n)*BoxSide)],['auto',DirPar[1]],groups = GN02))
Obj.append(MacObject('BoxAng32',[(X0+CoefHor*(2**n)*BoxSide*3/2,Y0+CoefVer*(2**n)*BoxSide*3/2),((2**n)*BoxSide,(2**n)*BoxSide)],['auto',DirPar[2]],groups = GN03))
Obj.append(MacObject('Box42',[(X0+CoefHor*(2**n)*BoxSide*3/2,Y0+CoefVer*(2**n)*BoxSide/2),((2**n)*BoxSide,(2**n)*BoxSide)],['auto',DirPar[3]],groups = GN04))
else :
Obj.append(MacObject('Box42',[(X0+CoefHor*(2**n)*BoxSide/2,Y0+CoefVer*(2**n)*BoxSide*3/2),((2**n)*BoxSide,(2**n)*BoxSide)],['auto',DirPar[1]],groups = GN05))
Obj.append(MacObject('BoxAng32',[(X0+CoefHor*(2**n)*BoxSide*3/2,Y0+CoefVer*(2**n)*BoxSide*3/2),((2**n)*BoxSide,(2**n)*BoxSide)],['auto',DirPar[2]],groups = GN06))
Obj.append(MacObject('Box42',[(X0+CoefHor*(2**n)*BoxSide*3/2,Y0+CoefVer*(2**n)*BoxSide/2),((2**n)*BoxSide,(2**n)*BoxSide)],['auto',DirPar[3]],groups = GN07))
OuterMeshing = (3/2)*InternalMeshing*2**(NLevels-1)
OuterSegLength = (DLocal/OuterMeshing)
if DX > DLocal : Obj.append(MacObject('BoxAng32',[(X0+CoefHor*BoxSide/2,Y0+CoefVer*BoxSide/2),(BoxSide,BoxSide)],[InternalMeshing,DirPar[0]]))
dX = DX - DLocal Obj.append(MacObject('BoxAng32',[(X0-CoefHor*BoxSide/2,Y0+CoefVer*BoxSide/2),(BoxSide,BoxSide)],['auto',DirPar[1]], groups = GroupArray(ToLook[0],GroupNames[0])))
Obj = Obj + CompositeBox(X0+CoefHor*(DLocal+dX/2.),Y0+CoefVer*(DLocal)/2.,dX,DLocal, groups = GN08) Obj.append(MacObject('BoxAng32',[(X0+CoefHor*BoxSide/2,Y0-CoefVer*BoxSide/2),(BoxSide,BoxSide)],['auto',DirPar[2]], groups = GroupArray(ToLook[1],GroupNames[1])))
if DY > DLocal :
dY = DY - DLocal
if DX > DLocal : for N in range (1,NLevels+1):
Obj = Obj + CompositeBox(X0+CoefHor*(DLocal+(DX-DLocal)/2.),Y0+CoefVer*(DLocal+dY/2.),DX-DLocal,dY, groups = GN09) n = N-1
if N < NLevels :
Obj.append(MacObject('Box42',[(X0-CoefHor*BoxSide*(2**n)*3/2,Y0+CoefVer*(2**n)*BoxSide/2),((2**n)*BoxSide,(2**n)*BoxSide)],['auto',DirPar[3]] , groups = GN00))
Obj.append(MacObject('BoxAng32',[(X0-CoefHor*(2**n)*BoxSide*3/2,Y0+CoefVer*(2**n)*BoxSide*3/2),((2**n)*BoxSide,(2**n)*BoxSide)],['auto',DirPar[4]] ))
Obj.append(MacObject('Box42',[(X0-CoefHor*(2**n)*BoxSide/2,Y0+CoefVer*(2**n)*BoxSide*3/2),((2**n)*BoxSide,(2**n)*BoxSide)],['auto',DirPar[5]] ))
Obj.append(MacObject('Box42',[(X0+CoefHor*(2**n)*BoxSide/2,Y0+CoefVer*(2**n)*BoxSide*3/2),((2**n)*BoxSide,(2**n)*BoxSide)],['auto',DirPar[6]] ))
Obj.append(MacObject('BoxAng32',[(X0+CoefHor*(2**n)*BoxSide*3/2,Y0+CoefVer*(2**n)*BoxSide*3/2),((2**n)*BoxSide,(2**n)*BoxSide)],['auto',DirPar[7]] ))
Obj.append(MacObject('Box42',[(X0+CoefHor*(2**n)*BoxSide*3/2,Y0+CoefVer*(2**n)*BoxSide/2),((2**n)*BoxSide,(2**n)*BoxSide)],['auto',DirPar[8]] ))
Obj.append(MacObject('Box42',[(X0+CoefHor*(2**n)*BoxSide*3/2,Y0-CoefVer*(2**n)*BoxSide/2),((2**n)*BoxSide,(2**n)*BoxSide)],['auto',DirPar[9]] ))
Obj.append(MacObject('BoxAng32',[(X0+CoefHor*(2**n)*BoxSide*3/2,Y0-CoefVer*(2**n)*BoxSide*3/2),((2**n)*BoxSide,(2**n)*BoxSide)],['auto',DirPar[10]] ))
Obj.append(MacObject('Box42',[(X0+CoefHor*(2**n)*BoxSide/2,Y0-CoefVer*(2**n)*BoxSide*3/2),((2**n)*BoxSide,(2**n)*BoxSide)],['auto',DirPar[11]] , groups = GN01))
else :
Obj.append(MacObject('Box42',[(X0-CoefHor*BoxSide*(2**n)*3/2,Y0+CoefVer*(2**n)*BoxSide/2),((2**n)*BoxSide,(2**n)*BoxSide)],['auto',DirPar[3]] , groups = GN1))
Obj.append(MacObject('BoxAng32',[(X0-CoefHor*(2**n)*BoxSide*3/2,Y0+CoefVer*(2**n)*BoxSide*3/2),((2**n)*BoxSide,(2**n)*BoxSide)],['auto',DirPar[4]] , groups = GN2))
Obj.append(MacObject('Box42',[(X0-CoefHor*(2**n)*BoxSide/2,Y0+CoefVer*(2**n)*BoxSide*3/2),((2**n)*BoxSide,(2**n)*BoxSide)],['auto',DirPar[5]] , groups = GN3))
Obj.append(MacObject('Box42',[(X0+CoefHor*(2**n)*BoxSide/2,Y0+CoefVer*(2**n)*BoxSide*3/2),((2**n)*BoxSide,(2**n)*BoxSide)],['auto',DirPar[6]] , groups = GN3))
Obj.append(MacObject('BoxAng32',[(X0+CoefHor*(2**n)*BoxSide*3/2,Y0+CoefVer*(2**n)*BoxSide*3/2),((2**n)*BoxSide,(2**n)*BoxSide)],['auto',DirPar[7]] , groups = GN4))
Obj.append(MacObject('Box42',[(X0+CoefHor*(2**n)*BoxSide*3/2,Y0+CoefVer*(2**n)*BoxSide/2),((2**n)*BoxSide,(2**n)*BoxSide)],['auto',DirPar[8]] , groups = GN5))
Obj.append(MacObject('Box42',[(X0+CoefHor*(2**n)*BoxSide*3/2,Y0-CoefVer*(2**n)*BoxSide/2),((2**n)*BoxSide,(2**n)*BoxSide)],['auto',DirPar[9]] , groups = GN5))
Obj.append(MacObject('BoxAng32',[(X0+CoefHor*(2**n)*BoxSide*3/2,Y0-CoefVer*(2**n)*BoxSide*3/2),((2**n)*BoxSide,(2**n)*BoxSide)],['auto',DirPar[10]], groups = GN6))
Obj.append(MacObject('Box42',[(X0+CoefHor*(2**n)*BoxSide/2,Y0-CoefVer*(2**n)*BoxSide*3/2),((2**n)*BoxSide,(2**n)*BoxSide)],['auto',DirPar[11]] , groups = GN7))
Obj = Obj + CompositeBox(X0+CoefHor*DLocal/2,Y0+CoefVer*(DLocal+dY/2.),DLocal,dY,groups = GN10) OuterMeshing = (3/2)*InternalMeshing*2**(NLevels-1)
OuterSegLength = (DLocal/OuterMeshing)
return Obj if DX > DLocal :
dX = DX - DLocal
Obj.append(MacObject('CompBoxF',[(X0+CoefHor*(DX)/2.,Y0),(dX,DLocal)],['auto'], groups = GN21))
if DY > DLocal :
dY = DY - DLocal
if DX > DLocal :
Obj.append(MacObject('CompBoxF',[(X0+CoefHor*DX/2.,Y0+CoefVer*(DY)/2.),(DX-DLocal,dY)],['auto'], groups = GN23))
Obj.append(MacObject('CompBoxF',[(X0,Y0+CoefVer*(DY)/2.),(DLocal,dY)],['auto'], groups = GN22))
return Obj
def SharpAngleIn (X0 , Y0 , DX , DY , DLocal, LocalMeshing , CornerOrientation , NLevels, **args) :
if DLocal == 'auto' : DLocal = float(min(DX,DY))
BoxSide = DLocal/(2.**(NLevels))
InternalMeshing = int(math.ceil(BoxSide/(3*LocalMeshing)))
InternalMeshing = InternalMeshing+InternalMeshing%2 # An even number is needed, otherwise the objects would not be compatible once created
if InternalMeshing == 0 : InternalMeshing = 2 # This sets a minimum meshing condition in order to avoid an error. The user is notified of the value considered for the local meshing
print "Possible Local meshing is :", BoxSide/(3*InternalMeshing), "\nThis value is returned by this function for your convenience..."
DirPar = {'NE' : lambda : ['NE', 'SN', 'NE', 'WE'],
'NW' : lambda : ['NW', 'SN', 'NW', 'EW'],
'SE' : lambda : ['SE', 'NS', 'SE', 'WE'],
'SW' : lambda : ['SW', 'NS', 'SW', 'EW'], }[CornerOrientation]()
CoefVer = {'NE' : lambda : 1,
'NW' : lambda : 1,
'SE' : lambda : -1,
'SW' : lambda : -1, }[CornerOrientation]()
CoefHor = {'NE' : lambda : 1,
'NW' : lambda : -1,
'SE' : lambda : 1,
'SW' : lambda : -1, }[CornerOrientation]()
ToLook = {'NE' : lambda : [0,2,1,3],
'NW' : lambda : [0,3,1,2],
'SE' : lambda : [1,2,0,3],
'SW' : lambda : [1,3,0,2], }[CornerOrientation]()
if args.__contains__('groups') :
GroupNames = args['groups']
else : GroupNames = [None, None, None, None]
GN01 = GroupArray([ToLook[0],ToLook[1]],[GroupNames[ToLook[0]],GroupNames[ToLook[1]]])
GN02 = GroupArray(ToLook[1],GroupNames[ToLook[1]])
GN03 = [None, None, None, None]
GN04 = GroupArray(ToLook[0],GroupNames[ToLook[0]])
if DY == DLocal :
GN05 = GroupArray([ToLook[1],ToLook[2]],[GroupNames[ToLook[1]],GroupNames[ToLook[2]]])
GN08 = GroupArray([ToLook[0],ToLook[2],ToLook[3]],[GroupNames[ToLook[0]],GroupNames[ToLook[2]],GroupNames[ToLook[3]]])
if DX == DLocal:
GN06 = GroupArray([ToLook[2],ToLook[3]],[GroupNames[ToLook[2]],GroupNames[ToLook[3]]])
GN07 = GroupArray([ToLook[0],ToLook[3]],[GroupNames[ToLook[0]],GroupNames[ToLook[3]]])
else :
GN06 = GroupArray(ToLook[2],GroupNames[ToLook[2]])
GN07 = GroupArray(ToLook[0],GroupNames[ToLook[0]])
else :
GN05 = GroupArray(ToLook[1],GroupNames[ToLook[1]])
if DX == DLocal :
GN06 = GroupArray(ToLook[3],GroupNames[ToLook[3]])
GN07 = GroupArray([ToLook[0],ToLook[3]],[GroupNames[ToLook[0]],GroupNames[ToLook[3]]])
GN10 = GroupArray([ToLook[1],ToLook[2],ToLook[3]],[GroupNames[ToLook[1]],GroupNames[ToLook[2]],GroupNames[ToLook[3]]])
else :
GN06 = [None, None, None, None]
GN07 = GroupArray(ToLook[0],GroupNames[ToLook[0]])
GN08 = GroupArray([ToLook[0],ToLook[3]],[GroupNames[ToLook[0]],GroupNames[ToLook[3]]])
GN09 = GroupArray([ToLook[2],ToLook[3]],[GroupNames[ToLook[2]],GroupNames[ToLook[3]]])
GN10 = GroupArray([ToLook[1],ToLook[2]],[GroupNames[ToLook[1]],GroupNames[ToLook[2]]])
Obj = []
Obj.append(MacObject('BoxAng32',[(X0+CoefHor*BoxSide/2,Y0+CoefVer*BoxSide/2),(BoxSide,BoxSide)],[InternalMeshing,DirPar[0]],groups = GN01))
for N in range (1,NLevels+1):
n = N-1
if N < NLevels :
Obj.append(MacObject('Box42',[(X0+CoefHor*(2**n)*BoxSide/2,Y0+CoefVer*(2**n)*BoxSide*3/2),((2**n)*BoxSide,(2**n)*BoxSide)],['auto',DirPar[1]],groups = GN02))
Obj.append(MacObject('BoxAng32',[(X0+CoefHor*(2**n)*BoxSide*3/2,Y0+CoefVer*(2**n)*BoxSide*3/2),((2**n)*BoxSide,(2**n)*BoxSide)],['auto',DirPar[2]],groups = GN03))
Obj.append(MacObject('Box42',[(X0+CoefHor*(2**n)*BoxSide*3/2,Y0+CoefVer*(2**n)*BoxSide/2),((2**n)*BoxSide,(2**n)*BoxSide)],['auto',DirPar[3]],groups = GN04))
else :
Obj.append(MacObject('Box42',[(X0+CoefHor*(2**n)*BoxSide/2,Y0+CoefVer*(2**n)*BoxSide*3/2),((2**n)*BoxSide,(2**n)*BoxSide)],['auto',DirPar[1]],groups = GN05))
Obj.append(MacObject('BoxAng32',[(X0+CoefHor*(2**n)*BoxSide*3/2,Y0+CoefVer*(2**n)*BoxSide*3/2),((2**n)*BoxSide,(2**n)*BoxSide)],['auto',DirPar[2]],groups = GN06))
Obj.append(MacObject('Box42',[(X0+CoefHor*(2**n)*BoxSide*3/2,Y0+CoefVer*(2**n)*BoxSide/2),((2**n)*BoxSide,(2**n)*BoxSide)],['auto',DirPar[3]],groups = GN07))
OuterMeshing = (3/2)*InternalMeshing*2**(NLevels-1)
OuterSegLength = (DLocal/OuterMeshing)
if DX > DLocal :
dX = DX - DLocal
Obj = Obj + CompositeBox(X0+CoefHor*(DLocal+dX/2.),Y0+CoefVer*(DLocal)/2.,dX,DLocal, groups = GN08)
if DY > DLocal :
dY = DY - DLocal
if DX > DLocal :
Obj = Obj + CompositeBox(X0+CoefHor*(DLocal+(DX-DLocal)/2.),Y0+CoefVer*(DLocal+dY/2.),DX-DLocal,dY, groups = GN09)
Obj = Obj + CompositeBox(X0+CoefHor*DLocal/2,Y0+CoefVer*(DLocal+dY/2.),DLocal,dY,groups = GN10)
return Obj
def GroupArray(indices, GroupNames) : def GroupArray(indices, GroupNames) :
if type(indices) is int : if type(indices) is int :
indices = [indices] indices = [indices]
GroupNames = [GroupNames] GroupNames = [GroupNames]
Output = [None,None,None,None] Output = [None,None,None,None]
for i, ind in enumerate(indices) : for i, ind in enumerate(indices) :
Output[ind] = GroupNames[i] Output[ind] = GroupNames[i]
return Output return Output

37
src/Tools/Verima/Base/importFromCSV.py
View File

@ -8,24 +8,23 @@ from dataBase import Base
if __name__ == "__main__": if __name__ == "__main__":
from optparse import OptionParser from optparse import OptionParser
p=OptionParser() p=OptionParser()
p.add_option('-p',dest='partiel',action="store_true", default=False,help='import de machine, groupe, ratio Maille et Perf uniquement') p.add_option('-p',dest='partiel',action="store_true", default=False,help='import de machine, groupe, ratio Maille et Perf uniquement')
p.add_option('-f',dest='force',action="store_true", default=False,help='ecrasement des valeurs dans la base par les valeurs dans les fichiers en cas de meme clef primaire') p.add_option('-f',dest='force',action="store_true", default=False,help='ecrasement des valeurs dans la base par les valeurs dans les fichiers en cas de meme clef primaire')
p.add_option('-d',dest='database',default="myMesh.db",help='nom de la database') p.add_option('-d',dest='database',default="myMesh.db",help='nom de la database')
options, args = p.parse_args() options, args = p.parse_args()
if len(args) != 1 : if len(args) != 1 :
print "entrer SVP le nom de la directory ou sont rangees les fichiers a charger" print "entrer SVP le nom de la directory ou sont rangees les fichiers a charger"
exit() exit()
folder=args[0] folder=args[0]
if not(os.path.isdir(folder)): if not(os.path.isdir(folder)):
print folder , " n existe pas" print folder , " n existe pas"
exit() exit()
maBase=Base(options.database)
maBase.create()
maBase.initialise()
maBase.importFromCSV(folder,options.partiel,options.force)
maBase.close()
maBase=Base(options.database)
maBase.create()
maBase.initialise()
maBase.importFromCSV(folder,options.partiel,options.force)
maBase.close()

190
src/Tools/Verima/Base/tableDeBase.py
View File

@ -2,114 +2,112 @@ from qtsalome import QSqlQuery
import datetime import datetime
class TableDeBase : class TableDeBase :
def __init__(self,nom): def __init__(self,nom):
self.nom=nom self.nom=nom
def setField(self,FieldStringList): def setField(self,FieldStringList):
self.FieldStringList=FieldStringList self.FieldStringList=FieldStringList
self.idName=FieldStringList[0] self.idName=FieldStringList[0]
def setTypeField(self,FieldTypeListe,clef):
self.FieldTypeListe = FieldTypeListe
self.clef=clef
def getFields(self): def setTypeField(self,FieldTypeListe,clef):
return self.FieldStringList self.FieldTypeListe = FieldTypeListe
self.clef=clef
def insereLigne(self,valeurs,debug=False):
if self.verifieExitenceId(valeurs[0])!=0 :
print "impossible d inserer " , valeurs, "dans ", self.nom
print "l id est deja existant"
return False
texteQuery='insert into ' + self.nom + " values "+ str(valeurs)+ ';'
maQuery=QSqlQuery()
if debug : print texteQuery, " " , maQuery.exec_(texteQuery)
else : maQuery.exec_(texteQuery)
def insereLigneAutoId(self,valeurs,debug=False): def getFields(self):
texteQuery='insert into ' + self.nom + self.cols+ " values "+ str(valeurs)+ ';' return self.FieldStringList
maQuery=QSqlQuery()
if debug : print texteQuery, " " , maQuery.exec_(texteQuery)
else : maQuery.exec_(texteQuery)
def insereOuRemplaceLigne(self,valeurs,debug=False): def insereLigne(self,valeurs,debug=False):
texteQuery='insert or replace into ' + self.nom + " values "+ str(valeurs)+ ';' if self.verifieExitenceId(valeurs[0])!=0 :
maQuery=QSqlQuery() print "impossible d inserer " , valeurs, "dans ", self.nom
if debug : print texteQuery, " " , maQuery.exec_(texteQuery) print "l id est deja existant"
else : maQuery.exec_(texteQuery) return False
texteQuery='insert into ' + self.nom + " values "+ str(valeurs)+ ';'
maQuery=QSqlQuery()
if debug : print texteQuery, " " , maQuery.exec_(texteQuery)
else : maQuery.exec_(texteQuery)
def insereLigneAutoId(self,valeurs,debug=False):
texteQuery='insert into ' + self.nom + self.cols+ " values "+ str(valeurs)+ ';'
maQuery=QSqlQuery()
if debug : print texteQuery, " " , maQuery.exec_(texteQuery)
else : maQuery.exec_(texteQuery)
def insereOuRemplaceLigne(self,valeurs,debug=False):
texteQuery='insert or replace into ' + self.nom + " values "+ str(valeurs)+ ';'
maQuery=QSqlQuery()
if debug : print texteQuery, " " , maQuery.exec_(texteQuery)
else : maQuery.exec_(texteQuery)
def verifieExitenceId(self,valeur): def verifieExitenceId(self,valeur):
# ne fonctionne pas correctement, il faudrait se servir de la clef # ne fonctionne pas correctement, il faudrait se servir de la clef
texteQuery= "select * from " + self.nom + " where "+ self.idName+'='+str(valeur) +';' texteQuery= "select * from " + self.nom + " where "+ self.idName+'='+str(valeur) +';'
maQuery=QSqlQuery() maQuery=QSqlQuery()
maQuery.exec_(texteQuery) maQuery.exec_(texteQuery)
nb=0 nb=0
while(maQuery.next()): nb=nb+1 while(maQuery.next()): nb=nb+1
return nb return nb
def remplit(self): def remplit(self):
print "Pas de remplissage sauf si cette methode est surchargee" print "Pas de remplissage sauf si cette methode est surchargee"
def createSqlTable(self): def createSqlTable(self):
print "Pas de creation par defaut : cette methode doit etre surchargee" print "Pas de creation par defaut : cette methode doit etre surchargee"
# On ne se sert pas du csv python entre autre parcequ'il ne gere pas les entetes # On ne se sert pas du csv python entre autre parcequ'il ne gere pas les entetes
def exportToCSV(self): def exportToCSV(self):
aujourdhui=datetime.date.today() aujourdhui=datetime.date.today()
monFolder="ExportDB"+str(aujourdhui) monFolder="ExportDB"+str(aujourdhui)
monFichier=monFolder+"/Sauve_"+str(self.nom)+'.csv' monFichier=monFolder+"/Sauve_"+str(self.nom)+'.csv'
texteQuery= "select * from " + self.nom +';' texteQuery= "select * from " + self.nom +';'
texteSauve="" texteSauve=""
for col in self.FieldStringList: for col in self.FieldStringList:
texteSauve+=col+";" texteSauve+=col+";"
texteSauve=texteSauve[0:-1] # on enleve le dernier ";" texteSauve=texteSauve[0:-1] # on enleve le dernier ";"
texteSauve+="\n" texteSauve+="\n"
maQuery=QSqlQuery()
maQuery.exec_(texteQuery)
asauver=0
while(maQuery.next()):
asauver=1
for i in range(len(self.FieldStringList)):
texteSauve+=str(maQuery.value(i).toString())+";"
texteSauve=texteSauve[0:-1] # on enleve le dernier ";"
texteSauve+="\n"
if asauver == 0 :
print "pas de sauvegarde de : " , self.nom , " table vide"
return
from Stats.utiles import writeFile maQuery=QSqlQuery()
Bok=writeFile(monFichier,texteSauve) maQuery.exec_(texteQuery)
if Bok : asauver=0
print "sauvegarde de : " , self.nom , " effectuee " while(maQuery.next()):
else : asauver=1
print "pas de sauvegarde de : " , self.nom , " IOerror" for i in range(len(self.FieldStringList)):
texteSauve+=str(maQuery.value(i).toString())+";"
texteSauve=texteSauve[0:-1] # on enleve le dernier ";"
texteSauve+="\n"
def importFromCSV(self,folder,force): if asauver == 0 :
monFichier=folder+"/Sauve_"+str(self.nom)+'.csv' print "pas de sauvegarde de : " , self.nom , " table vide"
try : return
f=open(monFichier,'r')
except:
print "Pas de chargement de la table ", self.nom
print "Impossible d'ouvrir le fichier ", monFichier
return 0
lignes=f.readlines()
enTete=tuple(lignes[0][0:-1].split(";"))
if enTete!=self.FieldStringList:
print "Pas de chargement de la table ", self.nom
print "les entetes ne correspondent pas"
return 0
for StrVal in lignes[1:]:
listeVal=tuple(StrVal[0:-1].split(";"))
listeValTypee=[]
for i in range(len(listeVal)):
if self.FieldTypeListe[i]=='int' : listeValTypee.append(int(listeVal[i]))
if self.FieldTypeListe[i]=='float': listeValTypee.append(float(listeVal[i]))
if self.FieldTypeListe[i]=='str' : listeValTypee.append(listeVal[i])
if force==1 : self.insereOuRemplaceLigne(tuple(listeValTypee))
if force==0 : self.insereLigne(tuple(listeValTypee))
from Stats.utiles import writeFile
Bok=writeFile(monFichier,texteSauve)
if Bok :
print "sauvegarde de : " , self.nom , " effectuee "
else :
print "pas de sauvegarde de : " , self.nom , " IOerror"
def importFromCSV(self,folder,force):
monFichier=folder+"/Sauve_"+str(self.nom)+'.csv'
try :
f=open(monFichier,'r')
except:
print "Pas de chargement de la table ", self.nom
print "Impossible d'ouvrir le fichier ", monFichier
return 0
lignes=f.readlines()
enTete=tuple(lignes[0][0:-1].split(";"))
if enTete!=self.FieldStringList:
print "Pas de chargement de la table ", self.nom
print "les entetes ne correspondent pas"
return 0
for StrVal in lignes[1:]:
listeVal=tuple(StrVal[0:-1].split(";"))
listeValTypee=[]
for i in range(len(listeVal)):
if self.FieldTypeListe[i]=='int' : listeValTypee.append(int(listeVal[i]))
if self.FieldTypeListe[i]=='float': listeValTypee.append(float(listeVal[i]))
if self.FieldTypeListe[i]=='str' : listeValTypee.append(listeVal[i])
if force==1 : self.insereOuRemplaceLigne(tuple(listeValTypee))
if force==0 : self.insereLigne(tuple(listeValTypee))

38
src/Tools/Verima/Base/tableGroupesRef.py
View File

@ -2,30 +2,30 @@ from qtsalome import QSqlQuery
from tableDeBase import TableDeBase from tableDeBase import TableDeBase
class TableGroupesRef (TableDeBase): class TableGroupesRef (TableDeBase):
def __init__(self): def __init__(self):
TableDeBase.__init__(self,"GroupesRef") TableDeBase.__init__(self,"GroupesRef")
self.setField(("nomGroupe","idMaillage")) self.setField(("nomGroupe","idMaillage"))
self.setTypeField(('str','int'),('nomGroupe')) self.setTypeField(('str','int'),('nomGroupe'))
def createSqlTable(self): def createSqlTable(self):
query=QSqlQuery() query=QSqlQuery()
texteQuery ="create table GroupesRef(nomGroupe varchar(40), idMaillage int," texteQuery ="create table GroupesRef(nomGroupe varchar(40), idMaillage int,"
texteQuery+="foreign key (idMaillage) references Maillages(idMaillage)," texteQuery+="foreign key (idMaillage) references Maillages(idMaillage),"
texteQuery+="primary key (nomGroupe,idMaillage));" texteQuery+="primary key (nomGroupe,idMaillage));"
print "Creation de TableGroupesRef : " , query.exec_(texteQuery) print "Creation de TableGroupesRef : " , query.exec_(texteQuery)
def getVals(self,idMaillage): def getVals(self,idMaillage):
query=QSqlQuery() query=QSqlQuery()
texteQuery ='select NomGroupe from GroupesRef where idMaillage='+str(idMaillage) +";" texteQuery ='select NomGroupe from GroupesRef where idMaillage='+str(idMaillage) +";"
listeGroupes=[] listeGroupes=[]
query.exec_(texteQuery) query.exec_(texteQuery)
while (query.next()) : while (query.next()) :
listeGroupes.append(str(query.value(0).toString())) listeGroupes.append(str(query.value(0).toString()))
return listeGroupes return listeGroupes
# def remplit(self): # def remplit(self):
# Groupe pour le script du tunnel (fiche 7566) # Groupe pour le script du tunnel (fiche 7566)
# self.insereLigne(('FRONT_07',1)) # self.insereLigne(('FRONT_07',1))
# self.insereLigne(('FOND_07',1)) # self.insereLigne(('FOND_07',1))

45
src/Tools/Verima/Base/tableMachines.py
View File

@ -3,29 +3,28 @@ from tableDeBase import TableDeBase
import os import os
class TableMachines (TableDeBase): class TableMachines (TableDeBase):
def __init__(self): def __init__(self):
TableDeBase.__init__(self,"Machines") TableDeBase.__init__(self,"Machines")
self.setField(("nomMachine","Os")) self.setField(("nomMachine","Os"))
self.setTypeField(('str','str'),('nomMachine')) self.setTypeField(('str','str'),('nomMachine'))
def createSqlTable(self): def createSqlTable(self):
query=QSqlQuery() query=QSqlQuery()
print "creation de TableMachine : ", query.exec_("create table Machines( nomMachine varchar(10) primary key, os varchar(10));") print "creation de TableMachine : ", query.exec_("create table Machines( nomMachine varchar(10) primary key, os varchar(10));")
def creeMachine(self): def creeMachine(self):
nomMachine=os.uname()[1] nomMachine=os.uname()[1]
nomOs=os.uname()[2] nomOs=os.uname()[2]
self.insereLigne((nomMachine,nomOs)) self.insereLigne((nomMachine,nomOs))
def chercheMachine(self):
query=QSqlQuery()
machine=os.uname()[1]
texteQuery ="select nomMachine from Machines where nomMachine ='" + machine +"' ;"
query.exec_(texteQuery)
nb=0
while(query.next()):
nb=nb+1
nom=str(query.value(0).toString())
if nb != 1 : return 0, ""
return 1, nom
def chercheMachine(self):
query=QSqlQuery()
machine=os.uname()[1]
texteQuery ="select nomMachine from Machines where nomMachine ='" + machine +"' ;"
query.exec_(texteQuery)
nb=0
while(query.next()):
nb=nb+1
nom=str(query.value(0).toString())
if nb != 1 : return 0, ""
return 1, nom

170
src/Tools/Verima/Base/tableMaillages.py
View File

@ -2,99 +2,99 @@ from qtsalome import QSqlQuery
from tableDeBase import TableDeBase from tableDeBase import TableDeBase
class TableMaillages (TableDeBase): class TableMaillages (TableDeBase):
def __init__(self): def __init__(self):
TableDeBase.__init__(self,"Maillages") TableDeBase.__init__(self,"Maillages")
self.setField(("id","nomMaillage","Script","fichier","idMailleur","Dimension","Seuil CPU","Seuil Ratio","Seuil Taille","Seuil Nb Maille","Commentaire")) self.setField(("id","nomMaillage","Script","fichier","idMailleur","Dimension","Seuil CPU","Seuil Ratio","Seuil Taille","Seuil Nb Maille","Commentaire"))
self.cols="(nomMaillage,nomScript,medResultat,idMailleur,dimension,seuilCPU,seuilRatio,seuilTaille,seuilNbMaille,commentaire)" self.cols="(nomMaillage,nomScript,medResultat,idMailleur,dimension,seuilCPU,seuilRatio,seuilTaille,seuilNbMaille,commentaire)"
self.setTypeField(('int','str','str','str','int','int','int','int','int','int','str'),('id')) self.setTypeField(('int','str','str','str','int','int','int','int','int','int','str'),('id'))
def createSqlTable(self): def createSqlTable(self):
query=QSqlQuery() query=QSqlQuery()
texteQuery ="create table Maillages(id integer primary key autoincrement, nomMaillage varchar(10), " texteQuery ="create table Maillages(id integer primary key autoincrement, nomMaillage varchar(10), "
texteQuery+="nomScript varchar(40), medResultat varchar(15), idMailleur int, dimension int," texteQuery+="nomScript varchar(40), medResultat varchar(15), idMailleur int, dimension int,"
texteQuery+="seuilCPU int, seuilRatio int, seuilTaille int, seuilNbMaille int, commentaire varchar(60), " texteQuery+="seuilCPU int, seuilRatio int, seuilTaille int, seuilNbMaille int, commentaire varchar(60), "
texteQuery+="foreign key (idMailleur) references Mailleur(id));" texteQuery+="foreign key (idMailleur) references Mailleur(id));"
print "creation de TableMaillages : " , query.exec_(texteQuery) print "creation de TableMaillages : " , query.exec_(texteQuery)
def getVal(self,idMaillage, nomChamp): def getVal(self,idMaillage, nomChamp):
query=QSqlQuery() query=QSqlQuery()
valeur=None valeur=None
texteQuery ='select '+ nomChamp + ' from Maillages where id=' + str(idMaillage) + ";" texteQuery ='select '+ nomChamp + ' from Maillages where id=' + str(idMaillage) + ";"
query.exec_(texteQuery) query.exec_(texteQuery)
while (query.next()) : while (query.next()) :
valeur=query.value(0).toInt()[0] valeur=query.value(0).toInt()[0]
while (query.next()) : while (query.next()) :
print "plusieurs enregistrements dans Maillages pour ",str(idMaillage) print "plusieurs enregistrements dans Maillages pour ",str(idMaillage)
exit() exit()
return valeur return valeur
def dejaRemplie(self): def dejaRemplie(self):
texteQuery="select * from Maillages where medResultat='/tmp/tetra.med';" texteQuery="select * from Maillages where medResultat='/tmp/tetra.med';"
maQuery=QSqlQuery() maQuery=QSqlQuery()
maQuery.exec_(texteQuery) maQuery.exec_(texteQuery)
nb=0 nb=0
while(maQuery.next()): nb=nb+1 while(maQuery.next()): nb=nb+1
return nb return nb
def remplit(self): def remplit(self):
if self.dejaRemplie(): if self.dejaRemplie():
print "table Maillage deja initialisee" print "table Maillage deja initialisee"
return return
# self.insereLigneAutoId(('Fiche_7566_TUNNEL', '/home/H77945/CAS_TEST/MAILLEUR/FICHE_7566_TUNNEL/Fiche_7566_TUNNEL.py', '/tmp/Fiche_7566_TUNNEL.med', 3,3,10,10,10,10, 'Maillage d un tunnel')) # self.insereLigneAutoId(('Fiche_7566_TUNNEL', '/home/H77945/CAS_TEST/MAILLEUR/FICHE_7566_TUNNEL/Fiche_7566_TUNNEL.py', '/tmp/Fiche_7566_TUNNEL.med', 3,3,10,10,10,10, 'Maillage d un tunnel'))
# self.insereLigneAutoId(('Fiche_7957_AILETTE', '/home/H77945/CAS_TEST/MAILLEUR/FICHE_7957_AILETTE/Fiche_7957_AILETTE.py', '/tmp/Fiche_7957_AILETTE.med', 1,2,10,10,10,10, 'Maillage d une attache d aillette')) # self.insereLigneAutoId(('Fiche_7957_AILETTE', '/home/H77945/CAS_TEST/MAILLEUR/FICHE_7957_AILETTE/Fiche_7957_AILETTE.py', '/tmp/Fiche_7957_AILETTE.med', 1,2,10,10,10,10, 'Maillage d une attache d aillette'))
def construitListeMaillages(self): def construitListeMaillages(self):
maQuery=QSqlQuery() maQuery=QSqlQuery()
texteQuery="select id, nomScript,medResultat from Maillages;" texteQuery="select id, nomScript,medResultat from Maillages;"
maQuery.exec_(texteQuery)
listeMaillages=[]
while(maQuery.next()):
listeMaillages.append((maQuery.value(0).toInt()[0], maQuery.value(1).toString(), maQuery.value(2).toString()))
return listeMaillages
def verifieListeMaillages(self,listeMaillage):
newListeMaillages=[]
maQuery=QSqlQuery()
for idM in listeMaillage:
texteQuery="select id, nomScript,medResultat from Maillages where id = " + str(idM) +';'
maQuery.exec_(texteQuery) maQuery.exec_(texteQuery)
listeMaillages=[] maSize=0
while(maQuery.next()): while(maQuery.next()):
listeMaillages.append((maQuery.value(0).toInt()[0], maQuery.value(1).toString(), maQuery.value(2).toString())) maSize+=1
return listeMaillages newListeMaillages.append((maQuery.value(0).toInt()[0], maQuery.value(1).toString(), maQuery.value(2).toString()))
if maSize != 1 :
def verifieListeMaillages(self,listeMaillage): print "impossible de traiter le maillage : ", idM
newListeMaillages=[] return newListeMaillages
maQuery=QSqlQuery()
for idM in listeMaillage:
texteQuery="select id, nomScript,medResultat from Maillages where id = " + str(idM) +';'
maQuery.exec_(texteQuery)
maSize=0
while(maQuery.next()):
maSize+=1
newListeMaillages.append((maQuery.value(0).toInt()[0], maQuery.value(1).toString(), maQuery.value(2).toString()))
if maSize != 1 :
print "impossible de traiter le maillage : ", idM
return newListeMaillages
def getSeuilsPourMaillage(self,idMaillage): def getSeuilsPourMaillage(self,idMaillage):
texteQuery="select id,nomMaillage,seuilCPU,seuilRatio,seuilTaille,seuilNbMaille from Maillages where id = "+ str(idMaillage) +" ;" texteQuery="select id,nomMaillage,seuilCPU,seuilRatio,seuilTaille,seuilNbMaille from Maillages where id = "+ str(idMaillage) +" ;"
maQuery=QSqlQuery() maQuery=QSqlQuery()
maQuery.exec_(texteQuery) maQuery.exec_(texteQuery)
while(maQuery.next()): while(maQuery.next()):
l1 = maQuery.value(0).toInt()[0] l1 = maQuery.value(0).toInt()[0]
l2 = maQuery.value(1).toString() l2 = maQuery.value(1).toString()
l3 = maQuery.value(2).toInt()[0] l3 = maQuery.value(2).toInt()[0]
l4 = maQuery.value(3).toInt()[0] l4 = maQuery.value(3).toInt()[0]
l5 = maQuery.value(4).toInt()[0] l5 = maQuery.value(4).toInt()[0]
l6 = maQuery.value(5).toInt()[0] l6 = maQuery.value(5).toInt()[0]
return l1,l2,l3,l4,l5,l6 return l1,l2,l3,l4,l5,l6
def getTous(self): def getTous(self):
maillagesIdListe=[]; maillagesNomListe=[] maillagesIdListe=[]; maillagesNomListe=[]
texteQuery="select id,nomMaillage from Maillages order by id;" texteQuery="select id,nomMaillage from Maillages order by id;"
maQuery=QSqlQuery() maQuery=QSqlQuery()
maQuery.exec_(texteQuery) maQuery.exec_(texteQuery)
while(maQuery.next()): while(maQuery.next()):
maillagesIdListe.append( maQuery.value(0).toInt()[0]) maillagesIdListe.append( maQuery.value(0).toInt()[0])
maillagesNomListe.append( maQuery.value(1).toString()) maillagesNomListe.append( maQuery.value(1).toString())
return maillagesIdListe, maillagesNomListe return maillagesIdListe, maillagesNomListe
def getMailleurId(self,idMaillage): def getMailleurId(self,idMaillage):
texteQuery="select idMailleur from Maillages where id = "+ str(idMaillage) +" ;" texteQuery="select idMailleur from Maillages where id = "+ str(idMaillage) +" ;"
maQuery=QSqlQuery() maQuery=QSqlQuery()
print texteQuery print texteQuery
print maQuery.exec_(texteQuery) print maQuery.exec_(texteQuery)
maQuery.exec_(texteQuery) maQuery.exec_(texteQuery)
while(maQuery.next()): while(maQuery.next()):
idMailleur = maQuery.value(0).toInt()[0] idMailleur = maQuery.value(0).toInt()[0]
return idMailleur return idMailleur

96
src/Tools/Verima/Base/tableMailleurs.py
View File

@ -2,58 +2,56 @@ from qtsalome import QSqlQuery
from tableDeBase import TableDeBase from tableDeBase import TableDeBase
class TableMailleurs (TableDeBase): class TableMailleurs (TableDeBase):
def __init__(self): def __init__(self):
TableDeBase.__init__(self,"Mailleurs") TableDeBase.__init__(self,"Mailleurs")
self.cols=" (nomMailleur) " self.cols=" (nomMailleur) "
self.setField(("id","nomMailleur")) self.setField(("id","nomMailleur"))
self.setTypeField(("int","str"),('id')) self.setTypeField(("int","str"),('id'))
def createSqlTable(self): def createSqlTable(self):
query=QSqlQuery() query=QSqlQuery()
print "Creation de TableMailleurs", query.exec_("create table Mailleurs(id integer primary key autoincrement, nomMailleur varchar(40));") print "Creation de TableMailleurs", query.exec_("create table Mailleurs(id integer primary key autoincrement, nomMailleur varchar(40));")
def dejaRemplie(self): def dejaRemplie(self):
texteQuery="select * from Mailleurs where nomMailleur='Blsurf+Ghs3D';" texteQuery="select * from Mailleurs where nomMailleur='Blsurf+Ghs3D';"
maQuery=QSqlQuery() maQuery=QSqlQuery()
maQuery.exec_(texteQuery) maQuery.exec_(texteQuery)
nb=0 nb=0
while(maQuery.next()): nb=nb+1 while(maQuery.next()): nb=nb+1
return nb return nb
def remplit(self): def remplit(self):
if self.dejaRemplie() : if self.dejaRemplie() :
print "Table Mailleurs deja initialisee" print "Table Mailleurs deja initialisee"
return return
self.insereLigneAutoId(('BLSURF',)) self.insereLigneAutoId(('BLSURF',))
self.insereLigneAutoId(('NETGEN1D2D',)) self.insereLigneAutoId(('NETGEN1D2D',))
self.insereLigneAutoId(('GHS3D+BLSURF',)) self.insereLigneAutoId(('GHS3D+BLSURF',))
self.insereLigneAutoId(('GHS3D+NETGEN1D2D',)) self.insereLigneAutoId(('GHS3D+NETGEN1D2D',))
self.insereLigneAutoId(('NETGEN1D2D3D',)) self.insereLigneAutoId(('NETGEN1D2D3D',))
def insereLigneAutoId(self,valeurs,debug=False): def insereLigneAutoId(self,valeurs,debug=False):
# difficulte a construire le texte avec une seule valeur # difficulte a construire le texte avec une seule valeur
texteQuery='insert into Mailleurs (nomMailleur) values ("'+ str(valeurs[0])+ '");' texteQuery='insert into Mailleurs (nomMailleur) values ("'+ str(valeurs[0])+ '");'
maQuery=QSqlQuery() maQuery=QSqlQuery()
if debug : print texteQuery, " " , maQuery.exec_(texteQuery) if debug : print texteQuery, " " , maQuery.exec_(texteQuery)
else : maQuery.exec_(texteQuery) else : maQuery.exec_(texteQuery)
def getTous(self): def getTous(self):
l1=[] l1=[]
l2=[] l2=[]
texteQuery="select * from Mailleurs;" texteQuery="select * from Mailleurs;"
maQuery=QSqlQuery() maQuery=QSqlQuery()
maQuery.exec_(texteQuery) maQuery.exec_(texteQuery)
while(maQuery.next()): while(maQuery.next()):
l1.append( maQuery.value(0).toInt()[0]) l1.append( maQuery.value(0).toInt()[0])
l2.append( maQuery.value(1).toString()) l2.append( maQuery.value(1).toString())
return l1,l2 return l1,l2
def getName(self,mailleurId): def getName(self,mailleurId):
texteQuery="select nomMailleur from Mailleurs where id = " + str(mailleurId) + " ;" texteQuery="select nomMailleur from Mailleurs where id = " + str(mailleurId) + " ;"
maQuery=QSqlQuery() maQuery=QSqlQuery()
maQuery.exec_(texteQuery) maQuery.exec_(texteQuery)
while(maQuery.next()): while(maQuery.next()):
mailleurName=maQuery.value(0).toString() mailleurName=maQuery.value(0).toString()
return mailleurName return mailleurName

65
src/Tools/Verima/Base/tableVersions.py
View File

@ -2,43 +2,40 @@ from qtsalome import QSqlQuery
from tableDeBase import TableDeBase from tableDeBase import TableDeBase
class TableVersions (TableDeBase): class TableVersions (TableDeBase):
def __init__(self): def __init__(self):
TableDeBase.__init__(self,"Versions") TableDeBase.__init__(self,"Versions")
self.setField(("id","nomVersion","commentaire")) self.setField(("id","nomVersion","commentaire"))
self.setTypeField(('int','str','str'),('id',)) self.setTypeField(('int','str','str'),('id',))
self.cols=" (nomVersion, commentaire) " self.cols=" (nomVersion, commentaire) "
def createSqlTable(self): def createSqlTable(self):
query=QSqlQuery() query=QSqlQuery()
texteQuery ="create table Versions(id integer primary key autoincrement, nomVersion varchar(10)," texteQuery ="create table Versions(id integer primary key autoincrement, nomVersion varchar(10),"
texteQuery+="commentaire varchar(30));" texteQuery+="commentaire varchar(30));"
print "Creation de TableVersions : " , query.exec_(texteQuery) print "Creation de TableVersions : " , query.exec_(texteQuery)
def remplit(self): def remplit(self):
self.insereLigneAutoId(('Salome7.2.0','')) self.insereLigneAutoId(('Salome7.2.0',''))
self.insereLigneAutoId(('Salome7.3.0','')) self.insereLigneAutoId(('Salome7.3.0',''))
self.insereLigneAutoId(('Salome7.4.0','')) self.insereLigneAutoId(('Salome7.4.0',''))
def creeVersion(self,version,commentaire=""): def creeVersion(self,version,commentaire=""):
self.insereLigneAutoId((version,commentaire)) self.insereLigneAutoId((version,commentaire))
def chercheVersion(self,version):
query=QSqlQuery()
version=str(version)
if bool(version) == True :
texteQuery ="select id, nomVersion from Versions where id = " + str(version) +";"
else:
texteQuery ="select id, nomVersion from Versions where nomVersion ='" + version +"' ;"
query.exec_(texteQuery)
nb=0
while(query.next()):
nb=nb+1
id=query.value(0).toInt()[0]
nom=query.value(1).toString()
if nb != 1 : return 0, 0, ""
return 1, id, nom
def chercheVersion(self,version):
query=QSqlQuery()
version=str(version)
if bool(version) == True :
texteQuery ="select id, nomVersion from Versions where id = " + str(version) +";"
else:
texteQuery ="select id, nomVersion from Versions where nomVersion ='" + version +"' ;"
query.exec_(texteQuery)
nb=0
while(query.next()):
nb=nb+1
id=query.value(0).toInt()[0]
nom=query.value(1).toString()
if nb != 1 : return 0, 0, ""
return 1, id, nom

43
src/Tools/Verima/passeJobs.py
View File

@ -8,25 +8,24 @@ from Base.versions import Chercheversion
if __name__ == "__main__": if __name__ == "__main__":
from optparse import OptionParser from optparse import OptionParser
p=OptionParser() p=OptionParser()
p.add_option('-a',dest='all',action="store_true", default=False,help='passe l ensemble des Tests') p.add_option('-a',dest='all',action="store_true", default=False,help='passe l ensemble des Tests')
p.add_option('-s',dest='salomePath',help='chemin du runAppli',default="Appli") p.add_option('-s',dest='salomePath',help='chemin du runAppli',default="Appli")
p.add_option('-v',dest='version',help='id de la version') p.add_option('-v',dest='version',help='id de la version')
p.add_option('-d',dest='database',default="myMesh.db",help='nom de la database') p.add_option('-d',dest='database',default="myMesh.db",help='nom de la database')
p.add_option('-f',dest='force',default=True,help='force la passage des jobs meme si l execution a deja eu lieu sur cette machine pour cette version de salome') p.add_option('-f',dest='force',default=True,help='force la passage des jobs meme si l execution a deja eu lieu sur cette machine pour cette version de salome')
options, args = p.parse_args() options, args = p.parse_args()
if len(args) == 0 and options.all== False: if len(args) == 0 and options.all== False:
print "Enter -a ou un numero de job" print "Enter -a ou un numero de job"
print 2 print 2
exit() exit()
if options.salomePath==None : if options.salomePath==None :
print "chemin du runAppli obligatoire" print "chemin du runAppli obligatoire"
exit() exit()
if options.version==None : if options.version==None :
options.version=Chercheversion(options.salomePath) options.version=Chercheversion(options.salomePath)
maBase=Base(options.database) maBase=Base(options.database)
maBase.initialise() maBase.initialise()
maBase.passeJobs(options.all,options.salomePath,options.version,options.force,args) maBase.passeJobs(options.all,options.salomePath,options.version,options.force,args)
maBase.close() maBase.close()

38
src/Tools/YamsPlug/monViewText.py
View File

@ -35,8 +35,8 @@ verbose = True
force = os.getenv("FORCE_DISTENE_LICENSE_FILE") force = os.getenv("FORCE_DISTENE_LICENSE_FILE")
if force != None: if force != None:
os.environ["DISTENE_LICENSE_FILE"] = force os.environ["DISTENE_LICENSE_FILE"] = force
os.environ["DLIM8VAR"] = "NOTHING" os.environ["DLIM8VAR"] = "NOTHING"
class MonViewText(Ui_ViewExe, QDialog): class MonViewText(Ui_ViewExe, QDialog):
""" """
@ -54,7 +54,7 @@ class MonViewText(Ui_ViewExe, QDialog):
self.monExe.readyReadStandardOutput.connect( self.readFromStdOut ) self.monExe.readyReadStandardOutput.connect( self.readFromStdOut )
self.monExe.readyReadStandardError.connect( self.readFromStdErr ) self.monExe.readyReadStandardError.connect( self.readFromStdErr )
self.monExe.finished.connect( self.finished ) self.monExe.finished.connect( self.finished )
cmds = '' cmds = ''
ext = '' ext = ''
if sys.platform == "win32": if sys.platform == "win32":
@ -73,14 +73,14 @@ class MonViewText(Ui_ViewExe, QDialog):
cmds += 'echo %s\n' % txt #to see what is compute command cmds += 'echo %s\n' % txt #to see what is compute command
cmds += txt+'\n' cmds += txt+'\n'
cmds += 'echo "END_OF_MGSurfOpt"\n' cmds += 'echo "END_OF_MGSurfOpt"\n'
nomFichier = os.path.splitext(self.parent().fichierOut)[0] + ext nomFichier = os.path.splitext(self.parent().fichierOut)[0] + ext
with open(nomFichier, 'w') as f: with open(nomFichier, 'w') as f:
f.write(cmds) f.write(cmds)
self.make_executable(nomFichier) self.make_executable(nomFichier)
if verbose: print("INFO: MGSurfOpt launch script file: %s" % nomFichier) if verbose: print("INFO: MGSurfOpt launch script file: %s" % nomFichier)
self.monExe.start(nomFichier) self.monExe.start(nomFichier)
self.monExe.closeWriteChannel() self.monExe.closeWriteChannel()
self.enregistreResultatsDone=False self.enregistreResultatsDone=False
@ -98,12 +98,12 @@ class MonViewText(Ui_ViewExe, QDialog):
if fn.isNull() : return if fn.isNull() : return
ulfile = os.path.abspath(unicode(fn)) ulfile = os.path.abspath(unicode(fn))
try: try:
f = open(fn, 'wb') f = open(fn, 'wb')
f.write(str(self.TB_Exe.toPlainText())) f.write(str(self.TB_Exe.toPlainText()))
f.close() f.close()
except IOError, why: except IOError, why:
QMessageBox.critical(self, 'Save File', QMessageBox.critical(self, 'Save File',
'The file <b>%1</b> could not be saved.<br>Reason: %2'%(unicode(fn), str(why))) 'The file <b>%1</b> could not be saved.<br>Reason: %2'%(unicode(fn), str(why)))
def readFromStdErr(self): def readFromStdErr(self):
a=self.monExe.readAllStandardError() a=self.monExe.readAllStandardError()
@ -112,14 +112,14 @@ class MonViewText(Ui_ViewExe, QDialog):
def readFromStdOut(self) : def readFromStdOut(self) :
a=self.monExe.readAllStandardOutput() a=self.monExe.readAllStandardOutput()
aa=unicode(a.data()) aa=unicode(a.data())
self.TB_Exe.append(aa) self.TB_Exe.append(aa)
def finished(self): def finished(self):
self.parent().enregistreResultat() self.parent().enregistreResultat()
self.enregistreResultatsDone=True self.enregistreResultatsDone=True
def theClose(self): def theClose(self):
if not self.enregistreResultatsDone: if not self.enregistreResultatsDone:
self.parent().enregistreResultat() self.parent().enregistreResultat()
self.enregistreResultatsDone=True self.enregistreResultatsDone=True
self.close() self.close()

33
src/Tools/padder/spadderpy/gui/plugindialog.py
View File

@ -86,7 +86,7 @@ class PluginDialog(QDialog):
self.__ui.btnClear.setIcon(icon) self.__ui.btnClear.setIcon(icon)
# Then, we can connect the slot to there associated button event # Then, we can connect the slot to there associated button event
self.__ui.btnInput.clicked.connect( self.onInput ) self.__ui.btnInput.clicked.connect( self.onInput )
self.__ui.btnCompute.clicked.connect( self.onCompute ) self.__ui.btnCompute.clicked.connect( self.onCompute )
self.__ui.btnRefresh.clicked.connect( self.onRefresh ) self.__ui.btnRefresh.clicked.connect( self.onRefresh )
self.__ui.btnPublish.clicked.connect( self.onPublish ) self.__ui.btnPublish.clicked.connect( self.onPublish )
@ -95,7 +95,7 @@ class PluginDialog(QDialog):
self.clear() self.clear()
self.setupJobManager() self.setupJobManager()
def setupJobManager(self): def setupJobManager(self):
''' '''
@ -105,8 +105,8 @@ class PluginDialog(QDialog):
the initialize step, by specifing the name of the resource to the initialize step, by specifing the name of the resource to
be used. be used.
''' '''
# We first # We first
configReader = ConfigReader() configReader = ConfigReader()
config = configReader.getLocalConfig() config = configReader.getLocalConfig()
configId = config.resname configId = config.resname
@ -139,8 +139,8 @@ class PluginDialog(QDialog):
self.__inputDialog.windowFlags() | Qt.WindowStaysOnTopHint) self.__inputDialog.windowFlags() | Qt.WindowStaysOnTopHint)
# The signal inputValidated emitted from inputDialog is # The signal inputValidated emitted from inputDialog is
# connected to the slot function onProcessInput: # connected to the slot function onProcessInput:
self.__inputDialog.inputValidated.connect( self.onProcessInput ) self.__inputDialog.inputValidated.connect( self.onProcessInput )
else: else:
self.__ui.frameInput.setVisible(True) self.__ui.frameInput.setVisible(True)
self.__ui.btnInput.setVisible(False) self.__ui.btnInput.setVisible(False)
@ -150,13 +150,13 @@ class PluginDialog(QDialog):
def getInputFrame(self): def getInputFrame(self):
return self.__ui.frameInput return self.__ui.frameInput
def __setGuiState(self,states=["CAN_SELECT"]): def __setGuiState(self,states=["CAN_SELECT"]):
if "CAN_SELECT" in states: if "CAN_SELECT" in states:
self.__ui.btnInput.setEnabled(True) self.__ui.btnInput.setEnabled(True)
else: else:
self.__ui.btnInput.setEnabled(False) self.__ui.btnInput.setEnabled(False)
if "CAN_COMPUTE" in states: if "CAN_COMPUTE" in states:
self.__ui.btnCompute.setEnabled(True) self.__ui.btnCompute.setEnabled(True)
else: else:
@ -200,7 +200,7 @@ class PluginDialog(QDialog):
def __log(self, message): def __log(self, message):
""" """
This function prints the specified message in the log area This function prints the specified message in the log area
""" """
self.__ui.txtLog.append(message) self.__ui.txtLog.append(message)
def __exportMesh(self, meshName, meshObject): def __exportMesh(self, meshName, meshObject):
@ -256,12 +256,12 @@ class PluginDialog(QDialog):
self.__ui.lblStatusBar.setText("Input data OK") self.__ui.lblStatusBar.setText("Input data OK")
self.__log("INF: Press \"Compute\" to start the job") self.__log("INF: Press \"Compute\" to start the job")
self.__setGuiState(["CAN_SELECT", "CAN_COMPUTE"]) self.__setGuiState(["CAN_SELECT", "CAN_COMPUTE"])
def onCompute(self): def onCompute(self):
''' '''
This function is the slot connected to the Compute button. It This function is the slot connected to the Compute button. It
initializes a mesh computation job and start it using the initializes a mesh computation job and start it using the
SALOME launcher. SALOME launcher.
''' '''
# We first have to create the list of parameters for the # We first have to create the list of parameters for the
# initialize function. For that, we have to create the files # initialize function. For that, we have to create the files
@ -290,7 +290,7 @@ class PluginDialog(QDialog):
self.__log("ERR: %s"%jobManager.getLastErrorMessage()) self.__log("ERR: %s"%jobManager.getLastErrorMessage())
return return
self.__log("INF: the job has been initialized with jobid = "+str(self.__jobid)) self.__log("INF: the job has been initialized with jobid = "+str(self.__jobid))
startOk = jobManager.start(self.__jobid) startOk = jobManager.start(self.__jobid)
if not startOk: if not startOk:
self.__log("ERR: the job with jobid = "+str(self.__jobid)+" can't be started") self.__log("ERR: the job with jobid = "+str(self.__jobid)+" can't be started")
@ -326,7 +326,7 @@ class PluginDialog(QDialog):
This function is the slot connected on the Publish button. It This function is the slot connected on the Publish button. It
requests the mesh job manager to download the results data requests the mesh job manager to download the results data
from the computation resource host and load the med file in from the computation resource host and load the med file in
the SALOME study. the SALOME study.
""" """
jobManager = self.__getJobManager() jobManager = self.__getJobManager()
state = jobManager.getState(self.__jobid) state = jobManager.getState(self.__jobid)
@ -372,13 +372,13 @@ class PluginDialog(QDialog):
one is running. one is running.
""" """
self.clear() self.clear()
__dialog=None __dialog=None
def getDialog(): def getDialog():
""" """
This function returns a singleton instance of the plugin dialog. This function returns a singleton instance of the plugin dialog.
""" """
global __dialog global __dialog
if __dialog is None: if __dialog is None:
@ -401,6 +401,3 @@ def TEST_PluginDialog():
if __name__ == "__main__": if __name__ == "__main__":
TEST_PluginDialog() TEST_PluginDialog()