# - dist2WallsEikonal (pyTree) - import Converter.PyTree as C import Connector.PyTree as X import Converter.Internal as Internal import Dist2Walls.PyTree as DTW import Geom.PyTree as D import Generator.PyTree as G import numpy DEPTH = 2 snear = 0.4; vmin = 21 # Init wall body = D.circle((0,0,0),1.,N=60) res = G.octree([body],[snear], dfar=5., balancing=1) res = G.octree2Struct(res, vmin=vmin, ext=DEPTH+1,merged=1) t = C.newPyTree(['Base']); t[2][1][2] = res # Mark solid and fluid points t = X.applyBCOverlaps(t,depth=DEPTH,loc='nodes') tc = Internal.copyRef(t) tc = X.setInterpData(t,tc,loc='nodes',storage="inverse") C._initVars(t,"cellN",1.) t = X.blankCells(t, [[body]], numpy.array([[1]]), blankingType='node_in') t = X.setHoleInterpolatedPoints(t,depth=1,loc='nodes') C._initVars(t,'flag=({cellN}>1.)') t = DTW.distance2WallsEikonal(t,body,tc=tc,DEPTH=DEPTH,nitmax=10) C.convertPyTree2File(t, 'out.cgns')
import Transform.PyTree as T import Initiator.PyTree as I import KCore.test as test import sys a = G.cart((-1, -1, -1), (0.04, 0.04, 1), (51, 51, 3)) s = G.cylinder((0, 0, -1), 0, 0.4, 360, 0, 4, (30, 30, 5)) s = C.convertArray2Tetra(s) s = T.join(s) s = P.exteriorFaces(s) t = C.newPyTree(['Base']) t[2][1][2] = [a] # Blanking bodies = [[s]] BM = N.array([[1]], N.int32) t = X.blankCells(t, bodies, BM, blankingType='center_in') t = X.setHoleInterpolatedPoints(t, depth=-2) # Dist2Walls t = DTW.distance2Walls(t, [s], type='ortho', loc='centers', signed=1) t = C.center2Node(t, 'centers:TurbulentDistance') # Gradient de distance localise en centres => normales t = P.computeGrad(t, 'TurbulentDistance') t = I.initConst(t, MInf=0.2, loc='centers') tc = C.node2Center(t) t = X.setIBCData(t, tc, loc='centers', storage='direct') #test avec arbre tc compact zones = Internal.getNodesFromType2(t, 'Zone_t') X.miseAPlatDonnorTree__(zones, t, procDict=None) t2 = X.setInterpTransfers(t, tc, bcType=0, varType=1)
vol Returns ------- """ if c == 0. and vol > volmin: return 1. else: return 0. # Refine the octree inside the sphere until all the elements inside the # sphere are of finest level end = 0 while end == 0: t = X.blankCells(t, [[a]], BM, blankingType='center_in') t = G.getVolumeMap(t) volmin = C.getMinValue(t, 'centers:vol') t = C.initVars(t, 'centers:indicator', F, ['centers:cellN', 'centers:vol']) end = 1 if C.getMaxValue(t, 'centers:indicator') == 1.: end = 0 # Maintien du niveau de raffinement le plus fin o = t[2][1][2][0] o = G.adaptOctree(o, 'centers:indicator', balancing=1) # Sortie t = C.newPyTree(['Base']) t[2][1][2] += [o] C.convertPyTree2File(t, 'out.cgns')
# - blankCells (pyTree) - import Converter.PyTree as C import Connector.PyTree as X import Generator.PyTree as G import Geom.PyTree as D import Transform.PyTree as T surf = D.sphere((0, 0, 0), 0.5, 20) a = G.cart((-1., -1., -1.), (0.1, 0.1, 0.1), (20, 20, 20)) t = C.newPyTree(['Cart']) t[2][1][2].append(a) t = C.initVars(t, 'centers:cellN', 1.) bodies = [[surf]] # Matrice de masquage (arbre d'assemblage) import numpy BM = numpy.array([[1]]) t = X.blankCells(t, bodies, BM, blankingType='cell_intersect', delta=0.) C.convertPyTree2File(t, 'out.cgns')
import Converter.PyTree as C import Connector.PyTree as X import Generator.PyTree as G import Geom.PyTree as D import KCore.test as test surf = D.circle((0,0,0), 0.5, 20) a = G.cart((-1.,-1.,0.),(0.1,0.1,1), (20,20,1)) C._addBC2Zone(a, 'ov', 'BCOverlap', 'jmin') t = C.newPyTree(['Cart',2,a]) t[2][1] = C.addState(t[2][1], 'EquationDimension', 2) C._fillEmptyBCWith(t, 'wall', 'BCWall') C._addVars(t, 'Density') C._initVars(t, 'centers:cellN', 1.) bodies = [[surf]] criterions = ['cell_intersect', 'cell_intersect_opt', 'center_in'] # Matrice de masquage (arbre d'assemblage) import numpy BM = numpy.array([[1]]) c = 1 for delta in [0.,0.1]: for type in criterions: if (type == 'cell_intersect_opt' and delta > 0): c += 1 else: t2 = X.blankCells(t, bodies, BM, blankingType=type, delta=delta, dim=2) test.testT(t2,c) c += 1
def adaptInsideOctree(): 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 # EquationDimension node = Internal.getNodeFromName(CTK.t, 'EquationDimension') if node is not None: dim = Internal.getValue(node) else: CTK.TXT.insert('START', 'EquationDimension not found (tkState). Using 3D.\n') CTK.TXT.insert('START', 'Warning: ', 'Warning') dim = 3 nzs = CPlot.getSelectedZones() if (nzs == []): CTK.TXT.insert('START', 'Selection is empty.\n') CTK.TXT.insert('START', 'Error: ', 'Error') return snearsarg = VARS[0].get() try: volmin = float(snearsarg) volmin = volmin**dim except: CTK.TXT.insert('START', 'snear is invalid.\n') CTK.TXT.insert('START', 'Error: ', 'Error') return snearsarg = snearsarg.split(';') for s in snearsarg: snears.append(float(s)) # Octree meshes 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) # surfaces des corps name = VARS[6].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 (len(surfaces) == 0): CTK.TXT.insert('START', 'Invalid body surface.\n') CTK.TXT.insert('START', 'Error: ', 'Error') return # Blank CTK.saveTree() BM = numpy.zeros((1, 1), numpy.int32) BM[0, 0] = 1 end = 0 count = 0 while end == 0: tp = X.blankCells(tp, [surfaces], blankingMatrix=BM, blankingType='center_in', dim=dim) tp = G.getVolumeMap(tp) C._initVars( tp, '{centers:indicator}=({centers:cellN}<1.)*({centers:vol}>%20.16g)' % volmin) end = 1 if C.getMaxValue(tp, 'centers:indicator') == 1.: end = 0 for noz in xrange(len(tp[2][1][2])): tp[2][1][2][noz] = G.adaptOctree(tp[2][1][2][noz], 'centers:indicator', balancing=1) count += 1 # Back to tree c = 0 for nz in nzs: nob = CTK.Nb[nz] + 1 noz = CTK.Nz[nz] z = tp[2][1][2][c] CTK.t[2][nob][2][noz] = z c += 1 fail = False #C._fillMissingVariables(CTK.t) if fail == False: CTK.TXT.insert('START', 'Adapt octree computed.\n') else: CTK.TXT.insert('START', 'Adapt octree failed.\n') CTK.TXT.insert('START', 'Error: ', 'Error') (CTK.Nb, CTK.Nz) = CPlot.updateCPlotNumbering(CTK.t) CTK.TKTREE.updateApp() CPlot.render()
def blank(): 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 type = VARS[8].get() # EquationDimension node = Internal.getNodeFromName(CTK.t, 'EquationDimension') if node is not None: dim = Internal.getValue(node) else: CTK.TXT.insert('START', 'EquationDimension not found (tkState). Using 3D.\n') CTK.TXT.insert('START', 'Warning: ', 'Warning') dim = 3 # Blanking surfaces name = VARS[6].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) # Reglages XRay delta = float(VARS[1].get()) tol = float(VARS[2].get()) # Creation de l'arbre temporaire nzs = CPlot.getSelectedZones() if nzs == []: CTK.TXT.insert('START', 'Selection is empty.\n') CTK.TXT.insert('START', 'Error: ', 'Error') return t = C.newPyTree(['Base']) for nz in nzs: nob = CTK.Nb[nz] + 1 noz = CTK.Nz[nz] z = CTK.t[2][nob][2][noz] t[2][1][2].append(z) # Create blanking Matrix BM = numpy.zeros((1, 1), numpy.int32) BM[0, 0] = 1 # BlankCells CTK.saveTree() t = X.blankCells(t, [surfaces], blankingMatrix=BM, blankingType=type, delta=delta, dim=dim, tol=tol) # Back to tree c = 0 for nz in nzs: nob = CTK.Nb[nz] + 1 noz = CTK.Nz[nz] z = t[2][1][2][c] CTK.t[2][nob][2][noz] = z c += 1 #C._fillMissingVariables(CTK.t) CTK.TXT.insert('START', 'Blanking done.\n') CTK.TKTREE.updateApp() CTK.display(CTK.t)
xmax = BB[3] ymax = BB[4] zmax = BB[5]+0.5 hi = (xmax-xmin)/(ni-1) hj = (ymax-ymin)/(nj-1) h = min(hi, hj) ni = int((xmax-xmin)/h)+7 nj = int((ymax-ymin)/h)+7 b = G.cart((xmin-3*h, ymin-3*h, zmin), (h, h, 1.), (ni, nj, nk)) t = C.newPyTree(['Cart']) t[2][1][2].append(b) # Masquage t = C.initVars(t, 'cellN', 1) BM = numpy.array([[1]]) t = X.blankCells(t, [[s2]], BM, blankingType='node_in', dim=2) # Adapte le front de la grille a la surface dim = Internal.getZoneDim(b) t = T.subzone(t, (1, 1, 2), (dim[1], dim[2], 2)) t = G.snapFront(t, [s2]) t = C.addBase2PyTree(t, 'Surface', cellDim=2) s2 = C.initVars(s2, 'cellN', 1) t[2][2][2].append(s2) C.convertPyTree2File(t, 'out.cgns')
def bodyFit(): 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 # EquationDimension node = Internal.getNodeFromName(CTK.t, 'EquationDimension') if node is not None: dim = Internal.getValue(node) else: CTK.TXT.insert('START', 'EquationDimension not found (tkState). Using 3D.\n') CTK.TXT.insert('START', 'Warning: ', 'Warning') dim = 3 nzs = CPlot.getSelectedZones() if (nzs == []): CTK.TXT.insert('START', 'Selection is empty.\n') CTK.TXT.insert('START', 'Error: ', 'Error') return # Blanking 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) # surfaces des corps name = VARS[6].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 (len(surfaces) == 0): CTK.TXT.insert('START', 'Invalid body surface.\n') CTK.TXT.insert('START', 'Error: ', 'Error') return # Blank BM = numpy.zeros((1, 1), numpy.int32) BM[0, 0] = 1 tp = X.blankCells(tp, [surfaces], blankingMatrix=BM, blankingType='node_in', dim=dim) CTK.saveTree() # Back to tree c = 0 for nz in nzs: nob = CTK.Nb[nz] + 1 noz = CTK.Nz[nz] z = tp[2][1][2][c] CTK.t[2][nob][2][noz] = z c += 1 # Snap fail = False errors = [] for nz in nzs: nob = CTK.Nb[nz] + 1 noz = CTK.Nz[nz] z = CTK.t[2][nob][2][noz] try: z = G.snapFront(z, surfaces, optimized=2) CTK.t[2][nob][2][noz] = z except Exception as e: fail = True errors += [0, str(e)] #C._fillMissingVariables(CTK.t) if fail == False: CTK.TXT.insert('START', 'Snapped to body.\n') else: Panels.displayErrors(errors, header='Error: snapFront') CTK.TXT.insert('START', 'Snap fails for at least one zone.\n') CTK.TXT.insert('START', 'Warning: ', 'Warning') CTK.TKTREE.updateApp() CTK.display(CTK.t)
NIT = 10 DEPTH = 2 # Bloc cartesien N = 128 h = 0.1 a = G.cart((0., 0., 0.), (h, h, h), (N, N, 1)) # Init wall sphere = D.sphere((6.4, 6.4, 0), 1., 100) sphere = C.convertArray2Tetra(sphere) sphere = G.close(sphere) t = C.newPyTree(['Base', a]) for it in range(NIT): T._translate(sphere, (0.1 * it, 0, 0)) C._initVars(t, "cellN", 1.) t = X.blankCells(t, [[sphere]], numpy.array([[1]]), blankingType='node_in') t = X.setHoleInterpolatedPoints(t, depth=1, loc='nodes') C._initVars(t, '{flag}=({cellN}>1.)') t = DTW.distance2WallsEikonal(t, sphere, DEPTH=DEPTH, nitmax=10) test.testT(t, 1) # Centers t = C.newPyTree(['Base']) t[2][1][2] = [a] sphere = D.sphere((6.4, 6.4, 0), 1., 100) sphere = C.convertArray2Tetra(sphere) sphere = G.close(sphere) for it in range(NIT): T._translate(sphere, (0.1 * it, 0, 0)) C._initVars(t, "centers:cellN", 1.) t = X.blankCells(t, [[sphere]],
import Transform.PyTree as T import Connector.PyTree as X import Converter.Internal as Internal import numpy rank = Cmpi.rank size = Cmpi.size # lecture des corps servant a masquer bodies = C.convertFile2PyTree('walls.cgns') bodies = Internal.getNodesFromType(bodies, 'Zone_t') # lecture du squelette a = Cmpi.convertFile2SkeletonTree('in.cgns') # equilibrage (a, dic) = Distributor2.distribute(a, NProc=size, algorithm='fast', useCom=0) # load des zones locales dans le squelette a = Cmpi.readZones(a, 'in.cgns', proc=rank) # Passage en arbre partiel a = Cmpi.convert2PartialTree(a) # Blanking local BM = numpy.array([[1]]) a = X.blankCells(a, [bodies], BM, blankingType='node_in', dim=3) # Reconstruit l'arbre complet a l'ecriture Cmpi.convertPyTree2File(a, 'out.cgns')
import Transform.PyTree as T import KCore.test as test import numpy surf = D.sphere((0,0,0), 0.5, 20) T._rotate(surf,(0.,0.,0.),(0.,1.,0.), 90.) a = G.cart((-1.,-1.,-1.),(0.1,0.1,0.1), (20,20,20)) C._addBC2Zone(a, 'ov', 'BCOverlap', 'jmin') t = C.newPyTree(['Cart',a]) t[2][1] = C.addState(t[2][1], 'EquationDimension', 3) C._fillEmptyBCWith(t, 'wall', 'BCWall') C._addVars(t, 'Density') bodies = [[surf]] C._initVars(t, 'centers:cellN', 1.) # Matrice de masquage (arbre d'assemblage) BM = numpy.array([[1]]) t2 = X.blankCells(t, bodies, BM) test.testT(t2, 1) # in place C._initVars(t2, 'centers:cellN', 1.) X._blankCells(t2, bodies, BM) test.testT(t2,1) # masque inverse BM = numpy.array([[-1]]) t2 = X.blankCells(t, bodies, BM) test.testT(t2,2)
t = C.addBase2PyTree(t, 'CARTESIAN') t[2][2][2] = res # ajout d un plan en k t = T.addkplane(t) # #--------------------------- # Assemblage Chimere #--------------------------- DEPTH = 2 # bodies description bodies = [] bases = Internal.getNodesFromType(t, 'CGNSBase_t') for b in bases: walls = C.extractBCOfType(b, 'BCWall') if walls != []: bodies.append(walls) # blanking BM = numpy.array([[0], [1]]) t = X.blankCells(t, bodies, BM, depth=DEPTH, dim=2) t = X.setHoleInterpolatedPoints(t, depth=DEPTH) t = X.applyBCOverlaps(t, depth=DEPTH) t = X.optimizeOverlap(t, priorities=['Cylindre1', 0, 'CARTESIAN', 1]) t = X.maximizeBlankedCells(t, depth=DEPTH) t = X.setInterpolations(t, loc='cell') # Arbre a la Cassiopee C.convertPyTree2File(t, 'out_cassiopee.cgns') # Arbre a la elsA t = CE.convert2elsAxdt(t) C.convertPyTree2File(t, 'out_elsa.cgns')
# ============================================================================== # 1. Set cellN to 2 to centers near overlap BCs # ============================================================================== t = X.applyBCOverlaps(t, depth=2) # ============================================================================== # 2. Blanking # ============================================================================== # bodies description bodyC1 = C.extractBCOfType(t[2][1][2], 'BCWall') bodyC2 = C.extractBCOfType(t[2][2][2], 'BCWall') bodies = [bodyC1, bodyC2] # blanking matrix BM = numpy.array([[0, 1], [1, 0], [1, 1]]) # blanking t = X.blankCells(t, bodies, BM, depth=2, dim=2) # set interpolated cells around interpolated points t = X.setHoleInterpolatedPoints(t, depth=2) # ============================================================================== # 3. Overlap optimisation with a high priority to cylinders # ============================================================================== t = X.optimizeOverlap(t, priorities=['Corps1', 0, 'Corps2', 0, 'Bgrd', 1]) t = X.maximizeBlankedCells(t, depth=2) # ============================================================================== # 4. Convert indices of cellN = 0 into OversetHoles nodes # ============================================================================== t = X.cellN2OversetHoles(t) # ============================================================================== # 5. Computes Chimera connectivity # ============================================================================== t = X.setInterpolations(t, loc='cell')