def updateInfo(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()
npTot = 0; ncellsTot = 0; nfacesTot = 0
nzones = 0
minv = 1e6; maxv = -1e6
var = VARS[5].get()
failed = False
if nzs == []:
zones = Internal.getZones(CTK.t)
for z in zones:
dim = Internal.getZoneDim(z)
try: minv = min(minv, C.getMinValue(z, var))
except: failed = True
try: maxv = max(maxv, C.getMaxValue(z, var))
except: failed = True
np, ncells, nfaces = computeMeshInfo(z, dim)
npTot += np
ncellsTot += ncells
nfacesTot += nfaces
nzones += 1
else:
for nz in nzs:
nob = CTK.Nb[nz]+1
noz = CTK.Nz[nz]
z = CTK.t[2][nob][2][noz]
dim = Internal.getZoneDim(z)
minv = min(minv, C.getMinValue(z, var))
maxv = max(maxv, C.getMaxValue(z, var))
np, ncells, nfaces = computeMeshInfo(z, dim)
npTot += np
ncellsTot += ncells
nfacesTot += nfaces
nzones += 1
VARS[0].set(strwg__(npTot))
VARS[6].set(strwg__(ncellsTot))
VARS[7].set(strwg__(nfacesTot))
VARS[1].set(str(minv))
VARS[2].set(str(maxv))
VARS[4].set('')
if nzs == []:
VARS[3].set('Tree')
if nzones == 0 or nzones == 1:
VARS[4].set(strwg__(nzones)+' zone')
else: VARS[4].set(strwg__(nzones)+' zones')
elif len(nzs) > 1:
VARS[3].set('Multiple')
VARS[4].set(str(nzones)+' zones')
else:
nz = nzs[0]
nob = CTK.Nb[nz]+1
noz = CTK.Nz[nz]
z = CTK.t[2][nob][2][noz]
VARS[3].set(CTK.t[2][nob][0]+'/'+z[0])
dim = Internal.getZoneDim(z)
if dim[0] == 'Structured':
VARS[4].set('Structured')
VARS[0].set(str(npTot) + ' ('+str(dim[1])+'x'+str(dim[2])+'x'+str(dim[3])+')')
else:
VARS[4].set(dim[3])
if not failed:
CTK.TXT.insert('START', 'Info updated.\n')
else:
CTK.TXT.insert('START', 'Variable min-max was not computed.\n')
CTK.TXT.insert('START', 'Warning: ', 'Warning')
# - adaptNGon2Index (pyTree) - import Generator.PyTree as G import Converter.PyTree as C import Converter.Internal as Internal a = G.cartNGon((0, 0, 0), (1, 1, 1), (10, 10, 10)) Internal._adaptNFace2PE(a, remove=False) Internal._adaptNGon2Index(a) Internal._adaptNFace2Index(a) C.convertPyTree2File(a, 'out.cgns')
def step2():
import Transform as T
import Generator as G
CTK.saveTree()
# taille de maille en envergure
hp = float(VARS[5].get())
# Hauteur du maillage
Dfar = float(VARS[4].get())
# Envergure
span = float(VARS[6].get())
# Recupere la base STEP1
base = Internal.getNodesFromName1(CTK.t, 'STEP1')
if base == []: return
zones = base[0][2]
l = len(zones)
if l == 7: culot = 0
else: culot = 1
if culot == 0:
# 2 zones exterieures, le reste interieur
M2 = [
C.getAllFields(zones[l - 2], 'nodes')[0],
C.getAllFields(zones[l - 1], 'nodes')[0]
]
M1 = []
for z in zones[0:l - 2]:
M1.append(C.getAllFields(z, 'nodes')[0])
else:
# 3 zones exterieures, le reste interieur
M2 = [
C.getAllFields(zones[l - 2], 'nodes')[0],
C.getAllFields(zones[l - 1], 'nodes')[0],
C.getAllFields(zones[l - 3], 'nodes')[0]
]
M1 = []
for z in zones[0:l - 3]:
M1.append(C.getAllFields(z, 'nodes')[0])
#==========================================================================
# stack + resserement vers les extremites
#==========================================================================
M1b = T.translate(M1, (0, 0, Dfar))
B1 = []
for i in range(len(M1)):
B1.append(G.stack(M1[i], M1b[i]))
M1c = T.translate(M1, (0, 0, -span))
M1d = T.translate(M1, (0, 0, -span - Dfar))
B2 = []
for i in range(len(M1c)):
B2.append(G.stack(M1c[i], M1d[i]))
#C.convertArrays2File(B1+B2, 'bouchon.plt')
M2b = T.translate(M2, (0, 0, Dfar))
M2c = T.translate(M2, (0, 0, -span - Dfar))
I = []
for i in range(len(M2b)):
I.append(G.stack(M2c[i], M2b[i]))
# B1, B2: les bouchons; I le reste
#C.convertArrays2File(B1+B2+I, 'all.plt')
#==========================================================================
# Remaille la surface
N = int(Dfar / hp) + 1
distrib = G.cart((0, 0, 0), (1. / (N - 1), 1, 1), (N, 1, 1))
for i in range(len(B1)):
B1[i] = G.map(B1[i], distrib, 3)
for i in range(len(B2)):
B2[i] = G.map(B2[i], distrib, 3)
N = int((2 * Dfar + span) / hp) + 1
distrib = G.cart((0, 0, 0), (1. / (N - 1), 1, 1), (N, 1, 1))
for i in range(len(I)):
I[i] = G.map(I[i], distrib, 3)
# Back to zones
zones = []
for b in B1 + B2 + I:
zones.append(C.convertArrays2ZoneNode('zone', [b]))
base = Internal.getNodesFromName1(CTK.t, 'STEP2')
if base != []:
(p, c) = Internal.getParentOfNode(CTK.t, base[0])
del p[2][c]
CTK.t = C.addBase2PyTree(CTK.t, 'STEP2', 3)
base = Internal.getNodesFromName1(CTK.t, 'STEP2')[0]
(p, c) = Internal.getParentOfNode(CTK.t, base)
base[2] += zones
# Add BCs
base = X.connectMatch(base, tol=1.e-6)
# # Blocs exterieurs
if culot == 0:
z = base[2][10]
z = C.addBC2Zone(z, 'overlap', 'BCOverlap', 'jmax')
z = C.addBC2Zone(z, 'overlap', 'BCOverlap', 'kmax')
z = C.addBC2Zone(z, 'overlap', 'BCOverlap', 'kmin')
z = C.addBC2Zone(z, 'overlap', 'BCOverlap', 'imin')
base[2][10] = z
z = base[2][11]
z = C.addBC2Zone(z, 'overlap', 'BCOverlap', 'jmax')
z = C.addBC2Zone(z, 'overlap', 'BCOverlap', 'kmax')
z = C.addBC2Zone(z, 'overlap', 'BCOverlap', 'kmin')
z = C.addBC2Zone(z, 'overlap', 'BCOverlap', 'imax')
base[2][11] = z
for i in range(5):
z = base[2][i]
z = C.addBC2Zone(z, 'overlap', 'BCOverlap', 'kmax')
base[2][i] = z
for i in range(5):
z = base[2][5 + i]
z = C.addBC2Zone(z, 'overlap', 'BCOverlap', 'kmax')
base[2][5 + i] = z
else:
z = base[2][6]
z = C.addBC2Zone(z, 'overlap', 'BCOverlap', 'jmax')
z = C.addBC2Zone(z, 'overlap', 'BCOverlap', 'kmax')
z = C.addBC2Zone(z, 'overlap', 'BCOverlap', 'kmin')
z = C.addBC2Zone(z, 'overlap', 'BCOverlap', 'imax')
base[2][6] = z
z = base[2][8]
z = C.addBC2Zone(z, 'overlap', 'BCOverlap', 'jmax')
z = C.addBC2Zone(z, 'overlap', 'BCOverlap', 'kmax')
z = C.addBC2Zone(z, 'overlap', 'BCOverlap', 'kmin')
z = C.addBC2Zone(z, 'overlap', 'BCOverlap', 'imin')
base[2][8] = z
z = base[2][7]
z = C.addBC2Zone(z, 'overlap', 'BCOverlap', 'imax')
z = C.addBC2Zone(z, 'overlap', 'BCOverlap', 'kmax')
z = C.addBC2Zone(z, 'overlap', 'BCOverlap', 'kmin')
base[2][7] = z
for i in range(3):
z = base[2][i]
z = C.addBC2Zone(z, 'overlap', 'BCOverlap', 'kmax')
base[2][i] = z
for i in range(3):
z = base[2][3 + i]
z = C.addBC2Zone(z, 'overlap', 'BCOverlap', 'kmax')
base[2][3 + i] = z
base = C.fillEmptyBCWith(base, 'wall', 'BCWall')
CTK.t[2][c] = base
CTK.TXT.insert('START', 'Step2 performed.\n')
(CTK.Nb, CTK.Nz) = CPlot.updateCPlotNumbering(CTK.t)
CTK.TKTREE.updateApp()
CTK.display(CTK.t)
# - newElements (pyTree) -
import Converter.Internal as Internal
# Create an elements node
b = Internal.newElements(name='Elements',
etype='UserDefined',
econnectivity=None,
eboundary=0)
print b
# Attach it to tree
z = Internal.newZone('Zone', [[10], [2], [0]], 'Unstructured')
Internal.newElements(name='Elements',
etype='UserDefined',
econnectivity=None,
eboundary=0,
parent=z)
print z
#
a = G.cart((0., 0., 0.), (0.1, 0.1, 0.1), (11, 21, 1))
a = C.initVars(a, 'centers:Density={centers:CoordinateX}')
a = C.initVars(a, 'F={CoordinateY}*{CoordinateX}')
a = C.addBC2Zone(a, 'wall1', 'BCWall', 'jmin')
# partiellement coincident
a2 = G.cart((1., 0.4, 0.), (0.1, 0.1, 0.1), (11, 21, 1))
a2 = T.oneovern(a2, (2, 2, 1))
a2 = C.initVars(a2, 'centers:Density={centers:CoordinateX}')
a2 = C.initVars(a2, 'F={CoordinateY}*{CoordinateX}')
a2 = C.addBC2Zone(a2, 'overlap1', 'BCOverlap', 'imax')
t = C.newPyTree(['Base', 2])
t[2][1][2] += [a, a2]
t[2][1] = C.addState(t[2][1], 'EquationDimension', 2)
t = X.connectNearMatch(t, dim=2)
t = Internal.addGhostCells(t, t, 2, adaptBCs=0, fillCorner=1)
t = Internal.rmGhostCells(t, t, 2, adaptBCs=0)
test.testT(t, 1)
#
t = C.newPyTree(['Base', 2])
t[2][1][2] += [a, a2]
t[2][1] = C.addState(t[2][1], 'EquationDimension', 2)
t = X.connectNearMatch(t, dim=2)
t = Internal.addGhostCells(t, t, 2, adaptBCs=1, fillCorner=1)
t = Internal.rmGhostCells(t, t, 2, adaptBCs=1)
test.testT(t, 2)
# geometrical extrapolation of corner cells
t = C.newPyTree(['Base', 2])
t[2][1][2] += [a, a2]
t[2][1] = C.addState(t[2][1], 'EquationDimension', 2)
# - checkPyTree (pyTree) - import Converter.PyTree as C import Generator.PyTree as G import Connector.PyTree as X import Converter.Internal as Internal a = G.cart((0,0,0), (1,1,1), (10,10,10)) b = G.cart((9,0,0), (1,1,1), (10,10,10)) c = G.cartTetra((9,9,0), (1,1,1), (10,10,10)) a = C.addBC2Zone(a, 'wall1', 'BCWall', 'imin') t = C.newPyTree(['Base',a,b,c]) t = X.connectMatch(t) errors = [] # check unique base names errors += Internal.checkPyTree(t, level=2) # check unique zone names errors += Internal.checkPyTree(t, level=3) # check unique BC names errors += Internal.checkPyTree(t, level=4) # check BC ranges errors += Internal.checkPyTree(t, level=5) # check opposite ranges errors += Internal.checkPyTree(t, level=6) # check family definition errors += Internal.checkPyTree(t, level=7) # check CGNSTypes errors += Internal.checkPyTree(t, level=8) # check element nodes errors += Internal.checkPyTree(t, level=9); print errors #>> []
# - newGridConnectivity1to1 (pyTree) -
import Converter.Internal as Internal
# Create a node
n = Internal.newGridConnectivity1to1(name='Match', donorName='blk1', pointRange=[1,1,1,33,1,69], pointRangeDonor=[51,51,1,33,1,69], transform=None); Internal.printTree(n)
#>> ['Match',array('blk1',dtype='|S1'),[2 sons],'GridConnectivity1to1_t']
#>> |_['PointRange',array(shape=(6,),dtype='int32',order='F'),[0 son],'IndexRange_t']
#>> |_['PointRangeDonor',array(shape=(6,),dtype='int32',order='F'),[0 son],'IndexRange_t']
# Attach it to a parent node
d = Internal.newZoneGridConnectivity(name='ZoneGridConnectivity')
Internal.newGridConnectivity1to1(name='Match', donorName='blk1', pointRange=[1,1,1,33,1,69], pointRangeDonor=[51,51,1,33,1,69], transform=None, parent=d)
# - getSizeOf (pyTree) - import Generator.PyTree as G import Converter.Internal as Internal a = G.cart((0, 0, 0), (1, 1, 1), (10, 10, 10)) print(Internal.getSizeOf(a))
# - getNodeFromName (pyTree) - import Converter.PyTree as C import Generator.PyTree as G import Converter.Internal as Internal a = G.cart((0, 0, 0), (1, 1, 1), (10, 10, 10)) t = C.newPyTree(['Base', a]) # Return the node named 'cart' node = Internal.getNodeFromName(t, 'cart') print node
# - newBCDataSet (pyTree) -
import Converter.Internal as Internal
# Create a BC data set node
n = Internal.newBCDataSet(name='BCDataSet', value='BCWall'); Internal.printTree(n)
#>> ['BCDataSet',array('BCWall',dtype='|S1'),[0 son],'BCDataSet_t']
# Attach it to a parent node
d = Internal.newBC(name='BC', pointList=[22,1036,101,43], btype='BCFarfield')
Internal.newBCDataSet(name='BCDataSet', value='UserDefined', parent=d)
# Complete BC + BCDataSet + BCData
b = Internal.newBC(name='BC', pointList=[22,1036,101,43], btype='BCFarfield')
d = Internal.newBCDataSet(name='BCDataSet', value='UserDefined', gridLocation='FaceCenter', parent=b)
d = Internal.newBCData('BCNeumann', parent=d)
d = Internal.newDataArray('Density', value=[1.,1.,1.,1.], parent=d)
# - addGhostCells (pyTree) -
import Generator.PyTree as G
import Converter.PyTree as C
import Converter.Internal as Internal
a = G.cart((1,1,1), (1.,1.,1.), (4,2,3)); a[0]='cart1'
b = G.cart((1,1,-3), (1.,1.,0.5), (4,2,9)); b[0]='cart2'
a = C.addBC2Zone(a,'match','BCMatch','kmin',b[0],[1,4,1,2,9,9],[1,2,3])
b = C.addBC2Zone(b,'match','BCMatch','kmax',a[0],[1,4,1,2,1,1],[1,2,3])
t = C.newPyTree(['Base',a,b])
# Physical BC (here BCWall)
t = C.addBC2Zone(t, 'wall', 'BCWall', 'imin')
t = C.initVars(t, '{F}=3*{CoordinateX}+2*{CoordinateY}')
#
a = t[2][1][2][0]
ag = Internal.addGhostCells(t,a,2,adaptBCs=1)
t[2][1][2][0] = ag
ag = Internal.rmGhostCells(t,ag,2)
t[2][1][2][0] = ag
C.convertPyTree2File(t,'out.cgns')
# - getBCFaceNode (pyTree) - import Converter.Internal as Internal import Converter.PyTree as C import Generator.PyTree as G import KCore.test as test # structure a = G.cart((0, 0, 0), (1, 1, 1), (10, 10, 10)) a = C.addBC2Zone(a, 'wall', 'BCWall', 'imin') b = Internal.getNodeFromName(a, 'wall') ind = Internal.getBCFaceNode(a, b) test.testO(ind, 1)
# - getNodeFromPath (pyTree) - import Converter.PyTree as C import Generator.PyTree as G import Converter.Internal as Internal a = G.cart((0, 0, 0), (1, 1, 1), (10, 10, 10)) t = C.newPyTree(['Base', a]) # Return GridCoordinates node coords = Internal.getNodeFromPath(t, 'Base/cart/GridCoordinates') print coords #>> ['GridCoordinates', None, [..], 'DataArray_t'] # Return GridCoordinates node (path is relative to input node) coords = Internal.getNodeFromPath(a, 'GridCoordinates') print coords #>> ['GridCoordinates', None, [..], 'DataArray_t']
if (Cmpi.rank == 0): C.convertPyTree2File(t, 'in.cgns')
Cmpi.barrier()
# lecture du squelette
a = Cmpi.convertFile2SkeletonTree('in.cgns')
# equilibrage 1
(a, dic) = D2.distribute(a, NProc=Cmpi.size, algorithm='fast', useCom=0)
# load des zones locales dans le squelette
a = Cmpi.readZones(a, 'in.cgns', proc=Cmpi.rank)
# equilibrage 2 (a partir d'un squelette charge)
(a, dic) = D2.distribute(a,
NProc=Cmpi.size,
algorithm='gradient1',
useCom='match')
a = D2mpi.redispatch(a)
# force toutes les zones sur 0
zones = Internal.getNodesFromType(a, 'Zone_t')
for z in zones:
nodes = Internal.getNodesFromName(z, 'proc')
Internal.setValue(nodes[0], 0)
a = D2mpi.redispatch(a)
# Reconstruit l'arbre complet a l'ecriture
Cmpi.convertPyTree2File(a, 'out.cgns')
# - getParentFromType (pyTree) -
import Converter.Internal as Internal
a = Internal.createNode('level0', 'DataArray_t', 0)
b = Internal.createChild(a, 'level1', 'DataArray_t', 1)
c = Internal.createChild(b, 'level2', 'DataArray_t', 2)
p = Internal.getParentFromType(a, c, 'DataArray_t')
print(p[0])
#>> level1
# - rmNodesByType (pyTree) -
import Converter.PyTree as C
import Generator.PyTree as G
import Converter.Internal as Internal
import KCore.test as test
t = C.newPyTree(['Base', 'Base2'])
for i in range(10):
a = G.cart( (0,0,0), (1,1,1), (10,10,10) )
a[0] = 'Cart'+str(i)
t[2][1][2].append(a)
t = Internal.rmNodesByType(t, 'Zone_t')
test.testO(t, 1)
# - newZone (pyTree) - import Converter.Internal as Internal # Create a zone node z = Internal.newEMConductivityModel(value='Null') print z # Create a zone node and attach it to tree t = Internal.newFlowEquationSet() z = Internal.newEMConductivityModel(value='Chemistry_LinRessler', parent=t) print t
def runCheckPyTree():
if CTK.t == []: return
errors = []
v = VARS[3].get()
if v == 'All conformity' or v == ' > Node conformity':
errors += Internal.checkPyTree(CTK.t, level=1)
if v == 'All conformity' or v == ' > Unique base name':
errors += Internal.checkPyTree(CTK.t, level=2)
if v == 'All conformity' or v == ' > Unique zone name':
errors += Internal.checkPyTree(CTK.t, level=3)
if v == 'All conformity' or v == ' > Unique BC name':
errors += Internal.checkPyTree(CTK.t, level=4)
if v == 'All conformity' or v == ' > Valid BC ranges':
errors += Internal.checkPyTree(CTK.t, level=5)
if v == 'All conformity' or v == ' > Valid BC match':
errors += Internal.checkPyTree(CTK.t, level=6)
if v == 'All conformity' or v == ' > Referenced families':
errors += Internal.checkPyTree(CTK.t, level=7)
if v == 'All conformity' or v == ' > Valid CGNS types':
errors += Internal.checkPyTree(CTK.t, level=8)
if v == 'All conformity' or v == ' > Valid element nodes':
errors += Internal.checkPyTree(CTK.t, level=9)
if v == 'All conformity' or v == ' > Valid CGNS flowfield name':
errors += Internal.checkPyTree(CTK.t, level=10)
if v == 'Multigrid compatibility':
MGlevel = CTK.varsFromWidget(VARS[2].get(), type=2)
minBlk = CTK.varsFromWidget(VARS[0].get(), type=2)
minBC = CTK.varsFromWidget(VARS[1].get(), type=2)
if len(MGlevel) > 0 and len(minBlk) > 0 and len(minBC) > 0:
errors += Internal.checkMultigrid(CTK.t,
level=MGlevel[0],
nbMinCoarseB=minBlk[0],
nbMinCoarseW=minBC[0])
if (v == 'Maximum number of nodes'):
minBlk = CTK.varsFromWidget(VARS[0].get(), type=2)
if len(minBlk) > 0:
errors = Internal.checkSize(CTK.t, sizeMax=minBlk[0])
if len(errors) == 0: errors = [0, 'No error found.']
Panels.displayErrors(errors, header='Checking pyTree')
CTK.TXT.insert('START', 'pyTree checked.\n')
# - newTurbulenceClosure (pyTree) -
import Converter.Internal as Internal
# Create a node
n = Internal.newTurbulenceClosure(value='Null'); Internal.printTree(n)
#>> ['TurbulenceClosure',array('Null',dtype='|S1'),[0 son],'TurbulenceClosure_t']
# Create a node and attach it to parent
t = Internal.newFlowEquationSet()
n = Internal.newTurbulenceClosure(value='ReynoldsStress', parent=t)
def correctPyTree():
if CTK.t == []: return
v = VARS[3].get()
if v == 'Multigrid compatibility':
CTK.TXT.insert('START', 'Can not correct for multigrid.\n')
CTK.TXT.insert('START', 'Error: ', 'Error')
return
if v == 'Maximum number of nodes':
CTK.TXT.insert('START',
'Can not correct for maximum number of nodes.\n')
CTK.TXT.insert('START', 'Error: ', 'Error')
return
if v == 'All conformity' or v == ' > Node conformity':
Internal._correctPyTree(CTK.t, level=1)
if v == 'All conformity' or v == ' > Unique base name':
Internal._correctPyTree(CTK.t, level=2)
if v == 'All conformity' or v == ' > Unique zone name':
Internal._correctPyTree(CTK.t, level=3)
if v == 'All conformity' or v == ' > Unique BC name':
Internal._correctPyTree(CTK.t, level=4)
if v == 'All conformity' or v == ' > Valid BC ranges':
Internal._correctPyTree(CTK.t, level=5)
if v == 'All conformity' or v == ' > Valid BC match':
Internal._correctPyTree(CTK.t, level=6)
if v == 'All conformity' or v == ' > Referenced families':
Internal._correctPyTree(CTK.t, level=7)
if v == 'All conformity' or v == ' > Valid CGNS types':
Internal._correctPyTree(CTK.t, level=8)
if v == 'All conformity' or v == ' > Valid element nodes':
Internal._correctPyTree(CTK.t, level=9)
if v == 'All conformity' or v == ' > Valid CGNS flowfield name':
Internal.correctPyTree(CTK.t, level=10)
#C._fillMissingVariables(CTK.t)
(CTK.Nb, CTK.Nz) = CPlot.updateCPlotNumbering(CTK.t)
CTK.TKTREE.updateApp()
CTK.display(CTK.t)
CTK.TXT.insert('START', 'pyTree corrected.\n')
"""
import Converter.PyTree as C
import Distributor2.PyTree as Distributor2
import Converter.Mpi as Cmpi
import Transform.PyTree as T
import Connector.PyTree as X
import Converter.Internal as Internal
import numpy
rank = Cmpi.rank
size = Cmpi.size
# lecture des corps servant a masquer
bodies = C.convertFile2PyTree('walls.cgns')
bodies = Internal.getNodesFromType(bodies, 'Zone_t')
# lecture du squelette
a = Cmpi.convertFile2SkeletonTree('in.cgns')
# equilibrage
(a, dic) = Distributor2.distribute(a, NProc=size, algorithm='fast', useCom=0)
# load des zones locales dans le squelette
a = Cmpi.readZones(a, 'in.cgns', proc=rank)
# Passage en arbre partiel
a = Cmpi.convert2PartialTree(a)
# Blanking local
BM = numpy.array([[1]])
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 Transform.PyTree as T
import numpy
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'])
t[2][1][2] = [a]
#
NIT = 10
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.)')
tc = Internal.copyRef(t)
t = DTW.distance2WallsEikonal(t, sphere, tc=tc, DEPTH=DEPTH, nitmax=10)
C.convertPyTree2File(t, 'out.cgns')
# - addFlowSolution (pyTree) - import Converter.PyTree as C import Generator.PyTree as G import Converter.elsAProfile as elsAProfile a = G.cart((0, 0, 0), (1, 1, 1), (10, 10, 10)) t = C.newPyTree(['Base', a]) t = elsAProfile.addFlowSolution(t, governingEquations='Euler') import Converter.Internal as Internal Internal.printTree(t) C.convertPyTree2File(t, 'out.cgns')
# - getValue of a node (pyTree) - import Converter.PyTree as C import Generator.PyTree as G import Converter.Internal as Internal # Structured array a = G.cart((0, 0, 0), (1., 0.5, 1.), (40, 50, 20)) # Get value stored in a zone node print Internal.getValue(a) #>> [[40 39 0] [50 49 0] [20 19 0]] # Get type of a zone (from ZoneType node) node = Internal.getNodeFromName(a, 'ZoneType') # Print node[1], which is a numpy array print node[1] #>> array(['S', 't', 'r', 'u', 'c', 't', 'u', 'r', 'e', 'd'] # getValue, return a string in this case print Internal.getValue(node) #>> Structured
# - newFlowEquationSet (pyTree) -
import Converter.Internal as Internal
# Create a node
n = Internal.newFlowEquationSet()
Internal.printTree(n)
#>> ['FlowEquationSet',None,[0 son],'FlowEquationSet_t']
# Create a node and attach it to parent
t = Internal.newCGNSTree()
b = Internal.newCGNSBase('Base', 3, 3, parent=t)
n = Internal.newFlowEquationSet(parent=b)
import Generator.PyTree as G import Converter.Internal as Internal import KCore.test as test a = G.cart((0., 0., 0.), (0.1, 0.1, 1), (10, 10, 1)) a[0] = 'cart1' b = G.cart((0.5, 0., 0.), (0.1, 0.1, 1), (10, 10, 1)) b[0] = 'cart2' c = G.cart((0.75, 0., 0.), (0.1, 0.1, 1), (10, 10, 1)) c[0] = 'cart3' # --- CL a = C.addBC2Zone(a, 'wall1', 'BCWall', 'imin') b = C.addBC2Zone(b, 'wall1', 'BCWall', 'imin') b = C.addBC2Zone(b, 'overlap1', 'BCOverlap', 'jmax') c = C.addBC2Zone(c, 'wall1', 'BCWall', 'imin') t = C.newPyTree(['Cart']) # --- Equation state t[2][1] = C.addState(t[2][1], 'EquationDimension', 2) t[2][1][2] += [a, b, c] # --- champ aux centres C._initVars(t, 'centers:cellN', 1.) # --- champ aux noeuds C._initVars(t, 'F', 2.) bases = Internal.getNodesFromType(t, 'CGNSBase_t') base = bases[0] doms = X.getCEBBIntersectingDomains(base, bases, sameBase=1) test.testO(doms) doms = X.getCEBBIntersectingDomains(base, bases, sameBase=0) test.testO(doms, 2)
def step1():
if CTK.t == []: return
# Recupere le profil
nzs = CPlot.getSelectedZones()
if (nzs == []):
CTK.TXT.insert('START', 'Selection is empty.\n')
CTK.TXT.insert('START', 'Error: ', 'Error')
return
if (len(nzs) > 2):
CTK.TXT.insert(
'START',
'Input profile must be one curve or two curves (blunt profiles).\n'
)
CTK.TXT.insert('START', 'Error: ', 'Error')
return
if (len(nzs) == 2): culot = 1
else: culot = 0
zones = []
errors = []
for nz in nzs:
nob = CTK.Nb[nz] + 1
noz = CTK.Nz[nz]
z = CTK.t[2][nob][2][noz]
dim = Internal.getZoneDim(z)
if dim[0] == 'Unstructured':
try:
z = C.convertBAR2Struct(z)
except Exception as e:
#print('Error: blader: %s'%str(e))
errors += [0, str(e)]
CTK.TXT.insert('START', 'Input profile must be structured.\n')
CTK.TXT.insert('START', 'Error: ', 'Error')
return
zones.append(z)
if (len(errors) > 0): Panels.displayErrors(errors, header='Error: blader')
CTK.saveTree()
# -- Go to array world!
import Geom as D
import Generator as G
import Transform as T
import Converter
# repere le culot si 2 courbes sont fournies
a = C.getAllFields(zones[0], 'nodes')[0]
if (culot == 1):
ac = C.getAllFields(zones[1], 'nodes')[0]
bb1 = G.bbox(a)
bb2 = G.bbox(ac)
if (bb1[0] > bb2[0]):
temp = a
a = ac
ac = temp
# taille de maille trailing edge et culot
h = float(VARS[1].get())
# deraffinement par rapport a la distribution initiale
h2 = float(VARS[2].get())
# Point de split (pour la ligne medianne), en % de la longeur du profil
Nsplit = float(VARS[0].get())
# Creation delta (Ndelta est en nbre de pts sur le profil remaille)
Ndelta = int(VARS[3].get())
# Hauteur du maillage
Dfar = float(VARS[4].get())
#==========================================================================
# Remaille uniforme du profil avec h2
l = D.getLength(a)
npts = int(l / h2) + 1
if (npts / 2 == npts * 0.5): npts += 1
distrib = G.cart((0, 0, 0), (1. / (npts - 1.), 1, 1), (npts, 1, 1))
a = G.map(a, distrib)
#===========================================================================
# Split du profil en intrados/extrados
N = a[2]
Ns = int(N * Nsplit)
a1 = T.subzone(a, (1, 1, 1), (Ns + 1, 1, 1))
a2 = T.subzone(a, (Ns + 1, 1, 1), (N, 1, 1))
a2 = T.reorder(a2, (-1, 2, 3))
#===========================================================================
# Resserement bord de fuite et bord d'attaque
l = D.getLength(a1)
s = D.getCurvilinearAbscissa(a1)
s[0] = 'x'
s = Converter.initVars(s, 'y', 0.)
s = Converter.initVars(s, 'z', 0.)
N = a1[2]
distrib = G.enforcePlusX(s, h / l, N / 10, 1)
distrib = G.enforceMoinsX(distrib, h / l, N / 10, 1)
a1 = G.map(a1, distrib)
l = D.getLength(a2)
s = D.getCurvilinearAbscissa(a2)
s[0] = 'x'
s = Converter.initVars(s, 'y', 0.)
s = Converter.initVars(s, 'z', 0.)
N = a2[2]
distrib = G.enforcePlusX(s, h / l, N / 10, 1)
distrib = G.enforceMoinsX(distrib, h / l, N / 10, 1)
a2 = G.map(a2, distrib)
#==========================================================================
# ligne delta
#===========================================================================
ni = a1[2]
b1 = T.subzone(a1, (1, 1, 1), (Ndelta, 1, 1))
c1 = T.subzone(a1, (Ndelta, 1, 1), (ni, 1, 1))
b2 = T.subzone(a2, (1, 1, 1), (Ndelta, 1, 1))
c2 = T.subzone(a2, (Ndelta, 1, 1), (ni, 1, 1))
P1 = (c1[1][0, 0], c1[1][1, 0], c1[1][2, 0])
P2 = (c2[1][0, 0], c2[1][1, 0], c2[1][2, 0])
NdeltaDelta = Ndelta - 4
delta = D.line(P1, P2, 2 * NdeltaDelta - 1)
#===========================================================================
# ligne medianne
#===========================================================================
# ligne medianne droite
P1 = Converter.getValue(c1, c1[2] - 1)
P2 = Converter.getValue(delta, delta[2] / 2)
median = D.line(P1, P2, N=10)
# ligne medianne moyenne
N1 = c1[2]
# cree une ligne k2 remaillant c2 avec N1
s = D.getCurvilinearAbscissa(c1)
s[0] = 'x'
s = Converter.initVars(s, 'y', 0.)
s = Converter.initVars(s, 'z', 0.)
k2 = G.map(c2, s)
# cree la ligne moyenne
median = Converter.copy(c1)
median[1][0, :] = 0.5 * (c1[1][0, :] + k2[1][0, :])
median[1][1, :] = 0.5 * (c1[1][1, :] + k2[1][1, :])
median[1][2, :] = 0.5 * (c1[1][2, :] + k2[1][2, :])
# Remaillage ligne medianne
s = D.getCurvilinearAbscissa(c1)
s[0] = 'x'
s = Converter.initVars(s, 'y', 0.)
s = Converter.initVars(s, 'z', 0.)
median = G.map(median, s)
median = G.refine(median, 0.9, 1)
N1 = c1[2]
N2 = median[2]
d = N1 - N2
if (d / 2 != d * 0.5):
factor = (N2 + 2.) / N2
median = G.refine(median, factor, 1)
#===========================================================================
# Maillage TRI au bout
if (culot == 0):
#Converter.convertArrays2File([b1,b2,delta], 'bout1.plt')
m3 = trimesh(b1, b2, delta)
if (m3[0] == 0): raise ValueError(m3[1])
#Converter.convertArrays2File([b1,b2,delta]+m3, 'bout1.plt')
else:
# Dans le cas avec culot, on remaille le culot comme delta
l = D.getLength(ac)
npts = delta[2]
distrib = G.cart((0, 0, 0), (1. / (npts - 1.), 1, 1), (npts, 1, 1))
ac = G.map(ac, distrib)
m3 = [G.TFI([b1, delta, b2, ac])]
#===========================================================================
# Maillage du reste de l'interieur du profil
ni = c1[2]
d1 = T.subzone(c1, (1, 1, 1), (ni - NdeltaDelta + 1, 1, 1))
e1 = T.subzone(c1, (ni - NdeltaDelta + 1, 1, 1), (ni, 1, 1))
ni = c2[2]
d2 = T.subzone(c2, (1, 1, 1), (ni - NdeltaDelta + 1, 1, 1))
e2 = T.subzone(c2, (ni - NdeltaDelta + 1, 1, 1), (ni, 1, 1))
# remaillage de l'axe median
s = D.getCurvilinearAbscissa(d1)
s[0] = 'x'
s = Converter.initVars(s, 'y', 0.)
s = Converter.initVars(s, 'z', 0.)
median = G.map(median, s)
npt = delta[2]
delta1 = T.subzone(delta, (1, 1, 1), (npt / 2 + 1, 1, 1))
delta2 = T.subzone(delta, (npt / 2 + 1, 1, 1), (npt, 1, 1))
#Converter.convertArrays2File([d1,e1,delta1,delta2,median,d2,e2], 'curv1.plt')
m1 = G.TFI([d1, e1, delta1, median])
m2 = G.TFI([d2, e2, delta2, median])
#===========================================================================
# Ajout de la ligne arriere
P1 = Converter.getValue(a1, 0)
P2 = Converter.getValue(a1, 1)
P3 = (P1[0] + Dfar, P1[1], P1[2])
line2 = D.line(P1, P3, N=50)
N = 50
s = G.cart((0, 0, 0), (1. / (N - 1.), 1, 1), (N, 1, 1))
s = G.enforcePlusX(s, abs(P2[0] - P1[0]) / Dfar, N, 1)
line2 = G.map(line2, s)
#Converter.convertArrays2File([a1,a2,line2], 'out.plt')
if (culot == 0):
line2p = Converter.copy(line2)
else:
P1 = Converter.getValue(a2, 0)
P2 = Converter.getValue(a2, 1)
P3 = (P1[0] + Dfar, P1[1], P1[2])
line2p = D.line(P1, P3, N=50)
s = D.getCurvilinearAbscissa(line2)
s[0] = 'x'
s = Converter.initVars(s, 'y', 0.)
s = Converter.initVars(s, 'z', 0.)
line2p = G.map(line2p, s)
#===========================================================================
# Add normal layers
N = 50
h = abs(P2[0] - P1[0])
N = int(Dfar / (3 * h) / 2) + 1
d = G.cart((0, 0, 0), (3 * h, 1, 1), (N + 1, 1, 1))
# shift
line2p[1][1, :] -= 1.e-9
a2[1][1, 0] -= 1.e-9
#Converter.convertArrays2File([a2,line2,a1,line2p], 'curve0.plt')
curve0 = T.join([line2, a1, a2, line2p])
curve0 = T.reorder(curve0, (-1, 2, 3))
#Converter.convertArrays2File([curve0], 'curve.plt')
m4 = G.addNormalLayers([curve0], d, niter=1000, check=0)
m4 = G.close(m4, 1.e-8)
#Converter.convertArrays2File([m1,m2]+m3+m4, 'all.plt')
# check volume + subzone
vol = G.getVolumeMap(m4[0])
nk = vol[4]
ni = vol[2]
for k in range(nk - 1):
sub = T.subzone(vol, (1, 1, k + 1), (ni, 1, k + 2))
volmin = Converter.getMinValue(sub, 'vol')
if volmin < 0.:
if k > 10: kc = k - 4
else: kc = k - 1
m4[0] = T.subzone(m4[0], (1, 1, 1), (m4[0][2], 1, kc))
break
if culot == 1:
r1p = T.translate(ac, (Dfar, 0, 0))
Converter.convertArrays2File([ac, line2, r1p, line2p], 'sub.plt')
bsup = G.TFI([ac, line2, r1p, line2p])
# interieur
M1 = [m1, m2] + m3
# exterieur
M2 = m4
M2 = T.reorder(M2, (1, 3, 2))
# split du bloc M2 comme les blocs interieurs (pour connectMatch)
a = M2[0]
mp = line2[2] + a1[2] - 1
i1 = T.subzone(a, (1, 1, 1), (mp, a[3], a[4]))
i2 = T.subzone(a, (mp, 1, 1), (a[2], a[3], a[4]))
M2 = [i1, i2]
if culot == 1: M2 += [bsup]
#==========================================================================
# Zones resultantes dans l'arbre
meshes = M1 + M2
zones = []
for m in meshes:
z = C.convertArrays2ZoneNode('zone', [m])
zones.append(z)
base = Internal.getNodesFromName1(CTK.t, 'STEP1')
if (base != []):
(p, c) = Internal.getParentOfNode(CTK.t, base[0])
del p[2][c]
CTK.t = C.addBase2PyTree(CTK.t, 'STEP1', 3)
base = Internal.getNodesFromName1(CTK.t, 'STEP1')[0]
base[2] += zones
CTK.TXT.insert('START', 'Step1 performed.\n')
(CTK.Nb, CTK.Nz) = CPlot.updateCPlotNumbering(CTK.t)
CTK.TKTREE.updateApp()
CTK.display(CTK.t)
def updateStats():
if CTK.t == []: return
# Update canvas
c = WIDGETS['canvas']
c.delete(TK.ALL)
width = int(c.cget("width"))
height = int(c.cget("height"))
c.create_line(0, height / 2., width, height / 2., fill='red')
try:
NProc = int(VARS[0].get())
except:
CTK.TXT.insert('START', 'stats: NProc is invalid.\n')
CTK.TXT.insert('START', 'Error: ', 'Error')
return
# Calcul du nombre de pts par proc
zones = Internal.getZones(CTK.t)
a = numpy.zeros((NProc), numpy.int32)
for z in zones:
param = Internal.getNodesFromName1(z, '.Solver#Param')
if param != []:
proc = Internal.getNodesFromName1(param[0], 'proc')
if (proc != []):
value = proc[0][1][0, 0]
dim = Internal.getZoneDim(z)
if dim[0] == 'Structured':
a[value] += dim[1] * dim[2] * dim[3]
else:
a[value] += dim[1]
m = STATS['meanPtsPerProc']
fmin = 1.e10
fmax = 0
for i in a:
fmin = min(i, fmin)
fmax = max(i, fmax)
alpha = min(1. / abs(fmax - m + 1.e-6), 1. / abs(fmin - m + 1.e-6))
alpha = min(alpha, 1. / m)
barWidth = width * 1. / (NProc * 1.)
for i in range(NProc):
v = -alpha * (a[i] - m * 1.)
if a[i] == 0: fillColor = 'yellow'
elif i % 2 == 0: fillColor = 'blue'
else: fillColor = 'red'
c.create_rectangle(i * barWidth,
height / 2., (i + 1) * barWidth,
v * height / 2. + height / 2.,
fill=fillColor)
varRMS = int(STATS['varRMS'] * 10000) / 100.
varMin = int(STATS['varMin'] * 10000) / 100.
varMax = int(STATS['varMax'] * 10000) / 100.
nptsCom = STATS['nptsCom']
comRatio = int(STATS['comRatio'] * 10000) / 100.
CTK.TXT.insert(
'START', 'stats: mean=' + str(m) + ' pts, varMax=' + str(varMax) +
'%, nptsCom=' + str(nptsCom) + ' npts, ratio=' + str(comRatio) +
'%.\n')
# Update info bulle
b = WIDGETS['bulle']
stats = 'meanPtsPerProc=' + str(STATS['meanPtsPerProc']) + '.\n'
stats += 'varMax='+str(varMax)+'%, varMin='+\
str(varMin)+'%, varRMS='+str(varRMS)+'%.\n'
stats += 'nptsCom=' + str(
STATS['nptsCom']) + ', ratio=' + str(comRatio) + '%.'
b.label.configure(text=stats)
import Converter.PyTree as C
import Generator.PyTree as G
import Converter.Internal as Internal
import Connector.PyTree as X
import Geom.PyTree as D
import KCore.test as test
d = 2
a = D.sphere6((0, 0, 0), 0.5, N=20)
dk = G.cart((0, 0, 0), (0.01, 1, 1), (11, 1, 1))
a = G.addNormalLayers(a, dk)
t = C.newPyTree(['Base'])
t[2][1][2] = a
t = X.connectMatch(t, dim=3)
t = Internal.addGhostCells(t, t, d, adaptBCs=1)
#---------
# Centers
#---------
t = C.initVars(t, 'centers:F', 0.)
tc = C.node2Center(t)
tc = C.initVars(tc, '{F}={CoordinateX}*{CoordinateY}')
# stockage direct
t1 = X.setInterpDataForGhostCells__(t, tc, storage='direct', loc='centers')
test.testT(t1, 1)
# stockage inverse
tc1 = X.setInterpDataForGhostCells__(t, tc, storage='inverse', loc='centers')
test.testT(tc1, 2)
#---------
# Nodes
#---------
# noeuds, stockage direct
def reorder():
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
ii = VARS[0].get()
if (ii == 'I -> I'): i1 = 1
elif (ii == 'I -> -I'): i1 = -1
elif (ii == 'I -> J'): i1 = 2
elif (ii == 'I -> -J'): i1 = -2
elif (ii == 'I -> K'): i1 = 3
elif (ii == 'I -> -K'): i1 = -3
jj = VARS[1].get()
if (jj == 'J -> I'): j1 = 1
elif (jj == 'J -> -I'): j1 = -1
elif (jj == 'J -> J'): j1 = 2
elif (jj == 'J -> -J'): j1 = -2
elif (jj == 'J -> K'): j1 = 3
elif (jj == 'J -> -K'): j1 = -3
kk = VARS[2].get()
if (kk == 'K -> I'): k1 = 1
elif (kk == 'K -> -I'): k1 = -1
elif (kk == 'K -> J'): k1 = 2
elif (kk == 'K -> -J'): k1 = -2
elif (kk == 'K -> K'): k1 = 3
elif (kk == 'K -> -K'): k1 = -3
if abs(i1)+abs(j1)+abs(k1) != 6:
CTK.TXT.insert('START', 'Reordering settings is invalid.\n')
CTK.TXT.insert('START', 'Error: ', 'Error'); return
CTK.saveTree()
fail = False; errors = []
for nz in nzs:
nob = CTK.Nb[nz]+1
noz = CTK.Nz[nz]
z = CTK.t[2][nob][2][noz]
dim = Internal.getZoneDim(z)
try:
if dim[0] == 'Unstructured':
T._reorder(z, (-1,), topTree=CTK.t)
else:
#ni = dim[1]; nj = dim[2]; nk = dim[3]
#if (nk == 1): a = T.reorder(z, (-1,2,3), topTree=CTK.t)
#elif (nj == 1): a = T.reorder(z, (-1,2,3), topTree=CTK.t)
#elif (ni == 1): a = T.reorder(z, (1,2,-3), topTree=CTK.t)
#else: a = T.reorder(z, (-1,2,3), topTree=CTK.t)
T._reorder(z, (i1,j1,k1), topTree=CTK.t)
CTK.replace(CTK.t, nob, noz, z)
except Exception as e:
fail = True; errors += [0,str(e)]
if not fail:
CTK.TXT.insert('START', 'Zones reordered.\n')
else:
Panels.displayErrors(errors, header='Error: reorder')
CTK.TXT.insert('START', 'Reorder fails for at least one zone.\n')
CTK.TXT.insert('START', 'Warning: ', 'Warning')
CTK.TKTREE.updateApp()
CPlot.render()
