def updateInfo(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() npTot = 0; ncellsTot = 0; nfacesTot = 0 nzones = 0 minv = 1e6; maxv = -1e6 var = VARS[5].get() failed = False if nzs == []: zones = Internal.getZones(CTK.t) for z in zones: dim = Internal.getZoneDim(z) try: minv = min(minv, C.getMinValue(z, var)) except: failed = True try: maxv = max(maxv, C.getMaxValue(z, var)) except: failed = True np, ncells, nfaces = computeMeshInfo(z, dim) npTot += np ncellsTot += ncells nfacesTot += nfaces nzones += 1 else: for nz in nzs: nob = CTK.Nb[nz]+1 noz = CTK.Nz[nz] z = CTK.t[2][nob][2][noz] dim = Internal.getZoneDim(z) minv = min(minv, C.getMinValue(z, var)) maxv = max(maxv, C.getMaxValue(z, var)) np, ncells, nfaces = computeMeshInfo(z, dim) npTot += np ncellsTot += ncells nfacesTot += nfaces nzones += 1 VARS[0].set(strwg__(npTot)) VARS[6].set(strwg__(ncellsTot)) VARS[7].set(strwg__(nfacesTot)) VARS[1].set(str(minv)) VARS[2].set(str(maxv)) VARS[4].set('') if nzs == []: VARS[3].set('Tree') if nzones == 0 or nzones == 1: VARS[4].set(strwg__(nzones)+' zone') else: VARS[4].set(strwg__(nzones)+' zones') elif len(nzs) > 1: VARS[3].set('Multiple') VARS[4].set(str(nzones)+' zones') else: nz = nzs[0] nob = CTK.Nb[nz]+1 noz = CTK.Nz[nz] z = CTK.t[2][nob][2][noz] VARS[3].set(CTK.t[2][nob][0]+'/'+z[0]) dim = Internal.getZoneDim(z) if dim[0] == 'Structured': VARS[4].set('Structured') VARS[0].set(str(npTot) + ' ('+str(dim[1])+'x'+str(dim[2])+'x'+str(dim[3])+')') else: VARS[4].set(dim[3]) if not failed: CTK.TXT.insert('START', 'Info updated.\n') else: CTK.TXT.insert('START', 'Variable min-max was not computed.\n') CTK.TXT.insert('START', 'Warning: ', 'Warning')
# - adaptNGon2Index (pyTree) - import Generator.PyTree as G import Converter.PyTree as C import Converter.Internal as Internal a = G.cartNGon((0, 0, 0), (1, 1, 1), (10, 10, 10)) Internal._adaptNFace2PE(a, remove=False) Internal._adaptNGon2Index(a) Internal._adaptNFace2Index(a) C.convertPyTree2File(a, 'out.cgns')
def step2(): import Transform as T import Generator as G CTK.saveTree() # taille de maille en envergure hp = float(VARS[5].get()) # Hauteur du maillage Dfar = float(VARS[4].get()) # Envergure span = float(VARS[6].get()) # Recupere la base STEP1 base = Internal.getNodesFromName1(CTK.t, 'STEP1') if base == []: return zones = base[0][2] l = len(zones) if l == 7: culot = 0 else: culot = 1 if culot == 0: # 2 zones exterieures, le reste interieur M2 = [ C.getAllFields(zones[l - 2], 'nodes')[0], C.getAllFields(zones[l - 1], 'nodes')[0] ] M1 = [] for z in zones[0:l - 2]: M1.append(C.getAllFields(z, 'nodes')[0]) else: # 3 zones exterieures, le reste interieur M2 = [ C.getAllFields(zones[l - 2], 'nodes')[0], C.getAllFields(zones[l - 1], 'nodes')[0], C.getAllFields(zones[l - 3], 'nodes')[0] ] M1 = [] for z in zones[0:l - 3]: M1.append(C.getAllFields(z, 'nodes')[0]) #========================================================================== # stack + resserement vers les extremites #========================================================================== M1b = T.translate(M1, (0, 0, Dfar)) B1 = [] for i in range(len(M1)): B1.append(G.stack(M1[i], M1b[i])) M1c = T.translate(M1, (0, 0, -span)) M1d = T.translate(M1, (0, 0, -span - Dfar)) B2 = [] for i in range(len(M1c)): B2.append(G.stack(M1c[i], M1d[i])) #C.convertArrays2File(B1+B2, 'bouchon.plt') M2b = T.translate(M2, (0, 0, Dfar)) M2c = T.translate(M2, (0, 0, -span - Dfar)) I = [] for i in range(len(M2b)): I.append(G.stack(M2c[i], M2b[i])) # B1, B2: les bouchons; I le reste #C.convertArrays2File(B1+B2+I, 'all.plt') #========================================================================== # Remaille la surface N = int(Dfar / hp) + 1 distrib = G.cart((0, 0, 0), (1. / (N - 1), 1, 1), (N, 1, 1)) for i in range(len(B1)): B1[i] = G.map(B1[i], distrib, 3) for i in range(len(B2)): B2[i] = G.map(B2[i], distrib, 3) N = int((2 * Dfar + span) / hp) + 1 distrib = G.cart((0, 0, 0), (1. / (N - 1), 1, 1), (N, 1, 1)) for i in range(len(I)): I[i] = G.map(I[i], distrib, 3) # Back to zones zones = [] for b in B1 + B2 + I: zones.append(C.convertArrays2ZoneNode('zone', [b])) base = Internal.getNodesFromName1(CTK.t, 'STEP2') if base != []: (p, c) = Internal.getParentOfNode(CTK.t, base[0]) del p[2][c] CTK.t = C.addBase2PyTree(CTK.t, 'STEP2', 3) base = Internal.getNodesFromName1(CTK.t, 'STEP2')[0] (p, c) = Internal.getParentOfNode(CTK.t, base) base[2] += zones # Add BCs base = X.connectMatch(base, tol=1.e-6) # # Blocs exterieurs if culot == 0: z = base[2][10] z = C.addBC2Zone(z, 'overlap', 'BCOverlap', 'jmax') z = C.addBC2Zone(z, 'overlap', 'BCOverlap', 'kmax') z = C.addBC2Zone(z, 'overlap', 'BCOverlap', 'kmin') z = C.addBC2Zone(z, 'overlap', 'BCOverlap', 'imin') base[2][10] = z z = base[2][11] z = C.addBC2Zone(z, 'overlap', 'BCOverlap', 'jmax') z = C.addBC2Zone(z, 'overlap', 'BCOverlap', 'kmax') z = C.addBC2Zone(z, 'overlap', 'BCOverlap', 'kmin') z = C.addBC2Zone(z, 'overlap', 'BCOverlap', 'imax') base[2][11] = z for i in range(5): z = base[2][i] z = C.addBC2Zone(z, 'overlap', 'BCOverlap', 'kmax') base[2][i] = z for i in range(5): z = base[2][5 + i] z = C.addBC2Zone(z, 'overlap', 'BCOverlap', 'kmax') base[2][5 + i] = z else: z = base[2][6] z = C.addBC2Zone(z, 'overlap', 'BCOverlap', 'jmax') z = C.addBC2Zone(z, 'overlap', 'BCOverlap', 'kmax') z = C.addBC2Zone(z, 'overlap', 'BCOverlap', 'kmin') z = C.addBC2Zone(z, 'overlap', 'BCOverlap', 'imax') base[2][6] = z z = base[2][8] z = C.addBC2Zone(z, 'overlap', 'BCOverlap', 'jmax') z = C.addBC2Zone(z, 'overlap', 'BCOverlap', 'kmax') z = C.addBC2Zone(z, 'overlap', 'BCOverlap', 'kmin') z = C.addBC2Zone(z, 'overlap', 'BCOverlap', 'imin') base[2][8] = z z = base[2][7] z = C.addBC2Zone(z, 'overlap', 'BCOverlap', 'imax') z = C.addBC2Zone(z, 'overlap', 'BCOverlap', 'kmax') z = C.addBC2Zone(z, 'overlap', 'BCOverlap', 'kmin') base[2][7] = z for i in range(3): z = base[2][i] z = C.addBC2Zone(z, 'overlap', 'BCOverlap', 'kmax') base[2][i] = z for i in range(3): z = base[2][3 + i] z = C.addBC2Zone(z, 'overlap', 'BCOverlap', 'kmax') base[2][3 + i] = z base = C.fillEmptyBCWith(base, 'wall', 'BCWall') CTK.t[2][c] = base CTK.TXT.insert('START', 'Step2 performed.\n') (CTK.Nb, CTK.Nz) = CPlot.updateCPlotNumbering(CTK.t) CTK.TKTREE.updateApp() CTK.display(CTK.t)
# - newElements (pyTree) - import Converter.Internal as Internal # Create an elements node b = Internal.newElements(name='Elements', etype='UserDefined', econnectivity=None, eboundary=0) print b # Attach it to tree z = Internal.newZone('Zone', [[10], [2], [0]], 'Unstructured') Internal.newElements(name='Elements', etype='UserDefined', econnectivity=None, eboundary=0, parent=z) print z
# a = G.cart((0., 0., 0.), (0.1, 0.1, 0.1), (11, 21, 1)) a = C.initVars(a, 'centers:Density={centers:CoordinateX}') a = C.initVars(a, 'F={CoordinateY}*{CoordinateX}') a = C.addBC2Zone(a, 'wall1', 'BCWall', 'jmin') # partiellement coincident a2 = G.cart((1., 0.4, 0.), (0.1, 0.1, 0.1), (11, 21, 1)) a2 = T.oneovern(a2, (2, 2, 1)) a2 = C.initVars(a2, 'centers:Density={centers:CoordinateX}') a2 = C.initVars(a2, 'F={CoordinateY}*{CoordinateX}') a2 = C.addBC2Zone(a2, 'overlap1', 'BCOverlap', 'imax') t = C.newPyTree(['Base', 2]) t[2][1][2] += [a, a2] t[2][1] = C.addState(t[2][1], 'EquationDimension', 2) t = X.connectNearMatch(t, dim=2) t = Internal.addGhostCells(t, t, 2, adaptBCs=0, fillCorner=1) t = Internal.rmGhostCells(t, t, 2, adaptBCs=0) test.testT(t, 1) # t = C.newPyTree(['Base', 2]) t[2][1][2] += [a, a2] t[2][1] = C.addState(t[2][1], 'EquationDimension', 2) t = X.connectNearMatch(t, dim=2) t = Internal.addGhostCells(t, t, 2, adaptBCs=1, fillCorner=1) t = Internal.rmGhostCells(t, t, 2, adaptBCs=1) test.testT(t, 2) # geometrical extrapolation of corner cells t = C.newPyTree(['Base', 2]) t[2][1][2] += [a, a2] t[2][1] = C.addState(t[2][1], 'EquationDimension', 2)
# - checkPyTree (pyTree) - import Converter.PyTree as C import Generator.PyTree as G import Connector.PyTree as X import Converter.Internal as Internal a = G.cart((0,0,0), (1,1,1), (10,10,10)) b = G.cart((9,0,0), (1,1,1), (10,10,10)) c = G.cartTetra((9,9,0), (1,1,1), (10,10,10)) a = C.addBC2Zone(a, 'wall1', 'BCWall', 'imin') t = C.newPyTree(['Base',a,b,c]) t = X.connectMatch(t) errors = [] # check unique base names errors += Internal.checkPyTree(t, level=2) # check unique zone names errors += Internal.checkPyTree(t, level=3) # check unique BC names errors += Internal.checkPyTree(t, level=4) # check BC ranges errors += Internal.checkPyTree(t, level=5) # check opposite ranges errors += Internal.checkPyTree(t, level=6) # check family definition errors += Internal.checkPyTree(t, level=7) # check CGNSTypes errors += Internal.checkPyTree(t, level=8) # check element nodes errors += Internal.checkPyTree(t, level=9); print errors #>> []
# - newGridConnectivity1to1 (pyTree) - import Converter.Internal as Internal # Create a node n = Internal.newGridConnectivity1to1(name='Match', donorName='blk1', pointRange=[1,1,1,33,1,69], pointRangeDonor=[51,51,1,33,1,69], transform=None); Internal.printTree(n) #>> ['Match',array('blk1',dtype='|S1'),[2 sons],'GridConnectivity1to1_t'] #>> |_['PointRange',array(shape=(6,),dtype='int32',order='F'),[0 son],'IndexRange_t'] #>> |_['PointRangeDonor',array(shape=(6,),dtype='int32',order='F'),[0 son],'IndexRange_t'] # Attach it to a parent node d = Internal.newZoneGridConnectivity(name='ZoneGridConnectivity') Internal.newGridConnectivity1to1(name='Match', donorName='blk1', pointRange=[1,1,1,33,1,69], pointRangeDonor=[51,51,1,33,1,69], transform=None, parent=d)
# - getSizeOf (pyTree) - import Generator.PyTree as G import Converter.Internal as Internal a = G.cart((0, 0, 0), (1, 1, 1), (10, 10, 10)) print(Internal.getSizeOf(a))
# - getNodeFromName (pyTree) - import Converter.PyTree as C import Generator.PyTree as G import Converter.Internal as Internal a = G.cart((0, 0, 0), (1, 1, 1), (10, 10, 10)) t = C.newPyTree(['Base', a]) # Return the node named 'cart' node = Internal.getNodeFromName(t, 'cart') print node
# - newBCDataSet (pyTree) - import Converter.Internal as Internal # Create a BC data set node n = Internal.newBCDataSet(name='BCDataSet', value='BCWall'); Internal.printTree(n) #>> ['BCDataSet',array('BCWall',dtype='|S1'),[0 son],'BCDataSet_t'] # Attach it to a parent node d = Internal.newBC(name='BC', pointList=[22,1036,101,43], btype='BCFarfield') Internal.newBCDataSet(name='BCDataSet', value='UserDefined', parent=d) # Complete BC + BCDataSet + BCData b = Internal.newBC(name='BC', pointList=[22,1036,101,43], btype='BCFarfield') d = Internal.newBCDataSet(name='BCDataSet', value='UserDefined', gridLocation='FaceCenter', parent=b) d = Internal.newBCData('BCNeumann', parent=d) d = Internal.newDataArray('Density', value=[1.,1.,1.,1.], parent=d)
# - addGhostCells (pyTree) - import Generator.PyTree as G import Converter.PyTree as C import Converter.Internal as Internal a = G.cart((1,1,1), (1.,1.,1.), (4,2,3)); a[0]='cart1' b = G.cart((1,1,-3), (1.,1.,0.5), (4,2,9)); b[0]='cart2' a = C.addBC2Zone(a,'match','BCMatch','kmin',b[0],[1,4,1,2,9,9],[1,2,3]) b = C.addBC2Zone(b,'match','BCMatch','kmax',a[0],[1,4,1,2,1,1],[1,2,3]) t = C.newPyTree(['Base',a,b]) # Physical BC (here BCWall) t = C.addBC2Zone(t, 'wall', 'BCWall', 'imin') t = C.initVars(t, '{F}=3*{CoordinateX}+2*{CoordinateY}') # a = t[2][1][2][0] ag = Internal.addGhostCells(t,a,2,adaptBCs=1) t[2][1][2][0] = ag ag = Internal.rmGhostCells(t,ag,2) t[2][1][2][0] = ag C.convertPyTree2File(t,'out.cgns')
# - getBCFaceNode (pyTree) - import Converter.Internal as Internal import Converter.PyTree as C import Generator.PyTree as G import KCore.test as test # structure a = G.cart((0, 0, 0), (1, 1, 1), (10, 10, 10)) a = C.addBC2Zone(a, 'wall', 'BCWall', 'imin') b = Internal.getNodeFromName(a, 'wall') ind = Internal.getBCFaceNode(a, b) test.testO(ind, 1)
# - getNodeFromPath (pyTree) - import Converter.PyTree as C import Generator.PyTree as G import Converter.Internal as Internal a = G.cart((0, 0, 0), (1, 1, 1), (10, 10, 10)) t = C.newPyTree(['Base', a]) # Return GridCoordinates node coords = Internal.getNodeFromPath(t, 'Base/cart/GridCoordinates') print coords #>> ['GridCoordinates', None, [..], 'DataArray_t'] # Return GridCoordinates node (path is relative to input node) coords = Internal.getNodeFromPath(a, 'GridCoordinates') print coords #>> ['GridCoordinates', None, [..], 'DataArray_t']
if (Cmpi.rank == 0): C.convertPyTree2File(t, 'in.cgns') Cmpi.barrier() # lecture du squelette a = Cmpi.convertFile2SkeletonTree('in.cgns') # equilibrage 1 (a, dic) = D2.distribute(a, NProc=Cmpi.size, algorithm='fast', useCom=0) # load des zones locales dans le squelette a = Cmpi.readZones(a, 'in.cgns', proc=Cmpi.rank) # equilibrage 2 (a partir d'un squelette charge) (a, dic) = D2.distribute(a, NProc=Cmpi.size, algorithm='gradient1', useCom='match') a = D2mpi.redispatch(a) # force toutes les zones sur 0 zones = Internal.getNodesFromType(a, 'Zone_t') for z in zones: nodes = Internal.getNodesFromName(z, 'proc') Internal.setValue(nodes[0], 0) a = D2mpi.redispatch(a) # Reconstruit l'arbre complet a l'ecriture Cmpi.convertPyTree2File(a, 'out.cgns')
# - getParentFromType (pyTree) - import Converter.Internal as Internal a = Internal.createNode('level0', 'DataArray_t', 0) b = Internal.createChild(a, 'level1', 'DataArray_t', 1) c = Internal.createChild(b, 'level2', 'DataArray_t', 2) p = Internal.getParentFromType(a, c, 'DataArray_t') print(p[0]) #>> level1
# - rmNodesByType (pyTree) - import Converter.PyTree as C import Generator.PyTree as G import Converter.Internal as Internal import KCore.test as test t = C.newPyTree(['Base', 'Base2']) for i in range(10): a = G.cart( (0,0,0), (1,1,1), (10,10,10) ) a[0] = 'Cart'+str(i) t[2][1][2].append(a) t = Internal.rmNodesByType(t, 'Zone_t') test.testO(t, 1)
# - newZone (pyTree) - import Converter.Internal as Internal # Create a zone node z = Internal.newEMConductivityModel(value='Null') print z # Create a zone node and attach it to tree t = Internal.newFlowEquationSet() z = Internal.newEMConductivityModel(value='Chemistry_LinRessler', parent=t) print t
def runCheckPyTree(): if CTK.t == []: return errors = [] v = VARS[3].get() if v == 'All conformity' or v == ' > Node conformity': errors += Internal.checkPyTree(CTK.t, level=1) if v == 'All conformity' or v == ' > Unique base name': errors += Internal.checkPyTree(CTK.t, level=2) if v == 'All conformity' or v == ' > Unique zone name': errors += Internal.checkPyTree(CTK.t, level=3) if v == 'All conformity' or v == ' > Unique BC name': errors += Internal.checkPyTree(CTK.t, level=4) if v == 'All conformity' or v == ' > Valid BC ranges': errors += Internal.checkPyTree(CTK.t, level=5) if v == 'All conformity' or v == ' > Valid BC match': errors += Internal.checkPyTree(CTK.t, level=6) if v == 'All conformity' or v == ' > Referenced families': errors += Internal.checkPyTree(CTK.t, level=7) if v == 'All conformity' or v == ' > Valid CGNS types': errors += Internal.checkPyTree(CTK.t, level=8) if v == 'All conformity' or v == ' > Valid element nodes': errors += Internal.checkPyTree(CTK.t, level=9) if v == 'All conformity' or v == ' > Valid CGNS flowfield name': errors += Internal.checkPyTree(CTK.t, level=10) if v == 'Multigrid compatibility': MGlevel = CTK.varsFromWidget(VARS[2].get(), type=2) minBlk = CTK.varsFromWidget(VARS[0].get(), type=2) minBC = CTK.varsFromWidget(VARS[1].get(), type=2) if len(MGlevel) > 0 and len(minBlk) > 0 and len(minBC) > 0: errors += Internal.checkMultigrid(CTK.t, level=MGlevel[0], nbMinCoarseB=minBlk[0], nbMinCoarseW=minBC[0]) if (v == 'Maximum number of nodes'): minBlk = CTK.varsFromWidget(VARS[0].get(), type=2) if len(minBlk) > 0: errors = Internal.checkSize(CTK.t, sizeMax=minBlk[0]) if len(errors) == 0: errors = [0, 'No error found.'] Panels.displayErrors(errors, header='Checking pyTree') CTK.TXT.insert('START', 'pyTree checked.\n')
# - newTurbulenceClosure (pyTree) - import Converter.Internal as Internal # Create a node n = Internal.newTurbulenceClosure(value='Null'); Internal.printTree(n) #>> ['TurbulenceClosure',array('Null',dtype='|S1'),[0 son],'TurbulenceClosure_t'] # Create a node and attach it to parent t = Internal.newFlowEquationSet() n = Internal.newTurbulenceClosure(value='ReynoldsStress', parent=t)
def correctPyTree(): if CTK.t == []: return v = VARS[3].get() if v == 'Multigrid compatibility': CTK.TXT.insert('START', 'Can not correct for multigrid.\n') CTK.TXT.insert('START', 'Error: ', 'Error') return if v == 'Maximum number of nodes': CTK.TXT.insert('START', 'Can not correct for maximum number of nodes.\n') CTK.TXT.insert('START', 'Error: ', 'Error') return if v == 'All conformity' or v == ' > Node conformity': Internal._correctPyTree(CTK.t, level=1) if v == 'All conformity' or v == ' > Unique base name': Internal._correctPyTree(CTK.t, level=2) if v == 'All conformity' or v == ' > Unique zone name': Internal._correctPyTree(CTK.t, level=3) if v == 'All conformity' or v == ' > Unique BC name': Internal._correctPyTree(CTK.t, level=4) if v == 'All conformity' or v == ' > Valid BC ranges': Internal._correctPyTree(CTK.t, level=5) if v == 'All conformity' or v == ' > Valid BC match': Internal._correctPyTree(CTK.t, level=6) if v == 'All conformity' or v == ' > Referenced families': Internal._correctPyTree(CTK.t, level=7) if v == 'All conformity' or v == ' > Valid CGNS types': Internal._correctPyTree(CTK.t, level=8) if v == 'All conformity' or v == ' > Valid element nodes': Internal._correctPyTree(CTK.t, level=9) if v == 'All conformity' or v == ' > Valid CGNS flowfield name': Internal.correctPyTree(CTK.t, level=10) #C._fillMissingVariables(CTK.t) (CTK.Nb, CTK.Nz) = CPlot.updateCPlotNumbering(CTK.t) CTK.TKTREE.updateApp() CTK.display(CTK.t) CTK.TXT.insert('START', 'pyTree corrected.\n')
""" import Converter.PyTree as C import Distributor2.PyTree as Distributor2 import Converter.Mpi as Cmpi 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]])
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 Transform.PyTree as T import numpy 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']) t[2][1][2] = [a] # NIT = 10 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.)') tc = Internal.copyRef(t) t = DTW.distance2WallsEikonal(t, sphere, tc=tc, DEPTH=DEPTH, nitmax=10) C.convertPyTree2File(t, 'out.cgns')
# - addFlowSolution (pyTree) - import Converter.PyTree as C import Generator.PyTree as G import Converter.elsAProfile as elsAProfile a = G.cart((0, 0, 0), (1, 1, 1), (10, 10, 10)) t = C.newPyTree(['Base', a]) t = elsAProfile.addFlowSolution(t, governingEquations='Euler') import Converter.Internal as Internal Internal.printTree(t) C.convertPyTree2File(t, 'out.cgns')
# - getValue of a node (pyTree) - import Converter.PyTree as C import Generator.PyTree as G import Converter.Internal as Internal # Structured array a = G.cart((0, 0, 0), (1., 0.5, 1.), (40, 50, 20)) # Get value stored in a zone node print Internal.getValue(a) #>> [[40 39 0] [50 49 0] [20 19 0]] # Get type of a zone (from ZoneType node) node = Internal.getNodeFromName(a, 'ZoneType') # Print node[1], which is a numpy array print node[1] #>> array(['S', 't', 'r', 'u', 'c', 't', 'u', 'r', 'e', 'd'] # getValue, return a string in this case print Internal.getValue(node) #>> Structured
# - newFlowEquationSet (pyTree) - import Converter.Internal as Internal # Create a node n = Internal.newFlowEquationSet() Internal.printTree(n) #>> ['FlowEquationSet',None,[0 son],'FlowEquationSet_t'] # Create a node and attach it to parent t = Internal.newCGNSTree() b = Internal.newCGNSBase('Base', 3, 3, parent=t) n = Internal.newFlowEquationSet(parent=b)
import Generator.PyTree as G import Converter.Internal as Internal import KCore.test as test a = G.cart((0., 0., 0.), (0.1, 0.1, 1), (10, 10, 1)) a[0] = 'cart1' b = G.cart((0.5, 0., 0.), (0.1, 0.1, 1), (10, 10, 1)) b[0] = 'cart2' c = G.cart((0.75, 0., 0.), (0.1, 0.1, 1), (10, 10, 1)) c[0] = 'cart3' # --- CL a = C.addBC2Zone(a, 'wall1', 'BCWall', 'imin') b = C.addBC2Zone(b, 'wall1', 'BCWall', 'imin') b = C.addBC2Zone(b, 'overlap1', 'BCOverlap', 'jmax') c = C.addBC2Zone(c, 'wall1', 'BCWall', 'imin') t = C.newPyTree(['Cart']) # --- Equation state t[2][1] = C.addState(t[2][1], 'EquationDimension', 2) t[2][1][2] += [a, b, c] # --- champ aux centres C._initVars(t, 'centers:cellN', 1.) # --- champ aux noeuds C._initVars(t, 'F', 2.) bases = Internal.getNodesFromType(t, 'CGNSBase_t') base = bases[0] doms = X.getCEBBIntersectingDomains(base, bases, sameBase=1) test.testO(doms) doms = X.getCEBBIntersectingDomains(base, bases, sameBase=0) test.testO(doms, 2)
def step1(): if CTK.t == []: return # Recupere le profil nzs = CPlot.getSelectedZones() if (nzs == []): CTK.TXT.insert('START', 'Selection is empty.\n') CTK.TXT.insert('START', 'Error: ', 'Error') return if (len(nzs) > 2): CTK.TXT.insert( 'START', 'Input profile must be one curve or two curves (blunt profiles).\n' ) CTK.TXT.insert('START', 'Error: ', 'Error') return if (len(nzs) == 2): culot = 1 else: culot = 0 zones = [] errors = [] for nz in nzs: nob = CTK.Nb[nz] + 1 noz = CTK.Nz[nz] z = CTK.t[2][nob][2][noz] dim = Internal.getZoneDim(z) if dim[0] == 'Unstructured': try: z = C.convertBAR2Struct(z) except Exception as e: #print('Error: blader: %s'%str(e)) errors += [0, str(e)] CTK.TXT.insert('START', 'Input profile must be structured.\n') CTK.TXT.insert('START', 'Error: ', 'Error') return zones.append(z) if (len(errors) > 0): Panels.displayErrors(errors, header='Error: blader') CTK.saveTree() # -- Go to array world! import Geom as D import Generator as G import Transform as T import Converter # repere le culot si 2 courbes sont fournies a = C.getAllFields(zones[0], 'nodes')[0] if (culot == 1): ac = C.getAllFields(zones[1], 'nodes')[0] bb1 = G.bbox(a) bb2 = G.bbox(ac) if (bb1[0] > bb2[0]): temp = a a = ac ac = temp # taille de maille trailing edge et culot h = float(VARS[1].get()) # deraffinement par rapport a la distribution initiale h2 = float(VARS[2].get()) # Point de split (pour la ligne medianne), en % de la longeur du profil Nsplit = float(VARS[0].get()) # Creation delta (Ndelta est en nbre de pts sur le profil remaille) Ndelta = int(VARS[3].get()) # Hauteur du maillage Dfar = float(VARS[4].get()) #========================================================================== # Remaille uniforme du profil avec h2 l = D.getLength(a) npts = int(l / h2) + 1 if (npts / 2 == npts * 0.5): npts += 1 distrib = G.cart((0, 0, 0), (1. / (npts - 1.), 1, 1), (npts, 1, 1)) a = G.map(a, distrib) #=========================================================================== # Split du profil en intrados/extrados N = a[2] Ns = int(N * Nsplit) a1 = T.subzone(a, (1, 1, 1), (Ns + 1, 1, 1)) a2 = T.subzone(a, (Ns + 1, 1, 1), (N, 1, 1)) a2 = T.reorder(a2, (-1, 2, 3)) #=========================================================================== # Resserement bord de fuite et bord d'attaque l = D.getLength(a1) s = D.getCurvilinearAbscissa(a1) s[0] = 'x' s = Converter.initVars(s, 'y', 0.) s = Converter.initVars(s, 'z', 0.) N = a1[2] distrib = G.enforcePlusX(s, h / l, N / 10, 1) distrib = G.enforceMoinsX(distrib, h / l, N / 10, 1) a1 = G.map(a1, distrib) l = D.getLength(a2) s = D.getCurvilinearAbscissa(a2) s[0] = 'x' s = Converter.initVars(s, 'y', 0.) s = Converter.initVars(s, 'z', 0.) N = a2[2] distrib = G.enforcePlusX(s, h / l, N / 10, 1) distrib = G.enforceMoinsX(distrib, h / l, N / 10, 1) a2 = G.map(a2, distrib) #========================================================================== # ligne delta #=========================================================================== ni = a1[2] b1 = T.subzone(a1, (1, 1, 1), (Ndelta, 1, 1)) c1 = T.subzone(a1, (Ndelta, 1, 1), (ni, 1, 1)) b2 = T.subzone(a2, (1, 1, 1), (Ndelta, 1, 1)) c2 = T.subzone(a2, (Ndelta, 1, 1), (ni, 1, 1)) P1 = (c1[1][0, 0], c1[1][1, 0], c1[1][2, 0]) P2 = (c2[1][0, 0], c2[1][1, 0], c2[1][2, 0]) NdeltaDelta = Ndelta - 4 delta = D.line(P1, P2, 2 * NdeltaDelta - 1) #=========================================================================== # ligne medianne #=========================================================================== # ligne medianne droite P1 = Converter.getValue(c1, c1[2] - 1) P2 = Converter.getValue(delta, delta[2] / 2) median = D.line(P1, P2, N=10) # ligne medianne moyenne N1 = c1[2] # cree une ligne k2 remaillant c2 avec N1 s = D.getCurvilinearAbscissa(c1) s[0] = 'x' s = Converter.initVars(s, 'y', 0.) s = Converter.initVars(s, 'z', 0.) k2 = G.map(c2, s) # cree la ligne moyenne median = Converter.copy(c1) median[1][0, :] = 0.5 * (c1[1][0, :] + k2[1][0, :]) median[1][1, :] = 0.5 * (c1[1][1, :] + k2[1][1, :]) median[1][2, :] = 0.5 * (c1[1][2, :] + k2[1][2, :]) # Remaillage ligne medianne s = D.getCurvilinearAbscissa(c1) s[0] = 'x' s = Converter.initVars(s, 'y', 0.) s = Converter.initVars(s, 'z', 0.) median = G.map(median, s) median = G.refine(median, 0.9, 1) N1 = c1[2] N2 = median[2] d = N1 - N2 if (d / 2 != d * 0.5): factor = (N2 + 2.) / N2 median = G.refine(median, factor, 1) #=========================================================================== # Maillage TRI au bout if (culot == 0): #Converter.convertArrays2File([b1,b2,delta], 'bout1.plt') m3 = trimesh(b1, b2, delta) if (m3[0] == 0): raise ValueError(m3[1]) #Converter.convertArrays2File([b1,b2,delta]+m3, 'bout1.plt') else: # Dans le cas avec culot, on remaille le culot comme delta l = D.getLength(ac) npts = delta[2] distrib = G.cart((0, 0, 0), (1. / (npts - 1.), 1, 1), (npts, 1, 1)) ac = G.map(ac, distrib) m3 = [G.TFI([b1, delta, b2, ac])] #=========================================================================== # Maillage du reste de l'interieur du profil ni = c1[2] d1 = T.subzone(c1, (1, 1, 1), (ni - NdeltaDelta + 1, 1, 1)) e1 = T.subzone(c1, (ni - NdeltaDelta + 1, 1, 1), (ni, 1, 1)) ni = c2[2] d2 = T.subzone(c2, (1, 1, 1), (ni - NdeltaDelta + 1, 1, 1)) e2 = T.subzone(c2, (ni - NdeltaDelta + 1, 1, 1), (ni, 1, 1)) # remaillage de l'axe median s = D.getCurvilinearAbscissa(d1) s[0] = 'x' s = Converter.initVars(s, 'y', 0.) s = Converter.initVars(s, 'z', 0.) median = G.map(median, s) npt = delta[2] delta1 = T.subzone(delta, (1, 1, 1), (npt / 2 + 1, 1, 1)) delta2 = T.subzone(delta, (npt / 2 + 1, 1, 1), (npt, 1, 1)) #Converter.convertArrays2File([d1,e1,delta1,delta2,median,d2,e2], 'curv1.plt') m1 = G.TFI([d1, e1, delta1, median]) m2 = G.TFI([d2, e2, delta2, median]) #=========================================================================== # Ajout de la ligne arriere P1 = Converter.getValue(a1, 0) P2 = Converter.getValue(a1, 1) P3 = (P1[0] + Dfar, P1[1], P1[2]) line2 = D.line(P1, P3, N=50) N = 50 s = G.cart((0, 0, 0), (1. / (N - 1.), 1, 1), (N, 1, 1)) s = G.enforcePlusX(s, abs(P2[0] - P1[0]) / Dfar, N, 1) line2 = G.map(line2, s) #Converter.convertArrays2File([a1,a2,line2], 'out.plt') if (culot == 0): line2p = Converter.copy(line2) else: P1 = Converter.getValue(a2, 0) P2 = Converter.getValue(a2, 1) P3 = (P1[0] + Dfar, P1[1], P1[2]) line2p = D.line(P1, P3, N=50) s = D.getCurvilinearAbscissa(line2) s[0] = 'x' s = Converter.initVars(s, 'y', 0.) s = Converter.initVars(s, 'z', 0.) line2p = G.map(line2p, s) #=========================================================================== # Add normal layers N = 50 h = abs(P2[0] - P1[0]) N = int(Dfar / (3 * h) / 2) + 1 d = G.cart((0, 0, 0), (3 * h, 1, 1), (N + 1, 1, 1)) # shift line2p[1][1, :] -= 1.e-9 a2[1][1, 0] -= 1.e-9 #Converter.convertArrays2File([a2,line2,a1,line2p], 'curve0.plt') curve0 = T.join([line2, a1, a2, line2p]) curve0 = T.reorder(curve0, (-1, 2, 3)) #Converter.convertArrays2File([curve0], 'curve.plt') m4 = G.addNormalLayers([curve0], d, niter=1000, check=0) m4 = G.close(m4, 1.e-8) #Converter.convertArrays2File([m1,m2]+m3+m4, 'all.plt') # check volume + subzone vol = G.getVolumeMap(m4[0]) nk = vol[4] ni = vol[2] for k in range(nk - 1): sub = T.subzone(vol, (1, 1, k + 1), (ni, 1, k + 2)) volmin = Converter.getMinValue(sub, 'vol') if volmin < 0.: if k > 10: kc = k - 4 else: kc = k - 1 m4[0] = T.subzone(m4[0], (1, 1, 1), (m4[0][2], 1, kc)) break if culot == 1: r1p = T.translate(ac, (Dfar, 0, 0)) Converter.convertArrays2File([ac, line2, r1p, line2p], 'sub.plt') bsup = G.TFI([ac, line2, r1p, line2p]) # interieur M1 = [m1, m2] + m3 # exterieur M2 = m4 M2 = T.reorder(M2, (1, 3, 2)) # split du bloc M2 comme les blocs interieurs (pour connectMatch) a = M2[0] mp = line2[2] + a1[2] - 1 i1 = T.subzone(a, (1, 1, 1), (mp, a[3], a[4])) i2 = T.subzone(a, (mp, 1, 1), (a[2], a[3], a[4])) M2 = [i1, i2] if culot == 1: M2 += [bsup] #========================================================================== # Zones resultantes dans l'arbre meshes = M1 + M2 zones = [] for m in meshes: z = C.convertArrays2ZoneNode('zone', [m]) zones.append(z) base = Internal.getNodesFromName1(CTK.t, 'STEP1') if (base != []): (p, c) = Internal.getParentOfNode(CTK.t, base[0]) del p[2][c] CTK.t = C.addBase2PyTree(CTK.t, 'STEP1', 3) base = Internal.getNodesFromName1(CTK.t, 'STEP1')[0] base[2] += zones CTK.TXT.insert('START', 'Step1 performed.\n') (CTK.Nb, CTK.Nz) = CPlot.updateCPlotNumbering(CTK.t) CTK.TKTREE.updateApp() CTK.display(CTK.t)
def updateStats(): if CTK.t == []: return # Update canvas c = WIDGETS['canvas'] c.delete(TK.ALL) width = int(c.cget("width")) height = int(c.cget("height")) c.create_line(0, height / 2., width, height / 2., fill='red') try: NProc = int(VARS[0].get()) except: CTK.TXT.insert('START', 'stats: NProc is invalid.\n') CTK.TXT.insert('START', 'Error: ', 'Error') return # Calcul du nombre de pts par proc zones = Internal.getZones(CTK.t) a = numpy.zeros((NProc), numpy.int32) for z in zones: param = Internal.getNodesFromName1(z, '.Solver#Param') if param != []: proc = Internal.getNodesFromName1(param[0], 'proc') if (proc != []): value = proc[0][1][0, 0] dim = Internal.getZoneDim(z) if dim[0] == 'Structured': a[value] += dim[1] * dim[2] * dim[3] else: a[value] += dim[1] m = STATS['meanPtsPerProc'] fmin = 1.e10 fmax = 0 for i in a: fmin = min(i, fmin) fmax = max(i, fmax) alpha = min(1. / abs(fmax - m + 1.e-6), 1. / abs(fmin - m + 1.e-6)) alpha = min(alpha, 1. / m) barWidth = width * 1. / (NProc * 1.) for i in range(NProc): v = -alpha * (a[i] - m * 1.) if a[i] == 0: fillColor = 'yellow' elif i % 2 == 0: fillColor = 'blue' else: fillColor = 'red' c.create_rectangle(i * barWidth, height / 2., (i + 1) * barWidth, v * height / 2. + height / 2., fill=fillColor) varRMS = int(STATS['varRMS'] * 10000) / 100. varMin = int(STATS['varMin'] * 10000) / 100. varMax = int(STATS['varMax'] * 10000) / 100. nptsCom = STATS['nptsCom'] comRatio = int(STATS['comRatio'] * 10000) / 100. CTK.TXT.insert( 'START', 'stats: mean=' + str(m) + ' pts, varMax=' + str(varMax) + '%, nptsCom=' + str(nptsCom) + ' npts, ratio=' + str(comRatio) + '%.\n') # Update info bulle b = WIDGETS['bulle'] stats = 'meanPtsPerProc=' + str(STATS['meanPtsPerProc']) + '.\n' stats += 'varMax='+str(varMax)+'%, varMin='+\ str(varMin)+'%, varRMS='+str(varRMS)+'%.\n' stats += 'nptsCom=' + str( STATS['nptsCom']) + ', ratio=' + str(comRatio) + '%.' b.label.configure(text=stats)
import Converter.PyTree as C import Generator.PyTree as G import Converter.Internal as Internal import Connector.PyTree as X import Geom.PyTree as D import KCore.test as test d = 2 a = D.sphere6((0, 0, 0), 0.5, N=20) dk = G.cart((0, 0, 0), (0.01, 1, 1), (11, 1, 1)) a = G.addNormalLayers(a, dk) t = C.newPyTree(['Base']) t[2][1][2] = a t = X.connectMatch(t, dim=3) t = Internal.addGhostCells(t, t, d, adaptBCs=1) #--------- # Centers #--------- t = C.initVars(t, 'centers:F', 0.) tc = C.node2Center(t) tc = C.initVars(tc, '{F}={CoordinateX}*{CoordinateY}') # stockage direct t1 = X.setInterpDataForGhostCells__(t, tc, storage='direct', loc='centers') test.testT(t1, 1) # stockage inverse tc1 = X.setInterpDataForGhostCells__(t, tc, storage='inverse', loc='centers') test.testT(tc1, 2) #--------- # Nodes #--------- # noeuds, stockage direct
def reorder(): 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 ii = VARS[0].get() if (ii == 'I -> I'): i1 = 1 elif (ii == 'I -> -I'): i1 = -1 elif (ii == 'I -> J'): i1 = 2 elif (ii == 'I -> -J'): i1 = -2 elif (ii == 'I -> K'): i1 = 3 elif (ii == 'I -> -K'): i1 = -3 jj = VARS[1].get() if (jj == 'J -> I'): j1 = 1 elif (jj == 'J -> -I'): j1 = -1 elif (jj == 'J -> J'): j1 = 2 elif (jj == 'J -> -J'): j1 = -2 elif (jj == 'J -> K'): j1 = 3 elif (jj == 'J -> -K'): j1 = -3 kk = VARS[2].get() if (kk == 'K -> I'): k1 = 1 elif (kk == 'K -> -I'): k1 = -1 elif (kk == 'K -> J'): k1 = 2 elif (kk == 'K -> -J'): k1 = -2 elif (kk == 'K -> K'): k1 = 3 elif (kk == 'K -> -K'): k1 = -3 if abs(i1)+abs(j1)+abs(k1) != 6: CTK.TXT.insert('START', 'Reordering settings is invalid.\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] dim = Internal.getZoneDim(z) try: if dim[0] == 'Unstructured': T._reorder(z, (-1,), topTree=CTK.t) else: #ni = dim[1]; nj = dim[2]; nk = dim[3] #if (nk == 1): a = T.reorder(z, (-1,2,3), topTree=CTK.t) #elif (nj == 1): a = T.reorder(z, (-1,2,3), topTree=CTK.t) #elif (ni == 1): a = T.reorder(z, (1,2,-3), topTree=CTK.t) #else: a = T.reorder(z, (-1,2,3), topTree=CTK.t) T._reorder(z, (i1,j1,k1), topTree=CTK.t) CTK.replace(CTK.t, nob, noz, z) except Exception as e: fail = True; errors += [0,str(e)] if not fail: CTK.TXT.insert('START', 'Zones reordered.\n') else: Panels.displayErrors(errors, header='Error: reorder') CTK.TXT.insert('START', 'Reorder fails for at least one zone.\n') CTK.TXT.insert('START', 'Warning: ', 'Warning') CTK.TKTREE.updateApp() CPlot.render()