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 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 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
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] += walls
CTK.TXT.insert('START', 'Walls extracted.\n')
(CTK.Nb, CTK.Nz) = CPlot.updateCPlotNumbering(CTK.t)
CTK.TKTREE.updateApp()
CTK.display(CTK.t)
def moveNodeUp():
if CTK.t == []: return
node = CTK.TKTREE.getCurrentSelectedNode()
if node[3] == 'CGNSTree_t': return # Tree node can not move
(p, c) = Internal.getParentOfNode(CTK.t, node)
if c == 0: return # already first
if node[3] == 'Zone_t': # optimise
z1 = p[2][c - 1]
z2 = p[2][c]
if z1[3] != 'Zone_t':
temp = p[2][c - 1]
p[2][c - 1] = p[2][c]
p[2][c] = temp
CTK.TKTREE.updateApp()
return
(nob1, noz1) = C.getNobNozOfZone(z1, CTK.t)
(nob2, noz2) = C.getNobNozOfZone(z2, CTK.t)
CTK.replace(CTK.t, nob1, noz1, z2)
CTK.replace(CTK.t, nob2, noz2, z1)
CTK.TKTREE.updateApp()
(CTK.Nb, CTK.Nz) = CPlot.updateCPlotNumbering(CTK.t)
CPlot.render()
elif node[3] == 'CGNSBase_t': # non optimise
temp = p[2][c - 1]
p[2][c - 1] = p[2][c]
p[2][c] = temp
CTK.TKTREE.updateApp()
(CTK.Nb, CTK.Nz) = CPlot.updateCPlotNumbering(CTK.t)
CTK.display(CTK.t)
else: # n'impacte pas CPlot
temp = p[2][c - 1]
p[2][c - 1] = p[2][c]
p[2][c] = temp
CTK.TKTREE.updateApp()
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
for nz in nzs:
nob = CTK.Nb[nz] + 1
noz = CTK.Nz[nz]
z = G.pointedHat(CTK.t[2][nob][2][noz], (x0, y0, z0))
CTK.replace(CTK.t, nob, noz, z)
CTK.TXT.insert('START', 'Pointed hat created.\n')
(CTK.Nb, CTK.Nz) = CPlot.updateCPlotNumbering(CTK.t)
CTK.TKTREE.updateApp()
CPlot.render()
return
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 streamRibbon():
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('Ribbon: 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.streamRibbon(CTK.t, (l[0], l[1], l[2]), (0, 0, 0.01),
[v1, v2, v3],
N=npts)
CTK.add(CTK.t, nob, -1, stream)
CTK.TXT.insert('START', 'Stream ribbon created.\n')
except Exception as e:
Panels.displayErrors([0, str(e)], header='Error: streamRibbon')
CTK.TXT.insert('START', 'Stream ribbon fails.\n')
CTK.TXT.insert('START', 'Error: ', 'Error')
(CTK.Nb, CTK.Nz) = CPlot.updateCPlotNumbering(CTK.t)
CTK.TKTREE.updateApp()
CTK.display(CTK.t)
def setDisplayInfo(event=None):
v = VARS[2].get()
va = 0
if v == 'Active': va = 1
elif v == 'Inactive': va = 0
CPlot.setState(displayInfo=va)
CPlot.setState(displayBB=va)
CTK.PREFS['displayInfo'] = str(va)
def TRITFI():
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 len(nzs) == 0:
CTK.TXT.insert('START', 'Selection is empty.\n')
CTK.TXT.insert('START', 'Error: ', 'Error')
return
surf = getSurfaces()
zones = []
for nz in nzs:
nob = CTK.Nb[nz] + 1
noz = CTK.Nz[nz]
z = CTK.t[2][nob][2][noz]
z = C.convertBAR2Struct(z)
zones.append(z)
if len(zones) != 3:
CTK.TXT.insert('START', 'TRI TFI takes 3 contours.\n')
CTK.TXT.insert('START', 'Error: ', 'Error')
return
coords1 = C.getFields(Internal.__GridCoordinates__, zones[0])[0]
coords2 = C.getFields(Internal.__GridCoordinates__, zones[1])[0]
coords3 = C.getFields(Internal.__GridCoordinates__, zones[2])[0]
[m1, m2, m3] = trimesh(coords1, coords2, coords3)
if (m1 == 0):
CTK.TXT.insert('START', m2 + '\n')
CTK.TXT.insert('START', 'Error: ', 'Error')
return
m1 = C.convertArrays2ZoneNode('TFI1', [m1])
m2 = C.convertArrays2ZoneNode('TFI2', [m2])
m3 = C.convertArrays2ZoneNode('TFI3', [m3])
if surf != []:
m1 = T.projectOrthoSmooth(m1, surf)
m2 = T.projectOrthoSmooth(m2, surf)
m3 = T.projectOrthoSmooth(m3, surf)
CTK.saveTree()
CTK.t = C.addBase2PyTree(CTK.t, 'MESHES')
bases = Internal.getNodesFromName1(CTK.t, 'MESHES')
nob = C.getNobOfBase(bases[0], CTK.t)
for i in [m1, m2, m3]:
CTK.add(CTK.t, nob, -1, i)
CTK.TXT.insert('START', 'TRI-TFI mesh created.\n')
#C._fillMissingVariables(CTK.t)
(CTK.Nb, CTK.Nz) = CPlot.updateCPlotNumbering(CTK.t)
CTK.TKTREE.updateApp()
CPlot.render()
def importFile(event=None):
if CTK.t == []: return
s = VARS[4].get()
s = s.split(';')
try:
t1 = []
for filename in s:
if filename != '':
t2 = C.convertFile2PyTree(filename)
# Fusion des bases de t et t2
if t1 == []: t1 = t2
else: t1 = C.mergeTrees(t1, t2)
except:
CTK.TXT.insert('START', 'Import failed.\n')
CTK.TXT.insert('START', 'Error: ', 'Error')
return
if t1 == []:
CTK.TXT.insert('START', 'Import failed.\n')
CTK.TXT.insert('START', 'Error: ', 'Error')
return
CTK.saveTree()
nzs = CPlot.getSelectedZones()
# Essaie de trouver une methode adaptee
method = 1 # match by geom
import sets
zoneNames = sets.Set(C.getZoneNames(CTK.t, prefixByBase=False))
zoneNames1 = sets.Set(C.getZoneNames(t1, prefixByBase=False))
inter = zoneNames & zoneNames1
linter = len(inter) * 1.
comp = min(len(zoneNames), len(zoneNames1)) * 1.
if linter / comp > 0.9: method = 0 # try match by name (safer)
if CTK.__MAINTREE__ <= 0 or nzs == []:
CTK.t = P.importVariables(t1, CTK.t, method=method)
else:
zones = C.newPyTree(['Base'])
for nz in nzs:
nob = CTK.Nb[nz] + 1
noz = CTK.Nz[nz]
zone = CTK.t[2][nob][2][noz]
zones[2][1][2].append(zone)
zones = P.importVariables(t1, zones, method=method)
c = 0
for nz in nzs:
nob = CTK.Nb[nz] + 1
noz = CTK.Nz[nz]
CTK.t[2][nob][2][noz] = zones[2][1][2][c]
c += 1
CTK.TXT.insert('START', 'Variable file %s imported.\n' % filename)
#C._fillMissingVariables(CTK.t)
(CTK.Nb, CTK.Nz) = CPlot.updateCPlotNumbering(CTK.t)
CTK.TKTREE.updateApp()
CTK.display(CTK.t)
if CTK.TKPLOTXY is not None: CTK.TKPLOTXY.updateApp()
def rotate(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
axis = VARS[2].get()
angle = CTK.varsFromWidget(VARS[3].get(), type=1)
if len(angle) == 1:
angle = angle[0]
X = None
elif len(angle) == 4:
X = (angle[1], angle[2], angle[3])
angle = angle[0]
else:
CTK.TXT.insert('START', 'Invalid angle or angle+rotation center.\n')
CTK.TXT.insert('START', 'Error: ', 'Error')
return
if axis == 'around X': axe = (1., 0., 0.)
elif axis == 'around Y': axe = (0., 1., 0.)
elif axis == 'around Z': axe = (0., 0., 1.)
elif axis == 'around view':
pos = CPlot.getState('posCam')
eye = CPlot.getState('posEye')
axe = (eye[0] - pos[0], eye[1] - pos[1], eye[2] - pos[2])
else:
axe = (0., 0., 1.)
try:
angle = float(angle)
except:
angle = 0.
nzs = CPlot.getSelectedZones()
if nzs == []:
CTK.TXT.insert('START', 'Selection is empty.\n')
CTK.TXT.insert('START', 'Error: ', 'Error')
return
CTK.saveTree()
if X is None:
sel = []
for nz in nzs:
nob = CTK.Nb[nz] + 1
noz = CTK.Nz[nz]
z = CTK.t[2][nob][2][noz]
sel.append(z)
X = G.barycenter(sel)
for nz in nzs:
nob = CTK.Nb[nz] + 1
noz = CTK.Nz[nz]
a = T.rotate(CTK.t[2][nob][2][noz], (X[0], X[1], X[2]), axe, angle)
CTK.replace(CTK.t, nob, noz, a)
CTK.TXT.insert('START', 'Zones have been rotated.\n')
CTK.TKTREE.updateApp()
CPlot.render()
def getPointCoordinates():
if CTK.t == []: return
nzs = CPlot.getSelectedZones()
if nzs == []:
CTK.TXT.insert('START', 'Selection is empty.\n')
CTK.TXT.insert('START', 'Error: ', 'Error')
return
point = CPlot.getActivePoint()
if point != []:
VARS[0].set(str(point[0]) + ';' + str(point[1]) + ';' + str(point[2]))
def uniformize(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
type = VARS[2].get()
density = -1; npts = 2; factor = -1
if type == 'Density':
density = CTK.varsFromWidget(VARS[0].get(), 1)
if len(density) != 1:
CTK.TXT.insert('START', 'Invalid points density.\n')
CTK.TXT.insert('START', 'Error: ', 'Error')
density = density[0]
elif type == 'Npts':
npts = CTK.varsFromWidget(VARS[0].get(), 2)
if len(npts) != 1:
CTK.TXT.insert('START', 'Invalid number of points.\n')
CTK.TXT.insert('START', 'Error: ', 'Error')
npts = npts[0]
elif type == 'Factor':
factor = CTK.varsFromWidget(VARS[0].get(), 1)
if len(factor) != 1:
CTK.TXT.insert('START', 'Invalid number factor.\n')
CTK.TXT.insert('START', 'Error: ', 'Error')
CTK.saveTree()
# Get first selected zone
nz = nzs[0]
nob = CTK.Nb[nz]+1
noz = CTK.Nz[nz]
zone = CTK.t[2][nob][2][noz]
dim = Internal.getZoneDim(zone)
if dim[0] == 'Structured':
if dim[2] != 1 and dim[3] != 1:
fail = apply3D(density, npts, factor, ntype=0)
elif dim[2] != 1 and dim[3] == 1:
fail = apply2D(density, npts, factor, ntype=0)
else: fail = uniformize1D(density, npts, factor)
else: fail = uniformize1D(density, npts, factor) # all zones
if not fail:
CTK.TXT.insert('START', 'Uniformize successfull.\n')
else:
CTK.TXT.insert('START', 'Uniformize edge 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 rotate():
if CTK.t == []: return
if not CTK.__BUSY__:
bb = G.bbox(CTK.t)
xc = 0.5 * (bb[3] + bb[0])
yc = 0.5 * (bb[4] + bb[1])
zc = 0.5 * (bb[5] + bb[2])
pos = CPlot.getState('posCam')
posCam = [pos[0], pos[1], pos[2]]
posEye = [xc, yc, zc]
dirCam = [0, 0, 1]
CTK.__BUSY__ = True
TTK.sunkButton(WIDGETS['rotate'])
CPlot.setState(cursor=2)
i = 0
while CTK.__BUSY__:
speed = WIDGETS['speed'].get() * 0.0006 / 100.
cs = math.cos(speed * i * math.pi / 180)
ss = math.sin(speed * i * math.pi / 180)
px = cs * (posCam[0] - xc) + ss * (posCam[1] - yc) + xc
py = -ss * (posCam[0] - xc) + cs * (posCam[1] - yc) + yc
posCam[0] = px
posCam[1] = py
CPlot.setState(posCam=posCam)
time.sleep(CPlot.__timeStep__)
WIDGETS['rotate'].update()
i += 1
CTK.__BUSY__ = False
TTK.raiseButton(WIDGETS['rotate'])
CPlot.setState(cursor=0)
else:
CTK.__BUSY__ = False
TTK.raiseButton(WIDGETS['rotate'])
CPlot.setState(cursor=0)
def measure():
if CTK.t == []: return
prev = []
w = WIDGETS['button']
if CTK.__BUSY__ == False:
CTK.__BUSY__ = True
TTK.sunkButton(w)
CPlot.setState(cursor=1)
while CTK.__BUSY__:
CPlot.unselectAllZones()
l = []
while (l == []):
l = CPlot.getActivePoint()
time.sleep(CPlot.__timeStep__)
w.update()
if CTK.__BUSY__ == False: break
if CTK.__BUSY__ == True:
if prev == []:
prev = l
CTK.TXT.insert('START', 'Click second point...\n')
elif prev != l:
dist = (l[0]-prev[0])*(l[0]-prev[0])+\
(l[1]-prev[1])*(l[1]-prev[1])+\
(l[2]-prev[2])*(l[2]-prev[2])
dist = math.sqrt(dist)
CTK.TXT.insert('START', 'dist= ' + str(dist) + '\n')
time.sleep(CPlot.__timeStep__)
prev = []
CTK.__BUSY__ = False
TTK.raiseButton(w)
CPlot.setState(cursor=0)
else:
CTK.__BUSY__ = False
TTK.raiseButton(w)
CPlot.setState(cursor=0)
def setViewMode2(event=None):
type = VARS[0].get()
if type == 'All fields':
CTK.__FIELD__ = '__all__'
if CTK.t != []: CTK.display(CTK.t)
elif type == 'No field':
CTK.__FIELD__ = '__none__'
if CTK.t != []: CPlot.setMode(0); CTK.display(CTK.t)
else:
CTK.__FIELD__ = type
if CTK.t != []: CTK.display(CTK.t)
def dirProject():
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
# surfaces
name = VARS[0].get()
names = name.split(';')
surfaces = []
for v in names:
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]): surfaces.append(z)
if (surfaces == []):
CTK.TXT.insert('START', 'Projection surface is empty.\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
eye = CPlot.getState('posEye')
cam = CPlot.getState('posCam')
dir = (eye[0] - cam[0], eye[1] - cam[1], eye[2] - cam[2])
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.projectDir(z, surfaces, dir)
CTK.replace(CTK.t, nob, noz, a)
except Exception as e:
fail = True
errors += [0, str(e)]
if (fail == False):
CTK.TXT.insert('START', 'Zones projected.\n')
else:
Panels.displayErrors(errors, header='Error: projectDir')
CTK.TXT.insert('START', 'Projection fails for at least one zone.\n')
CTK.TXT.insert('START', 'Warning: ', 'Warning')
CTK.TKTREE.updateApp()
CPlot.render()
def extrudeWCurve(mode=0):
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
# - curve -
name = VARS[3].get()
names = name.split(';')
curve = []
for v in names:
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]: curve.append(z)
if len(curve) == 0:
CTK.TXT.insert('START', 'Curve is incorrect.\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:
if mode == 0: z = D.lineDrive(z, curve)
else: z = D.orthoDrive(z, curve)
CTK.replace(CTK.t, nob, noz, z)
except Exception as e:
fail = True
errors += [0, str(e)]
if not fail:
CTK.TXT.insert('START', 'Mesh extruded with curve(s).\n')
else:
Panels.displayErrors(errors, header='Error: extrusion')
CTK.TXT.insert('START', 'Extrusion fails for at least one zone.\n')
CTK.TXT.insert('START', 'Warning: ', 'Warning')
(CTK.Nb, CTK.Nz) = CPlot.updateCPlotNumbering(CTK.t)
CTK.TKTREE.updateApp()
CPlot.render()
def setViewMode(v, l):
v.set(l)
type = v.get()
if type == 'All fields':
CTK.__FIELD__ = '__all__'
if CTK.t != []: CTK.display(CTK.t)
elif type == 'No field':
CTK.__FIELD__ = '__none__'
if CTK.t != []: CPlot.setMode(0); CTK.display(CTK.t)
else:
CTK.__FIELD__ = type
if CTK.t != []: CTK.display(CTK.t)
def deleteCanvasBase():
nodes = Internal.getNodesFromName1(CTK.t, 'CANVAS')
if nodes == []: return
canvas = nodes[0]
# delete from plotter
zones = Internal.getNodesFromType(canvas, 'Zone_t')
dels = []
for z in zones:
dels.append(canvas[0] + Internal.SEP1 + z[0])
CPlot.delete(dels)
ret = Internal.getParentOfNode(CTK.t, canvas)
del ret[0][2][ret[1]]
def extractIsoLine():
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
field = VARS[0].get()
value = VARS[2].get()
try:
value = float(value)
except:
value = 1.
nzs = CPlot.getSelectedZones()
CTK.saveTree()
if nzs == []:
z = Internal.getZones(CTK.t)
else:
z = []
for nz in nzs:
nob = CTK.Nb[nz] + 1
noz = CTK.Nz[nz]
z.append(CTK.t[2][nob][2][noz])
isos = []
fail = False
errors = []
for zone in z:
try:
i = P.isoLine(zone, field, value)
isos.append(i)
except Exception as e:
fail = True
errors += [0, str(e)]
CTK.t = C.addBase2PyTree(CTK.t, 'CONTOURS', 1)
bases = Internal.getNodesFromName1(CTK.t, 'CONTOURS')
nob = C.getNobOfBase(bases[0], CTK.t)
for i in isos:
CTK.add(CTK.t, nob, -1, i)
if (fail == False):
CTK.TXT.insert('START', 'Isolines extracted.\n')
else:
Panels.displayErrors(errors, header='Error: Isolines')
CTK.TXT.insert('START', 'Isolines fails for at least one zone.\n')
CTK.TXT.insert('START', 'Warning: ', 'Warning')
(CTK.Nb, CTK.Nz) = CPlot.updateCPlotNumbering(CTK.t)
CTK.TKTREE.updateApp()
CPlot.render()
def deleteBackgroundBase():
nodes = Internal.getNodesFromName1(CTK.t, 'BACKGROUND')
if nodes == []: return
base = nodes[0]
# delete from plotter
zones = Internal.getNodesFromType(base, 'Zone_t')
dels = []
for z in zones:
dels.append(base[0] + Internal.SEP1 + z[0])
CPlot.delete(dels)
# delete from tree
ret = Internal.getParentOfNode(CTK.t, base)
del ret[0][2][ret[1]]
def extract():
if CTK.t == []: return
type = VARS[0].get()
if CTK.__MAINTREE__ == 1:
CTK.__MAINACTIVEZONES__ = CPlot.getActiveZones()
active = []
zones = Internal.getZones(CTK.t)
for z in CTK.__MAINACTIVEZONES__:
active.append(CTK.t[2][CTK.Nb[z] + 1][2][CTK.Nz[z]])
Z = None
if type == 'cellN=-99999':
Z = selectWithFormula(active, '{cellN} == -99999')
elif type == 'cellN=1':
Z = selectWithFormula(active, '{cellN} == 1')
elif type == 'cellN=0':
Z = selectWithFormula(active, '{cellN} == 0')
elif type == 'cellN=2':
Z = selectWithFormula(active, '{cellN} == 2')
elif type == 'cellN<0':
Z = selectWithFormula(active, '{cellN}<0')
elif type == '0<cellN<1':
Z = selectWithFormula(active, '({cellN}>0) & ({cellN}<1)')
elif type == 'Interpolated points':
Z = X.extractChimeraInfo(zones, type='interpolated', loc='centers')
if Z == []: Z = None
elif type == 'Extrapolated points':
Z = X.extractChimeraInfo(zones, type='extrapolated', loc='centers')
if Z == []: Z = None
elif type == 'Orphan points':
Z = X.extractChimeraInfo(zones, type='orphan', loc='centers')
if Z == []: Z = None
elif type == 'cf>1':
Z = X.extractChimeraInfo(zones, type='cf>1', loc='centers')
if Z == []: Z = None
if Z is not None:
CTK.TXT.insert('START', 'Filter ' + type + ' extracted.\n')
C._addBase2PyTree(CTK.t, 'EXTRACT')
b = Internal.getNodesFromName1(CTK.t, 'EXTRACT')
base = b[0]
base[2] += Z
(CTK.Nb, CTK.Nz) = CPlot.updateCPlotNumbering(CTK.t)
#C._fillMissingVariables(CTK.t)
CTK.TKTREE.updateApp()
CTK.display(CTK.t)
else:
CTK.TXT.insert('START', 'Nothing extracted.\n')
CTK.TXT.insert('START', 'Error: ', 'Error')
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 streamSurface():
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
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]
nzs = CPlot.getSelectedZones()
if (nzs == []):
CTK.TXT.insert('START', 'Selection is empty.\n')
CTK.TXT.insert('START', 'Error: ', 'Error')
return
v1 = VARS[1].get()
v2 = VARS[2].get()
v3 = VARS[3].get()
streams = []
fail = False
errors = []
for nz in nzs:
nob = CTK.Nb[nz] + 1
noz = CTK.Nz[nz]
z = CTK.t[2][nob][2][noz]
z = C.convertArray2Tetra(z)
try:
stream = P.streamSurf(CTK.t, z, [v1, v2, v3], N=npts)
streams.append(stream)
except Exception as e:
fail = True
errors += [0, str(e)]
CTK.saveTree()
CTK.t = C.addBase2PyTree(CTK.t, 'STREAMS', 2)
b = Internal.getNodesFromName1(CTK.t, 'STREAMS')
nob = C.getNobOfBase(b[0], CTK.t)
for i in streams:
CTK.add(CTK.t, nob, -1, i)
if (fail == False):
CTK.TXT.insert('START', 'Stream surface created.\n')
else:
Panels.displayErrors(errors, header='Error: streamSurf')
CTK.TXT.insert('START', 'Sream surface fails for at least one zone.\n')
CTK.TXT.insert('START', 'Warning: ', 'Warning')
(CTK.Nb, CTK.Nz) = CPlot.updateCPlotNumbering(CTK.t)
CTK.TKTREE.updateApp()
CPlot.render()
def MONO2TFI():
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 len(nzs) == 0:
CTK.TXT.insert('START', 'Selection is empty.\n')
CTK.TXT.insert('START', 'Error: ', 'Error')
return
surf = getSurfaces()
zones = []
for nz in nzs:
nob = CTK.Nb[nz] + 1
noz = CTK.Nz[nz]
z = CTK.t[2][nob][2][noz]
z = C.convertBAR2Struct(z)
zones.append(z)
if len(zones) != 2:
CTK.TXT.insert('START', 'MONO2 TFI takes 2 contours.\n')
CTK.TXT.insert('START', 'Error: ', 'Error')
return
coords1 = C.getFields(Internal.__GridCoordinates__, zones[0])[0]
coords2 = C.getFields(Internal.__GridCoordinates__, zones[1])[0]
[m] = mono2mesh(coords1, coords2)
if isinstance(m, str):
CTK.TXT.insert('START', m + '\n')
CTK.TXT.insert('START', 'Error: ', 'Error')
return
m = C.convertArrays2ZoneNode('TFI', [m])
if surf != []: m = T.projectOrthoSmooth(m, surf)
CTK.saveTree()
CTK.t = C.addBase2PyTree(CTK.t, 'MESHES')
bases = Internal.getNodesFromName1(CTK.t, 'MESHES')
nob = C.getNobOfBase(bases[0], CTK.t)
CTK.add(CTK.t, nob, -1, m)
CTK.TXT.insert('START', 'HO-TFI mesh created.\n')
#C._fillMissingVariables(CTK.t)
(CTK.Nb, CTK.Nz) = CPlot.updateCPlotNumbering(CTK.t)
CTK.TKTREE.updateApp()
CPlot.render()
def changeFrame():
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
mode = VARS[7].get()
assert (mode in dir(T))
args = CTK.varsFromWidget(VARS[8].get(), type=1)
if len(args) != 6:
CTK.TXT.insert(
'START',
'{} requires 6 values.\nOrigin: x0;y0;z0\n Axis tx;ty;tz.\n'.
format(mode))
CTK.TXT.insert('START', 'Error: ', 'Error')
return
origin = (args[0], args[1], args[2])
axis = (args[3], args[4], args[5])
CTK.saveTree()
fail = False
errors = []
for nz in nzs:
nob = CTK.Nb[nz] + 1
noz = CTK.Nz[nz]
try:
func = getattr(T, mode)
a = func(CTK.t[2][nob][2][noz], origin, axis)
CTK.replace(CTK.t, nob, noz, a)
except Exception as e:
fail = True
errors += [0, str(e)]
if not fail: CTK.TXT.insert('START', '{} done.\n'.format(mode))
else:
Panels.displayErrors(errors, header='Error: {}'.format(mode))
CTK.TXT.insert('START',
'{} fails for at least one zone.\n'.format(mode))
CTK.TXT.insert('START', 'Warning: ', 'Warning')
CTK.TKTREE.updateApp()
CPlot.render()
def generatePLM():
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 len(nzs) == 0:
CTK.TXT.insert('START', 'Selection is empty.\n')
CTK.TXT.insert('START', 'Error: ', 'Error')
return
hf = CTK.varsFromWidget(VARS[1].get(), type=1)
if (len(hf) != 1):
CTK.TXT.insert('START', 'First cell height is incorrect.\n')
return
hf = hf[0]
h = CTK.varsFromWidget(VARS[0].get(), type=1)
if (len(h) != 1):
CTK.TXT.insert('START', 'Mesh height is incorrect.\n')
return
h = h[0]
density = CTK.varsFromWidget(VARS[2].get(), type=1)
if (len(density) != 1):
CTK.TXT.insert('START', 'Grid point density is incorrect.\n')
return
density = density[0]
try:
CTK.saveTree()
CTK.t = C.addBase2PyTree(CTK.t, 'MESHES')
bases = Internal.getNodesFromName1(CTK.t, 'MESHES')
gnob = C.getNobOfBase(bases[0], CTK.t)
for nz in nzs:
nob = CTK.Nb[nz] + 1
noz = CTK.Nz[nz]
z = CTK.t[2][nob][2][noz]
B = G.polyLineMesher(z, h, hf, density)
for i in B[0]:
CTK.add(CTK.t, gnob, -1, i)
CTK.TXT.insert('START', 'PLM mesh created.\n')
(CTK.Nb, CTK.Nz) = CPlot.updateCPlotNumbering(CTK.t)
CTK.TKTREE.updateApp()
CPlot.render()
except Exception, e:
Panels.displayErrors([0, str(e)], header='Error: PLM')
CTK.TXT.insert('START', 'PLM mesh failed.\n')
CTK.TXT.insert('START', 'Error: ', 'Error')
def remap():
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
a = []
for nz in nzs:
nob = CTK.Nb[nz]+1
noz = CTK.Nz[nz]
z = CTK.t[2][nob][2][noz]
a.append(z)
# density
density = CTK.varsFromWidget(VARS[0].get(), type=1)
if len(density) != 1:
CTK.TXT.insert('START', 'Density is incorrect.\n')
CTK.TXT.insert('START', 'Error: ', 'Error'); return
density = density[0]
# offset
offset = CTK.varsFromWidget(VARS[1].get(), type=1)
if len(offset) != 1:
CTK.TXT.insert('START', 'Offset is incorrect.\n')
CTK.TXT.insert('START', 'Error: ', 'Error'); return
offset = offset[0]
CTK.saveTree()
if VARS[2].get() == '0': iso = withCart(a, offset, density)
else: iso = withOctree(a, offset, density)
if iso != []:
nob = CTK.Nb[nzs[0]]+1
for i in iso: CTK.add(CTK.t, nob, -1, i)
#C._fillMissingVariables(CTK.t)
CTK.TXT.insert('START', 'Surface filtered and offset (offset=%g).\n'%offset)
(CTK.Nb, CTK.Nz) = CPlot.updateCPlotNumbering(CTK.t)
CTK.TKTREE.updateApp()
CPlot.render()
else:
CTK.TXT.insert('START', 'Surface filter failed.\n')
CTK.TXT.insert('START', 'Error: ', 'Error')
def getData():
if CTK.t == []: return
nzs = CPlot.getSelectedZones()
if nzs == []: return
# get first of selection
nz = nzs[0]
nob = CTK.Nb[nz] + 1
noz = CTK.Nz[nz]
zone = CTK.t[2][nob][2][noz]
if zone is not None:
n = Internal.getNodeFromPath(zone, '.RenderInfo/Material')
if n is not None:
val = Internal.getValue(n)
VARS[0].set(val)
n = Internal.getNodeFromPath(zone, '.RenderInfo/Color')
if n is not None:
val = Internal.getValue(n)
VARS[1].set(val)
n = Internal.getNodeFromPath(zone, '.RenderInfo/Blending')
if n is not None:
val = Internal.getValue(n)
WIDGETS['blending'].set(val * 100)
VARS[6].set('Blending [%.2f].' % val)
n = Internal.getNodeFromPath(zone, '.RenderInfo/MeshOverlay')
if n is not None:
val = Internal.getValue(n)
VARS[3].set(val)
n = Internal.getNodeFromPath(zone, '.RenderInfo/ShaderParameters')
if n is not None:
val = Internal.getValue(n)
WIDGETS['param1'].set(val[0] * 50)
VARS[4].set('Shader parameter 1 [%.2f].' % val[0])
WIDGETS['param2'].set(val[1] * 50)
VARS[4].set('Shader parameter 2 [%.2f].' % val[1])
