Height scale for SkewT

[dopplershift]

Should be a standalone graphical element, secondary scale that pulls from the standard atmosphere conversion function we have. Should be do-able modelling off of some of matplotlib's examples with multiple scales.

[guytcc]

Borrowing liberally from SkewT python 3 port, I added a height scale to a plot with the code below (the class is just a holder). Most would be easy to port into Metpy.SkewT with some finagling.

Two obvious problems would need to be worked out:

1. The axis for height doesn't show up. I've tried a number of settings with no luck.
2. Better(smart?) positioning of the axes and wind barbs.

from metpy.units import units

class Sondes(object):
    def __init__(self, sounding, dt):
        self.file = sounding
        self.dt = dt
        self.dt_str = dt.strftime('%Y-%m-%d %HZ')

        self.p = sounding.variables['pressure'][:]
        self.T = sounding.variables['temperature'][:]
        self.Td = sounding.variables['dewpoint'][:]
        self.u = sounding.variables['u_wind'][:]
        self.v = sounding.variables['v_wind'][:]

        # Calculate the parcel profile.
        self.H = mpcalc.pressure_to_height_std(self.p)
        self.zero_levs = mpcalc.find_intersections(self.H, self.T, np.zeros_like(self.T))

    def plot(self, fig=None, xlims=None, ylims=None, plot_barbs=False, bold_temp=None, add_height=False):
        if fig is None:
            fig = plt.figure(figsize=(7, 7))
        skew = SkewT(fig)
        _ = skew.ax.set_title(self.dt_str)
        _ = skew.ax.set_ylim(ylims)

        skew.plot(self.p, self.T, 'r', linewidth=2)
        skew.plot(self.p, self.Td, 'g', linewidth=2)

        if bold_temp is not None:
            for temp in bold_temp:
                skew.ax.axvline(temp, color='c', linestyle='--', linewidth=2)

        if plot_barbs:
            _ = skew.plot_barbs(self.p, self.u, self.v)

        # This order of plotting matters
        _ = skew.ax.set_xlim(xlims)
            
        if add_height:
            majorLocatorKM = MultipleLocator(1)
            majorLocatorKFT = MultipleLocator(5)
            minorLocator = MultipleLocator(1)

            plims = skew.ax.get_ylim() * units('hectopascal')
            zmin = mpcalc.pressure_to_height_std(plims[0]).magnitude
            zmax = mpcalc.pressure_to_height_std(plims[1]).magnitude
            zminf = zmin * 3.2808
            zmaxf = zmax * 3.2808

            kmhax = fig.add_axes([0.775, 0.1, 1e-6, 0.8], frameon=True)
            kmhax.xaxis.set_ticks([], [])
            kmhax.spines['left'].set_color('k')
            kmhax.spines['right'].set_visible(False)
            kmhax.tick_params(axis='y', colors='k', labelsize=8)
            kmhax.set_ylim(zmin, zmax)
            kmhax.set_title("km/kft", fontsize=10)
            kmhax.get_yaxis().set_tick_params(which="both", direction='out')
            kmhax.yaxis.set_major_locator(majorLocatorKM)
            kmhax.yaxis.set_minor_locator(minorLocator)

            fthax = kmhax.twinx()
            fthax.xaxis.set_ticks([], [])
            fthax.tick_params(axis='y', colors='k', labelsize=8)
            fthax.set_ylim(zminf, zmaxf)
            fthax.get_yaxis().set_tick_params(which="both", direction='out')
            fthax.yaxis.set_major_locator(majorLocatorKFT)
            fthax.yaxis.set_minor_locator(minorLocator)
        return skew

[dopplershift]

Thanks for digging that up! A few comments:

1. I'd really like to have it separated from the plotting call
2. In an ideal world, it'd be dynamically updated from the y-axis in pressure coords. I'm not sure if a
   matplotlib spine is enough, or if maybe we do need the separate Axes, but we use matplotlib's event
   handling to update the range on the height scale
3. I don't think the scaling for heights is correct. Pressure is plotted with log scaling, but I don't see any
   log scaling associated with the heights.

[guytcc]

I may misunderstand, but I just want to note that the plot in the class above is not equivalent to the plot in Metpy.SkewT, but is a handler that basically does most things from the individual examples. I'm sure matplotlib event handling could be used for dynamic updates, but I'd have to look into that, since the values for the heights are computed from the limits of the plot maybe this would be easier. (?)

I'm open to another method. Just went the "easy" route of least resistance (development).

The scaline for the heights is a linear scale. I made no attempt to have a logarithmic axis as we often don't think of altitude the same way we do atmospheric pressure.

[dopplershift]

So what I'd want to merge is a patch that adds a method to the SkewT class that allows the user to turn on the height scale bar.

As far as the scaling is concerned, I think there's some confusion. You start by taking the pressure values and converting them to heights--no problem here. When we make the skewT, pressure is logarithmically spaced (not changing the values) along the y-axis. If you want the heights to properly align with the pressure values, the height axis has to be logarithmically scaled as well.

[dopplershift]

Nevermind, I mis-read the code before. I see what's going on and everything is aligned just fine.