ForkMaster/smesh
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/smesh.git synced 2025-01-13 10:10:33 +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

3
bin/smesh_setenv.py
View File

@ -60,7 +60,7 @@ def set_env(args):
if plugin in plugin_list: continue
# add paths of plugin
plugin_list.append(plugin)
plugin_list.append(plugin)
if not os.environ.has_key("SALOME_"+plugin+"Resources"):
resource_path = os.path.join(plugin_root,"share",salome_subdir,"resources",plugin.lower())
os.environ["SALOME_"+plugin+"Resources"] = resource_path
@ -80,4 +80,3 @@ def set_env(args):
break
os.environ["SMESH_MeshersList"] = ":".join(plugin_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:
for i in range(a.number):
ind = a.indexes[ii]
print ind
print ind
ii = ii+1
print ii
print ii
i1 = a.indexes[ii]
ii = ii+1
i2 = a.indexes[ii]
print i2
print i2
ii = ii+1
print "ii", ii
print "ii", ii
i3 = a.indexes[ii]
print i3
print i3
#ii = ii+1
ii = ii+1
print "AddTriangle %i - %i %i %i" % (ind, i1, i2, i3)

390
src/SMESH_SWIG/batchmode_smesh.py
View File

@ -38,16 +38,16 @@ smesh.SetCurrentStudy(myStudy)
myStudyBuilder = myStudy.NewBuilder()
if myStudyBuilder is None:
raise RuntimeError, " Null myStudyBuilder"
raise RuntimeError, " Null myStudyBuilder"
father = myStudy.FindComponent("SMESH")
if father is None:
father = myStudyBuilder.NewComponent("SMESH")
FName = myStudyBuilder.FindOrCreateAttribute(father, "AttributeName")
Comp = modulecatalog.GetComponent("SMESH")
FName.SetValue(Comp._get_componentusername())
aPixmap = myStudyBuilder.FindOrCreateAttribute(father, "AttributePixMap")
aPixmap.SetPixMap("ICON_OBJBROWSER_Mesh")
father = myStudyBuilder.NewComponent("SMESH")
FName = myStudyBuilder.FindOrCreateAttribute(father, "AttributeName")
Comp = modulecatalog.GetComponent("SMESH")
FName.SetValue(Comp._get_componentusername())
aPixmap = myStudyBuilder.FindOrCreateAttribute(father, "AttributePixMap")
aPixmap.SetPixMap("ICON_OBJBROWSER_Mesh")
myStudyBuilder.DefineComponentInstance(father,smesh)
@ -70,255 +70,255 @@ Tag = {"HypothesisRoot":1,"AlgorithmsRoot":2,"RefOnShape":1,"RefOnAppliedHypothe
#------------------------------------------------------------
def Init():
pass
pass
#------------------------------------------------------------
def AddNewMesh(IOR):
# VSR: added temporarily - objects are published automatically by the engine
aSO = myStudy.FindObjectIOR( IOR )
if aSO is not None:
return aSO.GetID()
# VSR ######################################################################
# VSR: added temporarily - objects are published automatically by the engine
aSO = myStudy.FindObjectIOR( IOR )
if aSO is not None:
return aSO.GetID()
# 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,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)
if AlgorithmsRoot is None or res == 0:
AlgorithmsRoot = myStudyBuilder.NewObjectToTag (mySComponentMesh, Tag_AlgorithmsRoot)
aName = myStudyBuilder.FindOrCreateAttribute(AlgorithmsRoot, "AttributeName")
aName.SetValue("Algorithms")
aPixmap = myStudyBuilder.FindOrCreateAttribute(AlgorithmsRoot, "AttributePixMap")
aPixmap.SetPixMap( "mesh_tree_algo.png" )
aSelAttr = myStudyBuilder.FindOrCreateAttribute(AlgorithmsRoot, "AttributeSelectable")
aSelAttr.SetSelectable(0)
res, AlgorithmsRoot = mySComponentMesh.FindSubObject (Tag_AlgorithmsRoot)
if AlgorithmsRoot is None or res == 0:
AlgorithmsRoot = myStudyBuilder.NewObjectToTag (mySComponentMesh, Tag_AlgorithmsRoot)
aName = myStudyBuilder.FindOrCreateAttribute(AlgorithmsRoot, "AttributeName")
aName.SetValue("Algorithms")
aPixmap = myStudyBuilder.FindOrCreateAttribute(AlgorithmsRoot, "AttributePixMap")
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()
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):
# VSR: added temporarily - objects are published automatically by the engine
aSO = myStudy.FindObjectIOR( IOR )
if aSO is not None:
return aSO.GetID()
# VSR ######################################################################
# VSR: added temporarily - objects are published automatically by the engine
aSO = myStudy.FindObjectIOR( IOR )
if aSO is not None:
return aSO.GetID()
# 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")
aSelAttr = myStudyBuilder.FindOrCreateAttribute(HypothesisRoot, "AttributeSelectable")
aSelAttr.SetSelectable(0)
aPixmap = myStudyBuilder.FindOrCreateAttribute(HypothesisRoot, "AttributePixMap")
aPixmap.SetPixMap( "mesh_tree_hypo.png" )
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")
aSelAttr = myStudyBuilder.FindOrCreateAttribute(HypothesisRoot, "AttributeSelectable")
aSelAttr.SetSelectable(0)
aPixmap = myStudyBuilder.FindOrCreateAttribute(HypothesisRoot, "AttributePixMap")
aPixmap.SetPixMap( "mesh_tree_hypo.png" )
# Add New Hypothesis
newHypo = myStudyBuilder.NewObject(HypothesisRoot)
aPixmap = myStudyBuilder.FindOrCreateAttribute(newHypo, "AttributePixMap")
H = orb.string_to_object(IOR)
aType = H.GetName()
aPixmap.SetPixMap( "mesh_tree_hypo.png_" + aType )
anIOR = myStudyBuilder.FindOrCreateAttribute(newHypo, "AttributeIOR")
anIOR.SetValue(IOR)
return newHypo.GetID()
# Add New Hypothesis
newHypo = myStudyBuilder.NewObject(HypothesisRoot)
aPixmap = myStudyBuilder.FindOrCreateAttribute(newHypo, "AttributePixMap")
H = orb.string_to_object(IOR)
aType = H.GetName()
aPixmap.SetPixMap( "mesh_tree_hypo.png_" + aType )
anIOR = myStudyBuilder.FindOrCreateAttribute(newHypo, "AttributeIOR")
anIOR.SetValue(IOR)
return newHypo.GetID()
#------------------------------------------------------------
def AddNewAlgorithms(IOR):
# VSR: added temporarily - objects are published automatically by the engine
aSO = myStudy.FindObjectIOR( IOR )
if aSO is not None:
return aSO.GetID()
# VSR ######################################################################
# VSR: added temporarily - objects are published automatically by the engine
aSO = myStudy.FindObjectIOR( IOR )
if aSO is not None:
return aSO.GetID()
# VSR ######################################################################
res, AlgorithmsRoot = mySComponentMesh.FindSubObject (Tag_AlgorithmsRoot)
if AlgorithmsRoot is None or res == 0:
AlgorithmsRoot = myStudyBuilde.NewObjectToTag (mySComponentMesh, Tag_AlgorithmsRoot)
aName = myStudyBuilder.FindOrCreateAttribute(AlgorithmsRoot, "AttributeName")
aName.SetValue("Algorithms")
aSelAttr = myStudyBuilder.FindOrCreateAttribute(AlgorithmsRoot, "AttributeSelectable")
aSelAttr.SetSelectable(0)
aPixmap = myStudyBuilder.FindOrCreateAttribute(AlgorithmsRoot, "AttributePixMap")
aPixmap.SetPixMap( "mesh_tree_algo.png" )
res, AlgorithmsRoot = mySComponentMesh.FindSubObject (Tag_AlgorithmsRoot)
if AlgorithmsRoot is None or res == 0:
AlgorithmsRoot = myStudyBuilde.NewObjectToTag (mySComponentMesh, Tag_AlgorithmsRoot)
aName = myStudyBuilder.FindOrCreateAttribute(AlgorithmsRoot, "AttributeName")
aName.SetValue("Algorithms")
aSelAttr = myStudyBuilder.FindOrCreateAttribute(AlgorithmsRoot, "AttributeSelectable")
aSelAttr.SetSelectable(0)
aPixmap = myStudyBuilder.FindOrCreateAttribute(AlgorithmsRoot, "AttributePixMap")
aPixmap.SetPixMap( "mesh_tree_algo.png" )
# Add New Algorithms
newHypo = myStudyBuilder.NewObject(AlgorithmsRoot)
aPixmap = myStudyBuilder.FindOrCreateAttribute(newHypo, "AttributePixMap")
aPixmap = anAttr._narrow(SALOMEDS.AttributePixMap)
H = orb.string_to_object(IOR)
aType = H.GetName(); #QString in fact
aPixmap.SetPixMap( "mesh_tree_algo.png_" + aType )
anIOR = myStudyBuilder.FindOrCreateAttribute(newHypo, "AttributeIOR")
anIOR.SetValue(IOR)
return newHypo.GetID()
newHypo = myStudyBuilder.NewObject(AlgorithmsRoot)
aPixmap = myStudyBuilder.FindOrCreateAttribute(newHypo, "AttributePixMap")
aPixmap = anAttr._narrow(SALOMEDS.AttributePixMap)
H = orb.string_to_object(IOR)
aType = H.GetName(); #QString in fact
aPixmap.SetPixMap( "mesh_tree_algo.png_" + aType )
anIOR = myStudyBuilder.FindOrCreateAttribute(newHypo, "AttributeIOR")
anIOR.SetValue(IOR)
return newHypo.GetID()
#------------------------------------------------------------
def SetShape(ShapeEntry, MeshEntry):
SO_MorSM = myStudy.FindObjectID( MeshEntry )
SO_GeomShape = myStudy.FindObjectID( ShapeEntry )
SO_MorSM = myStudy.FindObjectID( MeshEntry )
SO_GeomShape = myStudy.FindObjectID( ShapeEntry )
if SO_MorSM is not None and SO_GeomShape is not None :
# VSR: added temporarily - shape reference is published automatically by the engine
res, Ref = SO_MorSM.FindSubObject( Tag_RefOnShape )
if res == 1 :
return
# VSR ######################################################################
if SO_MorSM is not None and SO_GeomShape is not None :
# VSR: added temporarily - shape reference is published automatically by the engine
res, Ref = SO_MorSM.FindSubObject( Tag_RefOnShape )
if res == 1 :
return
# VSR ######################################################################
SO = myStudyBuilder.NewObjectToTag (SO_MorSM, Tag_RefOnShape)
myStudyBuilder.Addreference (SO,SO_GeomShape)
SO = myStudyBuilder.NewObjectToTag (SO_MorSM, Tag_RefOnShape)
myStudyBuilder.Addreference (SO,SO_GeomShape)
#------------------------------------------------------------
def SetHypothesis(Mesh_Or_SubMesh_Entry, Hypothesis_Entry):
SO_MorSM = myStudy.FindObjectID( Mesh_Or_SubMesh_Entry )
SO_Hypothesis = myStudy.FindObjectID( Hypothesis_Entry )
SO_MorSM = myStudy.FindObjectID( Mesh_Or_SubMesh_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
res, AHR = SO_MorSM.FindSubObject (Tag_RefOnAppliedHypothesis)
if AHR is None or res == 0:
AHR = myStudyBuilder.NewObjectToTag (SO_MorSM, Tag_RefOnAppliedHypothesis)
aName = myStudyBuilder.FindOrCreateAttribute(AHR, "AttributeName")
#Find or Create Applied Hypothesis root
res, AHR = SO_MorSM.FindSubObject (Tag_RefOnAppliedHypothesis)
if AHR is None or res == 0:
AHR = myStudyBuilder.NewObjectToTag (SO_MorSM, Tag_RefOnAppliedHypothesis)
aName = myStudyBuilder.FindOrCreateAttribute(AHR, "AttributeName")
# The same name as in SMESH_Mesh_i::AddHypothesis() ##################
aName.SetValue("Applied hypotheses")
# The same name as in SMESH_Mesh_i::AddHypothesis() ##################
aName.SetValue("Applied hypotheses")
aSelAttr = myStudyBuilder.FindOrCreateAttribute(AHR, "AttributeSelectable")
aSelAttr.SetSelectable(0)
aPixmap = myStudyBuilder.FindOrCreateAttribute(AHR, "AttributePixMap")
aPixmap.SetPixMap( "mesh_tree_hypo.png" )
aSelAttr = myStudyBuilder.FindOrCreateAttribute(AHR, "AttributeSelectable")
aSelAttr.SetSelectable(0)
aPixmap = myStudyBuilder.FindOrCreateAttribute(AHR, "AttributePixMap")
aPixmap.SetPixMap( "mesh_tree_hypo.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() == Hypothesis_Entry :
return
it.Next()
# VSR ######################################################################
# 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() == Hypothesis_Entry :
return
it.Next()
# VSR ######################################################################
SO = myStudyBuilder.NewObject(AHR)
myStudyBuilder.Addreference (SO,SO_Hypothesis)
SO = myStudyBuilder.NewObject(AHR)
myStudyBuilder.Addreference (SO,SO_Hypothesis)
#------------------------------------------------------------
def SetAlgorithms(Mesh_Or_SubMesh_Entry, Algorithms_Entry):
SO_MorSM = myStudy.FindObjectID( Mesh_Or_SubMesh_Entry )
SO_Algorithms = myStudy.FindObjectID( Algorithms_Entry )
if SO_MorSM != None and SO_Algorithms != None :
#Find or Create Applied Algorithms root
res, AHR = SO_MorSM.FindSubObject (Tag_RefOnAppliedAlgorithms)
if AHR is None or res == 0:
AHR = myStudyBuilder.NewObjectToTag (SO_MorSM, Tag_RefOnAppliedAlgorithms)
aName = myStudyBuilder.FindOrCreateAttribute(AHR, "AttributeName")
#Find or Create Applied Algorithms root
res, AHR = SO_MorSM.FindSubObject (Tag_RefOnAppliedAlgorithms)
if AHR is None or res == 0:
AHR = myStudyBuilder.NewObjectToTag (SO_MorSM, Tag_RefOnAppliedAlgorithms)
aName = myStudyBuilder.FindOrCreateAttribute(AHR, "AttributeName")
# The same name as in SMESH_Mesh_i::AddHypothesis() ##################
aName.SetValue("Applied 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" )
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 ######################################################################
# 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)
SO = myStudyBuilder.NewObject(AHR)
myStudyBuilder.Addreference (SO,SO_Algorithms)
#------------------------------------------------------------
def UnSetHypothesis( Applied_Hypothesis_Entry ):
SO_Applied_Hypothesis = myStudy.FindObjectID( Applied_Hypothesis_Entry )
if SO_Applied_Hypothesis :
myStudyBuilder.RemoveObject(SO_Applied_Hypothesis)
SO_Applied_Hypothesis = myStudy.FindObjectID( Applied_Hypothesis_Entry )
if SO_Applied_Hypothesis :
myStudyBuilder.RemoveObject(SO_Applied_Hypothesis)
#------------------------------------------------------------
def AddSubMesh ( SO_Mesh_Entry, SM_IOR, ST):
# VSR: added temporarily - objects are published automatically by the engine
aSO = myStudy.FindObjectIOR( SM_IOR )
if aSO is not None:
return aSO.GetID()
# VSR ######################################################################
# VSR: added temporarily - objects are published automatically by the engine
aSO = myStudy.FindObjectIOR( SM_IOR )
if aSO is not None:
return aSO.GetID()
# VSR ######################################################################
SO_Mesh = myStudy.FindObjectID( SO_Mesh_Entry )
if ( SO_Mesh ) :
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"
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)
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()
SO = myStudyBuilder.NewObject (SubmeshesRoot)
anIOR = myStudyBuilder.FindOrCreateAttribute(SO, "AttributeIOR")
anIOR.SetValue(SM_IOR)
return SO.GetID()
return None
return None
#------------------------------------------------------------
def AddSubMeshOnShape (Mesh_Entry, GeomShape_Entry, SM_IOR, ST) :
# VSR: added temporarily - objects are published automatically by the engine
aSO = myStudy.FindObjectIOR( SM_IOR )
if aSO is not None:
return aSO.GetID()
# VSR ######################################################################
SO_GeomShape = myStudy.FindObjectID( GeomShape_Entry )
if SO_GeomShape != None :
SM_Entry = AddSubMesh (Mesh_Entry,SM_IOR,ST)
SO_SM = myStudy.FindObjectID( SM_Entry )
# VSR: added temporarily - objects are published automatically by the engine
aSO = myStudy.FindObjectIOR( SM_IOR )
if aSO is not None:
return aSO.GetID()
# VSR ######################################################################
SO_GeomShape = myStudy.FindObjectID( GeomShape_Entry )
if SO_GeomShape != None :
SM_Entry = AddSubMesh (Mesh_Entry,SM_IOR,ST)
SO_SM = myStudy.FindObjectID( SM_Entry )
if SO_SM != None :
SetShape (GeomShape_Entry, SM_Entry)
return SM_Entry
if SO_SM != None :
SetShape (GeomShape_Entry, SM_Entry)
return SM_Entry
return None
return None
#------------------------------------------------------------
def SetName(Entry, Name):
SO = myStudy.FindObjectID( Entry )
if SO != None :
aName = myStudyBuilder.FindOrCreateAttribute(SO, "AttributeName")
aName.SetValue(Name)
SO = myStudy.FindObjectID( Entry )
if SO != None :
aName = myStudyBuilder.FindOrCreateAttribute(SO, "AttributeName")
aName.SetValue(Name)

4
src/SMESH_SWIG/smesh.py
View File

@ -82,8 +82,8 @@ del pluginName
# export the methods of smeshBuilder
if smesh:
for k in dir( smesh ):
if k[0] == '_': continue
globals()[k] = getattr( smesh, k )
if k[0] == '_': continue
globals()[k] = getattr( smesh, k )
del k
pass

24
src/SMESH_SWIG/smeshBuilder.py
View File

@ -374,8 +374,8 @@ class smeshBuilder(object, SMESH._objref_SMESH_Gen):
global created
#print "--------------- smeshbuilder __init__ ---", created
if not created:
created = True
SMESH._objref_SMESH_Gen.__init__(self)
created = True
SMESH._objref_SMESH_Gen.__init__(self)
## Dump component to the Python script
# This method overrides IDL function to allow default values for the parameters.
@ -1195,7 +1195,7 @@ def New( study, instance=None):
global doLcc
engine = instance
if engine is None:
doLcc = True
doLcc = True
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__
smeshInst.init_smesh(study)
@ -2152,7 +2152,7 @@ class Mesh:
# @return an instance of SMESH_Group
# @ingroup l2_grps_operon
def UnionListOfGroups(self, groups, name):
return self.mesh.UnionListOfGroups(groups, name)
return self.mesh.UnionListOfGroups(groups, name)
## Prodice an intersection of two groups.
# A new group is created. All mesh elements that are common
@ -2168,7 +2168,7 @@ class Mesh:
# @return an instance of SMESH_Group
# @ingroup l2_grps_operon
def IntersectListOfGroups(self, groups, name):
return self.mesh.IntersectListOfGroups(groups, name)
return self.mesh.IntersectListOfGroups(groups, name)
## Produce a cut of two groups.
# A new group is created. All mesh elements that are present in
@ -4406,9 +4406,9 @@ class Mesh:
if ( isinstance( thePoint, list )):
thePoint = PointStruct( thePoint[0], thePoint[1], thePoint[2] )
if ( isinstance( theScaleFact, float )):
theScaleFact = [theScaleFact]
theScaleFact = [theScaleFact]
if ( isinstance( theScaleFact, int )):
theScaleFact = [ float(theScaleFact)]
theScaleFact = [ float(theScaleFact)]
self.mesh.SetParameters(thePoint.parameters)
@ -4434,9 +4434,9 @@ class Mesh:
if ( isinstance( thePoint, list )):
thePoint = PointStruct( thePoint[0], thePoint[1], thePoint[2] )
if ( isinstance( theScaleFact, float )):
theScaleFact = [theScaleFact]
theScaleFact = [theScaleFact]
if ( isinstance( theScaleFact, int )):
theScaleFact = [ float(theScaleFact)]
theScaleFact = [ float(theScaleFact)]
self.mesh.SetParameters(thePoint.parameters)
mesh = self.editor.ScaleMakeMesh(theObject, thePoint, theScaleFact,
@ -4892,7 +4892,7 @@ class Mesh:
# @return TRUE if operation has been completed successfully, FALSE otherwise
# @ingroup l2_modif_duplicat
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.
# Flat elements are mainly used by some types of mechanic calculations.
@ -5276,8 +5276,8 @@ for pluginName in os.environ[ "SMESH_MeshersList" ].split( ":" ):
try:
exec( "from salome.%s.%s import *" % (pluginName, pluginBuilderName))
except Exception, e:
from salome_utils import verbose
if verbose(): print "Exception while loading %s: %s" % ( pluginBuilderName, e )
from salome_utils import verbose
if verbose(): print "Exception while loading %s: %s" % ( pluginBuilderName, e )
continue
exec( "from salome.%s import %s" % (pluginName, pluginBuilderName))
plugin = eval( pluginBuilderName )

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

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

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

@ -33,155 +33,155 @@ import Config, GenFunctions
def CentralUnrefine (X0 , Y0 , DX , DY , Orientation, **args ) :
DirPar = {'SN' : lambda : ['NW', 'NE', 'EW', 'NW', 'SN', 'SN', 'NE', 'WE'],
'NS' : lambda : ['SE', 'SW', 'WE', 'SE', 'NS', 'NS', 'SW', 'EW'],
'EW' : lambda : ['NW', 'SW', 'SN', 'NW', 'EW', 'EW', 'SW', 'NS'],
'WE' : lambda : ['SE', 'NE', 'NS', 'SE', 'WE', 'WE', 'NE', 'SN'], }[Orientation]()
DirPar = {'SN' : lambda : ['NW', 'NE', 'EW', 'NW', 'SN', 'SN', 'NE', 'WE'],
'NS' : lambda : ['SE', 'SW', 'WE', 'SE', 'NS', 'NS', 'SW', 'EW'],
'EW' : lambda : ['NW', 'SW', 'SN', 'NW', 'EW', 'EW', 'SW', 'NS'],
'WE' : lambda : ['SE', 'NE', 'NS', 'SE', 'WE', 'WE', 'NE', 'SN'], }[Orientation]()
CoefVer = {'SN' : lambda : 1.,
'NS' : lambda : -1.,
'EW' : lambda : 0.,
'WE' : lambda : 0., }[Orientation]()
CoefVer = {'SN' : lambda : 1.,
'NS' : lambda : -1.,
'EW' : lambda : 0.,
'WE' : lambda : 0., }[Orientation]()
CoefHor = {'SN' : lambda : 0.,
'NS' : lambda : 0.,
'EW' : lambda : -1.,
'WE' : lambda : 1., }[Orientation]()
CoefHor = {'SN' : lambda : 0.,
'NS' : lambda : 0.,
'EW' : lambda : -1.,
'WE' : lambda : 1., }[Orientation]()
MacObject('CompBoxF',[(X0+CoefHor*DX/2,Y0+CoefVer*DY/2),(DX,DY)],['auto'],publish=0)
ToLook1 = {'SN' : lambda : 2,
'NS' : lambda : 3,
'EW' : lambda : 1,
'WE' : lambda : 0, }[Orientation]()
MacObject('CompBoxF',[(X0+CoefHor*DX/2,Y0+CoefVer*DY/2),(DX,DY)],['auto'],publish=0)
ToLook1 = {'SN' : lambda : 2,
'NS' : lambda : 3,
'EW' : lambda : 1,
'WE' : lambda : 0, }[Orientation]()
ToLook2 = {'SN' : lambda : 0,
'NS' : lambda : 0,
'EW' : lambda : 2,
'WE' : lambda : 2, }[Orientation]()
ToLook2 = {'SN' : lambda : 0,
'NS' : lambda : 0,
'EW' : lambda : 2,
'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]()
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]
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()
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)
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.
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])))
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
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 = [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
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])
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 :
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])
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))
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
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]
Config.ListObj = Config.ListObj[:-1]
Config.Connections = Config.Connections[:-1]
def GroupArray(indices, GroupNames) :
if type(indices) is int :
indices = [indices]
GroupNames = [GroupNames]
Output = [None,None,None,None]
for i, ind in enumerate(indices) :
Output[ind] = GroupNames[i]
return Output
if type(indices) is int :
indices = [indices]
GroupNames = [GroupNames]
Output = [None,None,None,None]
for i, ind in enumerate(indices) :
Output[ind] = GroupNames[i]
return Output

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

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

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

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

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

