def submenu(items): import Geom.PyTree as D import Transform.PyTree as T import Converter.PyTree as C nitems = len(items) out = []; c = 0 for i in items: a = D.text2D(i) CPlot._addRender2Zone(a, color='White') T._translate(a, (0,-c,0)) out.append(a) c += 10 t = C.newPyTree(['Base']); t[2][1][2] += out CPlot.display(t, mode='Render') CPlot.setState(activateShortCuts=0) current = 0 go = True; l = '' while go: while l == '': l = CPlot.getKeyboard(); time.sleep(dt) v = ord(l[0]); print(v) if v == 1: # up b = CPlot.addRender2Zone(out[current], color='White') CPlot.replace(t, 1, current, b) current -= 1 if current < 0: current = nitems-1 b = CPlot.addRender2Zone(out[current], color='Red') CPlot.replace(t, 1, current, b) CPlot.render() elif v == 2: # down b = CPlot.addRender2Zone(out[current], color='White') CPlot.replace(t, 1, current, b) current += 1 if current >= nitems: current = 0 b = CPlot.addRender2Zone(out[current], color='Red') CPlot.replace(t, 1, current, b) CPlot.render() elif v == 3: b = CPlot.addRender2Zone(out[current], color='White') CPlot.replace(t, 1, current, b) current -= 1 if current < 0: current = nitems-1 b = CPlot.addRender2Zone(out[current], color='Red') CPlot.replace(t, 1, current, b) CPlot.render() elif v == 4: b = CPlot.addRender2Zone(out[current], color='White') CPlot.replace(t, 1, current, b) current += 1 if current >= nitems: current = 0 b = CPlot.addRender2Zone(out[current], color='Red') CPlot.replace(t, 1, current, b) CPlot.render() elif v == 13: print('returning %s.'%str(current)) return current, items[current] time.sleep(dt) l = ''; v = -1; CPlot.resetKeyboard()
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
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
import KCore.test as test import Transform.PyTree as T NIT = 10 DEPTH = 2 # Bloc cartesien N = 128 h = 0.1 a = G.cart((0., 0., 0.), (h, h, h), (N, N, 1)) # Init wall sphere = D.sphere((6.4, 6.4, 0), 1., 100) sphere = C.convertArray2Tetra(sphere) sphere = G.close(sphere) t = C.newPyTree(['Base', a]) for it in range(NIT): T._translate(sphere, (0.1 * it, 0, 0)) C._initVars(t, "cellN", 1.) t = X.blankCells(t, [[sphere]], numpy.array([[1]]), blankingType='node_in') t = X.setHoleInterpolatedPoints(t, depth=1, loc='nodes') C._initVars(t, '{flag}=({cellN}>1.)') t = DTW.distance2WallsEikonal(t, sphere, DEPTH=DEPTH, nitmax=10) test.testT(t, 1) # Centers t = C.newPyTree(['Base']) t[2][1][2] = [a] sphere = D.sphere((6.4, 6.4, 0), 1., 100) sphere = C.convertArray2Tetra(sphere) sphere = G.close(sphere) for it in range(NIT): T._translate(sphere, (0.1 * it, 0, 0))
# - translate (pyTree) - import Transform.PyTree as T import Generator.PyTree as G import Converter.PyTree as C a = G.cart((0, 0, 0), (1, 1, 1), (10, 10, 3)) T._translate(a, (10., 0., 0.)) C.convertPyTree2File(a, 'out.cgns')