# - computeExtraVariable (pyTree) -
import Generator.PyTree as G
import Converter.PyTree as C
import Post.PyTree as P
import KCore.test as test

a = G.cart((0, 0, 0), (1, 1, 1), (10, 10, 10))
a = C.initVars(a, 'Density', 1.)
a = C.initVars(a, 'MomentumX', 1.)
a = C.initVars(a, 'MomentumY', 0.)
a = C.initVars(a, 'MomentumZ', 0.)
a = C.initVars(a, 'EnergyStagnationDensity', 1.)
a = P.computeExtraVariable(a, 'VorticityMagnitude')
a = P.computeExtraVariable(a, 'QCriterion')
a = P.computeExtraVariable(a, 'ShearStress')
t = C.newPyTree(['Base', a])
test.testT(t, 1)
Example #2
0
# - computeExtraVariable (pyTree) -
import Generator.PyTree as G
import Converter.PyTree as C
import Transform.PyTree as T
import Post.PyTree as P


def F(x, y):
    return x * x + y * y


a = G.cart((0, 0, 0), (1, 1, 1), (50, 50, 50))
a = C.initVars(a, 'Density', 1.)
a = C.initVars(a, 'MomentumX', F, ['CoordinateX', 'CoordinateY'])
a = C.initVars(a, 'MomentumY', 0.)
a = C.initVars(a, 'MomentumZ', 0.)
a = C.initVars(a, 'EnergyStagnationDensity', 100000.)
a = P.computeExtraVariable(a, 'centers:VorticityMagnitude')
a = P.computeExtraVariable(a, 'centers:QCriterion')
a = P.computeExtraVariable(a, 'centers:ShearStress')

b = T.subzone(a, (1, 1, 1), (50, 50, 1))
b = P.computeExtraVariable(b, 'centers:SkinFriction')
b = P.computeExtraVariable(b, 'centers:SkinFrictionTangential')

C.convertPyTree2File(a, 'out.cgns')
def computeVariables():
    if CTK.t == []: return
    nzs = CPlot.getSelectedZones()
    varname = VARS[0].get()

    # Adimensionnement
    adim = VARS[7].get()
    nodes = Internal.getNodesFromName(CTK.t, 'ReferenceState')
    if nodes != []: state = nodes[0]
    else:
        CTK.TXT.insert('START', 'ReferenceState is missing (tkState).\n')
        CTK.TXT.insert('START', 'Error: ', 'Error')
        return

    nodes = Internal.getNodesFromName(state, 'Mach')
    if nodes != []:
        if isinstance(nodes[0][1], numpy.ndarray):
            MInf = nodes[0][1][0]
        else:
            MInf = nodes[0][1]
    else:
        CTK.TXT.insert('START', 'Mach is missing (tkState).\n')
        CTK.TXT.insert('START', 'Error: ', 'Error')
        return

    nodes = Internal.getNodesFromName(state, 'Reynolds')
    if nodes != []:
        if isinstance(nodes[0][1], numpy.ndarray):
            ReInf = nodes[0][1][0]
        else:
            ReInf = nodes[0][1]
    else:
        ReInf = 1.

    if adim == 'Adim1 (ro,a,T)':
        adim = Adim.adim1(MInf, 0., 0., ReInf)
    elif adim == 'Adim2 (ro,u,T)':
        adim = Adim.adim2(MInf, 0., 0., ReInf)
    else:
        CTK.TXT.insert('START', 'Unknown adim type.\n')
        CTK.TXT.insert('START', 'Error: ', 'Error')
        return

    gamma = adim[11]
    cv = adim[7]
    rgp = (gamma - 1) * cv
    TInf = adim[6]
    muInf = 1. / ReInf
    Cs = adim[10]

    loc = VARS[6].get()

    CTK.saveTree()
    if (varname == 'Vorticity' or varname == 'VorticityMagnitude'
            or varname == 'QCriterion' or varname == 'ShearStress'
            or varname == 'SkinFriction'
            or varname == 'SkinFrictionTangential'):  # extra variables
        varloc = loc + ':' + varname
        if CTK.__MAINTREE__ <= 0 or nzs == []:
            try:
                CTK.t = P.computeExtraVariable(CTK.t,
                                               varloc,
                                               gamma=gamma,
                                               rgp=rgp,
                                               Cs=Cs,
                                               mus=muInf,
                                               Ts=TInf)
                CTK.TXT.insert('START', 'Variable %s computed.\n' % varloc)
            except Exception as e:
                Panels.displayErrors([0, str(e)],
                                     header='Error: computeExtraVariables')
                CTK.TXT.insert('START',
                               'Computation of variable %s failed.\n' % varloc)
                CTK.TXT.insert('START', 'Error: ', 'Error')

        else:
            fail = False
            errors = []
            for nz in nzs:
                nob = CTK.Nb[nz] + 1
                noz = CTK.Nz[nz]
                try:
                    CTK.t[2][nob][2][noz] = \
                        P.computeExtraVariable(CTK.t[2][nob][2][noz], varloc,
                                               gamma=gamma, rgp=rgp, Cs=Cs,
                                               mus=muInf, Ts=TInf)
                except Exception as e:
                    fail = True
                    errors += [0, str(e)]

            if not fail:
                CTK.TXT.insert('START', 'Variable %s computed.\n' % varloc)
            else:
                Panels.displayErrors(errors,
                                     header='Error: computeExtraVariables')
                CTK.TXT.insert('START',
                               'Computation of variable %s failed.\n' % varloc)
                CTK.TXT.insert('START', 'Error: ', 'Error')

    else:  # std variables
        varloc = loc + ':' + varname
        if CTK.__MAINTREE__ <= 0 or nzs == []:
            try:
                CTK.t = P.computeVariables(CTK.t, [varloc],
                                           gamma=gamma,
                                           rgp=rgp,
                                           Cs=Cs,
                                           mus=muInf,
                                           Ts=TInf)
                CTK.TXT.insert('START', 'Variable %s computed.\n' % varloc)
            except Exception as e:
                Panels.displayErrors([0, str(e)],
                                     header='Error: computeVariables')
                CTK.TXT.insert('START',
                               'Computation of variable %s failed.\n' % varloc)
                CTK.TXT.insert('START', 'Error: ', 'Error')

        else:
            fail = False
            errors = []
            for nz in nzs:
                nob = CTK.Nb[nz] + 1
                noz = CTK.Nz[nz]
                try:
                    CTK.t[2][nob][2][noz] = \
                        P.computeVariables(CTK.t[2][nob][2][noz], [varloc],
                                           gamma=gamma, rgp=rgp, Cs=Cs,
                                           mus=muInf, Ts=TInf)
                except Exception as e:
                    fail = True
                    errors += [0, str(e)]

            if not fail:
                CTK.TXT.insert('START', 'Variable %s computed.\n' % varloc)
            else:
                Panels.displayErrors(errors, header='Error: computeVariables')
                CTK.TXT.insert('START',
                               'Computation of variable %s failed.\n' % varloc)
                CTK.TXT.insert('START', 'Error: ', 'Error')
    #C._fillMissingVariables(CTK.t)
    CTK.TKTREE.updateApp()
    CTK.display(CTK.t)
    if CTK.TKPLOTXY is not None: CTK.TKPLOTXY.updateApp()