def compute():
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()
var1 = VARS[2].get()
if (type == 'INT((v1,v2,v3).ndS)' or 'INT((v1,v2,v3)^OMdS)'):
var2 = VARS[3].get()
var3 = VARS[4].get()
vector = [var1, var2, var3]
if (type == 'INT((v1,v2,v3)^OMdS)' or type == 'INT(v1n^OMdS)'):
center = CTK.varsFromWidget(VARS[1].get(), type=1)
if (len(center) != 3):
CTK.TXT.insert('START',
'Center for moment integration 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
res1 = 0.
res2 = 0.
res3 = 0.
for nz in nzs:
nob = CTK.Nb[nz] + 1
noz = CTK.Nz[nz]
z = CTK.t[2][nob][2][noz]
if (type == 'INT(v1dS)'):
res1 += P.integ(z, var1)[0]
elif (type == 'INT(v1.ndS)'):
res = P.integNorm(z, var1)[0]
res1 += res[0]
res2 += res[1]
res3 += res[2]
elif (type == 'INT((v1,v2,v3).ndS)'):
res1 += P.integNormProduct(z, vector)
elif (type == 'INT((v1,v2,v3)^OMdS)'):
res = P.integMoment(z, center, vector)
res1 += res[0]
res2 += res[1]
res3 += res[2]
elif (type == 'INT(v1n^OMdS)'):
res = P.integMomentNorm(z, center, var1)[0]
res1 += res[0]
res2 += res[1]
res3 += res[2]
if (type == 'INT((v1,v2,v3)^OMdS)' or type == 'INT(v1n^OMdS)'
or type == 'INT(v1.ndS)'):
res = [res1, res2, res3]
else:
res = res1
CTK.TXT.insert('START', 'Res=' + str(res) + '.\n')
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 selectTag(zones, Filter, vars):
if len(vars) == 0: return None
res = findVar(vars[0])
if res == 0: return None
if res == 1: # tag en noeuds
Z = C.initVars(zones, '__tag__', Filter, vars)
Z = P.selectCells2(Z, '__tag__')
C._rmVars(Z, '__tag__')
else: # tag en centres
Z = C.initVars(zones, 'centers:__tag__', Filter, vars)
Z = P.selectCells2(Z, 'centers:__tag__')
C._rmVars(Z, 'centers:__tag__')
for z in Z:
z[0] = C.getZoneName(z[0])
return Z
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 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 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 selectWithFormula(zones, formula):
res = findVar('cellN')
if res == 0:
res = findVar('cellnf')
if res == 0: return None
if res == 1: formula = formula.replace('cellN', 'cellnf')
if res == 2: formula = formula.replace('cellN', 'centers:cellnf')
elif res == 2:
formula = formula.replace('cellN', 'centers:cellN')
if res == 1: # cellN en noeuds
Z = P.selectCells(zones, formula)
else: # cellN en centres
Z = P.selectCells(zones, formula)
for z in Z:
z[0] = C.getZoneName(z[0])
return Z
def renameVar():
if CTK.t == []: return
CTK.saveTree()
varp = VARS[11].get()
varn = VARS[10].get()
CTK.t = P.renameVars(CTK.t, [varp], [varn])
CTK.TXT.insert('START', 'Variable %s replaced.\n' % varp)
CTK.TKTREE.updateApp()
CTK.display(CTK.t)
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 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 withOctree(a, offset, density):
# step
tol = 1./density
# octree
snears = []; sec = 0
for z in a:
bb = G.bbox(z)
rx = bb[3]-bb[0]; ry = bb[4]-bb[1]; rz = bb[5]-bb[2]
snear = min(rx, ry); snear = min(snear, rz)
snear = 0.1*snear
sec = max(sec, snear)
snears.append(snear)
o = G.octree(a, snears, dfar=offset+sec)
o = compDistance(o, a, loc='nodes')
# iteration d'adaptation
nit = 0
while nit < 10:
print('iterating: %d...'%nit)
o = C.node2Center(o, 'TurbulentDistance')
o = G.getVolumeMap(o)
# adapt
C._initVars(o, '{centers:vol}={centers:vol}**0.33333')
# was 2.1 factor
C._initVars(o, '{centers:indicator}=logical_and({centers:vol} > %20.16g , abs({centers:TurbulentDistance}-%20.16g) < 1.*{centers:vol})'%(tol,offset))
o1 = G.adaptOctree(o, 'centers:indicator')
#C.convertPyTree2File([o1]+a, 'out%d.cgns'%nit)
# check convergence
dim1 = Internal.getZoneDim(o1); dim = Internal.getZoneDim(o)
if dim1 == dim: break
#if (nit%2 == 0): o1 = P.extractMesh([o], o1)
o1 = compDistance(o1, a, loc='nodes')
o = o1
nit += 1
o = C.rmVars(o, 'centers:TurbulentDistance')
o = C.rmVars(o, 'centers:vol')
o = C.rmVars(o, 'centers:indicator')
#C.convertPyTree2File(o, 'out.cgns')
# Iso surface
iso = P.isoSurfMC([o], 'TurbulentDistance', value=offset)
return iso
def computeNormGrad():
if CTK.t == []: return
varname = VARS[2].get()
CTK.saveTree()
try:
CTK.t = P.computeNormGrad(CTK.t, varname)
except Exception as e:
Panels.displayErrors([0, str(e)], header='Error: computeNormGrad')
CTK.TXT.insert('START', 'Gradient\'s norm computation failed.\n')
CTK.TXT.insert('START', 'Error: ', 'Error')
return
CTK.TXT.insert('START', 'Gradient\'s norm of %s computed.\n' % varname)
CTK.TKTREE.updateApp()
CTK.display(CTK.t)
if CTK.TKPLOTXY is not None: CTK.TKPLOTXY.updateApp()
def view():
if CTK.t == []: return
type = VARS[0].get()
if type == 'Mesh':
CTK.display(CTK.t)
return
if CTK.__MAINTREE__ == 1:
CTK.__MAINACTIVEZONES__ = CPlot.getActiveZones()
tp = Internal.appendBaseName2ZoneName(CTK.t, separator=Internal.SEP1)
active = []
zones = Internal.getZones(tp)
for z in CTK.__MAINACTIVEZONES__:
active.append(zones[z])
Z = None
if type == 'cf>1':
Z = P.selectCells(active, Filter1, [
'interpCoefs1', 'interpCoefs2', 'interpCoefs3', 'interpCoefs4',
'interpCoefs5', 'interpCoefs6', 'interpCoefs7', 'interpCoefs8'
])
elif 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 == 'Orphan points':
Z = X.extractChimeraInfo(active, 'orphan')
elif type == 'Extrapolated points':
Z = X.extractChimeraInfo(active, 'extrapolated')
if Z is not None:
CTK.TXT.insert('START', 'Filter ' + type + ' displayed.\n')
CTK.dt = C.newPyTree(['Base'])
CTK.dt[2][1][2] += Z
CTK.display(CTK.dt, mainTree=CTK.CELLN)
else:
CTK.TXT.insert('START', 'Nothing to display.\n')
CTK.TXT.insert('START', 'Error: ', 'Error')
def computeCurl():
if CTK.t == []: return
vars = VARS[3].get()
vars = vars.replace(' ', '')
vars = vars.split(';')
CTK.saveTree()
try:
CTK.t = P.computeCurl(CTK.t, vars)
except Exception as e:
Panels.displayErrors([0, str(e)], header='Error: computeCurl')
CTK.TXT.insert('START', 'Curl computation failed.\n')
CTK.TXT.insert('START', 'Error: ', 'Error')
return
CTK.TXT.insert('START', 'Curl computed.\n')
CTK.TKTREE.updateApp()
CTK.display(CTK.t)
if CTK.TKPLOTXY is not None: CTK.TKPLOTXY.updateApp()
def extractIsoSurf(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
field = VARS[0].get()
value = VARS[1].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 = []
try:
iso = P.isoSurfMC(z, field, value)
isos += iso
except Exception as e:
Panels.displayErrors([0,str(e)], header='Error: isoSurf')
if isos == []:
CTK.TXT.insert('START', 'isoSurf failed.\n')
CTK.TXT.insert('START', 'Error: ', 'Error')
else:
CTK.TXT.insert('START', 'isoSurf of '+field+'='
+str(value)+' computed.\n')
for i in isos: i[0] = C.getZoneName(i[0]) # unique name
CTK.t = C.addBase2PyTree(CTK.t, 'SURFACES', 2)
base = Internal.getNodeFromName1(CTK.t, 'SURFACES')
nob = C.getNobOfBase(base, CTK.t)
for i in isos: CTK.add(CTK.t, nob, -1, i)
(CTK.Nb, CTK.Nz) = CPlot.updateCPlotNumbering(CTK.t)
CTK.TKTREE.updateApp()
CPlot.render()
def refineCells():
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
W = WIDGETS['refine']
if CTK.__BUSY__ == False:
CPlot.unselectAllZones()
CTK.__BUSY__ = True
TTK.sunkButton(W)
CPlot.setState(cursor=1)
while CTK.__BUSY__:
l = []
while l == []:
nz = CPlot.getSelectedZone()
l = CPlot.getActivePointIndex()
CPlot.unselectAllZones()
time.sleep(CPlot.__timeStep__)
W.update()
if CTK.__BUSY__ == False: break
if CTK.__BUSY__:
nob = CTK.Nb[nz] + 1
noz = CTK.Nz[nz]
CTK.saveTree()
z = CTK.t[2][nob][2][noz]
C._initVars(z, 'centers:__tag__', 0)
C.setValue(z, 'centers:__tag__', l[1], 1)
try:
z = P.refine(z, '__tag__')
CTK.replace(CTK.t, nob, noz, z)
except:
pass
CTK.TKTREE.updateApp()
CPlot.render()
CTK.__BUSY__ = False
TTK.raiseButton(W)
CPlot.setState(cursor=0)
else:
CTK.__BUSY__ = False
TTK.raiseButton(W)
CPlot.setState(cursor=0)
def exteriorFaces():
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, 'CONTOURS', 1)
p = Internal.getNodesFromName1(CTK.t, 'CONTOURS')
gnob = C.getNobOfBase(p[0], CTK.t)
fail = False
errors = []
for nz in nzs:
nob = CTK.Nb[nz] + 1
noz = CTK.Nz[nz]
try:
ext = P.exteriorFaces(CTK.t[2][nob][2][noz])
ext = T.splitConnexity(ext)
for i in ext:
CTK.add(CTK.t, gnob, -1, i)
except TypeError as e: # type d'element non reconnu
fail = True
errors += [0, str(e)]
except ValueError: # empty set
pass
#C._fillMissingVariables(CTK.t)
(CTK.Nb, CTK.Nz) = CPlot.updateCPlotNumbering(CTK.t)
CTK.TKTREE.updateApp()
if not fail: CTK.TXT.insert('START', 'Exterior faces done.\n')
else:
Panels.displayErrors(errors, header='Error: exteriorFaces')
CTK.TXT.insert('START',
'Exterior faces fails for at least one zone.\n')
CTK.TXT.insert('START', 'Warning: ', 'Warning')
CPlot.render()
def viewQual():
if CTK.t == []: return
qtype = VARS[1].get()
if qtype == 'Neg. volume cells':
res = findVar('vol')
if res == 0: CTK.t = G.getVolumeMap(CTK.t)
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]])
temp = C.newPyTree(['Base']); temp[2][1][2] += active
Z = C.initVars(temp, 'centers:__tag__', F1, ['centers:vol'])
Z = P.selectCells2(Z, 'centers:__tag__')
if Z is not None:
CTK.TXT.insert('START', 'Viewing '+qtype+'.\n')
CTK.dt = Z
CTK.display(CTK.dt, mainTree=CTK.MESHQUAL)
elif qtype == 'Mesh':
CTK.display(CTK.t)
def extractExternalContours():
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]
contours = P.exteriorFacesStructured(z)
CTK.t[2][nob][2] = CTK.t[2][nob][2] + contours
CTK.TXT.insert('START', 'External contours extracted.\n')
(CTK.Nb, CTK.Nz) = CPlot.updateCPlotNumbering(CTK.t)
CTK.TKTREE.updateApp()
CTK.display(CTK.t)
def withCart(a, offset, density):
# Calcul la grille cartesienne
BB = G.bbox(a)
xmin = BB[0]; ymin = BB[1]; zmin = BB[2]
xmax = BB[3]; ymax = BB[4]; zmax = BB[5]
ni = density*(xmax-xmin); nj = density*(ymax-ymin);
nk = density*(zmax-zmin)
if ni < 2: ni = 2
if nj < 2: nj = 2
if nk < 2: nk = 2
hi = (xmax-xmin)/(ni-1); hj = (ymax-ymin)/(nj-1); hk = (zmax-zmin)/(nk-1)
h = min(hi, hj); h = min(h, hk); h = max(h, 1.e-6)
ni = int((xmax-xmin)/h)+7; nj = int((ymax-ymin)/h)+7
nk = int((zmax-zmin)/h)+7
ni += int(2*offset/h); nj += int(2*offset/h); nk += int(2*offset/h)
b = G.cart( (xmin-3*h-offset, ymin-3*h-offset, zmin-3*h-offset), (h, h, h), (ni,nj,nk) )
# Calcul la distance a la paroi
b = compDistance(b, a, loc='nodes')
#C.convertPyTree2File(b, 'out.cgns')
# Extraction isoSurf
iso = P.isoSurfMC([b], 'TurbulentDistance', value=offset)
return iso
# - blankCellsTri (pyTree) - 'NODE IN' import Converter.PyTree as C import Connector.PyTree as X import Generator.PyTree as G import Geom.PyTree as D import Post.PyTree as P # Tet mask m = G.cart((0., 0., 0.), (0.1, 0.1, 0.2), (10, 10, 10)) m = P.exteriorFaces(m) m = C.convertArray2Tetra(m) # Mesh to blank a = G.cart((-5., -5., -5.), (0.5, 0.5, 0.5), (100, 100, 100)) t = C.newPyTree(['Cart', a]) t = C.initVars(t, 'centers:cellN', 1.) masks = [[m]] # Matrice de masquage (arbre d'assemblage) import numpy BM = numpy.array([[1]]) t = X.blankCellsTri(t, masks, BM, blankingType='node_in', tol=1.e-12) C.convertPyTree2File(t, 'out.cgns')
# - computeVariables (pyTree) -
import Converter.PyTree as C
import Converter.Internal as Internal
import Post.PyTree as P
import Generator.PyTree as G
import KCore.test as test
#-------------------------
# Test reference state
#-------------------------
ni = 31
dh = 10. / (ni - 1)
m = G.cart((0, 0, 0), (dh, dh, 1), (ni, ni, 1))
m = C.initVars(m, 'Density', 1.)
m = C.initVars(
m, '{MomentumX}=0.1+3.*{CoordinateX}+5.*{CoordinateY}+2.*{CoordinateZ}')
m = C.initVars(m, 'MomentumY', 0.)
m = C.initVars(m, 'MomentumZ', 0.)
m = C.initVars(
m,
'{EnergyStagnationDensity}=1.e5+1.5*{CoordinateX}**2+{CoordinateY}**2+3.*{CoordinateZ}**2'
)
t = C.newPyTree(['Base', 1])
t[2][1][2].append(m)
t = C.addState(t, adim='adim1', MInf=0.6)
t = P.computeVariables(t, ['Mach', 'Pressure'])
test.testT(t, 1)
# - plaster (pyTree) - import Generator.PyTree as G import Converter.PyTree as C import Transform.PyTree as T import Post.PyTree as P import Geom.PyTree as D a = D.sphere((0, 0, 0), 1) a = T.subzone(a, (6, 1, 1), (50, 200, 1)) a = C.convertArray2Hexa(a) a = G.close(a) # contours c = P.exteriorFaces(a) cs = T.splitConnexity(c) # plaster hole p = G.plaster([cs[0]], [a]) t = C.newPyTree(['Sphere', 2, 'Contours', 1, 'Plaster', 2]) t[2][1][2].append(a) t[2][2][2] += cs t[2][3][2].append(p) C.convertPyTree2File(t, 'out.cgns')
# - compIndicatorValue(pyTree) - import Generator.PyTree as G import Converter.PyTree as C import Geom.PyTree as D import Post.PyTree as P s = D.circle((0, 0, 0), 1.) snear = 0.1 o = G.octree([s], [snear], dfar=10., balancing=1) res = G.octree2Struct(o, vmin=11, merged=1) res = G.getVolumeMap(res) o = P.computeIndicatorValue(o, res, 'centers:vol') t = C.newPyTree(['Base']) t[2][1][2] += [o] C.convertPyTree2File(t, "out.cgns")
# Extraction de lignes x = cste
bb = G.bbox(a)
xmin = bb[0]
ymin = bb[1]
zmin = bb[2]
xmax = bb[3]
ymax = bb[4]
zmax = bb[5]
bands = []
dx = 1. / 10
for i in range(10):
x = i / 10.
b = G.cart((x, ymin - 1, zmin - 1), (dx, ymax - ymin + 2, zmax - zmin + 2),
(2, 2, 2))
b = P.exteriorFaces(b)
b = C.convertArray2Tetra(b)
b = T.join(b)
b = G.close(b)
b = T.reorder(b, (-1, ))
band = G.booleanIntersection(a, b)
bands += [band]
# Boolean operators do not keep field
bands = P.extractMesh(a, bands)
# Sortie
t = C.newPyTree(['Base'])
t[2][1][2] += bands
C.convertPyTree2File(t, 'out.cgns')
# - prepareIBMData (pyTree) - import Converter.PyTree as C import Generator.PyTree as G import Connector.ToolboxIBM as IBM import Post.PyTree as P import Geom.PyTree as D import Dist2Walls.PyTree as DTW import KCore.test as test N = 51 a = G.cart((0, 0, 0), (1. / (N - 1), 1. / (N - 1), 1. / (N - 1)), (N, N, N)) body = D.sphere((0.5, 0, 0), 0.1, N=20) t = C.newPyTree(['Base', a]) tb = C.newPyTree(['Base', body]) tb = C.addState(tb, 'EquationDimension', 3) tb = C.addState(tb, 'GoverningEquations', 'NSTurbulent') t = DTW.distance2Walls(t, bodies=tb, loc='centers', type='ortho') t = P.computeGrad(t, 'centers:TurbulentDistance') t, tc = IBM.prepareIBMData(t, tb, DEPTH=2, frontType=1) C.convertPyTree2File(t, 't.cgns') C.convertPyTree2File(t, 'tc.cgns')
m1 = G.cart((0, 0, 0), (10. / (ni - 1), 10. / (nj - 1), 1.), (ni, nj, 1))
m2 = G.cart((0, 10, 0), (10. / (ni - 1), 10. / (nj - 1), 1.), (ni, nj, 1))
m3 = G.cart((10, 0, 0), (10. / (ni - 1), 10. / (nj - 1), 1.), (ni, nj, 1))
t = C.newPyTree(['Base', m1, m2, m3])
t = X.connectMatch(t, dim=2)
t = C.fillEmptyBCWith(t, "wall", 'BCWall')
C._initVars(t, '{centers:fldX}= ({centers:CoordinateX})**2')
C._initVars(t, '{centers:fldY}= ({centers:CoordinateY})**2')
C._initBCDataSet(t, '{fldX}=0.5')
C._initBCDataSet(t, '{fldY}=0.5')
P._computeDiv2(t, 'centers:fld')
test.testT(t, 1)
# #----------
# # 3D STRUCT
# #----------
ni = 15
nj = 15
nk = 15
m1 = G.cart((0, 0, 0), (10. / (ni - 1), 10. / (nj - 1), 2. / (nk - 1)),
(ni, nj, nk))
m2 = G.cart((0, 10, 0), (10. / (ni - 1), 10. / (nj - 1), 2. / (nk - 1)),
(ni, nj, nk))
m3 = G.cart((0, 0, 2), (10. / (ni - 1), 10. / (nj - 1), 2. / (nk - 1)),
(ni, nj, nk))
import Post.PyTree as P
import KCore.test as test
def F(x, y, z):
if (x + 2 * y + z > 20.): return True
else: return False
# CAS 1D
a = G.cart((0, 9, 0), (1, 1, 1), (11, 1, 1))
C._addVars(a, 'Density')
C._addVars(a, 'centers:cellN')
t = C.newPyTree(['Base', 1, a])
t[2][1] = C.addState(t[2][1], 'Mach', 0.6)
t = P.selectCells(t, F, ['CoordinateX', 'CoordinateY', 'CoordinateZ'])
test.testT(t, 1)
# CAS 2D
a = G.cart((0, 0, 0), (1, 1, 1), (11, 11, 1))
C._addVars(a, 'Density')
C._addVars(a, 'centers:cellN')
a = C.addBC2Zone(a, 'ov', 'BCOverlap', 'imin')
t = C.newPyTree(['Base', 2, a])
t[2][1] = C.addState(t[2][1], 'Mach', 0.6)
t = P.selectCells(t, F, ['CoordinateX', 'CoordinateY', 'CoordinateZ'])
test.testT(t, 2)
# CAS 3D
a = G.cart((0, 0, 0), (1, 1, 1), (11, 11, 11))
C._addVars(a, 'Density')
# - integNormProduct (pyTree) - import Converter.PyTree as C import Generator.PyTree as G import Post.PyTree as P ni = 30 nj = 40 m = G.cart((0, 0, 0), (10. / (ni - 1), 10. / (nj - 1), 1), (ni, nj, 1)) m = C.initVars(m, 'MomentumX', 1.) m = C.initVars(m, 'MomentumY', 1.) m = C.initVars(m, 'MomentumZ', 1.) res = P.integNormProduct(m, ['MomentumX', 'MomentumY', 'MomentumZ']) print(res)
# - isoSurfMC (pyTree) -
import Post.PyTree as P
import Converter.PyTree as C
import Generator.PyTree as G
a = G.cartHexa( (-20,-20,-20), (0.5,0.5,0.5), (50,50,50))
a = C.initVars(a, 'field={CoordinateX}*{CoordinateX}+{CoordinateY}*{CoordinateY}+{CoordinateZ}')
iso = P.isoSurfMC(a, 'field', value=5.)
C.convertPyTree2File(iso, 'out.cgns')
