示例#1
0
#for nrun in arange(len(runs)):
#for nrun in [0,]:
for nrun in [
        1,
]:
    run = runs[nrun]
    #    for ntau in arange(len(mytau)):
    for ntau in [
            4,
    ]:

        close('all')

        tau = mytau[ntau]
        r = 'taux%04d_rb0110_%s' % (tau * 10000, run)
        b = bump_channel.BumpChannel(base_dir, r)
        sol = MITgcmdata.poisson.solver(b)  # conjugate gradient solver

        T = b.rdmds('Ttave')
        Tw = b.cgrid_to_ugrid(T)  # on the U grid
        Ts = b.cgrid_to_vgrid(T)  # on the V grid
        V = b.rdmds('Vveltave')
        U = b.rdmds('Uveltave')
        P = b.rdmds('Phhytave')

        Ug = -(b.f[newaxis, :, newaxis]**-1) * b.ddy_cgrid_to_vgrid(P)
        Vg = (b.f[newaxis, :, newaxis]**-1) * b.ddx_cgrid_to_ugrid(P)
        Ua = U - Ug
        Va = V - Vg

        UT = b.rdmds('UTtave')
示例#2
0
from pylab import *
import bump_channel
import mycolors
import os

base_dir = os.path.join(os.environ['D'], 'DATASTORE.RPA', 'projects',
                        'drag_strat')

b_bump = bump_channel.BumpChannel(base_dir, 'taux2000_rb0110_bump')
b_long = bump_channel.BumpChannel(base_dir, 'taux2000_rb0110_bumplong')

# k indices
kr = r_[0, 4, 8, 12, 15, 17:b_bump.Nz:2]

t**s = ['ridge', 'long']

for b in [b_bump, b_long]:
    b.load_default_fields()
    b.VTwave = (b.Vwave * b.cgrid_to_vgrid(b.Twave)).mean(axis=2)
    b.WTwave = (b.Wwave * b.cgrid_to_wgrid(b.Twave)).mean(axis=2)
    b.VTg = b.VpTpbar + b.VTwave
    b.WTg = b.WpTpbar + b.WTwave

deltaTheta = 8.
Qfac = b.rho0 * 3994
for b in [b_bump, b_long]:
    b.D = -2 * b.integrate_vertical(
        b.zc[:, newaxis] * b.Tbar) / b.integrate_vertical(b.Tbar)[-2]
    b.Kg = -b.integrate_vertical(b.VTg) * b.Ly / (b.D * deltaTheta)
    b.Hek = Qfac * b.Lx * b.integrate_vertical(b.Tbar * b.Vbar)
    b.Hg = Qfac * b.Lx * b.integrate_vertical(b.VTg)
示例#3
0
from pylab import *
import os
import bump_channel
import mycolors

rcParams['figure.figsize'] = [6, 3.5]
rcParams['legend.fontsize'] = 7
rcParams['font.size'] = 8

base_dir = os.path.join(os.environ['D'], 'DATASTORE.RPA', 'projects',
                        'drag_strat')

b = bump_channel.BumpChannel(base_dir, 'taux2000_rb0110_bump')
#b = bump_channel.BumpChannel(base_dir, 'taux2000_rb0110_flat')

T = b.rdmds('Ttave')
Tw = b.cgrid_to_ugrid(T)  # on the U grid
Ts = b.cgrid_to_vgrid(T)  # on the V grid
V = b.rdmds('Vveltave')
U = b.rdmds('Uveltave')
UT = b.rdmds('UTtave')
VT = b.rdmds('VTtave')

# vertically integrated fluxes
THETA = b.average_vertical(T)
THETAw = b.cgrid_to_ugrid(THETA)
THETAs = b.cgrid_to_ugrid(THETA)

# full time-mean flux
divTflux_m = b.ddx_ugrid_to_cgrid(UT) + b.ddy_vgrid_to_cgrid(VT)
# eddy flux
from pylab import *
import os
import bump_channel

