コード例 #1
0
def prepareCompositeIBMData(t, tb, DEPTH=2, loc='centers', frontType=1):
    dimPb = Internal.getNodeFromName(tb, 'EquationDimension')
    if dimPb is None:
        raise ValueError('EquationDimension is missing in input body tree.')
    dimPb = Internal.getValue(dimPb)
    tc = C.newPyTree()
    for nob in range(len(t[2])):
        if Internal.getType(t[2][nob]) == 'CGNSBase_t':
            basename = t[2][nob][0]
            C._addBase2PyTree(tc, basename)
    for nob in range(len(tb[2])):
        if tb[2][nob][3] == 'CGNSBase_t':
            basename = tb[2][nob][0]
            tloc = C.newPyTree([basename])
            tloc[2][1] = t[2][nob]
            tbloc = C.newPyTree([basename])
            tbloc[2][1] = tb[2][nob]
            # prepro IBM + interpolation entre blocs internes
            tloc, tcloc = prepareIBMData(tloc,
                                         tbloc,
                                         DEPTH=DEPTH,
                                         loc=loc,
                                         frontType=frontType,
                                         interp='composite')
            C._cpVars(tloc, 'centers:cellN', tcloc, 'cellN')
            tc[2][nob][2] += Internal.getZones(tcloc)
            Internal._rmNodesFromType(t[2][nob], "Zone_t")
            t[2][nob][2] += Internal.getZones(tloc)
    #
    offbodyZones = C.node2Center(t[2][-1][2])
    Internal._rmNodesByName(tc, "*TurbulentDistance*")
    Internal._rmNodesByName(tc, Internal.__FlowSolutionCenters__)
    tc[2][-1][2] += offbodyZones
    return t, tc
コード例 #2
0
def extract():
    if CTK.t == []: return
    type = VARS[0].get()

    if CTK.__MAINTREE__ == 1:
        CTK.__MAINACTIVEZONES__ = CPlot.getActiveZones()

    active = []
    zones = Internal.getZones(CTK.t)
    for z in CTK.__MAINACTIVEZONES__:
        active.append(CTK.t[2][CTK.Nb[z] + 1][2][CTK.Nz[z]])

    Z = None
    if type == 'cellN=-99999':
        Z = selectWithFormula(active, '{cellN} == -99999')
    elif type == 'cellN=1':
        Z = selectWithFormula(active, '{cellN} == 1')
    elif type == 'cellN=0':
        Z = selectWithFormula(active, '{cellN} == 0')
    elif type == 'cellN=2':
        Z = selectWithFormula(active, '{cellN} == 2')
    elif type == 'cellN<0':
        Z = selectWithFormula(active, '{cellN}<0')
    elif type == '0<cellN<1':
        Z = selectWithFormula(active, '({cellN}>0) & ({cellN}<1)')
    elif type == 'Interpolated points':
        Z = X.extractChimeraInfo(zones, type='interpolated', loc='centers')
        if Z == []: Z = None
    elif type == 'Extrapolated points':
        Z = X.extractChimeraInfo(zones, type='extrapolated', loc='centers')
        if Z == []: Z = None
    elif type == 'Orphan points':
        Z = X.extractChimeraInfo(zones, type='orphan', loc='centers')
        if Z == []: Z = None
    elif type == 'cf>1':
        Z = X.extractChimeraInfo(zones, type='cf>1', loc='centers')
        if Z == []: Z = None

    if Z is not None:
        CTK.TXT.insert('START', 'Filter ' + type + ' extracted.\n')
        C._addBase2PyTree(CTK.t, 'EXTRACT')
        b = Internal.getNodesFromName1(CTK.t, 'EXTRACT')
        base = b[0]
        base[2] += Z
        (CTK.Nb, CTK.Nz) = CPlot.updateCPlotNumbering(CTK.t)
        #C._fillMissingVariables(CTK.t)
        CTK.TKTREE.updateApp()
        CTK.display(CTK.t)
    else:
        CTK.TXT.insert('START', 'Nothing extracted.\n')
        CTK.TXT.insert('START', 'Error: ', 'Error')
コード例 #3
0
# - addBase2PyTree (pyTree) -
import Converter.PyTree as C
import KCore.test as test

# Sur un arbre existant
t = C.newPyTree(['Base', 3])
t = C.addBase2PyTree(t, 'Base2', 2)
C._addBase2PyTree(t, 'Base3', 3)
test.testT(t, 1)

# Sur un arbre vide
t2 = C.addBase2PyTree([], 'Base3', 3)
test.testT(t2, 2)

test.writeCoverage(100.)