Chameleon heat flux χ vs ε

Chameleon heat flux χ vs ε#

I’m confused by disagreements between heat flux calculated from χ or ε.

This notebook studies these differences using chamelon and χpods from EQUIX; and chameleon from TIWE

TODO:

calculate gradients using sorted profiles; this bumps up Jq by a factor of 2!
- Sasha’s dTdz is calculated using θ sorted by θ, and N2 is calculated using σ sorted by σ
- Sasha’s χpod N2 = gα dTdz with α calculated using S=34
Seems very sensitive to low gradient locations
Figure out what level to filter χ, ε at: 1e-2? 1e-5 in jims multiprofv2.m
Add values for sensor 1, sensor2 to χpod datasets
Add Jq_ε for χpods
Try with TH or TIWE
Need TIWE ADCP

def Jq(x, *, min_dTdz):
    j = (
        (
            1025
            * 4000
            * x.chi.where(x.chi < 2e-2)
            / 2
            / x.dTdz.where(np.abs(x.dTdz) > min_dTdz)
        )
        .rolling(depth=5, center=True)
        .mean()
    )
    j.attrs["long_name"] = "$J_q^χ$"
    j.attrs["units"] = "W/m^2"
    return j

Different Jq calculations#

f, ax = plt.subplots(1, 3)
f.set_size_inches((12, 3))

cham.dTdz.sel(depth=slice(125)).mean("time").cf.plot(ax=ax[0])
chamρ.dTdz.sel(depth=slice(125)).mean("time").cf.plot(ax=ax[0])
chamT.dTdz.sel(depth=slice(125)).mean("time").cf.plot(ax=ax[0])

ax[0].set_xlabel("$∂T/∂z$")

_, bins, _ = cham.dTdz.sel(depth=slice(125)).plot.hist(
    histtype="step", bins=np.linspace(-0.1, 0.1, 1000), ax=ax[1], label="Sasha"
)
chamρ.dTdz.sel(depth=slice(125)).plot.hist(
    histtype="step", bins=bins, yscale="log", ax=ax[1], label="T sorted by ρ"
)
chamT.dTdz.sel(depth=slice(125)).plot.hist(
    histtype="step",
    bins=bins,
    yscale="log",
    ax=ax[1],
    label="T sorted by T",
)
ax[1].set_xlabel("$∂T/∂z$")


def Jq_(x, Tname):
    dTdz = x[Tname].differentiate("depth")
    return x.rhoav * 4000 * x.chi.where(x.chi < 1e-2) / 2 / dTdz


_, bins, _ = (
    Jq_(cham, "T")
    .sel(depth=slice(125))
    .plot.hist(
        histtype="step", bins=np.linspace(-0.1, 0.1, 1000), ax=ax[2], label="Sasha"
    )
)
Jq_(cham, "sortT").sel(depth=slice(125)).plot.hist(
    histtype="step", bins=bins, yscale="log", ax=ax[2], label="T sorted by ρ"
)
Jq_(cham, "sortTbyT").sel(depth=slice(125)).plot.hist(
    histtype="step",
    bins=bins,
    yscale="log",
    ax=ax[2],
    label="T sorted by T",
)

ax[-1].set_xlabel("$J_q^χ$")
ax[-1].legend(bbox_to_anchor=(1.0, 0.5))

<matplotlib.legend.Legend at 0x7fab581a3d30>

_images/c343575d6ea5dca51dab72ea7faf04821135f180536a5f215095b01f8b074c8c.png

profile = cham.isel(time=200)
# profile.N2.plot()
(profile.DRHODZ).plot()
(thorpesort(profile.pden, profile.pden).diff("depth")).plot()

[<matplotlib.lines.Line2D at 0x7fab55a9edf0>]

_images/294b20468124ed0b51a355bc4b9d6a630e9d825ce40776d40ec93274f5bb1ff8.png

def plot(c, name):
    j = Jq(c, min_dTdz=1e-3)
    hdl = j.where(j < 0).mean("time").plot(y="depth", label=name)
    j.where(j > 0).mean("time").plot(
        color=hdl[0].get_color(), y="depth", yincrease=False
    )
    j.mean("time").plot(
        marker=".", color=hdl[0].get_color(), y="depth", yincrease=False
    )


plot(chamρ, "sorted by ρ")
plot(chamT, "sorted by T")
plt.legend()
plt.xlabel("$J_q^χ$")

