def optimizeOverlap(t, double_wall=0, priorities=[], graph=None,
intersectionsDict=None):
if graph is None:
tb = Cmpi.createBBoxTree(t)
graph = Cmpi.computeGraph(tb, type='bbox2',
intersectionsDict=intersectionsDict)
tl = Cmpi.addXZones(t, graph)
tl = Cmpi.convert2PartialTree(tl)
# print info
zones = Internal.getZones(tl)
#print 'Rank %d has %d zones.'%(Cmpi.rank, len(zones))
tl = X.optimizeOverlap(tl, double_wall, priorities, intersectionsDict)
tl = Cmpi.rmXZones(tl)
return tl
def _setInterpTransfers(aR, aD, variables=[],
variablesIBC=['Density','MomentumX','MomentumY','MomentumZ','EnergyStagnationDensity'],
bcType=0, varType=1, compact=0, graph=None,
procDict=None, type='ALLD',
Gamma=1.4, Cv=1.7857142857142865, MuS=1.e-08,
Cs=0.3831337844872463, Ts=1.0):
if (procDict is None): procDict = Cmpi.getProcDict(aD)
if (graph is None): graph = Cmpi.computeGraph(aD, type=type)
# Transferts locaux/globaux
# Calcul des solutions interpolees par arbre donneur
# On envoie aussi les indices receveurs pour l'instant
datas = {}
zonesD = Internal.getZones(aD)
for zD in zonesD:
infos = X.setInterpTransfersD(zD, variables, variablesIBC, bcType, varType, compact, Gamma, Cv, MuS, Cs, Ts)
for n in infos:
rcvName = n[0]
proc = procDict[rcvName]
if (proc == Cmpi.rank):
field = n[1]
#print 'direct', Cmpi.rank, rcvName
if field != []:
listIndices = n[2]
z = Internal.getNodesFromName2(aR, rcvName)[0]
C._setPartialFields(z, [field], [listIndices], loc=n[3])
else:
rcvNode = procDict[rcvName]
#print Cmpi.rank, 'envoie a ',rcvNode
if not datas.has_key(rcvNode): datas[rcvNode] = [n]
else: datas[rcvNode] += [n]
#print datas
# Envoie des numpys suivant le graph
rcvDatas = Cmpi.sendRecv(datas, graph)
# Remise des champs interpoles dans l'arbre receveur
for i in rcvDatas.keys():
#print Cmpi.rank, 'recoit de',i, '->', len(rcvDatas[i])
for n in rcvDatas[i]:
rcvName = n[0]
#print 'reception', Cmpi.rank, rcvName
field = n[1]
if field != []:
listIndices = n[2]
z = Internal.getNodesFromName2(aR, rcvName)[0]
C._setPartialFields(z, [field], [listIndices], loc=n[3])
return None
def computeBBoxes__(arrays, zoneNames):
bboxes = []
c = 0
for a in arrays:
try:
bb = G.bbox(a)
bb = bb + [zoneNames[c], True]
except:
bb = [0, 0, 0, 1, 1, 1, zoneNames[c], False]
bboxes.append(bb)
c += 1
# Parallel eventuel
try:
import Converter.Mpi as Cmpi
allboxes = Cmpi.allgather(bboxes)
c = 0
for bb in bboxes:
if (bb[7] == False):
for j in allboxes:
for k in j:
if (k[6] == bb[6] and k[7] == True):
bboxes[c] = k
c += 1
except:
pass
return bboxes
def redispatch(t, graph=None):
if graph is None:
graph = Cmpi.computeGraph(t, type='proc')
procs = D2.getProcDict(t)
t = Cmpi.addXZones(t, graph)
# Enleve les zones envoyees
zones = Internal.getZones(t)
for z in zones:
tag = Internal.getNodesFromName1(z, 'XZone')
if len(tag) == 0:
if procs[z[0]] != Cmpi.rank:
(p, c) = Internal.getParentOfNode(t, z)
del p[2][c]
else: # enleve le noeud tag XZone
(p, c) = Internal.getParentOfNode(z, tag[0])
del p[2][c]
return t
def extractMesh(t,
extractionMesh,
order=2,
extrapOrder=1,
constraint=40.,
tol=1.e-6,
mode='robust',
hook=None,
graph=None):
if graph is None:
tb = Cmpi.createBBoxTree(t)
tb2 = Cmpi.createBBoxTree(extractionMesh)
graph = Cmpi.computeGraph(tb, type='bbox3', t2=tb2)
tl = Cmpi.addXZones(t, graph)
tl = Cmpi.convert2PartialTree(tl)
ext = Cmpi.convert2PartialTree(extractionMesh)
# print info
zones = Internal.getZones(tl)
print('Rank %d has %d source zones.' % (Cmpi.rank, len(zones)))
ext = P.extractMesh(tl,
ext,
order=order,
extrapOrder=extrapOrder,
constraint=constraint,
tol=tol,
mode=mode,
hook=hook)
return ext
def __setInterpTransfers(zones, zonesD, vars, param_int, param_real, type_transfert,
bcType=0, varType=1, compact=1, graph=None,
procDict=None,
Gamma=1.4, Cv=1.7857142857142865, MuS=1.e-08, Cs=0.3831337844872463, Ts=1.0):
# Transferts locaux/globaux
# Calcul des solutions interpolees par arbre donneur
# On envoie aussi les indices receveurs pour l'instant
datas = {}
for comm_P2P in xrange(1,param_int[0]+1):
pt_ech = param_int[comm_P2P]
dest = param_int[pt_ech]
no_transfert = comm_P2P
if (dest == Cmpi.rank): #transfert intra_processus
# print 'transfert local', no_transfert
connector.___setInterpTransfers(zones, zonesD, vars, param_int, param_real, varType, bcType,
type_transfert, no_transfert, Gamma,Cv,MuS,Cs,Ts)
else:
# print 'transfert global'
infos = connector.__setInterpTransfersD(zones, zonesD, vars, param_int, param_real, varType, bcType,
type_transfert, no_transfert,Gamma,Cv,MuS,Cs,Ts)
for n in infos:
rcvNode = dest
#print Cmpi.rank, 'envoie a ',rcvNode, ' le paquet : ', n
if not datas.has_key(rcvNode): datas[rcvNode] = [n]
else: datas[rcvNode] += [n]
#print datas
# Envoie des numpys suivant le graph
rcvDatas = Cmpi.sendRecv(datas, graph)
# Remise des champs interpoles dans l'arbre receveur
for i in rcvDatas.keys():
#if Cmpi.rank==0 : print Cmpi.rank, 'recoit de',i, '->', len(rcvDatas[i])
for n in rcvDatas[i]:
rcvName = n[0]
#if Cmpi.rank==0 :print 'reception', Cmpi.rank, 'no zone', zones[ rcvName ][0]
field = n[1]
if field != []:
listIndices = n[2]
z = zones[rcvName]
C._setPartialFields(z, [field], [listIndices], loc='centers')
return None
# - getProcDict (pyTree) -
import Converter.PyTree as C
import Converter.Mpi as Cmpi
import Distributor2.PyTree as Distributor2
import Generator.PyTree as G
import KCore.test as test
LOCAL = test.getLocal()
# Cree le fichier test
if Cmpi.rank == 0:
a = G.cart((0, 0, 0), (1, 1, 1), (10, 10, 10))
b = G.cart((12, 0, 0), (1, 1, 1), (10, 10, 10))
t = C.newPyTree(['Base', a, b])
C.convertPyTree2File(t, LOCAL + '/in.cgns')
Cmpi.barrier()
# Relit des zones par procs
t = Cmpi.convertFile2SkeletonTree(LOCAL + '/in.cgns')
(t, dic) = Distributor2.distribute(t, NProc=2, algorithm='fast')
# Squelette
d = Cmpi.getProcDict(t)
if Cmpi.rank == 0: test.testO(d, 1)
t = Cmpi.readZones(t, LOCAL + '/in.cgns', rank=Cmpi.rank)
# Squelette charge
d = Cmpi.getProcDict(t)
if Cmpi.rank == 0: test.testO(d, 2)
t = Cmpi.convert2PartialTree(t)
# - readZones (pyTree) -
import Converter.PyTree as C
import Converter.Mpi as Cmpi
import Distributor2.PyTree as Distributor2
import Generator.PyTree as G
# Cree le fichier test
if Cmpi.rank == 0:
a = G.cart((0,0,0), (1,1,1), (10,10,10))
b = G.cart((12,0,0), (1,1,1), (10,10,10))
t = C.newPyTree(['Base',a,b])
C.convertPyTree2File(t, 'test.cgns')
Cmpi.barrier()
# Relit les zones par paths
t = Cmpi.convertFile2SkeletonTree('test.cgns')
Cmpi._readZones(t, 'test.cgns', zoneNames=['Base/cart'])
# Relit des zones par procs
t = Cmpi.convertFile2SkeletonTree('test.cgns')
(t, dic) = Distributor2.distribute(t, NProc=Cmpi.size, algorithm='fast')
t = Cmpi.readZones(t, 'test.cgns', rank=Cmpi.rank)
if Cmpi.rank == 0: C.convertPyTree2File(t, 'out.cgns')
# - convert2SkeletonTree (pyTree) - import Converter.PyTree as C import Converter.Mpi as Cmpi import Generator.PyTree as G import KCore.test as test a = G.cart((0, 0, 0), (1, 1, 1), (10, 10, 10)) a = Cmpi.convert2SkeletonTree(a) test.testT(a, 1)
# - Calcul de distance a la paroi en distribue -
import Converter.PyTree as C
import Distributor2.PyTree as Distributor2
import Converter.Mpi as Cmpi
import Transform.PyTree as T
import Dist2Walls.PyTree as Dist2Walls
rank = Cmpi.rank
size = Cmpi.size
# lecture des parois
bodies = C.convertFile2PyTree('walls.cgns')
# lecture du squelette
a = Cmpi.convertFile2SkeletonTree('in.cgns')
# equilibrage
(a, dic) = Distributor2.distribute(a, NProc=size, algorithm='fast', useCom=0)
# load des zones locales dans le squelette
a = Cmpi.readZones(a, 'in.cgns', proc=rank)
# Passage en arbre partiel
a = Cmpi.convert2PartialTree(a)
# Calcul des distances a la paroi
a = Dist2Walls.distance2Walls(a, bodies, type='mininterf')
# Reconstruit l'arbre complet a l'ecriture
Cmpi.convertPyTree2File(a, 'out.cgns')
# - createBBoxTree (pyTree) -
import Converter.PyTree as C
import Converter.Mpi as Cmpi
import Distributor2.PyTree as Distributor2
import Generator.PyTree as G
import KCore.test as test
LOCAL = test.getLocal()
# Cree le fichier test
if Cmpi.rank == 0:
a = G.cart((0,0,0), (1,1,1), (10,10,10))
b = G.cart((12,0,0), (1,1,1), (10,10,10))
t = C.newPyTree(['Base',a,b])
C.convertPyTree2File(t, LOCAL+'/in.cgns')
Cmpi.barrier()
# Relit des zones par procs
t = Cmpi.convertFile2SkeletonTree(LOCAL+'/in.cgns')
(t, dic) = Distributor2.distribute(t, NProc=Cmpi.size, algorithm='fast')
t = Cmpi.readZones(t, LOCAL+'/in.cgns', rank=Cmpi.rank)
# Cree le bbox tree a partir du squelette charge
tb = Cmpi.createBBoxTree(t)
if Cmpi.rank == 0: test.testT(tb, 1)
# Cree le bbox a partir d'un arbre partiel
t = Cmpi.convert2PartialTree(t)
tb = Cmpi.createBBoxTree(t)
if Cmpi.rank == 0: test.testT(tb, 2)
# - convert2PartialTree (pyTree) -
import Converter.PyTree as C
import Converter.Mpi as Cmpi
import Distributor2.PyTree as Distributor2
import Generator.PyTree as G
# Cree le fichier test
if Cmpi.rank == 0:
a = G.cart((0,0,0), (1,1,1), (10,10,10))
b = G.cart((12,0,0), (1,1,1), (10,10,10))
t = C.newPyTree(['Base',a,b])
C.convertPyTree2File(t, 'test.cgns')
Cmpi.barrier()
# Relit des zones par procs
t = Cmpi.convertFile2SkeletonTree('test.cgns')
(t, dic) = Distributor2.distribute(t, NProc=Cmpi.size, algorithm='fast')
t = Cmpi.readZones(t, 'test.cgns', proc=Cmpi.rank)
# Arbre partiel (sans zones squelettes)
t = Cmpi.convert2PartialTree(t)
if Cmpi.rank == 0: C.convertPyTree2File(t, 'out.cgns')
# - readZones (pyTree) -
import Converter.PyTree as C
import Distributor2.PyTree as Distributor2
import Generator.PyTree as G
import Converter.Mpi as Cmpi
import KCore.test as test
LOCAL = test.getLocal()
# Cree le fichier test HDF
if Cmpi.rank == 0:
a = G.cart((0, 0, 0), (1, 1, 1), (10, 10, 10))
b = G.cart((12, 0, 0), (1, 1, 1), (10, 10, 10))
t = C.newPyTree(['Base', a, b])
C.convertPyTree2File(t, LOCAL + '/test.hdf')
Cmpi.barrier()
# Relit des zones par procs
t = Cmpi.convertFile2SkeletonTree(LOCAL + '/test.hdf')
(t, dic) = Distributor2.distribute(t, NProc=2, algorithm='fast')
t = Cmpi.readZones(t, LOCAL + '/test.hdf', rank=Cmpi.rank)
if Cmpi.rank == 0: test.testT(t, 1)
# Cree le fichier test ADF
if Cmpi.rank == 0:
a = G.cart((0, 0, 0), (1, 1, 1), (10, 10, 10))
b = G.cart((12, 0, 0), (1, 1, 1), (10, 10, 10))
t = C.newPyTree(['Base', a, b])
C.convertPyTree2File(t, LOCAL + '/test.adf')
Cmpi.barrier()
# - addXZones (pyTree) -
import Converter.PyTree as C
import Converter.Mpi as Cmpi
import Distributor2.PyTree as Distributor2
import Generator.PyTree as G
import KCore.test as test
# Cree le fichier test
if (Cmpi.rank == 0):
a = G.cart( (0,0,0), (1,1,1), (10,10,10) )
b = G.cart( (9,0,0), (1,1,1), (10,10,10) )
t = C.newPyTree(['Base',a,b])
C.convertPyTree2File(t, 'test.cgns')
Cmpi.barrier()
# Relit des zones par procs
t = Cmpi.convertFile2SkeletonTree('test.cgns')
(t, dic) = Distributor2.distribute(t, NProc=Cmpi.size, algorithm='fast')
t = Cmpi.readZones(t, 'test.cgns', proc=Cmpi.rank)
# Cree le bbox tree
tb = Cmpi.createBBoxTree(t)
# Cree le graph
graph = Cmpi.computeGraph(tb)
# Add X Zones
t = Cmpi.addXZones(t, graph)
if (Cmpi.rank == 0): test.testT(t, 1)
import Transform.PyTree as T
import Connector.PyTree as X
import Converter.Internal as Internal
import Generator.PyTree as G
# Case
N = 11
t = C.newPyTree(['Base'])
pos = 0
for i in xrange(N):
a = G.cart((pos, 0, 0), (1, 1, 1), (10 + i, 10, 10))
pos += 10 + i - 1
t[2][1][2].append(a)
t = X.connectMatch(t)
if Cmpi.rank == 0: C.convertPyTree2File(t, 'in.cgns')
Cmpi.barrier()
# lecture du squelette
a = Cmpi.convertFile2SkeletonTree('in.cgns')
# equilibrage 1
(a, dic) = D2.distribute(a, NProc=Cmpi.size, algorithm='fast', useCom=0)
# load des zones locales dans le squelette
a = Cmpi.readZones(a, 'in.cgns', rank=Cmpi.rank)
# equilibrage 2 (a partir d'un squelette charge)
(a, dic) = D2.distribute(a,
NProc=Cmpi.size,
algorithm='gradient1',
useCom='match')
# - readZones (pyTree) -
import Converter.PyTree as C
import Distributor2.PyTree as Distributor2
import Generator.PyTree as G
import Converter.Mpi as Cmpi
import KCore.test as test
# Cree le fichier test HDF
if Cmpi.rank == 0:
a = G.cart((0, 0, 0), (1, 1, 1), (10, 10, 10))
b = G.cart((12, 0, 0), (1, 1, 1), (10, 10, 10))
t = C.newPyTree(['Base', a, b])
C.convertPyTree2File(t, 'test.hdf')
Cmpi.barrier()
# Relit des zones par procs
t = Cmpi.convertFile2SkeletonTree('test.hdf')
(t, dic) = Distributor2.distribute(t, NProc=2, algorithm='fast')
t = Cmpi.readZones(t, 'test.hdf', proc=Cmpi.rank)
if Cmpi.rank == 0: test.testT(t, 1)
# Cree le fichier test ADF
if Cmpi.rank == 0:
a = G.cart((0, 0, 0), (1, 1, 1), (10, 10, 10))
b = G.cart((12, 0, 0), (1, 1, 1), (10, 10, 10))
t = C.newPyTree(['Base', a, b])
C.convertPyTree2File(t, 'test.adf')
Cmpi.barrier()
# Relit des zones par procs
t = Cmpi.convertFile2SkeletonTree('test.adf')
# Create case
if Cmpi.rank == 0:
ni = 100
nj = 100
nk = 100
m = G.cart((0, 0, 0), (10. / (ni - 1), 10. / (nj - 1), 1), (ni, nj, nk))
m = C.initVars(m, 'Density', 2.)
m = C.initVars(m, 'centers:cellN', 1)
m = T.splitNParts(m, 4)
C.convertPyTree2File(m, 'in.cgns')
# Extraction mesh
a = G.cart((0., 0., 0.5), (1., 0.1, 1.), (20, 20, 1))
a[0] = 'extraction'
a = T.splitNParts(a, 2)
C.convertPyTree2File(a, 'in2.cgns')
Cmpi.barrier()
# Extract solution on extraction mesh
m = Cmpi.convertFile2SkeletonTree('in.cgns')
(m, dic) = Distributor2.distribute(m, NProc=Cmpi.size, algorithm='fast')
m = Cmpi.readZones(m, 'in.cgns', rank=Cmpi.rank)
a = Cmpi.convertFile2SkeletonTree('in2.cgns')
(a, dic) = Distributor2.distribute(a, NProc=Cmpi.size, algorithm='fast')
a = Cmpi.readZones(a, 'in2.cgns', rank=Cmpi.rank)
a = Pmpi.extractMesh(m, a)
if Cmpi.rank == 0:
test.testT(a, 1)
import Converter.PyTree as C
import Converter.Mpi as Cmpi
import Distributor2.PyTree as Distributor2
import Generator.PyTree as G
import Connector.PyTree as X
import KCore.test as test
LOCAL = test.getLocal()
if Cmpi.rank == 0:
a = G.cart( (0,0,0), (1,1,1), (10,10,10) )
b = G.cart( (9,0,0), (1,1,1), (10,10,10) )
t = C.newPyTree(['Base']); t[2][1][2] += [a,b]
t = X.connectMatch(t)
C.convertPyTree2File(t, LOCAL+'/in.cgns')
Cmpi.barrier()
t = Cmpi.convertFile2SkeletonTree(LOCAL+'/in.cgns')
(t, dic) = Distributor2.distribute(t, NProc=2, algorithm='fast')
t = Cmpi.readZones(t, LOCAL+'/in.cgns', proc=Cmpi.rank)
# Through BBox
tb = Cmpi.createBBoxTree(t)
graph = Cmpi.computeGraph(tb, type='bbox')
if Cmpi.rank == 0: test.testO(graph, 1)
# Through match
graph = Cmpi.computeGraph(t, type='match')
if Cmpi.rank == 0: test.testO(graph, 2)
# - ExtractMesh distribue - import Converter.PyTree as C import Distributor2.PyTree as Distributor2 import Converter.Mpi as Cmpi import Transform.PyTree as T import Post.Mpi as Pmpi import Converter.Internal as Internal rank = Cmpi.rank size = Cmpi.size # Maillage d'extraction (distribue) FILE = 'receiver.cgns' e = Cmpi.convertFile2SkeletonTree(FILE) (e, dic) = Distributor2.distribute(e, NProc=size, algorithm='fast', useCom=0) e = Cmpi.readZones(e, FILE, rank=rank) # Maillage source (distribue) FILE = 'donor.cgns' a = Cmpi.convertFile2SkeletonTree(FILE) (a, dic) = Distributor2.distribute(a, NProc=size, algorithm='fast', useCom=0) a = Cmpi.readZones(a, FILE, rank=rank) # Extract mesh e = Pmpi.extractMesh(a, e) # Reconstruit l'arbre complet a l'ecriture Cmpi.convertPyTree2File(e, 'out.cgns')
# - setProc (pyTree) -
import Converter.PyTree as C
import Converter.Internal as Internal
import Converter.Mpi as Cmpi
import Distributor2.PyTree as Distributor2
import Generator.PyTree as G
import KCore.test as test
a = G.cart((0, 0, 0), (1, 1, 1), (10, 10, 10))
b = G.cart((12, 0, 0), (1, 1, 1), (10, 10, 10))
t = C.newPyTree(['Base', a, b])
t = Cmpi.setProc(t, 1)
zones = Internal.getNodesFromType(t, 'Zone_t')
for z in zones:
print z[0] + ' -> ' + str(Cmpi.getProc(z))
if Cmpi.rank == 0:
Ni = 50
Nj = 50
Nk = 2
a = G.cart((0, 0, 0), (1. / (Ni - 1), 1. / (Nj - 1), 1), (Ni, Nj, Nk))
b = G.cart((0, 0, 0), (2. / (Ni - 1), 2. / (Nj - 1), 1), (Ni, Nj, Nk))
b[0] = 'cart2'
a = T.rotate(a, (0, 0, 0), (0, 0, 1), 10.)
a = T.translate(a, (0.5, 0.5, 0))
t = C.newPyTree(['Base1', 'Base2'])
t[2][1][2].append(a)
t[2][2][2].append(b)
t = C.fillEmptyBCWith(t, 'overlap', 'BCOverlap', dim=2)
t = C.addVars(t, 'Density')
t = C.addVars(t, 'centers:Pressure')
C.convertPyTree2File(t, 'in.cgns')
Cmpi.barrier()
t = Cmpi.convertFile2SkeletonTree('in.cgns')
import sys
sys.exit()
(t, dic) = Distributor2.distribute(t, NProc=Cmpi.size, algorithm='fast')
t = Cmpi.readZones(t, 'in.cgns', proc=Cmpi.rank)
t2 = Xmpi.optimizeOverlap(t)
if Cmpi.rank == 0:
test.testT(t2, 1)
# priorite sur Base2
#t2 = X.optimizeOverlap(t, priorities=['Base1',1,'Base2',0])
#if Cmpi.rank == 0: test.testT(t2,2)
# - convertFile2PyTree (pyTree) -
import Converter.PyTree as C
import Generator.PyTree as G
import Converter.Mpi as Cmpi
import Converter.Internal as Internal
if Cmpi.rank == 0:
a = G.cart((0., 0., 0.), (0.1, 0.1, 0.1), (11, 11, 11))
t = C.newPyTree(['Base', a])
C.convertPyTree2File(t, 'in.cgns')
Cmpi.barrier()
# Identique sur tous les procs
t1 = Cmpi.convertFile2PyTree('in.cgns')
if Cmpi.rank == 1 or Cmpi.rank == 0:
Internal.printTree(t1)
import Distributor2.PyTree as D2
import Converter.PyTree as C
import Connector.PyTree as X
import KCore.test as test
import Converter.Mpi as Cmpi
N = 11
# Cas test
t = C.newPyTree(['Base'])
off = 0
for i in range(N):
a = G.cart( (off,0,0), (1,1,1), (10+i, 10, 10) )
off += 9+i
t[2][1][2].append(a)
t = X.connectMatch(t)
if Cmpi.rank == 0: C.convertPyTree2File(t, 'in.cgns')
# arbre complet
t, stats = D2.distribute(t, NProc=5, algorithm='gradient', useCom='overlap')
print('full:', stats)
if Cmpi.rank == 0: test.testT(t, 1)
# arbre squelette charge (doit etre identique)
t = Cmpi.convertFile2SkeletonTree('in.cgns')
t, stats = D2.distribute(t, NProc=Cmpi.size, algorithm='fast', useCom=0)
t = Cmpi.readZones(t, 'in.cgns', rank=Cmpi.rank)
t, stats = D2.distribute(t, NProc=5, algorithm='gradient', useCom='overlap')
print('loaded skel:', stats)
if Cmpi.rank == 0: test.testT(t, 2)
# - getProc (pyTree) -
import Converter.PyTree as C
import Converter.Internal as Internal
import Converter.Mpi as Cmpi
import Distributor2.PyTree as Distributor2
import Generator.PyTree as G
import KCore.test as test
a = G.cart((0, 0, 0), (1, 1, 1), (10, 10, 10))
b = G.cart((12, 0, 0), (1, 1, 1), (10, 10, 10))
t = C.newPyTree(['Base', a, b])
(t, dic) = Distributor2.distribute(t, NProc=2, algorithm='fast')
zones = Internal.getNodesFromType(t, 'Zone_t')
for z in zones:
print z[0] + ' -> ' + str(Cmpi.getProc(z))
# - computeGraph (pyTree) -
import Converter.PyTree as C
import Converter.Mpi as Cmpi
import Distributor2.PyTree as Distributor2
import Generator.PyTree as G
import Connector.PyTree as X
import KCore.test as test
# Through BBox
a = G.cart((0, 0, 0), (1, 1, 1), (10, 10, 10))
b = G.cart((8, 0, 0), (1, 1, 1), (10, 10, 10))
t = C.newPyTree(['Base', a, b])
(t, dic) = Distributor2.distribute(t, NProc=2, algorithm='fast')
tb = Cmpi.createBBoxTree(t)
graph = Cmpi.computeGraph(tb, type='bbox')
if Cmpi.rank == 0: test.testO(graph, 1)
# Through match
a = G.cart((0, 0, 0), (1, 1, 1), (10, 10, 10))
b = G.cart((9, 0, 0), (1, 1, 1), (10, 10, 10))
t = C.newPyTree(['Base'])
t[2][1][2] += [a, b]
t = X.connectMatch(t)
(t, dic) = Distributor2.distribute(t, NProc=2, algorithm='fast')
graph = Cmpi.computeGraph(t, type='match')
if Cmpi.rank == 0:
test.testO(graph, 2)
#!/usr/bin/env python
# coding: utf-8
r"""<TBC>"""
# - Calcul d'isosurfaces a la paroi en distribue -
import Converter.PyTree as C
import Distributor2.PyTree as Distributor2
import Converter.Mpi as Cmpi
import Transform.PyTree as T
import Post.PyTree as P
rank = Cmpi.rank
size = Cmpi.size
# lecture du squelette
a = Cmpi.convertFile2SkeletonTree('cart.cgns')
# equilibrage
(a, dic) = Distributor2.distribute(a, NProc=size, algorithm='fast', useCom=0)
# load des zones locales dans le squelette
a = Cmpi.readZones(a, 'cart.cgns', proc=rank)
# Passage en arbre partiel
a = Cmpi.convert2PartialTree(a)
# Calcul de l'iso surface
isos = P.isoSurfMC(a, 'F', 0.3)
isos = Cmpi.setProc(isos, rank) # affecte les isos au proc local
t = C.newPyTree(['Base'])
t[2][1][2] += isos
import Converter.Internal as Internal
import Generator.PyTree as G
import KCore.test as test
# Case
N = 11
t = C.newPyTree(['Base'])
pos = 0
for i in xrange(N):
a = G.cart((pos, 0, 0), (1, 1, 1), (10 + i, 10, 10))
pos += 10 + i - 1
t[2][1][2].append(a)
t = C.initVars(t, '{centers:Density} = {CoordinateX} + {CoordinateY}')
t = X.connectMatch(t)
if (Cmpi.rank == 0): C.convertPyTree2File(t, 'in.cgns')
Cmpi.barrier()
# lecture du squelette
sk = Cmpi.convertFile2SkeletonTree('in.cgns')
# equilibrage
(sk, dic) = Distributor2.distribute(sk,
NProc=Cmpi.size,
algorithm='gradient0',
useCom='match')
# load des zones locales dans le squelette
a = Cmpi.readZones(sk, 'in.cgns', proc=Cmpi.rank)
# center2Node
a = Cmpi.center2Node(a, 'centers:Density')
# - convertFile2SkeletonTree (pyTree) -
import Converter.PyTree as C
import Generator.PyTree as G
import Converter.Mpi as Cmpi
import Converter.Internal as Internal
if Cmpi.rank == 0:
a = G.cart((0., 0., 0.), (0.1, 0.1, 0.1), (11, 11, 11))
t = C.newPyTree(['Base', a])
C.convertPyTree2File(t, 'in.cgns')
Cmpi.barrier()
t1 = Cmpi.convertFile2SkeletonTree('in.cgns')
Internal.printTree(t1)
#>> ['CGNSTree',None,[2 sons],'CGNSTree_t']
#>> |_['CGNSLibraryVersion',array([3.0999999046325684],dtype='float64'),[0 son],'CGNSLibraryVersion_t']
#>> |_['Base',array(shape=(2,),dtype='int32',order='F'),[1 son],'CGNSBase_t']
#>> |_['cart',array(shape=(3, 3),dtype='int32',order='F'),[2 sons],'Zone_t']
#>> |_['ZoneType',array('Structured',dtype='|S1'),[0 son],'ZoneType_t']
#>> |_['GridCoordinates',None,[3 sons],'GridCoordinates_t']
#>> |_['CoordinateX',None,[0 son],'DataArray_t']
#>> |_['CoordinateY',None,[0 son],'DataArray_t']
#>> |_['CoordinateZ',None,[0 son],'DataArray_t']
# - getProcDict (pyTree) -
import Converter.PyTree as C
import Converter.Internal as Internal
import Converter.Mpi as Cmpi
import Distributor2.PyTree as Distributor2
import Generator.PyTree as G
import KCore.test as test
# Cree le fichier test
if Cmpi.rank == 0:
a = G.cart((0,0,0), (1,1,1), (10,10,10))
b = G.cart((12,0,0), (1,1,1), (10,10,10))
t = C.newPyTree(['Base',a,b])
C.convertPyTree2File(t, 'in.cgns')
Cmpi.barrier()
# Relit des zones par procs
t = Cmpi.convertFile2SkeletonTree('in.cgns')
(t, dic) = Distributor2.distribute(t, NProc=2, algorithm='fast')
procDict = Cmpi.getProcDict(t)
if Cmpi.rank == 0: print procDict
#>> {'cart.0': 1, 'cart': 0}
# - send (array) -
import Converter as C
import Generator as G
import Transform as T
import Converter.Mpi as Cmpi
if Cmpi.rank == 0:
a = G.cart((0, 0, 0), (1, 1, 1), (50, 50, 30))
elif Cmpi.rank == 1:
a = G.cart((0, 100, 0), (1, 1, 1), (50, 50, 30))
else:
a = G.cart((100, 0, 0), (1, 1, 1), (50, 50, 30))
C.send(a, 'localhost', rank=Cmpi.rank)
Cmpi.barrier()
for i in range(10):
#import time; time.sleep(2)
a = T.rotate(a, (0, 0, 0), (0, 0, 1), 10.)
C.send(a, 'localhost', rank=Cmpi.rank)
Cmpi.barrier()
