def adjustNProc():
global STATS
if CTK.t == []: return
try:
NProc = int(VARS[0].get())
except:
NProc = 1
try:
comSpeed = float(VARS[1].get())
except:
CTK.TXT.insert('START', 'distribute: ComSpeed is invalid.\n')
CTK.TXT.insert('START', 'Error: ', 'Error')
return
algo = VARS[2].get()
useCom = VARS[3].get()
classes = [8, 16, 32, 64, 128, 256, 512]
CTK.saveTree()
for c in range(len(classes)):
if NProc > classes[c]: break
CTK.t, stat1 = D.distribute(CTK.t,
classes[c],
perfo=(1., 0., comSpeed),
useCom=useCom,
algorithm=algo)
if c > 0:
CTK.t, stat2 = D.distribute(CTK.t,
classes[c - 1],
perfo=(1., 0., comSpeed),
useCom=useCom,
algorithm=algo)
if c < len(classes) - 1:
CTK.t, stat3 = D.distribute(CTK.t,
classes[c + 1],
perfo=(1., 0., comSpeed),
useCom=useCom,
algorithm=algo)
# Best
VARS[0].set(str(classes[c]))
CTK.t, STATS = D.distribute(CTK.t,
classes[c],
perfo=(1., 0., comSpeed),
useCom=useCom,
algorithm=algo)
CTK.TXT.insert('START', 'Blocks distributed.\n')
CTK.TKTREE.updateApp()
updateStats()
return
def distribute(event=None):
global STATS
if CTK.t == []: return
try:
NProc = int(VARS[0].get())
except:
CTK.TXT.insert('START', 'distribute: NProc is invalid.\n')
CTK.TXT.insert('START', 'Error: ', 'Error')
return
try:
comSpeed = float(VARS[1].get())
except:
CTK.TXT.insert('START', 'distribute: ComSpeed is invalid.\n')
CTK.TXT.insert('START', 'Error: ', 'Error')
return
algo = VARS[2].get()
useCom = VARS[3].get()
CTK.saveTree()
CTK.t, STATS = D.distribute(CTK.t,
NProc,
perfo=(1., 0., comSpeed),
useCom=useCom,
algorithm=algo)
CTK.TXT.insert('START', 'Blocks distributed.\n')
CTK.TKTREE.updateApp()
updateStats()
def splitAndDistribute(event=None):
global STATS
if CTK.t == []: return
try:
NProc = int(VARS[0].get())
except:
CTK.TXT.insert('START', 'distribute: NProc is invalid.\n')
CTK.TXT.insert('START', 'Error: ', 'Error')
return
try:
comSpeed = float(VARS[1].get())
except:
CTK.TXT.insert('START', 'distribute: ComSpeed is invalid.\n')
CTK.TXT.insert('START', 'Error: ', 'Error')
return
algo = VARS[2].get()
useCom = VARS[3].get()
level = int(VARS[5].get())
CTK.saveTree()
try:
#CTK.t = T.splitNParts(CTK.t, NProc, multigrid=level)
CTK.t = T.splitSize(CTK.t, N=0, multigrid=level, R=NProc, type=2)
# no need to check inconsistant match (they have been deleted)
node = Internal.getNodeFromName(CTK.t, 'EquationDimension')
if node is not None:
ndim = Internal.getValue(node)
# Manque le reglage de la tol
else:
CTK.TXT.insert(
'START', 'EquationDimension not found (tkState). Using 3D.\n')
CTK.TXT.insert('START', 'Warning: ', 'Warning')
ndim = 3
CTK.t = X.connectMatch(CTK.t, dim=ndim)
CTK.display(CTK.t)
except Exception as e:
Panels.displayErrors([0, str(e)], header='Error: distribute/split')
CTK.TXT.insert('START', 'splitSize fails for at least one zone.\n')
CTK.TXT.insert('START', 'Warning: ', 'Warning')
(CTK.Nb, CTK.Nz) = CPlot.updateCPlotNumbering(CTK.t)
CTK.t, STATS = D.distribute(CTK.t,
NProc,
perfo=(1., 0., comSpeed),
useCom=useCom,
algorithm=algo)
CTK.TXT.insert('START', 'Blocks split and distributed.\n')
CTK.TKTREE.updateApp()
updateStats()
def loadAndSplitSkeleton(self, NParts=None, NProc=None):
"""Load and split skeleton."""
a = self.loadSkeleton()
import Transform.PyTree as T
# split on skeleton
splitDict = {}
if NParts is not None:
b = T.splitNParts(a, N=NParts, splitDict=splitDict)
else:
b = T.splitNParts(a, N=NProc, splitDict=splitDict)
self.splitDict = splitDict
zones = Internal.getZones(b)
if NProc is not None:
import Distributor2.PyTree as D2
D2._distribute(b, NProc)
# Correction dims en attendant que subzone fonctionne sur un skel
for z in zones:
j = splitDict[z[0]]
ni = j[2] - j[1] + 1
nj = j[4] - j[3] + 1
nk = j[6] - j[5] + 1
d = numpy.empty((3, 3), numpy.int32, order='Fortran')
d[0, 0] = ni
d[1, 0] = nj
d[2, 0] = nk
d[0, 1] = ni - 1
d[1, 1] = nj - 1
d[2, 1] = nk - 1
d[0, 2] = 0
d[1, 2] = 0
d[2, 2] = 0
z[1] = d
# END correction
return a
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')
# a est maintenant un arbre partiel
a = C.rmVars(a, 'centers:Density')
# Reconstruit l'arbre complet a l'ecriture
if (Cmpi.rank == 0):
test.testT(a, 1)
# - 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')
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)
# - 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
# Reconstruit l'arbre complet a l'ecriture
Cmpi.convertPyTree2File(t, 'out.cgns')
import Converter.PyTree as C
import Connector.PyTree as X
import KCore.test as test
N = 11
# Test raccords matchs
t = C.newPyTree(['Base'])
off = 0
for i in xrange(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)
t, stats = D2.distribute(t, NProc=5, algorithm='gradient')
test.testT(t, 1)
t, stats = D2.distribute(t, NProc=5, algorithm='genetic')
test.testT(t, 2)
t, stats = D2.distribute(t, NProc=5, algorithm='fast')
test.testT(t, 3)
# avec overlap
t = C.newPyTree(['Base'])
off = 0
for i in xrange(N):
a = G.cart((off, 0, 0), (1, 1, 1), (10 + i, 10, 10))
a = C.addBC2Zone(a, 'overlap', 'BCOverlap', 'imin')
a = C.addBC2Zone(a, 'overlap', 'BCOverlap', 'imax')
# - getProcList (pyTree) -
import Generator.PyTree as G
import Distributor2.PyTree as D2
import Converter.PyTree as C
import Connector.PyTree as X
N = 11
t = C.newPyTree(['Base'])
pos = 0
for i in range(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)
t, stats = D2.distribute(t, 3)
procList = D2.getProcList(t)
print(procList)
# - 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}
def loadAndSplit(fileName,
NParts=None,
noz=None,
NProc=None,
rank=None,
variables=[]):
if NParts is None: NParts = NProc
if NProc is None: NProc = NParts
import Transform.PyTree as T
a = convertFile2SkeletonTree(fileName)
# split on skeleton
splitDict = {}
b = T.splitNParts(a, N=NParts, splitDict=splitDict)
zones = Internal.getZones(b)
if rank is not None:
import Distributor2.PyTree as D2
D2._distribute(b, NProc)
noz = []
for i, z in enumerate(zones):
p = D2.getProc(z)
if p == rank: noz.append(i)
f = {}
for i in noz:
z = zones[i]
j = splitDict[z[0]]
# Correction de dimension en attendant que subzone fonctionne sur un skel
ni = j[2] - j[1] + 1
nj = j[4] - j[3] + 1
nk = j[6] - j[5] + 1
ni1 = max(ni - 1, 1)
nj1 = max(nj - 1, 1)
nk1 = max(nk - 1, 1)
d = numpy.empty((3, 3), numpy.int32, order='Fortran')
d[0, 0] = ni
d[1, 0] = nj
d[2, 0] = nk
d[0, 1] = ni1
d[1, 1] = nj1
d[2, 1] = nk1
d[0, 2] = 0
d[1, 2] = 0
d[2, 2] = 0
z[1] = d
# END correction
zname = z[0] # zone name in b
pname = zname.rsplit('.', 1)[0] # parent name (guessed)
(base, c) = Internal.getParentOfNode(b, z)
bname = base[0]
f = {}
# Node fields
path = []
cont = Internal.getNodeFromName2(z, Internal.__GridCoordinates__)
if cont is not None:
for c in cont[2]:
if c[3] == 'DataArray_t':
path += ['/%s/%s/%s/%s' % (bname, pname, cont[0], c[0])]
cont = Internal.getNodeFromName2(z, Internal.__FlowSolutionNodes__)
if cont is not None:
for c in cont[2]:
if c[3] == 'DataArray_t' and c[0] in variables:
path += ['/%s/%s/%s/%s' % (bname, pname, cont[0], c[0])]
DataSpaceMMRY = [[0, 0, 0], [1, 1, 1], [ni, nj, nk], [1, 1, 1]]
DataSpaceFILE = [[j[1] - 1, j[3] - 1, j[5] - 1], [1, 1, 1],
[ni, nj, nk], [1, 1, 1]]
DataSpaceGLOB = [[0]]
for p in path:
f[p] = DataSpaceMMRY + DataSpaceFILE + DataSpaceGLOB
# Center fields
path = []
cont = Internal.getNodeFromName2(z, Internal.__FlowSolutionCenters__)
if cont is not None:
for c in cont[2]:
if c[3] == 'DataArray_t' and 'centers:' + c[0] in variables:
path += ['/%s/%s/%s/%s' % (bname, pname, cont[0], c[0])]
DataSpaceMMRY = [[0, 0, 0], [1, 1, 1], [ni1, nj1, nk1], [1, 1, 1]]
DataSpaceFILE = [[j[1] - 1, j[3] - 1, j[5] - 1], [1, 1, 1],
[ni1, nj1, nk1], [1, 1, 1]]
DataSpaceGLOB = [[0]]
for p in path:
f[p] = DataSpaceMMRY + DataSpaceFILE + DataSpaceGLOB
r = readNodesFromFilter(fileName, f)
# Repositionne les chemins
for k in r:
k2 = k.replace(pname, zname)
n = Internal.getNodeFromPath(b, k2)
n[1] = r[k]
b = convert2PartialTree(b)
return b
# - printProcStats (pyTree) -
import Generator.PyTree as G
import Distributor2.PyTree as D2
import Converter.PyTree as C
import Connector.PyTree as X
N = 11
t = C.newPyTree(['Base'])
pos = 0
for i in range(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)
# Distribute on 3 processors
t, stats = D2.distribute(t, 3)
# With stats and NProc
D2.printProcStats(t, stats, NProc=3)
# NProc is guessed from stats
D2.printProcStats(t, stats)
# All are guessed from t
D2.printProcStats(t)
C.convertPyTree2File(t, 'out.cgns')
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')
a = D2mpi.redispatch(a)
# force toutes les zones sur 0
zones = Internal.getNodesFromType(a, 'Zone_t')
for z in zones:
# - getProcDict (pyTree) -
import Generator.PyTree as G
import Distributor2.PyTree as D2
import Converter.PyTree as C
import Connector.PyTree as X
import KCore.test as test
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)
t, stats = D2.distribute(t, 3)
proc = D2.getProcDict(t)
test.testO(proc, 1)
proc = D2.getProcDict(t, prefixByBase=True)
test.testO(proc, 2)
# - addProcNode (pyTree) - import Generator.PyTree as G import Distributor2.PyTree as D2 import KCore.test as test a = G.cart((0,0,0), (1,1,1), (10,10,10)) a = D2.addProcNode(a, 12) test.testT(a, 1)
# - distribute (pyTree) -
import Generator.PyTree as G
import Distributor2.PyTree as D2
import Converter.PyTree as C
import Connector.PyTree as X
N = 11
t = C.newPyTree(['Base'])
pos = 0
for i in range(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)
# Distribute on 3 processors
t, stats = D2.distribute(t, 3)
C.convertPyTree2File(t, 'out.cgns')
# - getProc (pyTree) - import Converter.PyTree as C import Generator.PyTree as G import Distributor2.PyTree as D2 a = G.cart((0, 0, 0), (1, 1, 1), (10, 10, 10)) a = D2.addProcNode(a, 12) proc = D2.getProc(a) print proc
# 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)
# - copyDistribution (pyTree) -
import Converter.PyTree as C
import Distributor2.PyTree as D2
import Generator.PyTree as G
# Case
N = 11
t = C.newPyTree(['Base'])
pos = 0
for i in range(N):
a = G.cart((pos, 0, 0), (1, 1, 1), (10 + i, 10, 10))
a[0] = 'cart%d' % i
pos += 10 + i - 1
D2._addProcNode(a, i)
t[2][1][2].append(a)
t2 = C.newPyTree(['Base'])
for i in range(N):
a = G.cart((pos, 0, 0), (1, 1, 1), (10 + i, 10, 10))
a[0] = 'cart%d' % i
pos += 10 + i - 1
t2[2][1][2].append(a)
t2 = D2.copyDistribution(t2, t)
C.convertPyTree2File(t2, 'out.cgns')
import KCore.test as test
LOCAL = test.getLocal()
# Case
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)
t, stats = D2.distribute(t, NProc=5, algorithm='fast', useCom=0)
if Cmpi.rank == 0: C.convertPyTree2File(t, LOCAL + '/in.cgns')
Cmpi.barrier()
# full
graph = Cmpi.computeGraph(t, type='match')
if Cmpi.rank == 0: test.testO(graph, 1)
# skel (doit etre identique)
t = Cmpi.convertFile2SkeletonTree(LOCAL + '/in.cgns')
graph = Cmpi.computeGraph(t, type='match')
if Cmpi.rank == 0: test.testO(graph, 2)
# load skel (doit etre identique)
t = Cmpi.convertFile2SkeletonTree(LOCAL + '/in.cgns')
t = Cmpi.readZones(t, LOCAL + '/in.cgns', rank=Cmpi.rank)