Text(0.5, 0, '$J_q^χ$')

_images/e299800ffc0d88978e7d9517741f8b91f47c2d32d9ac0696f7ea52534d69d22f.png

Averaging in temperature space#

# xr.set_options(use_numpy_groupies=False)
# cham_legacy = pump.tspace.regrid_chameleon(
# These thresholds make a big difference! but really it's a very small number of points
#    cham.where((cham.chi < 1e-2) & (cham.eps < 1e-5))
#    .sel(depth=slice(156))
#    .where(cham.depth > cham.mld + 5)
#    .isel(time=slice(24 * 6)),
#    time_freq="3H",
#    bins=bins,
#    trim_mld=False,
# )

f, ax = plt.subplots(1, 2, sharey=True)
cham_legacy.chi.mean("time").plot(ax=ax[0], y="theta_c")
cham_npg.chi.mean("time").plot(ax=ax[0], y="theta_c")

(cham_legacy.nobs - cham_npg.nobs).plot(ax=ax[1], y="theta_bins", cmap=mpl.cm.Reds)

# xr.set_options(use_flox=True)
cham_npg = pump.tspace.regrid_chameleon(
    # These thresholds make a big difference! but really it's a very small number of points
    cham.where((cham.chi < 1e-2))
    .sel(depth=slice(156))
    .where(cham.depth > cham.mld + 5),
    # .isel(time=slice(24 * 6)),
    time_freq="3H",
    bins=Tbins,
    trim_mld=False,
)

cham_Tspace = cham_npg
cham_Tmean = cham_Tspace.mean("time")
cham_Tmean.coords["z_c"] = cham_Tspace.z_c.mean("time")

%matplotlib inline
mpl.rcParams["figure.dpi"] = 140

cham_Tspace.nobs.plot(x="time")
plt.figure()
cham_Tmean.Jq.plot(y="z_c", marker="s", yincrease=True)

[<matplotlib.lines.Line2D at 0x7fdca55ae190>]

_images/85f90c5599ed7c5aaf3afa256bdc493dbcdc25ff3b24dae5aba9563158ce55f5.png

_images/4d978c28f5a6173bca2c511e2a01bbbee1258ccc987fbdd44e0474d2071c3608.png

\(J_q^ε\) vs \(J_q^χ\)#

Define

\begin{align*} J_q^χ &= ρ c_p K_T T_z = ρ c_p \frac{χ/2}{T_z^2} T_z \ J_q^ε &= ρ c_p K_ρ T_z = ρ c_p \frac{Γε}{N²} T_z \end{align*}

Compare many Jq estimates: \(J_q^χ\) and \(J_q^ε\) from χpod, chameleon

f, ax = plt.subplots(1, 3, sharex=True, sharey=True, constrained_layout=True)
f.set_size_inches((10, 5))

N2rho = 9.81 / 1025 * cham.pden.differentiate("depth")
N2sort = 9.81 / 1025 * thorpesort(cham.pden, cham.pden).differentiate("depth")
for cham_, label in zip(
    [cham, chamρ, chamT],
    ["2009 paper", "$T_z$ with T sorted by ρ", "$T_z$ with T sorted by T"],
):
    (1025 * 4000 * 0.2 * cham.eps / cham.N2.where(cham.N2 > 5e-6) * cham_.dTdz).mean(
        "time"
    ).plot(
        y="depth",
        yincrease=False,
        # color="k",
        label=label,
        ax=ax[0],
    )
ax[0].set_xlabel("$J_q^ε = ρ c_p K_ρ T_z$")


for cham_, axx in zip([chamρ, chamT], ax[1:]):
    Jq(cham, min_dTdz=1e-10).mean("time").plot(
        y="depth",
        yincrease=False,
        label="$J_q^χ$ (2009 paper)",
        ax=axx,
    )
    for min_dTdz in [1e-3, 5e-3]:
        Jq(cham_, min_dTdz=min_dTdz).mean("time").plot(
            y="depth",
            yincrease=False,
            label=f"$T_z$ > {min_dTdz:.0e}",
            ax=axx,
        )
    axx.set_xlabel("$J_q^χ = ρ c_p K_T T_z$")