run_name = 'taux2000_rb0110_bump'
base_dir = os.path.join(os.environ['D'], 'projects', 'drag_strat')
b = bump_channel.BumpChannel(base_dir, run_name)
outdir = '/Volumes/scratch/tmp/output_for_paraview/' + run_name

T = b.rdmds('Ttave')
V = b.rdmds('Vveltave')
U = b.rdmds('Uveltave')
W = b.rdmds('Wveltave')
P = b.rdmds('Phhytave')

UT = b.rdmds('UTtave')
VT = b.rdmds('VTtave')
WT = b.rdmds('WTtave')
Tdif = b.rdmds('Tdiftave')

Tbar = T.mean(axis=2)[:, :, newaxis]
Vbar = V.mean(axis=2)[:, :, newaxis]
Ubar = U.mean(axis=2)[:, :, newaxis]
Wbar = W.mean(axis=2)[:, :, newaxis]

Panom = P - P[:, :, 0][:, :, newaxis]

# terms in heat budget
dx_UT = b.ddx_ugrid_to_cgrid(UT)
dy_VT = b.ddy_vgrid_to_cgrid(VT)
dz_WT = b.ddz_wgrid_to_cgrid(WT)
示例#5
0
res = dict()
for k in [
        'D', 'D05', 'APE', 'PEtoKE', 'EPEtoEKE', 'PEtoIE', 'KEdiss', 'EKEdiss',
        'EKEbot', 'EKE'
]:
    res[k] = zeros(N)

for n in arange(N):
    tau0 = tau[n]
    if tau0 == 0:
        suf = 'flatshort'
    else:
        suf = 'flat'

    b = bump_channel.BumpChannel(base_dir,
                                 'taux%04d_rb0110_%s' % (tau0 * 10000, suf))
    b.load_default_fields()
    U2 = b.rdmds('UUtave')
    V2 = b.rdmds('VVtave')
    EKE = 0.5 * (U2 - b.U**2 + V2 - b.V**2).mean(axis=2)

    # thermocline depth
    D = -2 * b.integrate_vertical(
        b.zc[:, newaxis] *
        (b.Tbar - b.Tbar[-1])) / b.integrate_vertical(b.Tbar)
    res['D'][n] = D[-2]

    # depth of 0.5 degree isotherm
    res['D05'][n] = -interp(0.5, b.Tbar[::-1, -2], b.zc[::-1])

    # available potential energy
示例#6
0
from pylab import *
import bump_channel
#import mycolors
import os

base_dir = os.path.join(os.environ['D'], 'DATASTORE.RPA', 'projects',
                        'drag_strat')

b_bump = bump_channel.BumpChannel(base_dir, 'taux2000_rb0110_bump')
b_flat = bump_channel.BumpChannel(base_dir, 'taux2000_rb0110_flat')

for B in [b_bump]:  #,b_flat]:
    c = B.get_APEcomputer()
    Ep = c.calc_PE()
    Eb = c.calc_BPE()
    Ea = c.calc_APE()

    # Stu's QG approximation
    bmean = c.b.mean(axis=1).mean(axis=1)
    N2 = B.ddz_cgrid_centered(bmean)
    Ea_QG = sum(c.vol * 0.5 * (c.b - bmean[:, newaxis, newaxis])**2 /
                N2[:, newaxis, newaxis])

    bbar = tile(c.b.mean(axis=2)[:, :, newaxis], [1, 1, B.Nx])
    bbar_z = B.ddz_cgrid_centered(bbar)
    bwave = c.b - bbar

    print('%040s: %4.2f PJ' % ('Total Potential Energy', Ep / 1e15))
    print('%040s: %4.2f PJ' % ('Background Potential Energy', Eb / 1e15))
    print('%040s: %4.2f PJ' % ('Available Potential Energy', Ea / 1e15))
    print('%040s: %4.2f PJ' %