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()