for axx in ax:
    cham_Tmean.Jq.plot(
        y="z_c",
        marker="s",
        color="k",
        label="$J_q^χ$ Tspace",
        ax=axx,
        _labels=False,
    )
    (-1 * iop.Jq).mean("time").plot(
        y="depth",
        marker="v",
        ls="none",
        label="$J_q^χ$ EQUIX IOP",
        ax=axx,
        color="r",
        _labels=False,
    )
    (-1 * tao_iop.Jq).mean("time").plot(
        y="depth",
        marker="^",
        ls="none",
        label="$J_q^χ$ TAO IOP",
        ax=axx,
        color="b",
        _labels=False,
    )

    (-1 * iop.Jq_eps).mean("time").plot(
        ls="none",
        markerfacecolor="none",
        y="depth",
        marker="o",
        color="r",
        ax=axx,
        ms=5,
        label="$J_q^ε$ IOP",
        _labels=False,
    )
    (-1 * tao_iop.Jq_eps).mean("time").plot(
        ls="none",
        y="depth",
        marker="o",
        markerfacecolor="none",
        color="b",
        ax=axx,
        ms=5,
        label="$J_q^ε$ TAO IOP",
        _labels=False,
    )


ax[1].set_title("T sorted by ρ")
ax[2].set_title("T sorted by T")
# (4e6 * 0.2 * cham.eps / cham.N2.where(mask) * cham.dTdz).mean("time").plot(
#    y="depth", yincrease=False, ylim=[150, 20], xlim=[-1000, 1000]
# )

# (Jq(cham5m)).mean("time").plot(y="depth", yincrease=False)
# (4e6 * 0.2 * cham5m.eps / cham5m.N2.where(mask) * cham5m.dTdz).mean("time").plot(
#    y="depth", yincrease=False, ylim=[150, 20], xlim=[-1000, 1000]
# )

# cham5m.Jq_χ.mean("time").plot(y="depth", yincrease=False, color="k", ls="--")

plt.xlim(-600, 10)
plt.ylim(160, 15)
[ax.grid(True) for ax in ax]
[ax.legend() for ax in ax]
dcpy.plots.clean_axes(ax)
plt.savefig("../images/equix-jq-iop-cham-vs-chipod.png")

_images/bd01ec0837c3a6bc231ba9aca6b677ab6971a4744912d55d4f9c66ae5b2b9794.png

Perlin & Moum:#

Can I reproduce the figures of Perlin & Moum?

This is checking whether there’s something wrong in the dataset I have that might explain the differences in \(J_q^ε\) and \(J_q^χ\)

Conclusion: I can reasonably reproduce these figures, the differences are likely that in masking (I think I have a masked product). The only point of concern is that the TAO χpods are all systematically low by a factor of 2. I recombined these datasets from scratch, so it would be good to double-check that.

χ, ε#

Reproducing Perlin & Moum

75m TAO ε is low
ε below 120m is higher than Perlin & Moum by quite a bit but χ compares well.

f, axx = plt.subplots(1, 2, sharey=True, constrained_layout=True)
ax = dict(zip(["chi", "eps"], axx))

for var in ax:
    cham[var].where(cham[var] < 1e-3).mean("time").cf.plot(
        xscale="log", color="k", ax=ax[var], label="cham"
    )
    iop[var].mean("time").cf.plot(
        marker=".", ls="none", label="EQUIX", color="r", ax=ax[var]
    )
    tao_iop[var + "1"].mean("time").cf.plot(
        marker=".", color="b", ls="none", label="TAO", ax=ax[var]
    )
    # iop[var + "2"].mean("time").cf.plot(marker=".", ls="none", label="IOP", color='r', ax=ax[var])
    ax[var].legend()
    tao_iop[var + "2"].mean("time").cf.plot(
        marker="o",
        markerfacecolor="none",
        ms=4,
        color="b",
        ls="none",
        label="TAO",
        ax=ax[var],
    )

ax["chi"].set_xlim([1e-7, 1e-5])
ax["chi"].set_ylim([145, 5])
ax["chi"].set_yticks([125, 100, 75, 50, 25])
dcpy.plots.linex([1e-6, 6e-6], ax=ax["chi"])

ax["eps"].set_xlim([2e-9, 2e-5])
dcpy.plots.linex([5e-7, 1e-6, 2e-6], ax=ax["eps"])

_images/7cee935d5bb4c9bf1ac13bde33d8e956382e1854d8f6fb6a43ece3b6b08213e0.png

59m χpod sensor 2 is low, does not match Perlin & Moum.

tao_iop.chi1.sel(depth=58).plot(size=5, aspect=4)
tao_iop.chi2.sel(depth=58).plot(yscale="log")

