Exemple #1
0
    def plot(self, ax):

        # Get global u/v wind data
        ug, vg = self.chart.get_data(self.gfs_vars, apply_domain=False)

        # Get level coordinates for U/V wind components
        ug_lv_coord = gfs_utils.get_level_coord(ug, self.level_units)
        vg_lv_coord = gfs_utils.get_level_coord(vg, self.level_units)

        # Constrain to specified level(s)
        ugc = gfs_utils.get_coord_constraint(ug_lv_coord.name(), self.level)
        ug = ug.extract(ugc)

        vgc = gfs_utils.get_coord_constraint(vg_lv_coord.name(), self.level)
        vg = vg.extract(vgc)

        # Apply smoothing
        ug_data = wrf_smooth2d(ug.data, 6)
        ug.data = ug_data.data
        vg_data = wrf_smooth2d(vg.data, 6)
        vg.data = vg_data.data

        # Set up windspharm wind vector object
        w = VectorWind(ug, vg)

        # Get nondivergent component of wind
        upsi, vpsi = w.nondivergentcomponent()
        Vpsi = VectorWind(upsi, vpsi)

        # Partition streamfunction vorticity into curvature and shear
        # components

        # Bell and Keyser 1993 Appendix equation A.3b
        # Relative curvature vorticity:
        # V dalpha/ds = 1/V^2[u^2 dv/dx - v^2 du/dy - uv(du/dx - dv/dy)]

        dupsi_dx, dupsi_dy = Vpsi.gradient(upsi)
        dvpsi_dx, dvpsi_dy = Vpsi.gradient(vpsi)
        ws = Vpsi.magnitude()

        vrt = (upsi**2 * dvpsi_dx - vpsi**2 * dupsi_dy - upsi * vpsi *
               (dupsi_dx - dvpsi_dy)) / ws**2

        # Calculate advection of non-divergent curvature vorticity
        dvrt_dx, dvrt_dy = Vpsi.gradient(vrt)
        advec = -1 * (upsi * dvrt_dx + vpsi * dvrt_dy)

        # Second order advection term needed for masking
        dadv_dx, dadv_dy = Vpsi.gradient(advec)
        advec2 = upsi * dadv_dx + vpsi * dadv_dy

        # Apply domain constraint
        domain_constraint = gfs_utils.get_domain_constraint(self.chart.domain)
        upsi = upsi.extract(domain_constraint)
        vrt = vrt.extract(domain_constraint)
        advec = advec.extract(domain_constraint)
        advec2 = advec2.extract(domain_constraint)

        # Masking rules from Berry & Thorncroft 2007, Table 1

        # A1. Mask streamfunction curvature vorticity to exclude AEW
        # ridges axes or weak systems (BT2007: K1T = 0.5 * 10^-5 s^-1)
        K1T = 1.5 * 10**-5  # s^-1
        m1t = vrt.data <= K1T  # mask for troughs
        m1r = vrt.data >= -K1T  # mask for ridges

        # A2. Remove "pseudoridge" axes in nondivergent flow that is
        # highly cyclonically curved
        K2T = 0  # m s^-3
        m2 = advec2.data <= K2T

        # A3. Removes trough axes in westerly flow
        K3T = 0  # m s^-1
        m3 = upsi.data >= K3T

        trough_mask = m1t | m2 | m3
        ridge_mask = m1r | ~m2 | m3

        troughs = self.apply_size_mask(trough_mask, advec.data)
        ridges = self.apply_size_mask(ridge_mask, advec.data)

        # Plot troughs and ridges
        ax.contour(self.lon, self.lat, troughs, levels=0, **self.options)
        ax.contour(self.lon,
                   self.lat,
                   ridges,
                   levels=0,
                   **self.options,
                   linestyles="dotted")