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')