def _moveZone__(z, time):
cont = Internal.getNodeFromName1(z, 'TimeMotion')
if cont is not None:
motions = Internal.getNodesFromType1(cont, 'TimeRigidMotion_t')
for m in motions:
type = Internal.getNodeFromName1(m, 'MotionType')
dtype = type[1][0]
if dtype == 1: # type 1: time string
tx = evalTimeString__(m, 'tx', time)
ty = evalTimeString__(m, 'ty', time)
tz = evalTimeString__(m, 'tz', time)
cx = evalTimeString__(m, 'cx', time)
cy = evalTimeString__(m, 'cy', time)
cz = evalTimeString__(m, 'cz', time)
ex = evalTimeString__(m, 'ex', time)
ey = evalTimeString__(m, 'ey', time)
ez = evalTimeString__(m, 'ez', time)
angle = evalTimeString__(m, 'angle', time)
T._translate(z, (tx, ty, tz))
if (angle != 0):
angle = angle #*__RAD2DEG__
T._rotate(z, (cx, cy, cz), (ex - cx, ey - cy, ez - cz),
angle)
elif dtype == 2: # type 2: rotation motion CassiopeeSolver
try:
import Cassiopee as K
import elsA_user as E # caveat
import KBridge
except:
raise ImportError(
"evalPosition: motionRotor requires CassiopeeSolver.")
transl_speed = getNodeValue__(m, 'transl_speed')
psi0 = getNodeValue__(m, 'psi0')
psi0_b = getNodeValue__(m, 'psi0_b')
alp_pnt = getNodeValue__(m, 'alp_pnt')
alp_vct = getNodeValue__(m, 'alp_vct')
alp0 = getNodeValue__(m, 'alp0')
rot_pnt = getNodeValue__(m, 'rot_pnt')
rot_vct = getNodeValue__(m, 'rot_vct')
rot_omg = getNodeValue__(m, 'rot_omg')
del_pnt = getNodeValue__(m, 'del_pnt')
del_vct = getNodeValue__(m, 'del_vct')
del0 = getNodeValue__(m, 'del0')
delc = getNodeValue__(m, 'delc')
dels = getNodeValue__(m, 'dels')
bet_pnt = getNodeValue__(m, 'bet_pnt')
bet_vct = getNodeValue__(m, 'bet_vct')
bet0 = getNodeValue__(m, 'bet0')
betc = getNodeValue__(m, 'betc')
bets = getNodeValue__(m, 'bets')
tet_pnt = getNodeValue__(m, 'tet_pnt')
tet_vct = getNodeValue__(m, 'tet_vct')
tet0 = getNodeValue__(m, 'tet0')
tetc = getNodeValue__(m, 'tetc')
tets = getNodeValue__(m, 'tets')
span_vct = getNodeValue__(m, 'span_vct')
pre_lag_ang = getNodeValue__(m, 'pre_lag_ang')
pre_lag_pnt = getNodeValue__(m, 'pre_lag_pnt')
pre_lag_vct = getNodeValue__(m, 'pre_lag_vct')
pre_con_ang = getNodeValue__(m, 'pre_con_ang')
pre_con_pnt = getNodeValue__(m, 'pre_con_pnt')
pre_con_vct = getNodeValue__(m, 'pre_con_vct')
if z[0] + '_' + m[0] not in DEFINEDMOTIONS:
Func1 = E.function('rotor_motion', z[0] + '_' + m[0])
# angle initial du rotor par rapport au champ a l'infini
Func1.set("psi0", float(psi0[0]))
# Angle initial de la pale
# (si z est l'axe de rotation cet angle vaut psi0_b+pi/2)
Func1.set("psi0_b", float(psi0_b[0]))
# parametres inclinaison du rotor
Func1.set("alp_pnt_x", float(alp_pnt[0]))
Func1.set("alp_pnt_y", float(alp_pnt[1]))
Func1.set("alp_pnt_z", float(alp_pnt[2]))
Func1.set("alp_vct_x", float(alp_vct[0]))
Func1.set("alp_vct_y", float(alp_vct[1]))
Func1.set("alp_vct_z", float(alp_vct[2]))
Func1.set("alp0", float(alp0[0]))
# parametres rotation uniforme du rotor
Func1.set("rot_pnt_x", float(rot_pnt[0]))
Func1.set("rot_pnt_y", float(rot_pnt[1]))
Func1.set("rot_pnt_z", float(rot_pnt[2]))
Func1.set("rot_vct_x", float(rot_vct[0]))
Func1.set("rot_vct_y", float(rot_vct[1]))
Func1.set("rot_vct_z", float(rot_vct[2]))
Func1.set("rot_omg", float(rot_omg[0]))
# parametres 1ere rotation: trainee
Func1.set("del_pnt_x", float(del_pnt[0]))
Func1.set("del_pnt_y", float(del_pnt[1]))
Func1.set("del_pnt_z", float(del_pnt[2]))
Func1.set("del_vct_x", float(del_vct[0]))
Func1.set("del_vct_y", float(del_vct[1]))
Func1.set("del_vct_z", float(del_vct[2]))
Func1.set("del0", float(del0[0]))
Func1.set("nhdel", 3)
Func1.set("del1c", float(delc[0]))
Func1.set("del1s", float(dels[0]))
Func1.set("del2c", float(delc[1]))
Func1.set("del2s", float(dels[1]))
Func1.set("del3c", float(delc[2]))
Func1.set("del3s", float(dels[2]))
# parametres 2eme rotation: battement
Func1.set("bet_pnt_x", float(bet_pnt[0]))
Func1.set("bet_pnt_y", float(bet_pnt[1]))
Func1.set("bet_pnt_z", float(bet_pnt[2]))
Func1.set("bet_vct_x", float(bet_vct[0]))
Func1.set("bet_vct_y", float(bet_vct[1]))
Func1.set("bet_vct_z", float(bet_vct[2]))
Func1.set("bet0", float(bet0[0]))
Func1.set("nhbet", 3)
Func1.set("bet1c", float(betc[0]))
Func1.set("bet1s", float(bets[0]))
Func1.set("bet2c", float(betc[1]))
Func1.set("bet2s", float(bets[1]))
Func1.set("bet3c", float(betc[2]))
Func1.set("bet3s", float(bets[2]))
# parametres 3eme rotation: pas cyclique
Func1.set("tet_pnt_x", float(tet_pnt[0]))
Func1.set("tet_pnt_y", float(tet_pnt[1]))
Func1.set("tet_pnt_z", float(tet_pnt[2]))
Func1.set("tet_vct_x", float(tet_vct[0]))
Func1.set("tet_vct_y", float(tet_vct[1]))
Func1.set("tet_vct_z", float(tet_vct[2]))
Func1.set("tet0", float(tet0[0]))
Func1.set("nhtet", 1)
Func1.set("tet1c", float(tetc[0]))
Func1.set("tet1s", float(tets[0]))
Func1.set('span_vct_x', float(span_vct[0]))
Func1.set('span_vct_y', float(span_vct[1]))
Func1.set('span_vct_z', float(span_vct[2]))
Func1.set('pre_lag_ang', float(pre_lag_ang[0]))
Func1.set('pre_lag_pnt_x', float(pre_lag_pnt[0]))
Func1.set('pre_lag_pnt_y', float(pre_lag_pnt[1]))
Func1.set('pre_lag_pnt_z', float(pre_lag_pnt[2]))
Func1.set('pre_lag_vct_x', float(pre_lag_vct[0]))
Func1.set('pre_lag_vct_y', float(pre_lag_vct[1]))
Func1.set('pre_lag_vct_z', float(pre_lag_vct[2]))
Func1.set('pre_con_ang', float(pre_con_ang[0]))
Func1.set('pre_con_pnt_x', float(pre_con_pnt[0]))
Func1.set('pre_con_pnt_y', float(pre_con_pnt[1]))
Func1.set('pre_con_pnt_z', float(pre_con_pnt[2]))
Func1.set('pre_con_vct_x', float(pre_con_vct[0]))
Func1.set('pre_con_vct_y', float(pre_con_vct[1]))
Func1.set('pre_con_vct_z', float(pre_con_vct[2]))
DEFINEDMOTIONS[z[0] + '_' + m[0]] = Func1
else:
Func1 = DEFINEDMOTIONS[z[0] + '_' + m[0]]
M = KBridge.evalKDesFunction(Func1, time)
_evalPosition___(z, None, M)
T._translate(z,
(transl_speed[0] * time, transl_speed[1] * time,
transl_speed[2] * time))
elif dtype == 3: # type 3: constant transl + rotation
transl_speed = getNodeValue__(m, 'transl_speed')
axis_pnt = getNodeValue__(m, 'axis_pnt')
axis_vct = getNodeValue__(m, 'axis_vct')
omega = getNodeValue__(m, 'omega')
tx = transl_speed[0] * time
ty = transl_speed[1] * time
tz = transl_speed[2] * time
T._translate(z, (tx, ty, tz))
cx = axis_pnt[0] + tx
cy = axis_pnt[1] + ty
cz = axis_pnt[2] + tz
ex = axis_vct[0]
ey = axis_vct[1]
ez = axis_vct[2]
angle = omega[0] * time * __RAD2DEG__
T._rotate(z, (cx, cy, cz), (ex - cx, ey - cy, ez - cz), angle)
return None
rangeDonor='doubly_defined') #dd
#
C._addBC2Zone(b, 'overlap', 'BCOverlap', 'kmax')
C._fillEmptyBCWith(b, "wall", "BCWall")
for rangel in ['imin', 'imax', 'jmin', 'jmax']:
C._addBC2Zone(b,
'overlapdd',
'BCOverlap',
rangel,
zoneDonor=[a],
rangeDonor='doubly_defined')
import Converter.elsAProfile as CE
CE._addPeriodicDataInSolverParam(b,
rotationCenter=[0., 0., 0.],
rotationAngle=[0., 0., 1.],
NAzimutalSectors=3,
isChimera=True)
T._rotate(b, (0, 0, 0), (0, 0, 1), 60.)
#
t = C.newPyTree(['Base', a, 'Base2', b])
C._initVars(t, 'Density', 1.)
C._initVars(t, 'centers:cellN', 1)
t = X.applyBCOverlaps(t, depth=1)
t = X.setDoublyDefinedBC(t, depth=1)
t = X.setInterpolations(t,
double_wall=1,
storage='direct',
prefixFile=LOCAL + '/chm')
test.testT(t, 2)
# - blankCells (pyTree) - import Converter.PyTree as C import Connector.PyTree as X import Generator.PyTree as G import Geom.PyTree as D import Transform.PyTree as T import KCore.test as test import numpy surf = D.sphere((0,0,0), 0.5, 20) T._rotate(surf,(0.,0.,0.),(0.,1.,0.), 90.) a = G.cart((-1.,-1.,-1.),(0.1,0.1,0.1), (20,20,20)) C._addBC2Zone(a, 'ov', 'BCOverlap', 'jmin') t = C.newPyTree(['Cart',a]) t[2][1] = C.addState(t[2][1], 'EquationDimension', 3) C._fillEmptyBCWith(t, 'wall', 'BCWall') C._addVars(t, 'Density') bodies = [[surf]] C._initVars(t, 'centers:cellN', 1.) # Matrice de masquage (arbre d'assemblage) BM = numpy.array([[1]]) t2 = X.blankCells(t, bodies, BM) test.testT(t2, 1) # in place C._initVars(t2, 'centers:cellN', 1.) X._blankCells(t2, bodies, BM) test.testT(t2,1) # masque inverse
# - cart2Cyl (pyTree) - import Transform.PyTree as T import Generator.PyTree as G import Converter.PyTree as C import KCore.test as test a = G.cylinder((0., 0., 0.), 0.5, 1., 0., 359, 1., (360, 20, 10)) C._addBC2Zone(a, 'wall1', 'BCWall', 'imin') C._initVars(a, 'F', 2.) C._initVars(a, 'centers:G', 1.) T._cart2Cyl(a, (0., 0., 0.), (0, 0, 1)) test.testT(a, 1) a = G.cylinder((0., 0., 0.), 0.5, 1., 0., 359, 1., (360, 20, 10)) T._rotate(a, (0, 0, 0), (1, 0, 0), 90.) T._cart2Cyl(a, (0., 0., 0.), (0, 1, 0)) test.testT(a, 2) a = G.cylinder((0., 0., 0.), 0.5, 1., 0., 359, 1., (360, 20, 10)) T._rotate(a, (0, 0, 0), (0, 1, 0), 90.) T._cart2Cyl(a, (0., 0., 0.), (1, 0, 0)) test.testT(a, 3)
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
