def initLamb(t, position=(0.,0.), Gamma=2., MInf=0.5, loc='nodes'):
"""Init the pyTree with a Lamb vortex of
intensity Gamma and position (x0,y0).
Usage: initLamb(t, (x0,y0), Gamma, MInf)"""
tp = Internal.copyRef(t)
_initLamb(tp, position, Gamma, MInf, loc)
return tp
def setPrescribedMotion1(t,
name,
tx="0",
ty="0",
tz="0",
cx="0",
cy="0",
cz="0",
ex="0",
ey="0",
ez="1",
angle="0"):
tp = Internal.copyRef(t)
_setPrescribedMotion1(tp,
name,
tx=tx,
ty=ty,
tz=tz,
cx=cx,
cy=cy,
cz=cz,
ex=ex,
ey=ey,
ez=ez,
angle=angle)
return tp
def initVisbal(t, position=(0.,0.), Gamma=2., MInf=0.5, loc='nodes'):
"""Init the array defining a grid with a Visbal vortex of
intensity Gamma and position (x0,y0).
Returns the array of the grid + cfd field in centers
Usage: initVisbal(array, (x0,y0), Gamma, MInf)"""
tp = Internal.copyRef(t)
_initVisbal(tp, position, Gamma, MInf, loc)
return tp
def initConst(t, adim='adim1', MInf=None, alphaZ=0., alphaY=0., ReInf=1.e8,
loc='nodes'):
"""Init the pyTree by the reference state if it is defined in t, else by
input parameters.
Usage: initConst(t, adim, MInf, alphaZ, alphaY, ReInf, loc)"""
tp = Internal.copyRef(t)
_initConst(tp, adim, MInf, alphaZ, alphaY, ReInf, loc)
return tp
def initScully(t, position=(0.,0.), Gamma=2.,
coreRadius=1., MInf=0.5, model=0, loc='nodes'):
"""Init the array defining a block field with a Scully vortex
of intensity Gamma, core radius coreRadius and position (x0,y0).
Usage: initScully(array, (x0,y0), Gamma, coreRadius, MInf, model)"""
tp = Internal.copyRef(t)
_initScully(tp, position, Gamma, coreRadius, MInf, model, loc)
return tp
def addRender2Zone(t, material=None, color=None, blending=None,
meshOverlay=None, shaderParameters=None):
"""Add a renderInfo node to a zone node.
Usage: addRender2Zone(zone, renderInfo)"""
tp = Internal.copyRef(t)
_addRender2Zone(tp, material, color, blending,
meshOverlay, shaderParameters)
return tp
def agglomerateCellsWithSpecifiedFaces(
t,
pgs,
simplify=2
): # 0 : dno not simplify, 1 : simplify only internals, 2 : simlplify evrywhere
tp = Internal.copyRef(t)
_agglomerateCellsWithSpecifiedFaces(tp, pgs, simplify)
return tp
def find(event=None):
if CTK.t == []: return
if CTK.__MAINTREE__ <= 0:
CTK.TXT.insert('START', 'Fail on a temporary tree.\n')
CTK.TXT.insert('START', 'Error: ', 'Error')
return
nzs = CPlot.getSelectedZones()
if nzs == []:
CTK.TXT.insert('START', 'Selection is empty.\n')
CTK.TXT.insert('START', 'Error: ', 'Error')
return
if len(nzs) != 1:
CTK.TXT.insert('START', 'Only one block must be selected.\n')
CTK.TXT.insert('START', 'Error: ', 'Error')
return
nz = nzs[0]
nob = CTK.Nb[nz] + 1
noz = CTK.Nz[nz]
z = CTK.t[2][nob][2][noz]
type = VARS[0].get()
if type == 'Node index':
inds = CTK.varsFromWidget(VARS[1].get(), type=3)
if len(inds) == 0:
CTK.TXT.insert('START', 'Invalid index.\n')
CTK.TXT.insert('START', 'Error: ', 'Error')
return
[px, py, pz] = C.getValue(z, Internal.__GridCoordinates__, inds[0])
CTK.TXT.insert('START', 'Node %s found.\n' % VARS[1].get())
elif type == 'Coordinates':
vars = CTK.varsFromWidget(VARS[1].get(), type=1)
if len(vars) != 3:
CTK.TXT.insert('START', 'Invalid coordinates.\n')
CTK.TXT.insert('START', 'Error: ', 'Error')
return
[px, py, pz] = vars
CTK.TXT.insert('START', 'Coordinates %s found.\n' % VARS[1].get())
else: # type = element index
inds = CTK.varsFromWidget(VARS[1].get(), type=3)
if len(inds) == 0:
CTK.TXT.insert('START', 'Invalid index.\n')
CTK.TXT.insert('START', 'Error: ', 'Error')
return
zp = Internal.copyRef(z)
C._deleteAllBCAndSolutions__(zp)
zp = C.node2Center(z)
[px, py, pz] = C.getValue(zp, Internal.__GridCoordinates__, inds[0])
CTK.TXT.insert('START', 'Element %s found.\n' % VARS[1].get())
(xeye, yeye, zeye) = CPlot.getState('posEye')
(xcam, ycam, zcam) = CPlot.getState('posCam')
dx = xcam - xeye
dy = ycam - yeye
dz = zcam - zeye
CPlot.setState(posEye=(px, py, pz))
CPlot.setState(posCam=(px + dx, py + dy, pz + dz))
CPlot.setActivePoint(px, py, pz)
def getTangent(t):
"""
Makes the tangent of a 1D curve. The input argument shall be a structured
1D curve. Each node of the output represents the unitary tangent vector,
pointing towards the tangent direction of the input 1D curve.
Usage: b = getTangent(t)"""
tp = Internal.copyRef(t)
C._deleteFlowSolutions__(tp)
C._TZGC(tp, 'nodes', Geom.getTangent)
return tp
def volumeFromCrossSections(t):
"""Generate a 3D volume from cross sections contours in (x,y) planes.
Usage: volumeFromCrossSections(t)"""
tp = Internal.copyRef(t)
nodes = Internal.getZones(tp)
coords = []
for z in nodes:
coords.append(C.getFields(Internal.__GridCoordinates__, z)[0])
coordp = Geom.volumeFromCrossSections(coords)
zone = C.convertArrays2ZoneNode('Volume', [coordp])
return zone
def setInterpTransfers(aR, aD, variables=[],
variablesIBC=['Density','MomentumX','MomentumY','MomentumZ','EnergyStagnationDensity'],
bcType=0, varType=1, graph=None,
procDict=None, type='ALLD',
Gamma=1.4, Cv=1.7857142857142865, MuS=1.e-08,
Cs=0.3831337844872463, Ts=1.0):
tp = Internal.copyRef(aR)
compact = 0
_setInterpTransfers(tp, aD, variables, variablesIBC,
bcType, varType, compact, graph,
procDict, type, Gamma, Cv, MuS, Cs, Ts)
return tp
def addRender2PyTree(t, slot=0, posCam=None, posEye=None, dirCam=None,
mode=None, scalarField=None, niso=None, isoScales=None,
isoEdges=None, isoLight=None,
colormap=None, materials=None, bumpMaps=None, billBoards=None):
"""Add a renderInfo node to a tree.
Usage: addRender2PyTree(t, slot, renderInfo)"""
a = Internal.copyRef(t)
_addRender2PyTree(a, slot, posCam, posEye, dirCam,
mode, scalarField, niso, isoScales,
isoEdges, isoLight, colormap,
materials, bumpMaps, billBoards)
return a
def computeVorticityMagnitude(t):
t2 = Internal.copyRef(t)
presvx = C.isNamePresent(t2, 'centers:VorticityX')
if presvx == -1: t2 = computeVorticity(t)
t2 = C.magnitude(
t2, ['centers:VorticityX', 'centers:VorticityY', 'centers:VorticityZ'])
if presvx == -1:
t2 = C.rmVars(
t2,
['centers:VorticityX', 'centers:VorticityY', 'centers:VorticityZ'])
Internal._renameNode(t2, 'magnitudeVorticityXVorticityYVorticityZ',
'VorticityMagnitude')
return t2
def setPrescribedMotion3(t,
name,
transl_speed=(0., 0., 0.),
axis_pnt=(0., 0., 0.),
axis_vct=(0., 0., 0.),
omega=0.):
tp = Internal.copyRef(t)
_setPrescribedMotion3(tp,
name,
transl_speed=transl_speed,
axis_pnt=axis_pnt,
axis_vct=axis_vct,
omega=omega)
return tp
def computeVorticity(t):
t2 = Internal.copyRef(t)
presvx = C.isNamePresent(t2, 'VelocityX')
if presvx == -1:
presvxc = C.isNamePresent(t2, 'centers:VelocityX')
if presvxc > -1:
t2 = C.center2Node(t2, [
'centers:VelocityX', 'centers:VelocityY', 'centers:VelocityZ'
])
else:
t2 = P.computeVariables(t2,
['VelocityX', 'VelocityY', 'VelocityZ'])
t2 = P.computeCurl(t2, ['VelocityX', 'VelocityY', 'VelocityZ'])
if presvx == -1: t2 = C.rmVars(t2, ['VelocityX', 'VelocityY', 'VelocityZ'])
Internal._renameNode(t2, 'rotx', 'VorticityX')
Internal._renameNode(t2, 'roty', 'VorticityY')
Internal._renameNode(t2, 'rotz', 'VorticityZ')
return t2
def cpBlock():
if CTK.t == []: return
if CTK.__MAINTREE__ <= 0:
CTK.TXT.insert('START', 'Fail on a temporary tree.\n')
CTK.TXT.insert('START', 'Error: ', 'Error')
return
nzs = CPlot.getSelectedZones()
if nzs == []:
CTK.TXT.insert('START', 'Selection is empty.\n')
CTK.TXT.insert('START', 'Error: ', 'Error')
return
CTK.saveTree()
CTK.t = C.addBase2PyTree(CTK.t, 'COPY', 3)
base = Internal.getNodesFromName1(CTK.t, 'COPY')[0]
gnob = C.getNobOfBase(base, CTK.t)
newFamilyZoneNames = set()
for nz in nzs:
nob = CTK.Nb[nz] + 1
noz = CTK.Nz[nz]
z = Internal.copyRef(CTK.t[2][nob][2][noz])
z[0] = C.getZoneName(z[0] + '.dup')
CTK.add(CTK.t, gnob, -1, z)
# Create new Family Name for Family Zones
nbdup = z[0].split('.dup')[-1]
nodes = Internal.getNodesFromType1(z, 'FamilyName_t')
for f in nodes:
newFamilyZoneName = Internal.getValue(f) + '.dup' + nbdup
f[1] = newFamilyZoneName
if newFamilyZoneName not in newFamilyZoneNames:
newFamilyZoneNames.add(newFamilyZoneName)
CTK.TXT.insert(
'START', CTK.t[2][nob][0] + '/' + CTK.t[2][nob][2][noz][0] +
' duplicated.\n')
# Create new Family_t node for each Tag Zone
for f in newFamilyZoneNames:
Internal.newFamily(name=f, parent=base)
(CTK.Nb, CTK.Nz) = CPlot.updateCPlotNumbering(CTK.t)
CTK.TKTREE.updateApp()
CPlot.render()
def distribute(t,
NProc,
prescribed={},
perfo=[],
weight={},
useCom='all',
algorithm='gradient0',
nghost=0):
"""Distribute a pyTree over processors.
Usage: distribute(t, NProc, prescribed={}, perfo=[], weight={}, useCom='all', algorithm='gradient0')"""
tp = Internal.copyRef(t)
out = _distribute(tp,
NProc,
prescribed=prescribed,
perfo=perfo,
weight=weight,
useCom=useCom,
algorithm=algorithm,
nghost=nghost)
return tp, out
def computeQCriterion(t):
vars0 = [
'centers:gradxVelocityX', 'centers:gradyVelocityX',
'centers:gradzVelocityX', 'centers:gradxVelocityY',
'centers:gradyVelocityY', 'centers:gradzVelocityY',
'centers:gradxVelocityZ', 'centers:gradyVelocityZ',
'centers:gradzVelocityZ'
]
t2 = Internal.copyRef(t)
presvx = C.isNamePresent(t2, 'VelocityX')
if presvx == -1:
presvxc = C.isNamePresent(t2, 'centers:VelocityX')
if presvxc > -1:
t2 = C.center2Node(t2, [
'centers:VelocityX', 'centers:VelocityY', 'centers:VelocityZ'
])
else:
t2 = P.computeVariables(t2,
['VelocityX', 'VelocityY', 'VelocityZ'])
presgx = C.isNamePresent(t2, 'centers:gradxVelocityX')
if presgx == -1:
presgxn = C.isNamePresent(t2, 'gradxVelocityX')
if presgxn > -1: t2 = C.center2Node(t2, vars0)
else:
t2 = P.computeGrad(t2, 'VelocityX')
t2 = P.computeGrad(t2, 'VelocityY')
t2 = P.computeGrad(t2, 'VelocityZ')
if presvx == -1: t2 = C.rmVars(t2, ['VelocityX', 'VelocityY', 'VelocityZ'])
t2 = C.initVars(
t2,
'centers:QCriterion = -0.5*({centers:gradxVelocityX}*{centers:gradxVelocityX}+{centers:gradyVelocityY}*{centers:gradyVelocityY}+{centers:gradzVelocityZ}*{centers:gradzVelocityZ}+2*{centers:gradyVelocityX}*{centers:gradxVelocityY}+2*{centers:gradzVelocityX}*{centers:gradxVelocityZ}+2*{centers:gradzVelocityY}*{centers:gradyVelocityZ})'
)
if presgx == -1: t2 = C.rmVars(t2, vars0)
return t2
def overlayField(t1, t2, MInf=0.5, loc='nodes'):
"""Overlay the field of zone1 and zone2 in a unique zone.
Usage: overlayField(z1, z2, MInf, loc)"""
tp = Internal.copyRef(t1)
_overlayField(tp, t2, MInf, loc)
return tp
def enforceh(a, N=100, h=-1.):
"""Remesh a 1D curve with imposed steps."""
ap = Internal.copyRef(a)
_enforceh(ap, N, h)
return ap
# - dist2WallsEikonal (pyTree) -
import Converter.PyTree as C
import Connector.PyTree as X
import Converter.Internal as Internal
import Dist2Walls.PyTree as DTW
import Geom.PyTree as D
import Generator.PyTree as G
import numpy
DEPTH = 2
snear = 0.4; vmin = 21
# Init wall
body = D.circle((0,0,0),1.,N=60)
res = G.octree([body],[snear], dfar=5., balancing=1)
res = G.octree2Struct(res, vmin=vmin, ext=DEPTH+1,merged=1)
t = C.newPyTree(['Base']); t[2][1][2] = res
# Mark solid and fluid points
t = X.applyBCOverlaps(t,depth=DEPTH,loc='nodes')
tc = Internal.copyRef(t)
tc = X.setInterpData(t,tc,loc='nodes',storage="inverse")
C._initVars(t,"cellN",1.)
t = X.blankCells(t, [[body]], numpy.array([[1]]), blankingType='node_in')
t = X.setHoleInterpolatedPoints(t,depth=1,loc='nodes')
C._initVars(t,'flag=({cellN}>1.)')
t = DTW.distance2WallsEikonal(t,body,tc=tc,DEPTH=DEPTH,nitmax=10)
C.convertPyTree2File(t, 'out.cgns')
def copyDistribution(a, b):
o = Internal.copyRef(a)
_copyDistribution(o, b)
return o
def triangulateBC(t, bctype):
tp = Internal.copyRef(t)
_triangulateBC(tp, bctype)
return tp
def triangulateSpecifiedFaces(t, pgs):
tp = Internal.copyRef(t)
_triangulateSpecifiedFaces(tp, pgs)
return tp
def addVar__(t, var, loc='centers'):
tp = Internal.copyRef(t)
_addVar__(tp, var, loc)
return tp
def XcellN(t, prioritaryMesh, blankingMatrix=[]):
try:
import Transform as T
except:
raise ImportError("XcellN: requires Transform module.")
nb = -1
a = Internal.copyRef(t)
# ajout du celln aux centres si n'existe pas pour une zone
loc = 'centers'
a = addVar__(a, var='cellN', loc=loc)
bases = Internal.getBases(a)
if blankingMatrix == []:
blankingMatrix = numpy.ones((len(bases), len(prioritaryMesh)),
numpy.int32)
for b in bases:
nb += 1
#print 'bgm base : %d / %d' %(nb+1, len(bases))
coords = C.getFields(Internal.__GridCoordinates__, b)
if coords == []: continue
coords = Converter.convertArray2NGon(coords)
if loc == 'centers': cellN = C.getField('centers:cellN', b)
else: cellN = C.getField('cellN', b)
bc = []
wallpgs = [
] # LIST OF BODY WALLS IDS USED TO IGNORE BGM CELLS INSIDE THEM
ghostpgs = [
] # LIST OF BOUNDARIES TO EXTRUDE TO PREVENT UNECESSARY X COMPUTATIONS
cur_shift = 0
for nb2 in range(len(prioritaryMesh)):
blanking = blankingMatrix[nb, nb2]
#if (prioritaryMesh[nb2] == []): print('empty')
if (prioritaryMesh[nb2] == []): continue
#print('hiding base : %d / %d' %(nb2+1, len(prioritaryMesh)))
zones = Internal.getZones(prioritaryMesh[nb2])
i = 0
for z in zones:
c = C.getFields(Internal.__GridCoordinates__, z)
if c == []: continue
#print(' -- hiding base %d zone : %d / %d' %(nb2+1, i+1, len(zones)))
c = c[0]
bc.append(c)
(wallpgs, cur_shift_new) = concatenateBC('BCWall', zones, wallpgs,
cur_shift)
(ghostpgs, cur_shift_new) = concatenateBC('UserDefined', zones,
ghostpgs, cur_shift)
cur_shift = cur_shift_new
if (wallpgs != []):
wallpgs = numpy.concatenate(wallpgs) # create a single list
#print("nb of wall pgs %s"%(len(wallpgs)))
if (ghostpgs != []):
ghostpgs = numpy.concatenate(ghostpgs) # create a single list
#print("nb of ghost pgs %s"%(len(ghostpgs)))
if bc == []:
#print('Warning : no xcelln to compute for base %d'%(nb))
continue
bc = Converter.convertArray2NGon(bc)
bc = T.join(bc)
cellN = XOR.XcellN(coords, cellN, bc, wallpgs, ghostpgs)
bc = None
coords = None
C.setFields(cellN, b, loc, False)
return a
# - importVariables (pyTree) - import Converter.PyTree as C import Generator.PyTree as G import Post.PyTree as P import Converter.Internal as Internal import KCore.test as test # z2 sans solutions z1 = G.cart((0., 0., 0.), (0.1, 0.1, 0.1), (3, 3, 3)) C._addBC2Zone(z1, 'overlap', 'BCOverlap', 'imin') C._fillEmptyBCWith(z1, 'nref', 'BCFarfield') t1 = C.newPyTree(['Base', z1]) t2 = Internal.copyRef(t1) C._initVars(t1, 'centers:cellN', 1.) C._initVars(t1, 'Pressure', 10.) C._initVars(t1, 'Density', 1.) C._addState(t1[2][1], 'Mach', 0.6) C._addState(t2[2][1], 'Mach', 0.6) t2 = P.importVariables(t1, t2) test.testT(t2, 1) # z2 avec cellN = 0 C._initVars(t2, 'centers:cellN', 0.) t2 = P.importVariables(t1, t2) test.testT(t2, 2) # z1 en centres avec z2 sans solution Internal._rmNodesByType(t2, 'FlowSolution_t') t1 = C.node2Center(t1) t2 = P.importVariables(t1, t2) test.testT(t2, 3)
def evalPosition__(t, time):
a = Internal.copyRef(t)
_evalPosition__(a, time)
return a
def addProcNode(t, proc):
tp = Internal.copyRef(t)
_addProcNode(tp, proc)
return tp
def setPrescribedMotion2(t,
name,
transl_speed=(0., 0., 0.),
psi0=0.,
psi0_b=0.,
alp_pnt=(0., 0., 0.),
alp_vct=(0., 1., 0.),
alp0=0.,
rot_pnt=(0., 0., 0.),
rot_vct=(0., 0., 1.),
rot_omg=0.,
del_pnt=(0., 0., 0.),
del_vct=(0., 0., 1.),
del0=0.,
delc=(0., 0., 0.),
dels=(0., 0., 0.),
bet_pnt=(0., 0., 0.),
bet_vct=(0., 1., 0.),
bet0=0.,
betc=(0., 0., 0.),
bets=(0., 0., 0.),
tet_pnt=(0., 0., 0.),
tet_vct=(1., 0., 0.),
tet0=0.,
tetc=(0., ),
tets=(0., ),
span_vct=(1., 0., 0.),
pre_lag_pnt=(0., 0., 0.),
pre_lag_vct=(1., 0., 0.),
pre_lag_ang=0.,
pre_con_pnt=(0., 0., 0.),
pre_con_vct=(1., 0., 0.),
pre_con_ang=0.):
tp = Internal.copyRef(t)
_setPrescribedMotion2(tp,
name,
transl_speed=transl_speed,
psi0=psi0,
psi0_b=psi0_b,
alp_pnt=alp_pnt,
alp_vct=pl_vct,
alp0=alp0,
rot_pnt=rot_pnt,
rot_vct=rot_vct,
rot_omg=rot_omg,
del_pnt=del_pnt,
del_vct=del_vct,
del0=del0,
delc=delc,
dels=dels,
bet_pnt=bet_pnt,
bet_vct=bet_vct,
bet0=bet0,
betc=betc,
bets=bets,
tet_pnt=tet_pnt,
tet_vct=tet_vct,
tet0=tet0,
tetc=tetc,
tets=tets,
span_vct=span_vct,
pre_lag_pnt=pre_lag_pnt,
pre_lag_vct=pre_lag_vct,
pre_lag_ang=pre_lag_ang,
pre_con_pnt=pre_con_pnt,
pre_con_vct=pre_con_vct,
pre_con_ang=pre_con_ang)
return tp