def fillMissingVariables():
if CTK.t == []: return
CTK.saveTree()
C._fillMissingVariables(CTK.t)
CTK.TXT.insert('START', 'Missing variables filled.\n')
CTK.TKTREE.updateApp()
CTK.display(CTK.t)
def rmBCOfType():
if CTK.t == []: return
BCTypes = []
selection = WIDGETS['BCLB'].curselection()
for s in selection:
t = WIDGETS['BCLB'].get(s)
if t not in Internal.KNOWNBCS: t = 'FamilySpecified:' + t
BCTypes.append(t)
CTK.saveTree()
nzs = CPlot.getSelectedZones()
if CTK.__MAINTREE__ <= 0 or nzs == []:
if 'FamilySpecified:-All BC-' in BCTypes:
Internal._rmNodesByType(CTK.t, 'BC_t')
else:
for t in BCTypes:
C._rmBCOfType(CTK.t, t)
else:
for nz in nzs:
nob = CTK.Nb[nz] + 1
noz = CTK.Nz[nz]
z = CTK.t[2][nob][2][noz]
if 'FamilySpecified:-All BC-' in BCTypes:
Internal._rmNodesByType(z, 'BC_t')
else:
for t in BCTypes:
C._rmBCOfType(z, t)
CTK.TXT.insert('START', 'BCs of type %s have been removed.\n' % type)
CTK.TKTREE.updateApp()
check()
def convert2Tetra():
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()
fail = False
errors = []
for nz in nzs:
nob = CTK.Nb[nz] + 1
noz = CTK.Nz[nz]
try:
a = C.convertArray2Tetra(CTK.t[2][nob][2][noz])
CTK.replace(CTK.t, nob, noz, a)
except Exception as e:
fail = True
errors += [0, str(e)]
if not fail: CTK.TXT.insert('START', 'Zones converted to tetra.\n')
else:
Panels.displayErrors(errors, header='Error: convert2Tetra')
CTK.TXT.insert('START',
'Tetra conversion fails for at least one zone.\n')
CTK.TXT.insert('START', 'Warning: ', 'Warning')
#C._fillMissingVariables(CTK.t)
(CTK.Nb, CTK.Nz) = CPlot.updateCPlotNumbering(CTK.t)
CTK.TKTREE.updateApp()
CPlot.render()
def createApp(win):
# - Frame -
Frame = TTK.LabelFrame(win,
borderwidth=2,
relief=CTK.FRAMESTYLE,
text='tkRuler',
font=CTK.FRAMEFONT,
takefocus=1)
#BB = CTK.infoBulle(parent=Frame, text='Take measures by clicking.\nCtrl+c to close applet.', temps=0, btype=1)
Frame.bind('<Control-c>', hideApp)
Frame.bind('<ButtonRelease-3>', displayFrameMenu)
Frame.bind('<Enter>', lambda event: Frame.focus_set())
Frame.columnconfigure(0, weight=1)
WIDGETS['frame'] = Frame
# - Frame menu -
FrameMenu = TK.Menu(Frame, tearoff=0)
FrameMenu.add_command(label='Close', accelerator='Ctrl+c', command=hideApp)
CTK.addPinMenu(FrameMenu, 'tkRuler')
WIDGETS['frameMenu'] = FrameMenu
# - VARS -
# -0- Zone filter regexp -
#V = TK.StringVar(win); V.set(''); VARS.append(V)
# - Buttons -
B = TTK.Button(Frame, text="Measure mode", command=measure)
B.grid(row=0, column=0, sticky=TK.EW)
BB = CTK.infoBulle(parent=B,
text='Click on two points to obtain the distance.')
WIDGETS['button'] = B
def fillEmptyBCWith():
if CTK.t == []: return
typeBC = VARS[4].get()
if typeBC not in Internal.KNOWNBCS:
nameBC = typeBC
typeBC = 'FamilySpecified:' + typeBC
else:
nameBC = typeBC
node = Internal.getNodeFromName(CTK.t, 'EquationDimension')
if node is not None: ndim = Internal.getValue(node)
else:
CTK.TXT.insert('START',
'EquationDimension not found (tkState). Using 3D.\n')
CTK.TXT.insert('START', 'Warning: ', 'Warning')
ndim = 3
CTK.saveTree()
nzs = CPlot.getSelectedZones()
if CTK.__MAINTREE__ <= 0 or nzs == []:
C._fillEmptyBCWith(CTK.t, nameBC + 'Fill', typeBC, dim=ndim)
else:
for nz in nzs:
nob = CTK.Nb[nz] + 1
noz = CTK.Nz[nz]
C._fillEmptyBCWith(CTK.t[2][nob][2][noz],
nameBC + 'Fill',
typeBC,
dim=ndim)
CTK.TXT.insert('START', 'Empty BCs filled.\n')
CTK.TKTREE.updateApp()
check()
def saveApp():
CTK.PREFS['tkSmoothIter'] = VARS[0].get()
CTK.PREFS['tkSmoothConsStrength'] = VARS[2].get()
CTK.PREFS['tkSmoothEps'] = VARS[4].get()
CTK.PREFS['tkSmoothSharpAngle'] = VARS[6].get()
CTK.PREFS['tkSmoothType'] = VARS[8].get()
CTK.savePrefFile()
def setBackground(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
type = VARS[0].get()
CTK.saveTree()
if type == 'None':
deleteBackgroundBase()
else:
deleteBackgroundBase()
CTK.t = C.addBase2PyTree(CTK.t, 'BACKGROUND', 2)
if type == 'Half-Box': B = createBox(1)
elif type == 'Box': B = createBox(0)
elif type == 'Z-Half-Box': B = createBox(1, 1)
elif type == 'Z-Box': B = createBox(0, 1)
elif type == 'Z-Ellipse': B = createZEllipse()
elif type == 'Z-Plane': B = createZPlane()
elif type == 'Z-Square-Ground': B = createGround()
base = Internal.getNodesFromName1(CTK.t, 'BACKGROUND')[0]
nob = C.getNobOfBase(base, CTK.t)
for b in B:
CTK.add(CTK.t, nob, -1, b)
#C._fillMissingVariables(CTK.t)
(CTK.Nb, CTK.Nz) = CPlot.updateCPlotNumbering(CTK.t)
CTK.TKTREE.updateApp()
CPlot.render()
def distribute(event=None):
global STATS
if CTK.t == []: return
try:
NProc = int(VARS[0].get())
except:
CTK.TXT.insert('START', 'distribute: NProc is invalid.\n')
CTK.TXT.insert('START', 'Error: ', 'Error')
return
try:
comSpeed = float(VARS[1].get())
except:
CTK.TXT.insert('START', 'distribute: ComSpeed is invalid.\n')
CTK.TXT.insert('START', 'Error: ', 'Error')
return
algo = VARS[2].get()
useCom = VARS[3].get()
CTK.saveTree()
CTK.t, STATS = D.distribute(CTK.t,
NProc,
perfo=(1., 0., comSpeed),
useCom=useCom,
algorithm=algo)
CTK.TXT.insert('START', 'Blocks distributed.\n')
CTK.TKTREE.updateApp()
updateStats()
def saveApp():
CTK.PREFS['tkDistributorNProc'] = VARS[0].get()
CTK.PREFS['tkDistributorComSpeed'] = VARS[1].get()
CTK.PREFS['tkDistributorAlgorithm'] = VARS[2].get()
CTK.PREFS['tkDistributorComType'] = VARS[3].get()
CTK.PREFS['tkDistributorMultigrid'] = VARS[5].get()
CTK.savePrefFile()
def createApp(win):
# - Frame -
Frame = TK.LabelFrame(win,
borderwidth=2,
relief=CTK.FRAMESTYLE,
text='tkOutOfCore',
font=CTK.FRAMEFONT,
takefocus=1)
#BB = CTK.infoBulle(parent=Frame, text='Push blocks out/in core memory.\nCtrl+c to close applet.', temps=0, btype=1)
Frame.bind('<Control-c>', hideApp)
Frame.bind('<Enter>', lambda event: Frame.focus_set())
Frame.columnconfigure(0, weight=1)
WIDGETS['frame'] = Frame
FrameMenu = TK.Menu(Frame, tearoff=0)
FrameMenu.add_command(label='Close', accelerator='Ctrl+c', command=hideApp)
CTK.addPinMenu(FrameMenu, 'tkOutOfCore')
WIDGETS['frameMenu'] = FrameMenu
# - IN/OUT -
B = TK.Button(Frame, text="IN Core", command=inCore)
B.grid(row=0, column=0, sticky=TK.EW)
BB = CTK.infoBulle(parent=B, text='Get the selection in core memory.')
B = TK.Button(Frame, text="OUT of Core", command=outCore)
B.grid(row=0, column=1, sticky=TK.EW)
BB = CTK.infoBulle(parent=B, text='Get the selection out of core memory.')
def makeDirect():
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()
fail = False; errors = []
for nz in nzs:
nob = CTK.Nb[nz]+1
noz = CTK.Nz[nz]
z = CTK.t[2][nob][2][noz]
try:
a = T.makeDirect(z)
CTK.replace(CTK.t, nob, noz, a)
except Exception as e:
fail = True; errors += [0,str(e)]
if not fail:
CTK.TXT.insert('START', 'Zones made direct.\n')
else:
Panels.displayErrors(errors, header='Error: makeDirect')
CTK.TXT.insert('START', 'MakeDirect fails for at least one zone.\n')
CTK.TXT.insert('START', 'Warning: ', 'Warning')
CTK.TKTREE.updateApp()
CPlot.render()
def outCore():
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
for nz in nzs:
nob = CTK.Nb[nz] + 1
noz = CTK.Nz[nz]
z = CTK.t[2][nob][2][noz]
ooc = Internal.getNodesFromName1(z, 'OutOfCore')
if (len(ooc) == 0):
# Save zone
base = CTK.t[2][nob]
name = '.' + base[0] + '#' + z[0] + '.cgns'
t = C.newPyTree(['Base'])
t[2][1][2].append(z)
C.convertPyTree2File(t, name)
# Replace zone
bb = G.BB(z)
bb[2].append(['OutOfCore', numpy.array([1]), [], \
'UserDefinedData_t'])
bb = CPlot.addRender2Zone(bb, blending=0.2)
CTK.replace(CTK.t, nob, noz, bb)
CTK.saveTree() # il est apres pour forcer le flush
CTK.TXT.insert('START', 'Selected zones out of core.\n')
CTK.t = C.fillMissingVariables(CTK.t)
(CTK.Nb, CTK.Nz) = CPlot.updateCPlotNumbering(CTK.t)
CTK.TKTREE.updateApp()
CPlot.render()
def inCore():
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
for nz in nzs:
nob = CTK.Nb[nz] + 1
noz = CTK.Nz[nz]
z = CTK.t[2][nob][2][noz]
ooc = Internal.getNodesFromName1(z, 'OutOfCore')
if (len(ooc) != 0):
# Read zone
base = CTK.t[2][nob]
name = '.' + base[0] + '#' + z[0] + '.cgns'
t = C.convertFile2PyTree(name)
CTK.replace(CTK.t, nob, noz, t[2][1][2][0])
CTK.saveTree() # il est apres pour forcer le flush
CTK.TXT.insert('START', 'Selected zones in core.\n')
CTK.t = C.fillMissingVariables(CTK.t)
(CTK.Nb, CTK.Nz) = CPlot.updateCPlotNumbering(CTK.t)
CTK.TKTREE.updateApp()
CPlot.render()
def saveApp():
CTK.PREFS['tkVariablesName'] = VARS[0].get()
CTK.PREFS['tkVariablesAddVar'] = VARS[1].get()
CTK.PREFS['tkVariablesImportFile'] = VARS[4].get()
CTK.PREFS['tkVariablesLoc'] = VARS[6].get()
CTK.PREFS['tkVariablesAdim'] = VARS[7].get()
CTK.savePrefFile()
def pointedHat():
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()
args = VARS[3].get()
args = args.split(';')
if (len(args) != 3): return
x0 = float(args[0])
y0 = float(args[1])
z0 = float(args[2])
if (nzs == []):
CTK.TXT.insert('START', 'Selection is empty.\n')
CTK.TXT.insert('START', 'Error: ', 'Error')
return
else:
for nz in nzs:
nob = CTK.Nb[nz] + 1
noz = CTK.Nz[nz]
CTK.t[2][nob][2][noz] = G.pointedHat(CTK.t[2][nob][2][noz],
(x0, y0, z0))
CTK.TXT.insert('START', 'Pointed hat created.\n')
(CTK.Nb, CTK.Nz) = CPlot.updateCPlotNumbering(CTK.t)
CTK.TKTREE.updateApp()
CTK.display(CTK.t)
return
def smooth1D(niter, eps):
fail = False
nzs = CPlot.getSelectedZones()
for nz in nzs:
nob = CTK.Nb[nz]+1
noz = CTK.Nz[nz]
z = CTK.t[2][nob][2][noz]
dims = Internal.getZoneDim(z)
try:
if dims[0] == 'Unstructured': a = C.convertBAR2Struct(z)
else: a = z
a = D.getCurvilinearAbscissa(a)
distrib = C.cpVars(a, 's', a, 'CoordinateX')
C._initVars(distrib, 'CoordinateY', 0.)
C._initVars(distrib, 'CoordinateZ', 0.)
distrib = C.rmVars(distrib, 's')
bornes = P.exteriorFaces(distrib)
distrib = T.smooth(distrib, eps=eps, niter=niter,
fixedConstraints=[bornes])
b = G.map(a, distrib)
CTK.replace(CTK.t, nob, noz, b)
except Exception as e:
fail = True
Panels.displayErrors([0,str(e)], header='Error: smooth1D')
return fail
def extractBodies():
pref = 'BODY#'
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()
for nz in nzs:
nob = CTK.Nb[nz] + 1
noz = CTK.Nz[nz]
z = CTK.t[2][nob][2][noz]
baseName = CTK.t[2][nob][0]
bodyName = pref + baseName
CTK.t = C.addBase2PyTree(CTK.t, bodyName, cellDim=2)
nodes = Internal.getNodesFromName(CTK.t, bodyName)
p = Internal.getParentOfNode(CTK.t, nodes[0])
walls = C.extractBCOfType(z, 'BCWall')
walls += C.extractBCOfType(z, 'BCWallInviscid')
walls += C.extractBCOfType(z, 'BCWallViscous')
CTK.t[2][p[1]][2] = CTK.t[2][p[1]][2] + walls
CTK.TXT.insert('START', 'Walls extracted.\n')
(CTK.Nb, CTK.Nz) = CPlot.updateCPlotNumbering(CTK.t)
CTK.TKTREE.updateApp()
CTK.display(CTK.t)
def setTime(event=None):
if CTK.t == []: return
walls = VARS[3].get()
time = CTK.varsFromWidget(VARS[1].get(), type=1)
if len(time) != 1:
CTK.TXT.insert('START', 'Invalid time.\n')
CTK.TXT.insert('START', 'Error: ', 'Error')
return
time = time[0]
t0 = CTK.varsFromWidget(VARS[0].get(), type=1)[0]
tf = CTK.varsFromWidget(VARS[2].get(), type=1)[0]
step = (tf - t0) / 100.
if CTK.__MAINTREE__ == 1:
CTK.__MAINACTIVEZONES__ = CPlot.getActiveZones()
if walls == '1' and CTK.dt == []:
zones = Internal.getZones(CTK.t)
Z = buildWalls(zones)
CTK.dt = C.newPyTree(['Base'])
CTK.dt[2][1][2] += Z
if walls == '1': temp = RM.evalPosition(CTK.dt, time)
else: temp = RM.evalPosition(CTK.t, time)
WIDGETS['slider'].set((time - t0) / step)
WIDGETS['slider'].update()
CTK.display(temp, mainTree=CTK.TIME)
def saveApp():
CTK.PREFS['tkOctreeSnear'] = VARS[0].get()
CTK.PREFS['tkOctreeDfar'] = VARS[1].get()
CTK.PREFS['tkOctreeBalance'] = VARS[2].get()
CTK.PREFS['tkOctreeVmin'] = VARS[3].get()
CTK.PREFS['tkOctreeExpand'] = VARS[4].get()
CTK.savePrefFile()
def playForward(event=None):
if CTK.t == []: return
walls = VARS[3].get()
t0 = CTK.varsFromWidget(VARS[0].get(), type=1)[0]
time = CTK.varsFromWidget(VARS[1].get(), type=1)[0]
tf = CTK.varsFromWidget(VARS[2].get(), type=1)[0]
step = (tf - t0) / 100.
if CTK.__MAINTREE__ == 1:
CTK.__MAINACTIVEZONES__ = CPlot.getActiveZones()
if (walls == '1' and CTK.dt == []):
zones = Internal.getNodesFromType(CTK.t, 'Zone_t')
Z = buildWalls(zones)
CTK.dt = C.newPyTree(['Base'])
CTK.dt[2][1][2] += Z
CTK.__BUSY__ = True
CPlot.setState(cursor=2)
while (time < tf and CTK.__BUSY__):
if (walls == '1'): temp = RM.evalPosition(CTK.dt, time)
else: temp = RM.evalPosition(CTK.t, time)
CTK.display(temp, mainTree=CTK.TIME)
time += step
VARS[1].set(str(time))
WIDGETS['slider'].set((time - t0) / step)
WIDGETS['time'].update()
WIDGETS['slider'].update()
CTK.__BUSY__ = False
CPlot.setState(cursor=0)
def setVars3(event=None):
nzs = CPlot.getSelectedZones()
if (nzs == []):
CTK.TXT.insert('START', 'Selection is empty.\n')
CTK.TXT.insert('START', 'Error: ', 'Error')
return
name = VARS[0].get()
CTK.saveTree()
transl_speed = CTK.varsFromWidget(VARS[43].get(), 1)
axis_pnt = CTK.varsFromWidget(VARS[44].get(), 1)
axis_vct = CTK.varsFromWidget(VARS[45].get(), 1)
omega = VARS[46].get()
for nz in nzs:
nob = CTK.Nb[nz] + 1
noz = CTK.Nz[nz]
z = CTK.t[2][nob][2][noz]
CTK.t[2][nob][2][noz] = RM.setPrescribedMotion3(
z,
name,
transl_speed=transl_speed,
axis_pnt=axis_pnt,
axis_vct=axis_vct,
omega=omega)
CTK.TKTREE.updateApp()
CTK.TXT.insert('START', 'Motion set in selected zones.\n')
def rmBlock():
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
deletedZoneNames = []
for nz in nzs:
nob = CTK.Nb[nz] + 1
noz = CTK.Nz[nz]
deletedZoneNames.append(CTK.t[2][nob][0] + Internal.SEP1 +
CTK.t[2][nob][2][noz][0])
CTK.saveTree()
CTK.t = CPlot.deleteSelection(CTK.t, CTK.Nb, CTK.Nz, nzs)
CTK.TXT.insert('START', 'Selected zones deleted.\n')
(CTK.Nb, CTK.Nz) = CPlot.updateCPlotNumbering(CTK.t)
CTK.TKTREE.updateApp()
CPlot.delete(deletedZoneNames)
CPlot.render()
def selectCells(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
formula = VARS[0].get()
strict = VARS[1].get()
strict = int(strict)
nzs = CPlot.getSelectedZones()
if nzs == []:
CTK.TXT.insert('START', 'Selection is empty.\n')
CTK.TXT.insert('START', 'Error: ', 'Error')
return
CTK.saveTree()
for nz in nzs:
nob = CTK.Nb[nz] + 1
noz = CTK.Nz[nz]
z = CTK.t[2][nob][2][noz]
z = P.selectCells(z, formula, strict=strict)
CTK.replace(CTK.t, nob, noz, z)
#C._fillMissingVariables(CTK.t)
(CTK.Nb, CTK.Nz) = CPlot.updateCPlotNumbering(CTK.t)
CTK.TXT.insert('START', 'Cells selected.\n')
CTK.TKTREE.updateApp()
CPlot.render()
def saveApp():
CTK.PREFS['tkExtrusionHeight'] = VARS[0].get()
CTK.PREFS['tkExtrusionNLayers'] = VARS[1].get()
CTK.PREFS['tkExtrusionSmooth'] = VARS[2].get()
CTK.PREFS['tkExtrusionRevAngle'] = VARS[5].get()
CTK.PREFS['tkExtrusionNpts'] = VARS[6].get()
CTK.savePrefFile()
def streamLine():
if CTK.t == []: return
npts = CTK.varsFromWidget(VARS[0].get(), type=2)
if len(npts) != 1:
CTK.TXT.insert('START', 'Number of points in stream incorrect.\n')
CTK.TXT.insert('START', 'Error: ', 'Error')
return
npts = npts[0]
v1 = VARS[1].get()
v2 = VARS[2].get()
v3 = VARS[3].get()
CTK.TXT.insert('START', 'Click to select starting point...\n')
l = []
while l == []:
l = CPlot.getActivePoint()
time.sleep(0.1)
print('Stream: starting point %d.' % l)
CTK.saveTree()
CTK.t = C.addBase2PyTree(CTK.t, 'STREAMS', 2)
b = Internal.getNodesFromName1(CTK.t, 'STREAMS')
nob = C.getNobOfBase(b[0], CTK.t)
try:
stream = P.streamLine(CTK.t, (l[0], l[1], l[2]), [v1, v2, v3], N=npts)
CTK.add(CTK.t, nob, -1, stream)
CTK.TXT.insert('START', 'Stream line created.\n')
except Exception as e:
Panels.displayErrors([0, str(e)], header='Error: streamLine')
CTK.TXT.insert('START', 'Stream line fails.\n')
CTK.TXT.insert('START', 'Error: ', 'Error')
(CTK.Nb, CTK.Nz) = CPlot.updateCPlotNumbering(CTK.t)
CTK.TKTREE.updateApp()
CPlot.render()
def addkplanes():
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
N = CTK.varsFromWidget(VARS[1].get(), type=2)
if len(N) != 1:
CTK.TXT.insert('START', 'Number of layers is incorrect.\n')
CTK.TXT.insert('START', 'Error: ', 'Error')
return
N = N[0]
nzs = CPlot.getSelectedZones()
if nzs == []:
CTK.TXT.insert('START', 'Selection is empty.\n')
CTK.TXT.insert('START', 'Error: ', 'Error')
return
CTK.saveTree()
fail = False
for nz in nzs:
nob = CTK.Nb[nz] + 1
noz = CTK.Nz[nz]
#try:
z = T.addkplane(CTK.t[2][nob][2][noz], N=N)
CTK.replace(CTK.t, nob, noz, z)
#except Exception as e: fail = True
if not fail: CTK.TXT.insert('START', 'K planes added.\n')
else:
CTK.TXT.insert('START', 'add K planes failed.\n')
CTK.TXT.insert('START', 'Error: ', 'Error')
(CTK.Nb, CTK.Nz) = CPlot.updateCPlotNumbering(CTK.t)
CTK.TKTREE.updateApp()
CPlot.render()
def setShaderParameter(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
shaderParameter2 = (WIDGETS['param2'].get()) / 50.
shaderParameter1 = (WIDGETS['param1'].get()) / 50.
VARS[4].set('Shader parameter 1 [%.2f].' % shaderParameter1)
VARS[5].set('Shader parameter 2 [%.2f].' % shaderParameter2)
nzs = CPlot.getSelectedZones()
if nzs == []:
CTK.TXT.insert('START', 'Selection is empty.\n')
CTK.TXT.insert('START', 'Error: ', 'Error')
return
CTK.saveTree()
for nz in nzs:
nob = CTK.Nb[nz] + 1
noz = CTK.Nz[nz]
a = CPlot.addRender2Zone(
CTK.t[2][nob][2][noz],
shaderParameters=[shaderParameter1, shaderParameter2])
CTK.replace(CTK.t, nob, noz, a)
CTK.TKTREE.updateApp()
Panels.updateRenderPanel()
CPlot.render()
def setAll():
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
material = VARS[0].get()
color = VARS[1].get()
blending = WIDGETS['blending'].get() / 100.
VARS[6].set('Blending [%.2f].' % blending)
meshOverlay = VARS[3].get()
shaderParameter2 = (WIDGETS['param2'].get()) / 50.
shaderParameter1 = (WIDGETS['param1'].get()) / 50.
nzs = CPlot.getSelectedZones()
if nzs == []:
CTK.TXT.insert('START', 'Selection is empty.\n')
CTK.TXT.insert('START', 'Error: ', 'Error')
return
CTK.saveTree()
for nz in nzs:
nob = CTK.Nb[nz] + 1
noz = CTK.Nz[nz]
a = CPlot.addRender2Zone(
CTK.t[2][nob][2][noz],
material=material,
color=color,
blending=blending,
shaderParameters=[shaderParameter1, shaderParameter2])
CTK.replace(CTK.t, nob, noz, a)
CTK.TKTREE.updateApp()
Panels.updateRenderPanel()
CPlot.render()
def createApp(win):
# - Frame -
Frame = TTK.LabelFrame(win, borderwidth=2, relief=CTK.FRAMESTYLE,
text='tkInit', font=CTK.FRAMEFONT, takefocus=1)
#BB = CTK.infoBulle(parent=Frame, text='Init solution fields.\nCtrl+c to close applet.', temps=0, btype=1)
Frame.bind('<Control-c>', hideApp)
Frame.bind('<ButtonRelease-3>', displayFrameMenu)
Frame.bind('<Enter>', lambda event : Frame.focus_set())
Frame.columnconfigure(0, weight=1)
WIDGETS['frame'] = Frame
# - Frame menu -
FrameMenu = TK.Menu(Frame, tearoff=0)
FrameMenu.add_command(label='Close', accelerator='Ctrl+c', command=hideApp)
CTK.addPinMenu(FrameMenu, 'tkInit')
WIDGETS['frameMenu'] = FrameMenu
# - VARS -
# -0- Zone filter regexp -
#V = TK.StringVar(win); V.set(''); VARS.append(V)
# - Init solution -
B = TTK.Button(Frame, text="Initialize solution from state",
command=initSolution)
B.grid(row=0, column=0, columnspan=2, sticky=TK.EW)
BB = CTK.infoBulle(parent=B, text='Initialize the solution in centers (require state).')
# - Init wall distances -
B = TTK.Button(Frame, text="Initialize wall distances",
command=initWallDistance)
B.grid(row=1, column=0, columnspan=2, sticky=TK.EW)
BB = CTK.infoBulle(parent=B, text='Compute wall distances.')
def compute():
if CTK.t == []: return
nzs = CPlot.getSelectedZones()
if nzs == []:
CTK.TXT.insert('START', 'Selection is empty.\n')
CTK.TXT.insert('START', 'Error: ', 'Error')
return
surf = 0
walls = []
name = VARS[1].get()
if name == '': names = []
else: names = name.split(';')
for v in names:
surf = 1
v = v.lstrip()
v = v.rstrip()
sname = v.split('/', 1)
bases = Internal.getNodesFromName1(CTK.t, sname[0])
if bases != []:
nodes = Internal.getNodesFromType1(bases[0], 'Zone_t')
for z in nodes:
if z[0] == sname[1]: walls.append(z)
if surf == 0:
walls = C.extractBCOfType(CTK.t, 'BCWall')
walls += C.extractBCOfType(CTK.t, 'BCWallViscous')
walls += C.extractBCOfType(CTK.t, 'BCWallInviscid')
tp = C.newPyTree(['Base'])
for nz in nzs:
nob = CTK.Nb[nz] + 1
noz = CTK.Nz[nz]
z = CTK.t[2][nob][2][noz]
tp[2][1][2].append(z)
try:
if (VARS[2].get() == 'absolute'): signed = 0
else: signed = 1
tp = DTW.distance2Walls(tp,
walls,
type=VARS[0].get(),
loc=VARS[3].get(),
signed=signed)
c = 0
for nz in nzs:
nob = CTK.Nb[nz] + 1
noz = CTK.Nz[nz]
CTK.t[2][nob][2][noz] = tp[2][1][2][c]
c += 1
#C._fillMissingVariables(CTK.t)
CTK.TKTREE.updateApp()
CTK.display(CTK.t)
CTK.TXT.insert('START', 'Distance to walls computed.\n')
except Exception as e:
Panels.displayErrors([0, str(e)], header='Error: dist2Walls')
CTK.TXT.insert('START', 'Distance to walls failed.\n')
CTK.TXT.insert('START', 'Error: ', 'Error')