[<matplotlib.lines.Line2D at 0x7fdcb8ee7a60>]

_images/83425e348b7732b1fbfa091e3cc5775741a50b578d9ae07cb417c7d41fef9250.png

Variations in \(Ri_f\), \(Γ\)#

Γ is potentially a large uncertainty in \(J_q^ε\). Lets try the analysis of Monismith et al (2016). Definitions:

\begin{align*} Ri_f &= \frac{B}{B + ε} \ Re_b &= \frac{ε}{νN^2} \ B &= \frac{χ}{2} \frac{N^2}{T_z^2} \ Γ &= \frac{Ri_f}{1 - Ri_f} \end{align*}

I’m calculating gradients after thorpe-sorting by ρ

I’ll look at EQUIX and TIWE.

equixρ = chamρ
equixρ.attrs["name"] = "EQUIX"
tiweρ.attrs["name"] = "TIWE"

pump.calc.add_mixing_diagnostics(equixρ)
pump.calc.add_mixing_diagnostics(tiweρ)

Simple \(Re_b\) vs \(Ri_f\) scatter plot suggest two parameter regimes. More clearly in EQUIX

figs = tuple(
    np.log10(ds[["Reb", "Rif"]]).hvplot.hexbin(
        x="Reb",
        y="Rif",
        by=["depth", "time"],
        cnorm="eq_hist",
        logz=True,
        cmap="fire_r",
        title=ds.attrs["name"],
        frame_width=300,
    )
    for ds in [equixρ, tiweρ]
)

figs[0] + figs[1]

chamρ.where(chamρ.depth < chamρ.eucmax).plot.scatter(y="Rif", x="Reb", s=1, alpha=0.05)
chamρ.where(chamρ.depth > chamρ.eucmax).plot.scatter(y="Rif", x="Reb", s=1, alpha=0.05)
plt.gca().set_xscale("log")
plt.gca().set_yscale("log")

_images/454b06eed1e40b7fad758982f51c3c2896031eba82fd2d56ad0d2d3be5cb220c.png

tiweρ.where(tiweρ.depth < tiweρ.eucmax).plot.scatter(y="Rif", x="Reb", s=1, alpha=0.05)
tiweρ.where(tiweρ.depth > tiweρ.eucmax).plot.scatter(y="Rif", x="Reb", s=1, alpha=0.05)
plt.gca().set_xscale("log")
plt.gca().set_yscale("log")

_images/e0ae066a54c5eb984fc987832140f83e8e8d283dc100ab371cbcac067d4b6510.png

TIWE#

tiwe["Jq_ε"] = (
    1025
    * 4000
    * 0.2
    * tiwe.eps.where(tiwe.eps < 1e-5)
    / tiwe.N2.where(tiwe.N2 > 1e-6)
    * tiwe.dTdz.where(tiwe.dTdz > 1e-4)
)
tiwe["Jq_χ"] = (
    1025
    * 4000
    * tiwe.chi.where(tiwe.eps < 1e-5)
    / 2
    / tiwe.dTdz.where(np.abs(tiwe.sortT.diff("depth")) > 1e-3)
)

tiwe.Jq.sel(depth=slice(11, None)).mean("time").cf.plot(y="depth")
tiwe.Jq_ε.mean("time").cf.plot(y="depth")
tiwe.Jq_χ.mean("time").cf.plot(
    y="depth", yincrease=False, xscale="linear", xlim=(0, 120), ylim=(200, 0)
)

[<matplotlib.lines.Line2D at 0x7faa0e310190>]

_images/353d5b84e5941799a6cee6859ca6fd0b418427e92ba1f55f6437e724db2e445c.png

pump.plot.plot_mixing_diagnostics_timeseries(equixρ)
pump.plot.plot_mixing_diagnostics_timeseries(tiweρ)

_images/6387074b93e9803c28bc1e0e610dc937e2ad6e0d44bce12d3bbc7571e445d5c6.png

_images/4582ce11790ac16c5605f00f91d68dc7cf13ca64acfa0f67e52391411dcac98c.png

equixρ.Sh2.cf.plot(x="time", robust=True)

<matplotlib.collections.QuadMesh at 0x7f873fbb0a90>

_images/00b6514ba596c2a50feecc0c84ddc2569ae355f4e486f3bf9e3a6fb54b985665.png

Reproducing Perlin & Moum (2012)#