@ -28,199 +28,199 @@ geompy = geomBuilder.New( Config.theStudy )
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)
- 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
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.
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
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
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 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.
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
"""
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
- 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 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!)
- 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 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.
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.
- 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 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'])
"""
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)
OrigType = FindStandType(GeoObj,0)
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 = []
NumCuts = CheckInput(CutPlnLst, OutLvlLst, PrefixLst, 1)
OrigType = FindStandType(GeoObj,0)
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"
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))
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
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):
"""
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
- 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 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
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
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 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.
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
"""
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
- 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 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
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
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 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.
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
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'])
"""
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)
OrigType = FindStandType(GeoObj,0)
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"
NumCuts = CheckInput(CutPlnLst, OutLvlLst, PrefixLst, 0)
OrigType = FindStandType(GeoObj,0)
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))
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
return OutFather, Sections, Parts
else:
print("Fatal error, the routine cannot continue any further, check your input variables")
return -1
def FindStandType(GeoObj, method):
"""
Find the standard index for the Geometrical object/compound type input, see dictionary in geompy.ShapeType
"""
TopType = GeoObj.GetMaxShapeType().__str__()
UnModType = geompy.ShapeType[TopType]
if method == 0 :
StandType = UnModType-int(not(UnModType%2)) # So that wires and edges and considered the same, faces and shells, and so on
else :
StandType = UnModType
"""
Find the standard index for the Geometrical object/compound type input, see dictionary in geompy.ShapeType
"""
TopType = GeoObj.GetMaxShapeType().__str__()
UnModType = geompy.ShapeType[TopType]
if method == 0 :
StandType = UnModType-int(not(UnModType%2)) # So that wires and edges and considered the same, faces and shells, and so on
else :
StandType = UnModType
return(StandType)
return(StandType)
def CreatePlane(CutPlnVar,Trim):
"""
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_Vec = geompy.MakeVectorDXDYDZ(CutPlnVar[3], CutPlnVar[4], CutPlnVar[5])
CutPlane = geompy.MakePlane(Temp_Vtx, Temp_Vec, Trim)
return(CutPlane)
"""
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_Vec = geompy.MakeVectorDXDYDZ(CutPlnVar[3], CutPlnVar[4], CutPlnVar[5])
CutPlane = geompy.MakePlane(Temp_Vtx, Temp_Vec, Trim)
return(CutPlane)
def CheckInput(CutPlnLst, OutLvlLst, PrefixLst, AutoTrim):
"""
Checks the user input specifically if all needed parameters are provided
"""
if not ((len(CutPlnLst) == len(OutLvlLst)) and (len(CutPlnLst) == len(PrefixLst))):
print("Missing information about one or more of the cut planes")
return 0
elif not ((len(CutPlnLst[0]) == 6+int(not AutoTrim))):
print("For each cutting plane you need to specify 6 parameters = 2 x 3 coordinates")
return 0
else:
return len(CutPlnLst)
"""
Checks the user input specifically if all needed parameters are provided
"""
if not ((len(CutPlnLst) == len(OutLvlLst)) and (len(CutPlnLst) == len(PrefixLst))):
print("Missing information about one or more of the cut planes")
return 0
elif not ((len(CutPlnLst[0]) == 6+int(not AutoTrim))):
print("For each cutting plane you need to specify 6 parameters = 2 x 3 coordinates")
return 0
else:
return len(CutPlnLst)
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
"""
# 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])
OrigType = FindStandType(GeoSubObj,0)
if (OrigType >= 7): # Vertex
NonTrimDecision = abs(PlaneEq(geompy.PointCoordinates(GeoSubObj))) < tolerance
if len(CutPlnVar) == 6 : return NonTrimDecision # No trim condition used
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!
Verdict = True
for i in range(0,2):
Verdict = Verdict and IsOnPlane(geompy.GetVertexByIndex(GeoSubObj,i), CutPlnVar, tolerance)
return Verdict
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
NormalP1Coor = geompy.PointCoordinates(geompy.GetVertexByIndex(geompy.GetNormal(GeoSubObj),0))
NormalP2Coor = geompy.PointCoordinates(geompy.GetVertexByIndex(geompy.GetNormal(GeoSubObj),1))
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
if (abs(CrossP[0])<tolerance and abs(CrossP[1])<tolerance and abs(CrossP[2])<tolerance): # meaning zero cross product => parallel
return True
else :
return False
else :
return False
"""
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
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)
if (OrigType >= 7): # Vertex
NonTrimDecision = abs(PlaneEq(geompy.PointCoordinates(GeoSubObj))) < tolerance
if len(CutPlnVar) == 6 : return NonTrimDecision # No trim condition used
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!
Verdict = True
for i in range(0,2):
Verdict = Verdict and IsOnPlane(geompy.GetVertexByIndex(GeoSubObj,i), CutPlnVar, tolerance)
return Verdict
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
NormalP1Coor = geompy.PointCoordinates(geompy.GetVertexByIndex(geompy.GetNormal(GeoSubObj),0))
NormalP2Coor = geompy.PointCoordinates(geompy.GetVertexByIndex(geompy.GetNormal(GeoSubObj),1))
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
if (abs(CrossP[0])<tolerance and abs(CrossP[1])<tolerance and abs(CrossP[2])<tolerance): # meaning zero cross product => parallel
return True
else :
return False
else :
return False
def CrossProd(V1,V2):
"""
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]])
"""
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]])
def Distance2Pt(P1,P2):
"""
Returns the distance between two points
"""
return (math.sqrt((P1[0]-P2[0])**2+(P1[1]-P2[1])**2+(P1[2]-P2[2])**2))
"""
Returns the distance between two points
"""
return (math.sqrt((P1[0]-P2[0])**2+(P1[1]-P2[1])**2+(P1[2]-P2[2])**2))

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

@ -34,82 +34,82 @@ from MacObject import *
import Config, GenFunctions
def Cylinder (X0 , Y0 , D , DX , DY , LocalMeshing , **args) :
if args.__contains__('DLocal') : DLocal = float(args['DLocal'])
else : DLocal = float(min(DX,DY))
if args.__contains__('DLocal') : DLocal = float(args['DLocal'])
else : DLocal = float(min(DX,DY))
# K is the pitch ratio
K = float(D)/(DLocal-D)
print "A local pitch ratio of K =", K ," will be used. "
NumCuts = 2*GenFunctions.QuarCylParam(K)
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
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') :
GroupNames = args['groups']
else : GroupNames = [None, None, None, None, None]
# K is the pitch ratio
K = float(D)/(DLocal-D)
print "A local pitch ratio of K =", K ," will be used. "
NumCuts = 2*GenFunctions.QuarCylParam(K)
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
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') :
GroupNames = args['groups']
else : GroupNames = [None, None, None, None, None]
if DY == DLocal :
if DX == DLocal:
GN1 = [None,GroupNames[1],None,GroupNames[3],GroupNames[4]]
GN2 = [None,GroupNames[1],GroupNames[2],None,GroupNames[4]]
GN3 = [GroupNames[0],None,GroupNames[2],None,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]
if DY == DLocal :
if DX == DLocal:
GN1 = [None,GroupNames[1],None,GroupNames[3],GroupNames[4]]
GN2 = [None,GroupNames[1],GroupNames[2],None,GroupNames[4]]
GN3 = [GroupNames[0],None,GroupNames[2],None,GroupNames[4]]
GN4 = [GroupNames[0],None,None,GroupNames[3],GroupNames[4]]
else :
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]]
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 = [None,None,None,GroupNames[3]]
GN6 = [None,None,GroupNames[2],None]
GN5 = [GroupNames[0],GroupNames[1],None,GroupNames[3]]
GN6 = [GroupNames[0],GroupNames[1],GroupNames[2],None]
else :
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]]
GN9 = [GroupNames[0],None,None,GroupNames[3]]
GN10 = [GroupNames[0],None,None,None]
GN11 = [GroupNames[0],None,GroupNames[2],None]
GN5 = [None,None,None,GroupNames[3]]
GN6 = [None,None,GroupNames[2],None]
GN12 = [None,GroupNames[1],None,GroupNames[3]]
GN13 = [None,GroupNames[1],None,None]
GN14 = [None,GroupNames[1],GroupNames[2],None]
GN9 = [GroupNames[0],None,None,GroupNames[3]]
GN10 = [GroupNames[0],None,None,None]
GN11 = [GroupNames[0],None,GroupNames[2],None]
Obj = []
GN12 = [None,GroupNames[1],None,GroupNames[3]]
GN13 = [None,GroupNames[1],None,None]
GN14 = [None,GroupNames[1],GroupNames[2],None]
Obj.append(MacObject('QuartCyl',[(X0+DLocal/4.,Y0+DLocal/4.),(DLocal/2.,DLocal/2.)],[InternalMeshing,'NE',K], groups = GN1))
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))
Obj.append(MacObject('QuartCyl',[(X0+DLocal/4.,Y0-DLocal/4.),(DLocal/2.,DLocal/2.)],['auto','SE',K], groups = GN4))
Obj = []
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))
Obj.append(MacObject('QuartCyl',[(X0+DLocal/4.,Y0+DLocal/4.),(DLocal/2.,DLocal/2.)],[InternalMeshing,'NE',K], groups = GN1))
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))
Obj.append(MacObject('QuartCyl',[(X0+DLocal/4.,Y0-DLocal/4.),(DLocal/2.,DLocal/2.)],['auto','SE',K], groups = GN4))
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))
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))
return Obj
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

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

File diff suppressed because it is too large Load Diff

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

@ -20,281 +20,279 @@
class MacObject:
"""
This represents a python class definition which contains
all necessary information about the macro object being created
in Salome
"""
"""
This represents a python class definition which contains
all necessary information about the macro object being created
in Salome
"""
def __init__( self, ObjectType, GeoParameters, MeshParameters, **args ):
"""
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.
"""
import Config,GenFunctions
if Config.debug : print "Initializing object No. " + str(len(Config.ListObj)+1)
def __init__( self, ObjectType, GeoParameters, MeshParameters, **args ):
"""
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.
"""
import Config,GenFunctions
if Config.debug : print "Initializing object No. " + str(len(Config.ListObj)+1)
if 'publish' in args :
if args['publish']==0 : Config.publish = 0
else : Config.publish = 1
else : Config.publish = 1
if 'publish' in args :
if args['publish']==0 : Config.publish = 0
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 '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)]
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 ")
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) :
"""
This method generates the geometrical object with the corresponding mesh once all verifications (CheckInterfaces and AutoParam)
have been accomplished
"""
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]()
def Generate(self) :
"""
This method generates the geometrical object with the corresponding mesh once all verifications (CheckInterfaces and AutoParam)
have been accomplished
"""
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 Config.debug : Alarms.Message(self.status) # notification on the result of the generation algorithm
def CheckInterfaces(self):
"""
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.
Note that an object may have more than one neighbour for a given direction.
"""
import Alarms, Config
from GenFunctions import AddIfDifferent
from CompositeBox import FindCommonSide
def CheckInterfaces(self):
"""
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.
Note that an object may have more than one neighbour for a given direction.
"""
import Alarms, Config
from GenFunctions import AddIfDifferent
from CompositeBox import FindCommonSide
Config.Connections.append([(-1,),(-1,),(-1,),(-1,)])
itemID = len(Config.ListObj)
# In all cases except non ortho, PrincipleBoxes is unitary and contains the box in question
# In the non-ortho case it contains all possible combinations of boxes with 3 vertices
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
Config.Connections.append([(-1,),(-1,),(-1,),(-1,)])
itemID = len(Config.ListObj)
# In all cases except non ortho, PrincipleBoxes is unitary and contains the box in question
# In the non-ortho case it contains all possible combinations of boxes with 3 vertices
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
# 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) :
if max(ConnX,ConnY) == -1 and not('NonOrtho' in [self.Type,TestObj.Type]) : Alarms.Message(3)
else:
if ConnX == 1 and ConnY == -1:
if Config.Connections[i][1] == (-1,) : Config.Connections[i][1] = (itemID,)
else : Config.Connections[i][1] = AddIfDifferent(Config.Connections[i][1],itemID)
if Config.Connections[itemID][0] == (-1,) : Config.Connections[itemID][0] = (i,)
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)
if not (ConnX*ConnY == 0) :
if max(ConnX,ConnY) == -1 and not('NonOrtho' in [self.Type,TestObj.Type]) : Alarms.Message(3)
else:
if ConnX == 1 and ConnY == -1:
if Config.Connections[i][1] == (-1,) : Config.Connections[i][1] = (itemID,)
else : Config.Connections[i][1] = AddIfDifferent(Config.Connections[i][1],itemID)
if Config.Connections[itemID][0] == (-1,) : Config.Connections[itemID][0] = (i,)
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
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)
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 !!!")
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]])
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]
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)
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]
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.]
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
def GetBorder (self, Criterion):
import GenFunctions, Config
from salome.geom import geomBuilder
geompy = geomBuilder.New( Config.theStudy )
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)
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]()
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
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

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

@ -31,217 +31,216 @@ smesh = smeshBuilder.New( Config.theStudy )
##########################################################################################################
def PublishGroups ():
aFilterManager = smesh.CreateFilterManager()
aFilterManager = smesh.CreateFilterManager()
# Building geometric and mesh compounds and groups ##############################################
if Config.debug : print "Searching for geometric groups and publishing final compound"
# Building geometric and mesh compounds and groups ##############################################
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 = []
TempMESHList = []
TempNames = []
for MacroObj in Config.ListObj :
TempGEOList += MacroObj.GeoChildren
TempMESHList += MacroObj.Mesh
if group in MacroObj.GroupNames :
Occurences = IndexMultiOcc(MacroObj.GroupNames, group)
for Occ in Occurences :
TempGEOList += MacroObj.GetBorder(Occ)
GroupGEO.append(geompy.MakeCompound(TempGEOList))
geompy.addToStudyInFather(FinalCompound,GroupGEO[-1],'GR_'+group)
FinalCompound = geompy.MakeCompound(TempGEOList)
geompy.addToStudy (FinalCompound,Config.StudyName)
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)
#Criterion = smesh.Filter.Criterion(18,39,0,'GR_'+group,'GR_'+group,39,39,1e-06,smesh.EDGE,7)
MeshCompound.MakeGroupByCriterion(group,Criterion)
GroupGEO = []
for group in Config.Groups :
StudyBuilder = Config.theStudy.NewBuilder()
for MeshObj in TempMESHList:
SO = Config.theStudy.FindObjectIOR(Config.theStudy.ConvertObjectToIOR(MeshObj))
if SO is not None: StudyBuilder.RemoveObjectWithChildren(SO)
# Geometric groups definition
TempGEOList = []
TempNames = []
for MacroObj in Config.ListObj :
if group in MacroObj.GroupNames :
Occurences = IndexMultiOcc(MacroObj.GroupNames, group)
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
return MeshCompound
def IndexMultiOcc (Array,Element) :
"""
This function returns the occurrences indices of Element in Array.
As opposed to Array.index(Element) method, this allows determining
multiple entries rather than just the first one!
"""
Output = []
try : Array.index(Element)
except ValueError : print "No more occurrences"
else : Output.append(Array.index(Element))
"""
This function returns the occurrences indices of Element in Array.
As opposed to Array.index(Element) method, this allows determining
multiple entries rather than just the first one!
"""
Output = []
try : Array.index(Element)
except ValueError : print "No more occurrences"
else : Output.append(Array.index(Element))
if not(Output == [-1]) and len(Array) > 1 :
for index, ArrElem in enumerate(Array[Output[0]+1:]) :
if ArrElem is Element : Output.append(index+Output[0]+1)
if not(Output == [-1]) and len(Array) > 1 :
for index, ArrElem in enumerate(Array[Output[0]+1:]) :
if ArrElem is Element : Output.append(index+Output[0]+1)
return Output
return Output
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):
"""
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
corresponding to the symmetry lower and upper faces
Facultatif arguments are :
- Center [X,Y,Z], origin being the default
- Direction [VX,VY,VZ], x-axis being the default
- AngleDeg or AngleRad : ALPHA, 10 degrees being the default
- Scale : BETA, no scaling being default
"""
################################################################################
# Reading input arguments and proceeding to defaults if necessary
################################################################################
if 'Center' in args : CenterCoor = [float(Coor) for Coor in args['Center']]
else :
print "\nThe coordinates of the center of revolution were not given\nThe origin is used by default."
CenterCoor = [0.,0.,0.]
"""
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
corresponding to the symmetry lower and upper faces
Facultatif arguments are :
- Center [X,Y,Z], origin being the default
- Direction [VX,VY,VZ], x-axis being the default
- AngleDeg or AngleRad : ALPHA, 10 degrees being the default
- Scale : BETA, no scaling being default
"""
################################################################################
# Reading input arguments and proceeding to defaults if necessary
################################################################################
if 'Center' in args : CenterCoor = [float(Coor) for Coor in args['Center']]
else :
print "\nThe coordinates of the center of revolution were not given\nThe origin is used by default."
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 '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 '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.
if 'Scale' in args : Scale = float(args['Scale'])
else : Scale = 1.
# Creating the lower face group LOFAC
LOFAC = MainMesh.CreateEmptyGroup( SMESH.FACE, 'LOFAC' )
LOFAC.AddFrom(MainMesh.GetMesh())
# Creating the lower face group LOFAC
LOFAC = MainMesh.CreateEmptyGroup( SMESH.FACE, 'LOFAC' )
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)
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')
# 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])
# 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())
# 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' )
#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 )
# 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):
"""
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
corresponding to the symmetry lower and upper faces
Facultatif arguments are :
- Direction [VX,VY,VZ], z-axis being default
- Distance : D, default is 1
- NSteps : the object will be extruded by NSteps*Distance, default is Nsteps = 1
- Scale : BETA, no scaling being default
"""
################################################################################
# Reading input arguments and proceeding to defaults if necessary
################################################################################
if 'Distance' in args : Distance = float(args['Distance'])
else :
print "\nThe extrusion distance was not given\nA default value of 1 is used."
Distance = 1.
"""
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
corresponding to the symmetry lower and upper faces
Facultatif arguments are :
- Direction [VX,VY,VZ], z-axis being default
- Distance : D, default is 1
- NSteps : the object will be extruded by NSteps*Distance, default is Nsteps = 1
- Scale : BETA, no scaling being default
"""
################################################################################
# Reading input arguments and proceeding to defaults if necessary
################################################################################
if 'Distance' in args : Distance = float(args['Distance'])
else :
print "\nThe extrusion distance was not given\nA default value of 1 is used."
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 '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 'Scale' in args : Scale = float(args['Scale'])
else : Scale = 1.
if 'NSteps' in args : NSteps = int(args['NSteps'])
else : NSteps = 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())
# Creating the lower face group LOFAC
LOFAC = MainMesh.CreateEmptyGroup( SMESH.FACE, 'LOFAC' )
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)
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')
# 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')
# 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())
# 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' )
#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 )
# 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):
"""
This function returns a normalized vector (magnitude = Norm), parallel to the entered one
"""
V = [float(Coor) for Coor in V]
Norm = float(Norm)
MagV = math.sqrt(V[0]*V[0]+V[1]*V[1]+V[2]*V[2])
return [Coor*Norm/MagV for Coor in V]
"""
This function returns a normalized vector (magnitude = Norm), parallel to the entered one
"""
V = [float(Coor) for Coor in V]
Norm = float(Norm)
MagV = math.sqrt(V[0]*V[0]+V[1]*V[1]+V[2]*V[2])
return [Coor*Norm/MagV for Coor in V]

352
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
# 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
# ------- ---------
# ----> | | <----
# | NW NE | oo
# _____| |_____
# | | 8 6
# ------- ---------
# ----> | | <----
# | NW NE | oo
# _____| |_____
import sys, math, commands
CWD = commands.getoutput('pwd')
@ -36,212 +36,212 @@ from CompositeBox import *
import Config, GenFunctions
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))
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"
BoxSide = DLocal/(2.**(NLevels+1))
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', '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'],
'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]()
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'],
'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]()
CoefVer = {'NE' : lambda : 1,
'NW' : lambda : 1,
'SE' : lambda : -1,
'SW' : lambda : -1, }[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]()
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]()
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, None, None]
if args.__contains__('groups') :
GroupNames = args['groups']
else : GroupNames = [None, None, None, None, None, None]
GN00 = GroupArray(ToLook[0],GroupNames[0])
GN01 = GroupArray(ToLook[1],GroupNames[1])
GN00 = GroupArray(ToLook[0],GroupNames[0])
GN01 = GroupArray(ToLook[1],GroupNames[1])
GN1 = GroupArray([ToLook[0],ToLook[1]],[GroupNames[0],GroupNames[5]])
GN7 = GroupArray([ToLook[0],ToLook[1]],[GroupNames[4],GroupNames[1]])
GN1 = GroupArray([ToLook[0],ToLook[1]],[GroupNames[0],GroupNames[5]])
GN7 = GroupArray([ToLook[0],ToLook[1]],[GroupNames[4],GroupNames[1]])
if DY == DLocal :
GN2 = GroupArray([ToLook[1],ToLook[2]],[GroupNames[5],GroupNames[2]])
GN3 = GroupArray(ToLook[2],GroupNames[2])
if DX == DLocal:
GN4 = GroupArray([ToLook[2],ToLook[3]],[GroupNames[2],GroupNames[3]])
GN5 = GroupArray(ToLook[3],GroupNames[3])
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]])
if DY == DLocal :
GN2 = GroupArray([ToLook[1],ToLook[2]],[GroupNames[5],GroupNames[2]])
GN3 = GroupArray(ToLook[2],GroupNames[2])
if DX == DLocal:
GN4 = GroupArray([ToLook[2],ToLook[3]],[GroupNames[2],GroupNames[3]])
GN5 = GroupArray(ToLook[3],GroupNames[3])
GN6 = GroupArray([ToLook[3],ToLook[0]],[GroupNames[3],GroupNames[4]])
else :
GN2 = GroupArray(ToLook[1],GroupNames[5])
GN3 = [None,None,None,None]
if DX == DLocal:
GN4 = GroupArray(ToLook[3],GroupNames[3])
GN5 = GroupArray(ToLook[3],GroupNames[3])
GN6 = GroupArray([ToLook[3],ToLook[0]],[GroupNames[3],GroupNames[4]])
GN22 = GroupArray([ToLook[1],ToLook[2],ToLook[3]],[GroupNames[5],GroupNames[2],GroupNames[3]])
else :
GN4 = [None,None,None,None]
GN5 = [None,None,None,None]
GN6 = GroupArray(ToLook[0],GroupNames[4])
GN21 = GroupArray([ToLook[3],ToLook[0]],[GroupNames[3],GroupNames[4]])
GN22 = GroupArray([ToLook[1],ToLook[2]],[GroupNames[5],GroupNames[2]])
GN23 = GroupArray([ToLook[2],ToLook[3]],[GroupNames[2],GroupNames[3]])
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 :
GN2 = GroupArray(ToLook[1],GroupNames[5])
GN3 = [None,None,None,None]
if DX == DLocal:
GN4 = GroupArray(ToLook[3],GroupNames[3])
GN5 = GroupArray(ToLook[3],GroupNames[3])
GN6 = GroupArray([ToLook[3],ToLook[0]],[GroupNames[3],GroupNames[4]])
GN22 = GroupArray([ToLook[1],ToLook[2],ToLook[3]],[GroupNames[5],GroupNames[2],GroupNames[3]])
else :
GN4 = [None,None,None,None]
GN5 = [None,None,None,None]
GN6 = GroupArray(ToLook[0],GroupNames[4])
GN21 = GroupArray([ToLook[3],ToLook[0]],[GroupNames[3],GroupNames[4]])
GN22 = GroupArray([ToLook[1],ToLook[2]],[GroupNames[5],GroupNames[2]])
GN23 = GroupArray([ToLook[2],ToLook[3]],[GroupNames[2],GroupNames[3]])
Obj = []
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])))
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))
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)
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))
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))
Obj.append(MacObject('CompBoxF',[(X0,Y0+CoefVer*(DY)/2.),(DLocal,dY)],['auto'], groups = GN22))
return Obj
return Obj
def SharpAngleIn (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))
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..."
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]()
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]()
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]()
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]()
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]
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]])
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]])
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 :
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]]])
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 = []
Obj.append(MacObject('BoxAng32',[(X0+CoefHor*BoxSide/2,Y0+CoefVer*BoxSide/2),(BoxSide,BoxSide)],[InternalMeshing,DirPar[0]],groups = GN01))
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))
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)
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 :
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)
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)
Obj = Obj + CompositeBox(X0+CoefHor*DLocal/2,Y0+CoefVer*(DLocal+dY/2.),DLocal,dY,groups = GN10)
return Obj
return Obj
def GroupArray(indices, GroupNames) :
if type(indices) is int :
indices = [indices]
GroupNames = [GroupNames]
Output = [None,None,None,None]
for i, ind in enumerate(indices) :
Output[ind] = GroupNames[i]
return Output
if type(indices) is int :
indices = [indices]
GroupNames = [GroupNames]
Output = [None,None,None,None]
for i, ind in enumerate(indices) :
Output[ind] = GroupNames[i]
return Output

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

@ -8,24 +8,23 @@ from dataBase import Base
if __name__ == "__main__":
from optparse import 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('-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')
options, args = p.parse_args()
if len(args) != 1 :
print "entrer SVP le nom de la directory ou sont rangees les fichiers a charger"
exit()
folder=args[0]
from optparse import 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('-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')
options, args = p.parse_args()
if len(args) != 1 :
print "entrer SVP le nom de la directory ou sont rangees les fichiers a charger"
exit()
folder=args[0]
if not(os.path.isdir(folder)):
print folder , " n existe pas"
exit()
maBase=Base(options.database)
maBase.create()
maBase.initialise()
maBase.importFromCSV(folder,options.partiel,options.force)
maBase.close()
if not(os.path.isdir(folder)):
print folder , " n existe pas"
exit()
maBase=Base(options.database)
maBase.create()
maBase.initialise()
maBase.importFromCSV(folder,options.partiel,options.force)
maBase.close()

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

@ -2,114 +2,112 @@ from qtsalome import QSqlQuery
import datetime
class TableDeBase :
def __init__(self,nom):
self.nom=nom
def __init__(self,nom):
self.nom=nom
def setField(self,FieldStringList):
self.FieldStringList=FieldStringList
self.idName=FieldStringList[0]
def setField(self,FieldStringList):
self.FieldStringList=FieldStringList
self.idName=FieldStringList[0]
def setTypeField(self,FieldTypeListe,clef):
self.FieldTypeListe = FieldTypeListe
self.clef=clef
def setTypeField(self,FieldTypeListe,clef):
self.FieldTypeListe = FieldTypeListe
self.clef=clef
def getFields(self):
return self.FieldStringList
def getFields(self):
return self.FieldStringList
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 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):
texteQuery='insert into ' + self.nom + self.cols+ " 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 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
texteQuery= "select * from " + self.nom + " where "+ self.idName+'='+str(valeur) +';'
maQuery=QSqlQuery()
maQuery.exec_(texteQuery)
nb=0
while(maQuery.next()): nb=nb+1
return nb
texteQuery= "select * from " + self.nom + " where "+ self.idName+'='+str(valeur) +';'
maQuery=QSqlQuery()
maQuery.exec_(texteQuery)
nb=0
while(maQuery.next()): nb=nb+1
return nb
def remplit(self):
print "Pas de remplissage sauf si cette methode est surchargee"
def remplit(self):
print "Pas de remplissage sauf si cette methode est surchargee"
def createSqlTable(self):
print "Pas de creation par defaut : cette methode doit etre surchargee"
def createSqlTable(self):
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
def exportToCSV(self):
aujourdhui=datetime.date.today()
monFolder="ExportDB"+str(aujourdhui)
monFichier=monFolder+"/Sauve_"+str(self.nom)+'.csv'
texteQuery= "select * from " + self.nom +';'
texteSauve=""
for col in self.FieldStringList:
texteSauve+=col+";"
texteSauve=texteSauve[0:-1] # on enleve le dernier ";"
texteSauve+="\n"
def exportToCSV(self):
aujourdhui=datetime.date.today()
monFolder="ExportDB"+str(aujourdhui)
monFichier=monFolder+"/Sauve_"+str(self.nom)+'.csv'
texteQuery= "select * from " + self.nom +';'
texteSauve=""
for col in self.FieldStringList:
texteSauve+=col+";"
texteSauve=texteSauve[0:-1] # on enleve le dernier ";"
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"
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
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))
if asauver == 0 :
print "pas de sauvegarde de : " , self.nom , " table vide"
return
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))

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

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

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

@ -3,29 +3,28 @@ from tableDeBase import TableDeBase
import os
class TableMachines (TableDeBase):
def __init__(self):
TableDeBase.__init__(self,"Machines")
self.setField(("nomMachine","Os"))
self.setTypeField(('str','str'),('nomMachine'))
def __init__(self):
TableDeBase.__init__(self,"Machines")
self.setField(("nomMachine","Os"))
self.setTypeField(('str','str'),('nomMachine'))
def createSqlTable(self):
query=QSqlQuery()
print "creation de TableMachine : ", query.exec_("create table Machines( nomMachine varchar(10) primary key, os varchar(10));")
def createSqlTable(self):
query=QSqlQuery()
print "creation de TableMachine : ", query.exec_("create table Machines( nomMachine varchar(10) primary key, os varchar(10));")
def creeMachine(self):
nomMachine=os.uname()[1]
nomOs=os.uname()[2]
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 creeMachine(self):
nomMachine=os.uname()[1]
nomOs=os.uname()[2]
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

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

@ -2,99 +2,99 @@ from qtsalome import QSqlQuery
from tableDeBase import TableDeBase
class TableMaillages (TableDeBase):
def __init__(self):
TableDeBase.__init__(self,"Maillages")
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.setTypeField(('int','str','str','str','int','int','int','int','int','int','str'),('id'))
def __init__(self):
TableDeBase.__init__(self,"Maillages")
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.setTypeField(('int','str','str','str','int','int','int','int','int','int','str'),('id'))
def createSqlTable(self):
query=QSqlQuery()
texteQuery ="create table Maillages(id integer primary key autoincrement, nomMaillage varchar(10), "
texteQuery+="nomScript varchar(40), medResultat varchar(15), idMailleur int, dimension int,"
texteQuery+="seuilCPU int, seuilRatio int, seuilTaille int, seuilNbMaille int, commentaire varchar(60), "
texteQuery+="foreign key (idMailleur) references Mailleur(id));"
print "creation de TableMaillages : " , query.exec_(texteQuery)
def createSqlTable(self):
query=QSqlQuery()
texteQuery ="create table Maillages(id integer primary key autoincrement, nomMaillage varchar(10), "
texteQuery+="nomScript varchar(40), medResultat varchar(15), idMailleur int, dimension int,"
texteQuery+="seuilCPU int, seuilRatio int, seuilTaille int, seuilNbMaille int, commentaire varchar(60), "
texteQuery+="foreign key (idMailleur) references Mailleur(id));"
print "creation de TableMaillages : " , query.exec_(texteQuery)
def getVal(self,idMaillage, nomChamp):
query=QSqlQuery()
valeur=None
texteQuery ='select '+ nomChamp + ' from Maillages where id=' + str(idMaillage) + ";"
query.exec_(texteQuery)
while (query.next()) :
valeur=query.value(0).toInt()[0]
while (query.next()) :
print "plusieurs enregistrements dans Maillages pour ",str(idMaillage)
exit()
return valeur
def getVal(self,idMaillage, nomChamp):
query=QSqlQuery()
valeur=None
texteQuery ='select '+ nomChamp + ' from Maillages where id=' + str(idMaillage) + ";"
query.exec_(texteQuery)
while (query.next()) :
valeur=query.value(0).toInt()[0]
while (query.next()) :
print "plusieurs enregistrements dans Maillages pour ",str(idMaillage)
exit()
return valeur
def dejaRemplie(self):
texteQuery="select * from Maillages where medResultat='/tmp/tetra.med';"
maQuery=QSqlQuery()
maQuery.exec_(texteQuery)
nb=0
while(maQuery.next()): nb=nb+1
return nb
def dejaRemplie(self):
texteQuery="select * from Maillages where medResultat='/tmp/tetra.med';"
maQuery=QSqlQuery()
maQuery.exec_(texteQuery)
nb=0
while(maQuery.next()): nb=nb+1
return nb
def remplit(self):
if self.dejaRemplie():
print "table Maillage deja initialisee"
return
def remplit(self):
if self.dejaRemplie():
print "table Maillage deja initialisee"
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_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):
maQuery=QSqlQuery()
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 construitListeMaillages(self):
maQuery=QSqlQuery()
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)
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):
texteQuery="select id,nomMaillage,seuilCPU,seuilRatio,seuilTaille,seuilNbMaille from Maillages where id = "+ str(idMaillage) +" ;"
maQuery=QSqlQuery()
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)
maSize=0
while(maQuery.next()):
l1 = maQuery.value(0).toInt()[0]
l2 = maQuery.value(1).toString()
l3 = maQuery.value(2).toInt()[0]
l4 = maQuery.value(3).toInt()[0]
l5 = maQuery.value(4).toInt()[0]
l6 = maQuery.value(5).toInt()[0]
return l1,l2,l3,l4,l5,l6
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 getTous(self):
maillagesIdListe=[]; maillagesNomListe=[]
texteQuery="select id,nomMaillage from Maillages order by id;"
maQuery=QSqlQuery()
maQuery.exec_(texteQuery)
while(maQuery.next()):
maillagesIdListe.append( maQuery.value(0).toInt()[0])
maillagesNomListe.append( maQuery.value(1).toString())
return maillagesIdListe, maillagesNomListe
def getSeuilsPourMaillage(self,idMaillage):
texteQuery="select id,nomMaillage,seuilCPU,seuilRatio,seuilTaille,seuilNbMaille from Maillages where id = "+ str(idMaillage) +" ;"
maQuery=QSqlQuery()
maQuery.exec_(texteQuery)
while(maQuery.next()):
l1 = maQuery.value(0).toInt()[0]
l2 = maQuery.value(1).toString()
l3 = maQuery.value(2).toInt()[0]
l4 = maQuery.value(3).toInt()[0]
l5 = maQuery.value(4).toInt()[0]
l6 = maQuery.value(5).toInt()[0]
return l1,l2,l3,l4,l5,l6
def getMailleurId(self,idMaillage):
texteQuery="select idMailleur from Maillages where id = "+ str(idMaillage) +" ;"
maQuery=QSqlQuery()
print texteQuery
print maQuery.exec_(texteQuery)
maQuery.exec_(texteQuery)
while(maQuery.next()):
idMailleur = maQuery.value(0).toInt()[0]
return idMailleur
def getTous(self):
maillagesIdListe=[]; maillagesNomListe=[]
texteQuery="select id,nomMaillage from Maillages order by id;"
maQuery=QSqlQuery()
maQuery.exec_(texteQuery)
while(maQuery.next()):
maillagesIdListe.append( maQuery.value(0).toInt()[0])
maillagesNomListe.append( maQuery.value(1).toString())
return maillagesIdListe, maillagesNomListe
def getMailleurId(self,idMaillage):
texteQuery="select idMailleur from Maillages where id = "+ str(idMaillage) +" ;"
maQuery=QSqlQuery()
print texteQuery
print maQuery.exec_(texteQuery)
maQuery.exec_(texteQuery)
while(maQuery.next()):
idMailleur = maQuery.value(0).toInt()[0]
return idMailleur

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

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

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

@ -2,43 +2,40 @@ from qtsalome import QSqlQuery
from tableDeBase import TableDeBase
class TableVersions (TableDeBase):
def __init__(self):
TableDeBase.__init__(self,"Versions")
self.setField(("id","nomVersion","commentaire"))
self.setTypeField(('int','str','str'),('id',))
self.cols=" (nomVersion, commentaire) "
def __init__(self):
TableDeBase.__init__(self,"Versions")
self.setField(("id","nomVersion","commentaire"))
self.setTypeField(('int','str','str'),('id',))
self.cols=" (nomVersion, commentaire) "
def createSqlTable(self):
query=QSqlQuery()
texteQuery ="create table Versions(id integer primary key autoincrement, nomVersion varchar(10),"
texteQuery+="commentaire varchar(30));"
print "Creation de TableVersions : " , query.exec_(texteQuery)
def createSqlTable(self):
query=QSqlQuery()
texteQuery ="create table Versions(id integer primary key autoincrement, nomVersion varchar(10),"
texteQuery+="commentaire varchar(30));"
print "Creation de TableVersions : " , query.exec_(texteQuery)
def remplit(self):
self.insereLigneAutoId(('Salome7.2.0',''))
self.insereLigneAutoId(('Salome7.3.0',''))
self.insereLigneAutoId(('Salome7.4.0',''))
def creeVersion(self,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 remplit(self):
self.insereLigneAutoId(('Salome7.2.0',''))
self.insereLigneAutoId(('Salome7.3.0',''))
self.insereLigneAutoId(('Salome7.4.0',''))
def creeVersion(self,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

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

@ -8,25 +8,24 @@ from Base.versions import Chercheversion
if __name__ == "__main__":
from optparse import OptionParser
p=OptionParser()
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('-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('-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()
if len(args) == 0 and options.all== False:
print "Enter -a ou un numero de job"
print 2
exit()
if options.salomePath==None :
print "chemin du runAppli obligatoire"
exit()
if options.version==None :
options.version=Chercheversion(options.salomePath)
maBase=Base(options.database)
maBase.initialise()
maBase.passeJobs(options.all,options.salomePath,options.version,options.force,args)
maBase.close()
from optparse import OptionParser
p=OptionParser()
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('-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('-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()
if len(args) == 0 and options.all== False:
print "Enter -a ou un numero de job"
print 2
exit()
if options.salomePath==None :
print "chemin du runAppli obligatoire"
exit()
if options.version==None :
options.version=Chercheversion(options.salomePath)
maBase=Base(options.database)
maBase.initialise()
maBase.passeJobs(options.all,options.salomePath,options.version,options.force,args)
maBase.close()

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

@ -35,8 +35,8 @@ verbose = True
force = os.getenv("FORCE_DISTENE_LICENSE_FILE")
if force != None:
os.environ["DISTENE_LICENSE_FILE"] = force
os.environ["DLIM8VAR"] = "NOTHING"
os.environ["DISTENE_LICENSE_FILE"] = force
os.environ["DLIM8VAR"] = "NOTHING"
class MonViewText(Ui_ViewExe, QDialog):
"""
@ -76,7 +76,7 @@ class MonViewText(Ui_ViewExe, QDialog):
nomFichier = os.path.splitext(self.parent().fichierOut)[0] + ext
with open(nomFichier, 'w') as f:
f.write(cmds)
f.write(cmds)
self.make_executable(nomFichier)
if verbose: print("INFO: MGSurfOpt launch script file: %s" % nomFichier)
@ -98,12 +98,12 @@ class MonViewText(Ui_ViewExe, QDialog):
if fn.isNull() : return
ulfile = os.path.abspath(unicode(fn))
try:
f = open(fn, 'wb')
f.write(str(self.TB_Exe.toPlainText()))
f.close()
f = open(fn, 'wb')
f.write(str(self.TB_Exe.toPlainText()))
f.close()
except IOError, why:
QMessageBox.critical(self, 'Save File',
'The file <b>%1</b> could not be saved.<br>Reason: %2'%(unicode(fn), str(why)))
QMessageBox.critical(self, 'Save File',
'The file <b>%1</b> could not be saved.<br>Reason: %2'%(unicode(fn), str(why)))
def readFromStdErr(self):
a=self.monExe.readAllStandardError()
@ -119,7 +119,7 @@ class MonViewText(Ui_ViewExe, QDialog):
self.enregistreResultatsDone=True
def theClose(self):
if not self.enregistreResultatsDone:
self.parent().enregistreResultat()
self.enregistreResultatsDone=True
self.close()
if not self.enregistreResultatsDone:
self.parent().enregistreResultat()
self.enregistreResultatsDone=True
self.close()

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

@ -86,7 +86,7 @@ class PluginDialog(QDialog):
self.__ui.btnClear.setIcon(icon)
# 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.btnRefresh.clicked.connect( self.onRefresh )
self.__ui.btnPublish.clicked.connect( self.onPublish )
@ -139,7 +139,7 @@ class PluginDialog(QDialog):
self.__inputDialog.windowFlags() | Qt.WindowStaysOnTopHint)
# The signal inputValidated emitted from inputDialog is
# connected to the slot function onProcessInput:
self.__inputDialog.inputValidated.connect( self.onProcessInput )
self.__inputDialog.inputValidated.connect( self.onProcessInput )
else:
self.__ui.frameInput.setVisible(True)
@ -401,6 +401,3 @@ def TEST_PluginDialog():
if __name__ == "__main__":
TEST_PluginDialog()