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