I’m tuning max allowable χ, ε to visually match Perlin & Moum

Deepest 2 TAO χpods seem to be at wrong depths
TAO at 18m, 75m is too low.
~Need to save both sensors separately. If I did average then that’s an issue here.~ I did not average, just followed the comment and always picked sensor 1.

TODO:

Find all other sensor 2 data for EQUIX.
See if I can find Sasha’s merged files

f, ax = plt.subplots(1, 2, sharey=True)

for axx, var in zip(ax.flat, ["chi", "eps"]):
    cham[var].where((cham.chi < 1e-2) & (cham.eps < 6e-5)).mean("time").cf.plot(
        xscale="log", xlim=(1e-7, 1e-5), ylim=(140, 10), color="k", ax=axx
    )
    iop[var].mean("time").plot(
        y="depth", marker=".", color="r", ls="none", ms=8, ax=axx
    )
    tao_iop[var].mean("time").plot(
        y="depth", marker=".", color="b", ls="none", ms=8, ax=axx
    )
    tao_iop[var + "2"].mean("time").plot(
        y="depth", marker="o", color="b", ls="none", ms=8, ax=axx, fillstyle="none"
    )


ax[0].set_yticks([25, 50, 75, 100, 125])
dcpy.plots.liney(25, ax=ax[0])
dcpy.plots.linex([1e-6, 5e-6], ax=ax[0])
dcpy.plots.linex([5e-7, 1e-6, 2e-6], ax=ax[1])

_images/9fe081fa2e49a5577e6b7645d338c609cdc68b6e492b7bff67b282dd9ae54ba8.png

Tz, N2#

f, axx = plt.subplots(1, 2, sharey=True, constrained_layout=True)
ax = dict(zip(["dTdz", "N2"], axx))

for var in ax:
    if var == "dTdz":
        (-1 * cham[var]).mean("time").cf.plot(
            ls="--", xscale="log", color="k", ax=ax[var], label="cham"
        )
    if var == "N2":
        (4 * cham["N2"]).mean("time").cf.plot(
            ls="--", xscale="log", color="k", ax=ax[var], label="cham"
        )
    if var != "N2":
        iop[var].mean("time").cf.plot(
            marker=".", ls="none", label="IOP", color="r", ax=ax[var]
        )
        tao_iop[var].mean("time").cf.plot(
            marker=".", color="b", ls="none", label="TAO", ax=ax[var]
        )
    if var == "N2":
        (4 * cham["NT2"]).mean("time").cf.plot(
            ls="-", label="cham $N_T^2$", color="k", ax=ax[var]
        )
        (4 * iop["NT2"]).mean("time").cf.plot(
            marker=".", ls="none", label="IOP $N_T^2$", color="r", ax=ax[var]
        )
        (4 * tao_iop["NT21"]).mean("time").cf.plot(
            marker=".", color="b", ls="none", label="TAO $N_T^2$", ax=ax[var]
        )
        (4 * tao_iop["NT22"]).mean("time").cf.plot(
            marker=".", color="b", ls="none", ax=ax[var]
        )

    ax[var].legend()
ax["N2"].set_xlabel("$4N^2$")
ax["N2"].set_ylim([145, 15])
ax["dTdz"].set_yticks([125, 100, 75, 50, 25])
# ax["dTdz"].set_xlim([7.5e-4, 2e-3])
ax["N2"].set_xlim([7.5e-5, 2e-3])

(7.5e-05, 0.002)

_images/c455af423728e51d941bbe987465575941718dcbf191ab7c23b2eaab8b7f91d8.png

Explorations#

cham5m = cham.copy(deep=True)
cham5m["dTdz"] = cham5m.sortT.differentiate("depth")
# cham5m["dTdz"] = cham5m.theta.diff("depth")# / cham5m.depth.diff("depth")
# cham5m["dTdz"] = cham5m.dTdz.where(np.abs(cham5m.dTdz) > 5e-3)
cham5m["N2"] = 9.81 / 1025 * cham5m.pden.differentiate("depth")

cham5m = cham5m.where((cham5m.N2 > 5e-6) & (np.abs(cham5m.dTdz) > 1e-3))
# cham5m["N2"] = np.abs(cham5m.N2.where(cham5m.N2 > 5e-6))

