def prepareCompositeIBMData(t, tb, DEPTH=2, loc='centers', frontType=1): dimPb = Internal.getNodeFromName(tb, 'EquationDimension') if dimPb is None: raise ValueError('EquationDimension is missing in input body tree.') dimPb = Internal.getValue(dimPb) tc = C.newPyTree() for nob in range(len(t[2])): if Internal.getType(t[2][nob]) == 'CGNSBase_t': basename = t[2][nob][0] C._addBase2PyTree(tc, basename) for nob in range(len(tb[2])): if tb[2][nob][3] == 'CGNSBase_t': basename = tb[2][nob][0] tloc = C.newPyTree([basename]) tloc[2][1] = t[2][nob] tbloc = C.newPyTree([basename]) tbloc[2][1] = tb[2][nob] # prepro IBM + interpolation entre blocs internes tloc, tcloc = prepareIBMData(tloc, tbloc, DEPTH=DEPTH, loc=loc, frontType=frontType, interp='composite') C._cpVars(tloc, 'centers:cellN', tcloc, 'cellN') tc[2][nob][2] += Internal.getZones(tcloc) Internal._rmNodesFromType(t[2][nob], "Zone_t") t[2][nob][2] += Internal.getZones(tloc) # offbodyZones = C.node2Center(t[2][-1][2]) Internal._rmNodesByName(tc, "*TurbulentDistance*") Internal._rmNodesByName(tc, Internal.__FlowSolutionCenters__) tc[2][-1][2] += offbodyZones return t, tc
def _eikonal(t, tc=None, loc='nodes', nitmax=10, err=0.01): MB = 1 try: import Connector.PyTree as X except: MB = 0 if tc is None or MB == 0: for z in Internal.getNodesFromType2(t, 'Zone_t'): _eikonalForZone(z, loc) return None # Eikonal nzones = len(Internal.getNodesFromType2(t, "Zone_t")) isConverged = [0] * nzones it = 0 nocv = 0 # nb de zones convergees # calcul de la taille de maille sur le niveau le plus fin dhmin = PHIMAX for z in Internal.getNodesFromType2(t, "Zone_t"): dhmin = min( dhmin, C.getValue(z, 'CoordinateX', 1) - C.getValue(z, 'CoordinateX', 0)) while nocv < nzones and it < nitmax + 1: print 'Iteration %d' % it # Eikonal sur les zones non convergees et sources if loc == 'nodes': C._initVars(t, 'PhiM={Phi}') else: C._initVars(t, 'centers:PhiM={centers:Phi}') no = 0 for z in Internal.getNodesFromType2(t, "Zone_t"): if isConverged[no] < 1 and C.getMaxValue(z, loc + ':flag') > 0.: if loc == 'nodes': C._initVars( z, 'Phi=({flag}<0.1)*%f+({flag}>0.)*{Phi}' % PHIMAX) else: C._initVars( z, 'centers:Phi=({centers:flag}<0.1)*%f+({centers:flag}>0.)*{Phi}' % PHIMAX) _eikonalForZone(z, loc=loc) isConverged[no] = -1 no += 1 # Synchro print 'Synchronization/transfers' if tc is not None: no = 0 for z in Internal.getNodesFromType2(t, "Zone_t"): if isConverged[no] == -1: # a ete eikonalise: transferts z2 = Internal.getNodeFromName(tc, z[0]) C._cpVars(z, loc + ':Phi', z2, 'Phi') C._initVars(z2, 'flag', 1.) # PAS THREADE ????? X._setInterpTransfers(t, z2, variables=['Phi', 'flag'], variablesIBC=None) no += 1 # Convergence if it > 0: no = 0 nocv = 0 for z in Internal.getNodesFromType2(t, "Zone_t"): if loc == 'nodes': C._initVars( z, 'DPhi=abs({Phi}-{PhiM})/(maximum(1.e-12,{Phi}))') else: C._initVars( z, 'centers:DPhi=abs({centers:Phi}-{centers:PhiM})/(maximum(1.e-12,{centers:Phi}))' ) valmax = C.getMaxValue(z, loc + ':DPhi') dhloc = C.getValue(z, 'CoordinateX', 1) - C.getValue( z, 'CoordinateX', 0) errloc = err * dhloc / dhmin # on augmente la tolerance au fur et a mesure qu on diminue la resolution if valmax < errloc and isConverged[no] == -1: isConverged[no] = 1 nocv += 1 elif isConverged[no] == 1: nocv += 1 no += 1 # Iteration it += 1 #----------------------------------------------------------------------------- if it < nitmax + 1: print 'Distance by Eikonal converged after %d subiterations.' % it else: print 'Warning: distance by Eikonal did not converged after %d subiterations.' % nitmax noi = 0 for i in isConverged: if i != 1: print i, noi noi += 1 return None
def transferCellN__(t, tc, DEPTH, loc): if tc is None: return t try: import Connector.PyTree as X except: raise ImportError( "Dist2Walls: Eikonal version requires Connector module.") # POINTS EXTERIEURS # Marquage des pts de front entre du 0 et du 1 t = X.setHoleInterpolatedPoints(t, depth=DEPTH, loc=loc) # transfert du cellN aux raccords if tc is not None: C._cpVars(t, loc + ':cellN', tc, 'cellN') for zc in Internal.getNodesFromType2(tc, "Zone_t"): if C.getMaxValue(zc, 'cellN') == 2.: X._setInterpTransfers(t, zc, variables=["cellN"]) if loc == 'nodes': C._initVars(t, "cellN=({cellN}>1.5)*2.+({cellN}>0.)*({cellN}<1.5)") C._initVars(t, 'cellN = 1-{cellN}+({cellN}>1.5)*3') else: C._initVars( t, "centers:cellN=({centers:cellN}>1.5)*2.+({centers:cellN}>0.)*({centers:cellN}<1.5)" ) C._initVars( t, 'centers:cellN = 1-{centers:cellN}+({centers:cellN}>1.5)*3') t = X.setHoleInterpolatedPoints(t, depth=DEPTH, loc=loc) if loc == 'nodes': C._initVars(t, 'cellN = 1-{cellN}+({cellN}>1.5)*3') C._initVars(t, 'cellN2={cellN}') else: C._initVars( t, 'centers:cellN = 1-{centers:cellN}+({centers:cellN}>1.5)*3') C._initVars(t, 'centers:cellN2={centers:cellN}') # POINTS INTERIEURS if loc == 'nodes': C._initVars(t, 'cellN=minimum(1.,{cellN})') else: C._initVars(t, 'centers:cellN=minimum(1.,{centers:cellN})') t = X.setHoleInterpolatedPoints(t, depth=-DEPTH, loc=loc) # transfert du cellN aux raccords if tc is not None: C._cpVars(t, loc + ':cellN', tc, 'cellN') for zc in Internal.getNodesFromType2(tc, "Zone_t"): if C.getMaxValue(zc, 'cellN') == 2.: X._setInterpTransfers(t, zc, variables=["cellN"]) if loc == 'nodes': C._initVars(t, "cellN=({cellN}>1.5)*2.+({cellN}>0.)*({cellN}<1.5)") C._initVars(t, 'cellN = 1-{cellN}+({cellN}>1.5)*3') else: C._initVars( t, "centers:cellN=({centers:cellN}>1.5)*2.+({centers:cellN}>0.)*({centers:cellN}<1.5)" ) C._initVars( t, 'centers:cellN = 1-{centers:cellN}+({centers:cellN}>1.5)*3') t = X.setHoleInterpolatedPoints(t, depth=-DEPTH, loc=loc) if loc == 'nodes': C._initVars(t, 'cellN = 1-{cellN}+({cellN}>1.5)*3') C._initVars(t, 'cellN=maximum({cellN},{cellN2})') C._rmVars(t, ['cellN2']) else: C._initVars( t, 'centers:cellN = 1-{centers:cellN}+({centers:cellN}>1.5)*3') C._initVars(t, 'centers:cellN=maximum({centers:cellN},{centers:cellN2})') C._rmVars(t, ['centers:cellN2']) return t
def prepareSteadyOffBodyChimeraData(t, tc, tblank, noBaseOff, tBB=None, DEPTH=2, loc='centers', NIT=1, RotationCenter=[0, 0, 0], RotationAngle=[0, 0, 0.], Translation=[0, 0, 0], listOfSteadyOffBodyZones=None): if listOfSteadyOffBodyZones is None: raise ValueError( "prepareSteadyOffBodyChimeraData: listOfSteadyOffBodyZones is None." ) # arbre de BBox des zones donneuses if tBB is None: tBB = G.BB(tc) # BB des zones donneuses intersectionDict = X.getIntersectingDomains(tBB[2][noBaseOff]) dictOfOffBodyZoneNb = {} for noz in range(len(tc[2][noBaseOff][2])): z = tc[2][noBaseOff][2][noz] if Internal.getType(z) == 'Zone_t': dictOfOffBodyZoneNb[z[0]] = noz dictOfOffBodyZoneNbRcv = { } # t et tc peuvent ne pas avoir la meme structure for noz in range(len(t[2][noBaseOff][2])): z = t[2][noBaseOff][2][noz] if Internal.getType(z) == 'Zone_t': dictOfOffBodyZoneNbRcv[z[0]] = noz C._initVars(t[2][noBaseOff], "centers:cellN", 1.) t[2][noBaseOff] = X.applyBCOverlaps(t[2][noBaseOff], depth=DEPTH, loc=loc) C._cpVars(t[2][noBaseOff], "centers:cellN", tc[2][noBaseOff], "cellN") dictOfADT = {} # preconditionnement for zname in listOfSteadyOffBodyZones: noz = dictOfOffBodyZoneNbRcv[zname] z = t[2][noBaseOff][2][noz] intersectingZones = intersectionDict[zname] donorZones = [] hooks = [] for znamed in intersectingZones: nozd = dictOfOffBodyZoneNb[znamed] zd = tc[2][noBaseOff][2][nozd] if znamed not in dictOfADT: hook0 = C.createHook(zd, 'adt') dictOfADT[znamed] = hook0 hooks.append(dictOfADT[znamed]) donorZones.append(zd) donorZones = X.setInterpData(z,donorZones,nature=1,penalty=1,loc='centers',storage='inverse',sameName=1,\ hook=hooks, itype='chimera') for zd in donorZones: znamed = zd[0] nozd = dictOfOffBodyZoneNb[znamed] tc[2][noBaseOff][2][nozd] = zd for dnrname in dictOfADT: C.freeHook(dictOfADT[dnrname]) return t, tc
def prepareMotionChimeraData(t, tc, tblank, noBaseOff, tBB=None, DEPTH=2, loc='centers', NIT=1, RotationCenter=None, RotationAngle=None, Translation=None, listOfSteadyOffBodyZones=None, listOfOffBodyIntersectingNBZones=None): # arbre de BBox des zones donneuses if tBB is None: tBB = G.BB(tc) # BB des zones donneuses if listOfOffBodyIntersectingNBZones is None: listOfOffBodyIntersectingNBZones = getListOfOffBodyIntersectingNBZones( tBB, noBaseOff, NIT=NIT, DEPTH=DEPTH, RotationCenter=RotationCenter, RotationAngle=RotationAngle, Translation=Translation) listOfSteadyOffBodyZones = getListOfSteadyOffBodyZones( tBB, noBaseOff, listOfOffBodyIntersectingNBZones) if listOfSteadyOffBodyZones is None: listOfSteadyOffBodyZones = getListOfSteadyOffBodyZones( tBB, noBaseOff, listOfOffBodyIntersectingNBZones) dimPb = Internal.getNodeFromName(t, 'EquationDimension') if dimPb is None: raise ValueError('EquationDimension is missing in input body tree.') dimPb = Internal.getValue(dimPb) if dimPb == 2: z0 = Internal.getNodeFromType2(t, 'Zone_t') dims = Internal.getZoneDim(z0) npts = dims[1] * dims[2] * dims[3] zmin = C.getValue(z0, 'CoordinateZ', 0) zmax = C.getValue(z0, 'CoordinateZ', npts - 1) dz = zmax - zmin # Creation du corps 2D pour le preprocessing IBC tblank = T.addkplane(tblank) tblank = T.contract(tblank, (0, 0, 0), (1, 0, 0), (0, 1, 0), dz) rotation = True translation = True if RotationAngle is None: rotation = False if Translation is None: translation = False if rotation is True and translation is True: raise ValueError( "ToolboxIBM: translation and rotation not yet possible together.") constantMotion = False if rotation: if len(RotationAngle) == 3 and isinstance(RotationAngle[0], list) == False: constantMotion = True if translation: if len(Translation) == 3 and isinstance(Translation[0], list) == False: constantMotion = True xc0 = RotationCenter[0] yc0 = RotationCenter[1] zc0 = RotationCenter[2] C._initVars(t[2][noBaseOff], '{centers:cellNInit}={centers:cellN}') C._initVars(tc[2][noBaseOff], "{cellNInit}={cellN}") dictOfNearBodyBaseNb = {} dictOfNearBodyZoneNb = {} for nob in range(len(tc[2])): if nob != noBaseOff: base = tc[2][nob] if Internal.getType(base) == 'CGNSBase_t': for noz in range(len(base[2])): zone = base[2][noz] if Internal.getType(zone) == 'Zone_t': zname = zone[0] dictOfNearBodyZoneNb[zname] = noz dictOfNearBodyBaseNb[zname] = nob dictOfOffBodyZoneNb = {} dictOfOffBodyADT = {} # preconditionnement for noz in range(len(tc[2][noBaseOff][2])): z = tc[2][noBaseOff][2][noz] zname = z[0] if Internal.getType(z) == 'Zone_t': dictOfOffBodyZoneNb[zname] = noz if zname in listOfOffBodyIntersectingNBZones: zc = tc[2][noBaseOff][2][noz] hook0 = C.createHook(zc, 'adt') dictOfOffBodyADT[zname] = hook0 C._initVars(tc, '{CoordinateXInit}={CoordinateX}') C._initVars(tc, '{CoordinateYInit}={CoordinateY}') C._initVars(tc, '{CoordinateZInit}={CoordinateZ}') C._initVars(t, '{CoordinateXInit}={CoordinateX}') C._initVars(t, '{CoordinateYInit}={CoordinateY}') C._initVars(t, '{CoordinateZInit}={CoordinateZ}') C._initVars(tBB, '{CoordinateXInit}={CoordinateX}') C._initVars(tBB, '{CoordinateYInit}={CoordinateY}') C._initVars(tBB, '{CoordinateZInit}={CoordinateZ}') if NIT > 1: for zc in Internal.getZones(tc): IDatas = Internal.getNodesFromName(zc, "ID_*") for ID in IDatas: name = ID[0].split('_') ID[0] = 'IDSteady_%s' % (name[1]) tloc = C.newPyTree(['OffMotion']) for zr in t[2][noBaseOff][2]: if Internal.getType(zr) == 'Zone_t': znamer = zr[0] if znamer not in listOfSteadyOffBodyZones: # print " Zone de fond en mvt %s"%znamer tloc[2][1][2].append(zr) else: tloc[2][1][2].append(zr) tBBloc = G.BB(tloc) # a remonter dans l interface intersectionsDictOffOff = X.getIntersectingDomains(tBB[2][noBaseOff], method='AABB', taabb=tBB[2][noBaseOff]) listOfIntersectionDictsNBNB = {} for nob in range(len(t[2])): if nob != noBaseOff and Internal.getType(t[2][nob]) == 'CGNSBase_t': intersectionsDictNB = X.getIntersectingDomains(tBB[2][nob], method='AABB', taabb=tBB[2][nob]) listOfIntersectionDictsNBNB[nob] = intersectionsDictNB for it in range(NIT): print(' ------------------- Iteration %d ----------------------- ' % it) if constantMotion: if rotation: angleX = RotationAngle[0] * it angleY = RotationAngle[1] * it angleZ = RotationAngle[2] * it print('Rotation (degres) : (alphaX=%g,alphaY=%g,alphaZ=%g)' % (angleX, angleY, angleZ)) elif translation: tx = Translation[0] ty = Translation[1] tz = Translation[2] else: if rotation: angleX = RotationAngle[it][0] angleY = RotationAngle[it][1] angleZ = RotationAngle[it][2] print('Rotation (degres) : (alphaX=%g,alphaY=%g,alphaZ=%g)' % (angleX, angleY, angleZ)) elif translation: tx = Translation[it][0] ty = Translation[it][1] tz = Translation[it][2] if rotation: tblankM = T.rotate(tblank, (xc0, yc0, zc0), (angleX, angleY, angleZ)) elif translation: tblankM = T.translate(tblank, (tx, ty, tz)) C._initVars(tloc, "{centers:cellN}={centers:cellNInit}") tloc = blankByIBCBodies(tloc, tblankM, 'centers', dim=dimPb, gridType='composite') tloc = X.setHoleInterpolatedPoints(tloc, depth=DEPTH, loc='centers') for zloc in Internal.getZones(tloc): zname = zloc[0] nozloc = dictOfOffBodyZoneNb[zname] C._cpVars(zloc, 'centers:cellN', tc[2][noBaseOff][2][nozloc], "cellN") dictOfMotionADT = { } # ADT des blocs en mvt a detruire a chq pas de temps # bases proches corps interpolees par le maillage de fond fixe + ses voisins for nob in range(len(t[2])): base = t[2][nob] if nob != noBaseOff and Internal.getType(base) == 'CGNSBase_t': if rotation: T._rotate(base, (xc0, yc0, zc0), (angleX, angleY, angleZ)) T._rotate(tBB[2][nob], (xc0, yc0, zc0), (angleX, angleY, angleZ)) T._rotate(tc[2][nob], (xc0, yc0, zc0), (angleX, angleY, angleZ)) elif translation: T._translate(base, (tx, ty, tz)) T._translate(tBB[2][nob], (tx, ty, tz)) T._translate(tc[2][nob], (tx, ty, tz)) tBBNB = Internal.rmNodesByName(tBB, tBB[2][noBaseOff][0]) intersectionsDictOffNB = X.getIntersectingDomains( tBB[2][noBaseOff], t2=tBBNB, method='AABB', taabb=tBB[2][noBaseOff], taabb2=tBBNB) for nob in range(len(t[2])): base = t[2][nob] if nob != noBaseOff and Internal.getType(base) == 'CGNSBase_t': # test intersection entre maillage proche corps et maillage de fond intersectionsDictNBO = X.getIntersectingDomains( tBB[2][nob], t2=tBB[2][noBaseOff], method='AABB', taabb=tBB[2][nob], taabb2=tBB[2][noBaseOff]) print('Near-body base %s in motion' % (base[0])) intersectionsDictNBNB = listOfIntersectionDictsNBNB[nob] for zr in Internal.getZones(base): if Internal.getNodesFromName(zr, "ov_ext*") != []: znamer = zr[0] donorZones = [] hooks = [] for znamed in intersectionsDictNBO[znamer]: if znamed in dictOfOffBodyZoneNb: # donneur=fond nozd = dictOfOffBodyZoneNb[znamed] zd = tc[2][noBaseOff][2][nozd] hooks.append(dictOfOffBodyADT[znamed]) donorZones.append(zd) for znamed in intersectionsDictNBNB[znamer]: nozd = dictOfNearBodyZoneNb[znamed] nobd = dictOfNearBodyBaseNb[znamed] zd = tc[2][nobd][2][nozd] if znamed not in dictOfMotionADT: hook0 = C.createHook(zd, 'adt') dictOfMotionADT[znamed] = hook0 hooks.append(dictOfMotionADT[znamed]) donorZones.append(zd) donorZones = X.setInterpData(zr,donorZones,nature=1,penalty=1,loc='centers',storage='inverse',sameName=1,\ hook=hooks, itype='chimera') for zd in donorZones: znamed = zd[0] if znamed in dictOfOffBodyZoneNb: nozd = dictOfOffBodyZoneNb[znamed] tc[2][noBaseOff][2][nozd] = zd elif znamed in dictOfNearBodyZoneNb: nozd = dictOfNearBodyZoneNb[znamed] nobd = dictOfNearBodyBaseNb[znamed] tc[2][nobd][2][nozd] = zd # base de fond : interpolee depuis ses zones voisines + zones proches corps # les donneurs proches corps mobiles sont deja deplaces # intersectionsDict = X.getIntersectingDomains(tBBloc,t2=tBB,method='AABB',taabb=tBBloc,taabb2=tBB) for zr in Internal.getZones(tloc): znamer = zr[0] if znamer not in listOfSteadyOffBodyZones: donorZones = [] hooks = [] for znamed in intersectionsDictOffOff[ znamer]: # donneur=maillage de fond nozd = dictOfOffBodyZoneNb[znamed] zd = tc[2][noBaseOff][2][nozd] if znamed not in dictOfOffBodyADT: hook0 = C.createHook(zd, 'adt') dictOfOffBodyADT[znamed] = hook0 hooks.append(dictOfOffBodyADT[znamed]) donorZones.append(zd) for znamed in intersectionsDictOffNB[znamer]: nozd = dictOfNearBodyZoneNb[znamed] nobd = dictOfNearBodyBaseNb[znamed] zd = tc[2][nobd][2][nozd] if znamed not in dictOfMotionADT: hook0 = C.createHook(zd, 'adt') dictOfMotionADT[znamed] = hook0 hooks.append(dictOfMotionADT[znamed]) donorZones.append(zd) # print 'Off-body motion zone %s'%znamer donorZones = X.setInterpData(zr,donorZones,nature=1,penalty=1,loc='centers',storage='inverse',sameName=1,\ hook=hooks, itype='chimera') for zd in donorZones: znamed = zd[0] if znamed in dictOfOffBodyZoneNb: nozd = dictOfOffBodyZoneNb[znamed] tc[2][noBaseOff][2][nozd] = zd elif znamed in dictOfNearBodyZoneNb: nozd = dictOfNearBodyZoneNb[znamed] nobd = dictOfNearBodyBaseNb[znamed] tc[2][nobd][2][nozd] = zd for dnrname in dictOfMotionADT: C.freeHook(dictOfMotionADT[dnrname]) # Reinit if NIT == 1: for dnrname in dictOfOffBodyADT: C.freeHook(dictOfOffBodyADT[dnrname]) C._rmVars(tc, [ "CoordinateX", "CoordinateY", "CoordinateZ", "cellNInit", "CoordinateXInit", "CoordinateYInit", "CoordinateZInit" ]) C._initVars(t, '{CoordinateX}={CoordinateXInit}') C._initVars(t, '{CoordinateY}={CoordinateYInit}') C._initVars(t, '{CoordinateZ}={CoordinateZInit}') C._rmVars(t, [ "centers:cellNInit", "CoordinateXInit", "CoordinateYInit", "CoordinateZInit" ]) C._cpVars(tc, "cellN", t, 'centers:cellN') return t, tc else: for zc in Internal.getZones(tc): IDatas = Internal.getNodesFromName(zc, "ID_*") for ID in IDatas: name = ID[0].split('_') ID[0] = 'ID#%d_%s' % (it, name[1]) if it == 5: C.convertPyTree2File(t, "t5.cgns") C.convertPyTree2File(tc, "tc5.cgns") C._initVars(tc[2][noBaseOff], "{cellN}={cellNInit}") # reinit C._initVars(t[2][noBaseOff], "{centers:cellN}={centers:cellNInit}") # reinit C._initVars(tc, '{CoordinateX}={CoordinateXInit}') C._initVars(tc, '{CoordinateY}={CoordinateYInit}') C._initVars(tc, '{CoordinateZ}={CoordinateZInit}') C._initVars(t, '{CoordinateX}={CoordinateXInit}') C._initVars(t, '{CoordinateY}={CoordinateYInit}') C._initVars(t, '{CoordinateZ}={CoordinateZInit}') C._initVars(tBB, '{CoordinateX}={CoordinateXInit}') C._initVars(tBB, '{CoordinateY}={CoordinateYInit}') C._initVars(tBB, '{CoordinateZ}={CoordinateZInit}') for dnrname in dictOfOffBodyADT: C.freeHook(dictOfOffBodyADT[dnrname]) C._rmVars(t, [ "centers:cellNInit", "CoordinateXInit", "CoordinateYInit", "CoordinateZInit" ]) C._initVars(tc[2][noBaseOff], "{cellN}={cellNInit}") C._cpVars(tc, "cellN", t, "centers:cellN") C._rmVars( tc, ["cellNInit", "CoordinateXInit", "CoordinateYInit", "CoordinateZInit"]) return t, tc
# - cpVars (pyTree) - import Converter.PyTree as C import Generator.PyTree as G a = G.cart((0,0,0),(1,1,1),(10,10,10)); a[0] = 'cart1' b = G.cart((0,0,0),(1,1,1),(10,10,10)); b[0] = 'cart2' C._initVars(a, 'Density', 2.) C._initVars(b, 'centers:H', 4.) a = C.cpVars(a, 'Density', a, 'G') # copy in a C._cpVars(a, 'Density', b, 'Density') # copy from a to b a = C.cpVars(b, 'centers:H', a, 'centers:H') # copy from b to a t = C.newPyTree(['Base',a,b]) C.convertPyTree2File(t, 'out.cgns')
def _transfer(t, tc, variables, graph, intersectionDict, dictOfADT, dictOfNobOfRcvZones, dictOfNozOfRcvZones, dictOfNobOfDnrZones, dictOfNozOfDnrZones, dictOfNobOfRcvZonesC, dictOfNozOfRcvZonesC, time=0., absFrame=True, procDict=None, cellNName='cellN'): if procDict is None: procDict = Cmpi.getProcDict(tc) # dictionnaire des matrices de mouvement pour passer du repere relatif d une zone au repere absolu dictOfMotionMatR2A = {} dictOfMotionMatA2R = {} coordsD = [0., 0., 0.] coordsC = [0., 0., 0.] # XAbs = coordsD + Mat*(XRel-coordsC) dictOfFields = {} dictOfIndices = {} datas = {} for z in Internal.getZones(t): zname = Internal.getName(z) if zname not in dictOfNobOfRcvZones: continue # coordonnees dans le repere absolu de la zone receptrice # on les recupere de zc pour eviter un node2center des coordonnees de z nobc = dictOfNobOfRcvZonesC[zname] nozc = dictOfNozOfRcvZonesC[zname] zc = tc[2][nobc][2][nozc] if zc[0] != zname: # check raise ValueError( "_transfer: t and tc skeletons must be identical.") C._cpVars(z, 'centers:' + cellNName, zc, cellNName) res = X.getInterpolatedPoints(zc, loc='nodes', cellNName=cellNName) # print 'Zone %s du proc %d a interpoler'%(zname, Cmpi.rank) if res is not None: # print 'Res not None : zone %s du proc %d a interpoler'%(zname, Cmpi.rank) indicesI, XI, YI, ZI = res # passage des coordonnees du recepteur dans le repere absolu # si mouvement gere par FastS -> les coordonnees dans z sont deja les coordonnees en absolu if not absFrame: if zname in dictOfMotionMatR2A: MatRel2AbsR = RM.getMotionMatrixForZone(z, time=time, F=None) dictOfMotionMatR2A[zname] = MatRel2AbsR else: MatRel2AbsR = dictOfMotionMatR2A[zname] RM._moveN([XI, YI, ZI], coordsD, coordsC, MatRel2AbsR) procR = procDict[zname] for znamed in intersectionDict[zname]: procD = procDict[znamed] if procD == Cmpi.rank: nobc = dictOfNobOfDnrZones[znamed] nozc = dictOfNozOfDnrZones[znamed] zdnr = tc[2][nobc][2][nozc] adt = dictOfADT[znamed] if znamed in dictOfMotionMatA2R: MatAbs2RelD = dictOfMotionMatA2R[znamed] else: if znamed in dictOfMotionMatR2A: MatRel2AbsD = dictOfMotionMatR2A[znamed] MatAbs2RelD = numpy.transpose(MatRel2AbsD) dictOfMotionMatA2R[znamed] = MatAbs2RelD else: MatRel2AbsD = RM.getMotionMatrixForZone(zdnr, time=time, F=None) dictOfMotionMatR2A[znamed] = MatRel2AbsD MatAbs2RelD = numpy.transpose(MatRel2AbsD) dictOfMotionMatA2R[znamed] = MatAbs2RelD [XIRel, YIRel, ZIRel] = RM.moveN([XI, YI, ZI], coordsC, coordsD, MatAbs2RelD) # transfers avec coordonnees dans le repere relatif fields = X.transferFields(zdnr, XIRel, YIRel, ZIRel, hook=adt, variables=variables) if zname not in dictOfFields: dictOfFields[zname] = [fields] dictOfIndices[zname] = indicesI else: dictOfFields[zname].append(fields) else: # print ' ECHANGE GLOBAL entre recepteur %s du proc %d et donneur %s du proc %d '%(zname, Cmpi.rank, znamed, procD) if procD not in datas: datas[procD] = [[zname, znamed, indicesI, XI, YI, ZI]] else: datas[procD].append( [zname, znamed, indicesI, XI, YI, ZI]) # print 'Proc : ', Cmpi.rank, ' envoie les donnees : ' ,datas.keys() # print ' a partir du graphe ', graph # 1er envoi : envoi des numpys des donnees a interpoler suivant le graphe interpDatas = Cmpi.sendRecv(datas, graph) # recuperation par le proc donneur des donnees pour faire les transferts transferedDatas = {} for i in interpDatas: #print Cmpi.rank, 'recoit de',i, '->', len(interpDatas[i]) for n in interpDatas[i]: zdnrname = n[1] zrcvname = n[0] indicesR = n[2] XI = n[3] YI = n[4] ZI = n[5] nobc = dictOfNobOfDnrZones[zdnrname] nozc = dictOfNozOfDnrZones[zdnrname] zdnr = tc[2][nobc][2][nozc] adt = dictOfADT[zdnrname] if zdnrname in dictOfMotionMatA2R: MatAbs2RelD = dictOfMotionMatA2R[zdnrname] else: if zdnrname in dictOfMotionMatR2A: MatRel2AbsD = dictOfMotionMatR2A[zdnrname] MatAbs2RelD = numpy.transpose(MatRel2AbsD) dictOfMotionMatA2R[zdnrname] = MatAbs2RelD else: MatRel2AbsD = RM.getMotionMatrixForZone(zdnr, time=time, F=None) dictOfMotionMatR2A[zdnrname] = MatRel2AbsD MatAbs2RelD = numpy.transpose(MatRel2AbsD) dictOfMotionMatA2R[zdnrname] = MatAbs2RelD [XIRel, YIRel, ZIRel] = RM.moveN([XI, YI, ZI], coordsC, coordsD, MatAbs2RelD) # transferts avec coordonnees dans le repere relatif fields = X.transferFields(zdnr, XIRel, YIRel, ZIRel, hook=adt, variables=variables) procR = procDict[zrcvname] if procR not in transferedDatas: transferedDatas[procR] = [[zrcvname, indicesR, fields]] else: transferedDatas[procR].append([zrcvname, indicesR, fields]) if transferedDatas != {}: # 2nd envoi : envoi des numpys des donnees interpolees suivant le graphe rcvDatas = Cmpi.sendRecv(transferedDatas, graph) # remise des donnees interpolees chez les zones receveuses # une fois que tous les donneurs potentiels ont calcule et envoye leurs donnees for i in rcvDatas: #print Cmpi.rank, 'recoit des donnees interpolees de',i, '->', len(rcvDatas[i]) for n in rcvDatas[i]: zrcvname = n[0] indicesI = n[1] fields = n[2] if zrcvname not in dictOfFields: dictOfFields[zrcvname] = [fields] dictOfIndices[zrcvname] = indicesI else: dictOfFields[zrcvname].append(fields) for zrcvname in dictOfIndices: nob = dictOfNobOfRcvZones[zrcvname] noz = dictOfNozOfRcvZones[zrcvname] z = t[2][nob][2][noz] allInterpFields = dictOfFields[zrcvname] indicesI = dictOfIndices[zrcvname] C._filterPartialFields(z, allInterpFields, indicesI, loc='centers', startFrom=0, filterName='donorVol') # SORTIE return None