cham5m["KT"] = (
    cham5m.chi / 2 / cham5m.dTdz**2
)  # .where(np.abs(cham5m.dTdz) > 1e-3) ** 2
cham5m.KT.attrs = {"long_name": "$K_T$", "units": "m²/s"}
cham5m["Kρ"] = 0.2 * cham5m.eps / cham5m.N2
cham5m.Kρ.attrs = {"long_name": "$K_ρ$", "units": "m²/s"}
cham5m.chi.where(cham5m.chi < 1e-3)

cham5m["Jq_χ"] = 1025 * 4000 * cham5m.KT * cham5m.dTdz
cham5m.Jq_χ.attrs = {"long_name": "$J_q^χ$", "units": "W/m²"}
cham5m["Jq_ε"] = 1025 * 4000 * cham5m.Kρ * cham5m.dTdz
cham5m.Jq_ε.attrs = {"long_name": "$J_q^ε$", "units": "W/m²"}

cham5m.KT.plot.hist(
    bins=np.logspace(-7, -1, 35),
    xscale="log",
    histtype="step",
    density=True,
    label="$K_T$",
)
cham5m.Kρ.plot.hist(
    bins=np.logspace(-7, -1, 35),
    histtype="step",
    xscale="log",
    density=True,
    label="$K_ρ$",
)
plt.legend()

<matplotlib.legend.Legend at 0x7faa0b1a6a60>

_images/aab9a784f7fac7e87c84c499855f358db2dd5b725a6e1f35fe59d23e86ee19af.png

(4e6 * cham5m.KT * cham5m.dTdz).plot.hist(
    yscale="log", bins=np.linspace(-1500, 1500, 100), histtype="step", label="$J_q^χ$"
)
(4e6 * cham5m.Kρ * cham5m.dTdz).plot.hist(
    yscale="log", bins=np.linspace(-1500, 1500, 100), histtype="step", label="$J_q^ε$"
)
plt.legend()

<matplotlib.legend.Legend at 0x7fa9f6383670>

_images/57ae8b5da7a1fde65c88df74dd786cdeb567502a0b93266693aa903d61bb5ece.png

f, axx = plt.subplots(1, 2, sharey=True, constrained_layout=True)

cham5m.KT.mean("time").cf.plot(ax=axx[0], label="$K_T$")
cham5m.Kρ.mean("time").cf.plot(xscale="log", ax=axx[0], label="$K_ρ$")

cham5m.Jq_χ.where(cham5m.dTdz < 0).mean("time").cf.plot(ax=axx[1], label="$J_q^χ$")
cham5m.Jq_ε.where(cham5m.dTdz < 0).mean("time").cf.plot(
    xlim=(-700, 0), ax=axx[1], label="$J_q^ε$"
)

[ax.legend() for ax in axx.flat]

[<matplotlib.legend.Legend at 0x7fa9f814ab50>,
 <matplotlib.legend.Legend at 0x7fab86ba9340>]

_images/9c5b1714140f9e9cf4fb7906718054ba2b6727df60dcb43feac3967291a76ece.png

Old Stuff#

Test thorpe sorting#

import pandas as pd

time = pd.Timestamp("2008-11-03 04:00:00")

profile = cham.sel(time=[time], method="nearest")
profile.theta.plot(hue="time")
thorpesort(profile.theta, profile.theta, ascending=False).plot(hue="time", marker=".")
thorpesort(profile.theta, profile.pden, ascending=True).plot(hue="time", marker="x")

[<matplotlib.lines.Line2D at 0x7fabc7d716a0>]

_images/dea80b0244afeff97e4fbc45011a73a403e047731792494281b4eca6c20e68ac.png

time = pd.Timestamp("2008-11-03 04:00:00")

theta_old.sel(time=time, method="nearest").plot()
theta_old.sel(time=time, method="nearest").plot(color="k", marker=".")
cham.theta.sel(time=time, method="nearest").plot(color="blue", marker="^")
cham.sortT.sel(time=time, method="nearest").plot()
cham.sortTbyT.sel(time=time, method="nearest").plot(color="r")

[<matplotlib.lines.Line2D at 0x7faba6b77640>]

_images/1a85dad0eec43d1c38008a0b82f4a981c56609be3402ed10b5a380b68ef266e2.png

Chameleon heat flux χ vs ε

Contents

Chameleon heat flux χ vs ε#

Read datasets#

EQUIX Chameleon#

On masking#

On sorting and calculating gradients#

Comparing gradients#

EQUIX χpods#

TIWE chameleon#