예제 #1
0
def test_cross_section_error_on_missing_coordinate(test_ds_lonlat):
    """Test that the proper error is raised with missing coordinate."""
    # Use a variable with no crs coordinate
    data_bad = test_ds_lonlat['temperature'].copy()
    del data_bad['crs']
    start, end = (30.5, 255.5), (44.5, 274.5)

    with pytest.raises(ValueError):
        cross_section(data_bad, start, end)
예제 #2
0
def test_cross_section_error_on_missing_coordinate(test_ds_lonlat):
    """Test that the proper error is raised with missing coordinate."""
    # Use a variable with no crs coordinate
    data_bad = test_ds_lonlat['temperature'].copy()
    del data_bad['crs']
    start, end = (30.5, 255.5), (44.5, 274.5)

    with pytest.raises(ValueError):
        cross_section(data_bad, start, end)
예제 #3
0
def test_cross_section_dataarray_and_linear_interp(test_ds_xy):
    """Test the cross_section function with a data array and linear interpolation."""
    data = test_ds_xy['temperature']
    start, end = ((36.46, -112.45), (42.95, -68.74))
    data_cross = cross_section(data, start, end, steps=7)
    truth_values = np.array([[[250.00095489, 251.53646673, 253.11586664, 254.73477364,
                               256.38991013, 258.0794356, 259.80334269],
                              [260.04880178, 261.58431362, 263.16371353, 264.78262053,
                               266.43775702, 268.12728249, 269.85118958],
                              [270.09664867, 271.63216051, 273.21156042, 274.83046742,
                               276.48560391, 278.17512938, 279.89903647],
                              [280.14449556, 281.6800074, 283.25940731, 284.87831431,
                               286.5334508, 288.22297627, 289.94688336],
                              [290.19234245, 291.72785429, 293.3072542, 294.9261612,
                               296.58129769, 298.27082316, 299.99473025]]])
    truth_values_x = np.array([-499495.71907062, 98404.43537514, 688589.09865512,
                               1272690.44926197, 1852009.73516881, 2427525.45740665,
                               2999932.89862589])
    truth_values_y = np.array([-1499865.98780602, -1268717.36799267, -1029139.66048478,
                               -782037.60343652, -528093.95678826, -267710.32566917,
                               -939.10769171])
    index = xr.DataArray(range(7), name='index', dims=['index'])

    data_truth_x = xr.DataArray(
        truth_values_x,
        name='x',
        coords={
            'crs': data['crs'],
            'y': (['index'], truth_values_y),
            'x': (['index'], truth_values_x),
            'index': index,
        },
        dims=['index']
    )
    data_truth_y = xr.DataArray(
        truth_values_y,
        name='y',
        coords={
            'crs': data['crs'],
            'y': (['index'], truth_values_y),
            'x': (['index'], truth_values_x),
            'index': index,
        },
        dims=['index']
    )
    data_truth = xr.DataArray(
        truth_values * units.kelvin,
        name='temperature',
        coords={
            'time': data['time'],
            'isobaric': data['isobaric'],
            'index': index,
            'crs': data['crs'],
            'y': data_truth_y,
            'x': data_truth_x
        },
        dims=['time', 'isobaric', 'index']
    )

    xr.testing.assert_allclose(data_truth, data_cross)
예제 #4
0
def test_cross_section_dataset_and_nearest_interp(test_ds_lonlat):
    """Test the cross_section function with a dataset and nearest interpolation."""
    start, end = (30.5, 255.5), (44.5, 274.5)
    data_cross = cross_section(test_ds_lonlat, start, end, steps=7, interp_type='nearest')
    nearest_values = test_ds_lonlat.isel(lat=xr.DataArray([0, 1, 2, 3, 3, 4, 5], dims='index'),
                                         lon=xr.DataArray(range(7), dims='index'))
    truth_temp = nearest_values['temperature'].metpy.unit_array
    truth_rh = nearest_values['relative_humidity'].metpy.unit_array
    truth_values_lon = np.array([255.5, 258.20305939, 261.06299342, 264.10041516,
                                 267.3372208, 270.7961498, 274.5])
    truth_values_lat = np.array([30.5, 33.02800969, 35.49306226, 37.88512911, 40.19271688,
                                 42.40267088, 44.5])
    index = xr.DataArray(range(7), name='index', dims=['index'])

    data_truth = xr.Dataset(
        {
            'temperature': (['isobaric', 'index'], truth_temp),
            'relative_humidity': (['isobaric', 'index'], truth_rh)
        },
        coords={
            'isobaric': test_ds_lonlat['isobaric'],
            'index': index,
            'crs': test_ds_lonlat['crs'],
            'lat': (['index'], truth_values_lat),
            'lon': (['index'], truth_values_lon)
        },
    )

    xr.testing.assert_allclose(data_truth, data_cross)
예제 #5
0
def plot_rh(ds, model):
    data = ds.metpy.parse_cf()
    data['lon'] = np.mod(ds.lon - 180.0, 360.0) - 180.0
    start = (35., -120)
    end = (35., -90)
    cross = cross_section(data, start, end)

    fig = plt.figure(1, figsize=(10., 10.))
    ax = plt.axes()

    cf = ax.contourf(cross['lon'], cross['isobaric'], cross['Relative_humidity_isobaric'],
                     levels=np.arange(-18, 20, 2), cmap='Spectral_r')

    # Contour Fill the RH Values
    cb = plt.colorbar(cf, orientation='vertical')
    cb.set_label('Change in RH (%)')

    # Contour the U-Component of Wind
    clevs_500_hght = np.arange(4, 10, .5)
    cs = ax.contour(cross['lon'], cross['isobaric'], cross['air_temperature'], clevs_500_hght, colors='black')
    plt.clabel(cs, fmt='%d')

    ax.set_yscale('symlog')
    ax.set_yticklabels([1000, 850, 700, 500, 400, 300, 250, 200])
    ax.set_ylim(1000, 200)
    ax.set_yticks([1000, 850, 700, 500, 400, 300, 250, 200])
    ax.set_xlim(cross['lon'].min(), cross['lon'].max())
    plt.title('Delta RH (Filled) and Delta Temperature (Contoured) ' + model)
    plt.savefig('RH_Delta_' + model + '.png', dpi=200)
    return plt.show()
예제 #6
0
def test_cross_lonlat():
    """Return cross section on a lon/lat grid with no time coordinate for use in tests."""
    data_u = np.linspace(-40, 40, 5 * 6 * 7).reshape((5, 6, 7))
    data_v = np.linspace(40, -40, 5 * 6 * 7).reshape((5, 6, 7))
    ds = xr.Dataset(
        {
            'u_wind': (['isobaric', 'lat', 'lon'], data_u),
            'v_wind': (['isobaric', 'lat', 'lon'], data_v)
        },
        coords={
            'isobaric': xr.DataArray(
                np.linspace(1000, 500, 5),
                name='isobaric',
                dims=['isobaric'],
                attrs={'units': 'hPa'}
            ),
            'lat': xr.DataArray(
                np.linspace(30, 45, 6),
                name='lat',
                dims=['lat'],
                attrs={'units': 'degrees_north'}
            ),
            'lon': xr.DataArray(
                np.linspace(255, 275, 7),
                name='lon',
                dims=['lon'],
                attrs={'units': 'degrees_east'}
            )
        }
    )
    ds['u_wind'].attrs['units'] = 'knots'
    ds['v_wind'].attrs['units'] = 'knots'

    start, end = (30.5, 255.5), (44.5, 274.5)
    return cross_section(ds.metpy.parse_cf(), start, end, steps=7, interp_type='nearest')
예제 #7
0
def test_cross_lonlat():
    """Return cross section on a lon/lat grid with no time coordinate for use in tests."""
    data_u = np.linspace(-40, 40, 5 * 6 * 7).reshape((5, 6, 7)) * units.knots
    data_v = np.linspace(40, -40, 5 * 6 * 7).reshape((5, 6, 7)) * units.knots
    ds = xr.Dataset(
        {
            'u_wind': (['isobaric', 'lat', 'lon'], data_u),
            'v_wind': (['isobaric', 'lat', 'lon'], data_v)
        },
        coords={
            'isobaric': xr.DataArray(
                np.linspace(1000, 500, 5),
                name='isobaric',
                dims=['isobaric'],
                attrs={'units': 'hPa'}
            ),
            'lat': xr.DataArray(
                np.linspace(30, 45, 6),
                name='lat',
                dims=['lat'],
                attrs={'units': 'degrees_north'}
            ),
            'lon': xr.DataArray(
                np.linspace(255, 275, 7),
                name='lon',
                dims=['lon'],
                attrs={'units': 'degrees_east'}
            )
        }
    )

    start, end = (30.5, 255.5), (44.5, 274.5)
    return cross_section(ds.metpy.parse_cf(), start, end, steps=7, interp_type='nearest')
예제 #8
0
def test_cross_section_dataset_and_nearest_interp(test_ds_lonlat):
    """Test the cross_section function with a dataset and nearest interpolation."""
    start, end = (30.5, 255.5), (44.5, 274.5)
    data_cross = cross_section(test_ds_lonlat, start, end, steps=7, interp_type='nearest')
    nearest_values = test_ds_lonlat.isel(lat=xr.DataArray([0, 1, 2, 3, 3, 4, 5], dims='index'),
                                         lon=xr.DataArray(range(7), dims='index'))
    truth_temp = nearest_values['temperature'].values
    truth_rh = nearest_values['relative_humidity'].values
    truth_values_lon = np.array([255.5, 258.20305939, 261.06299342, 264.10041516,
                                 267.3372208, 270.7961498, 274.5])
    truth_values_lat = np.array([30.5, 33.02800969, 35.49306226, 37.88512911, 40.19271688,
                                 42.40267088, 44.5])
    index = xr.DataArray(range(7), name='index', dims=['index'])

    data_truth = xr.Dataset(
        {
            'temperature': (['isobaric', 'index'], truth_temp),
            'relative_humidity': (['isobaric', 'index'], truth_rh)
        },
        coords={
            'isobaric': test_ds_lonlat['isobaric'],
            'index': index,
            'crs': test_ds_lonlat['crs'],
            'lat': (['index'], truth_values_lat),
            'lon': (['index'], truth_values_lon)
        },
    )

    xr.testing.assert_allclose(data_truth, data_cross)
예제 #9
0
 def interpolate_csec(self, plevs, start, end, steps=100):
     start = (start['lat'], start['lon'])
     end = (end['lat'], end['lon'])
     xp_interp = cross_section(self.__press_inter, start, end, steps=steps)
     for name, (d_arr, conf) in list(self.var_conf.items()):
         d_arr = cross_section(d_arr, start, end, steps=steps)
         d_arr_interp = log_interpolate_1d(plevs, xp_interp, d_arr)
         # Back to DataArray:
         d_arr_interp = xr.DataArray(data=d_arr_interp,
                                     dims=['plevs', 'index'],
                                     coords={'lat': ('index', d_arr['lat']),
                                             'lon': ('index', d_arr['lon']),
                                             'plevs': ('plevs', plevs),
                                             'index': ('index', d_arr['index'])},
                                     attrs=d_arr.attrs)  # Anpassen, nicht identisch
         # Change dict entry for interpolated values
         self.var_conf[name] = (d_arr_interp, conf)
예제 #10
0
def test_cross_xy():
    """Return cross section on a x/y grid with a time coordinate for use in tests."""
    data_u = np.linspace(-25, 25, 5 * 6 * 7).reshape((1, 5, 6, 7))
    data_v = np.linspace(25, -25, 5 * 6 * 7).reshape((1, 5, 6, 7))
    ds = xr.Dataset(
        {
            'u_wind': (['time', 'isobaric', 'y', 'x'], data_u),
            'v_wind': (['time', 'isobaric', 'y', 'x'], data_v),
            'lambert_conformal': ([], '')
        },
        coords={
            'time': xr.DataArray(
                np.array([np.datetime64('2018-07-01T00:00')]),
                name='time',
                dims=['time']
            ),
            'isobaric': xr.DataArray(
                np.linspace(1000, 500, 5),
                name='isobaric',
                dims=['isobaric'],
                attrs={'units': 'hPa'}
            ),
            'y': xr.DataArray(
                np.linspace(-1500, 0, 6),
                name='y',
                dims=['y'],
                attrs={'units': 'km'}
            ),
            'x': xr.DataArray(
                np.linspace(-500, 3000, 7),
                name='x',
                dims=['x'],
                attrs={'units': 'km'}
            )
        }
    )
    ds['u_wind'].attrs = ds['v_wind'].attrs = {
        'units': 'm/s',
        'grid_mapping': 'lambert_conformal'
    }
    ds['lambert_conformal'].attrs = {
        'grid_mapping_name': 'lambert_conformal_conic',
        'standard_parallel': 50.0,
        'longitude_of_central_meridian': -107.0,
        'latitude_of_projection_origin': 50.0,
        'earth_shape': 'spherical',
        'earth_radius': 6367470.21484375
    }

    start, end = ((36.46, -112.45), (42.95, -68.74))
    return cross_section(ds.metpy.parse_cf(), start, end, steps=7)
예제 #11
0
def test_absolute_momentum_xarray_units_attr():
    """Test absolute momentum when `u` and `v` are DataArrays with a `units` attribute."""
    data = xr.open_dataset(get_test_data('narr_example.nc', False))
    data = data.metpy.parse_cf().squeeze()

    start = (37.0, -105.0)
    end = (35.5, -65.0)
    cross = cross_section(data, start, end)

    u = cross['u_wind'][0].sel(index=slice(0, 2))
    v = cross['v_wind'][0].sel(index=slice(0, 2))

    momentum = absolute_momentum(u, v)
    true_momentum_values = np.array([137.46164031, 134.11450232, 133.85196023])
    true_momentum = xr.DataArray(units.Quantity(true_momentum_values, 'm/s'),
                                 coords=u.coords)

    assert_xarray_allclose(momentum, true_momentum)
예제 #12
0
def Crosssection_Wind_Temp_RH(
        initial_time=None,
        fhour=24,
        levels=[1000, 950, 925, 900, 850, 800, 700, 600, 500, 400, 300, 200],
        day_back=0,
        model='ECMWF',
        output_dir=None,
        st_point=[43.5, 111.5],
        ed_point=[33, 125.0],
        map_extent=[70, 140, 15, 55],
        h_pos=[0.125, 0.665, 0.25, 0.2]):

    # micaps data directory
    try:
        data_dir = [
            utl.Cassandra_dir(data_type='high',
                              data_source=model,
                              var_name='RH',
                              lvl=''),
            utl.Cassandra_dir(data_type='high',
                              data_source=model,
                              var_name='UGRD',
                              lvl=''),
            utl.Cassandra_dir(data_type='high',
                              data_source=model,
                              var_name='VGRD',
                              lvl=''),
            utl.Cassandra_dir(data_type='high',
                              data_source=model,
                              var_name='TMP',
                              lvl=''),
            utl.Cassandra_dir(data_type='high',
                              data_source=model,
                              var_name='HGT',
                              lvl='500'),
            utl.Cassandra_dir(data_type='surface',
                              data_source=model,
                              var_name='PSFC')
        ]
    except KeyError:
        raise ValueError('Can not find all directories needed')

    # get filename
    if (initial_time != None):
        filename = utl.model_filename(initial_time, fhour)
    else:
        filename = utl.filename_day_back_model(day_back=day_back, fhour=fhour)

    # retrieve data from micaps server
    rh = get_model_3D_grid(directory=data_dir[0][0:-1],
                           filename=filename,
                           levels=levels,
                           allExists=False)
    if rh is None:
        return
    rh = rh.metpy.parse_cf().squeeze()

    u = get_model_3D_grid(directory=data_dir[1][0:-1],
                          filename=filename,
                          levels=levels,
                          allExists=False)
    if u is None:
        return
    u = u.metpy.parse_cf().squeeze()

    v = get_model_3D_grid(directory=data_dir[2][0:-1],
                          filename=filename,
                          levels=levels,
                          allExists=False)
    if v is None:
        return
    v = v.metpy.parse_cf().squeeze()

    v2 = get_model_3D_grid(directory=data_dir[2][0:-1],
                           filename=filename,
                           levels=levels,
                           allExists=False)
    if v2 is None:
        return
    v2 = v2.metpy.parse_cf().squeeze()

    t = get_model_3D_grid(directory=data_dir[3][0:-1],
                          filename=filename,
                          levels=levels,
                          allExists=False)
    if t is None:
        return
    t = t.metpy.parse_cf().squeeze()

    gh = get_model_grid(data_dir[4], filename=filename)

    psfc = get_model_grid(data_dir[5], filename=filename)
    psfc = psfc.metpy.parse_cf().squeeze()

    mask1 = ((psfc['lon'] >= t['lon'].values.min()) &
             (psfc['lon'] <= t['lon'].values.max()) &
             (psfc['lat'] >= t['lat'].values.min()) &
             (psfc['lat'] <= t['lat'].values.max()))

    t2, psfc_bdcst = xr.broadcast(t['data'], psfc['data'].where(mask1,
                                                                drop=True))
    mask2 = (psfc_bdcst > -10000)
    psfc_bdcst = psfc_bdcst.where(mask2, drop=True)
    #psfc_bdcst=psfc_bdcst.metpy.parse_cf().squeeze()
    if t is None:
        return

    resolution = u['lon'][1] - u['lon'][0]
    x, y = np.meshgrid(u['lon'], u['lat'])

    dx, dy = mpcalc.lat_lon_grid_deltas(u['lon'], u['lat'])

    #rh=rh.rename(dict(lat='latitude',lon='longitude'))
    cross = cross_section(rh, st_point, ed_point)
    cross_rh = cross.set_coords(('lat', 'lon'))
    cross = cross_section(u, st_point, ed_point)
    cross_u = cross.set_coords(('lat', 'lon'))
    cross = cross_section(v, st_point, ed_point)
    cross_v = cross.set_coords(('lat', 'lon'))

    cross_psfc = cross_section(psfc_bdcst, st_point, ed_point)
    #cross_psfc=cross.set_coords(('lat', 'lon'))

    cross_u['data'].attrs['units'] = units.meter / units.second
    cross_v['data'].attrs['units'] = units.meter / units.second
    cross_u['t_wind'], cross_v['n_wind'] = mpcalc.cross_section_components(
        cross_u['data'], cross_v['data'])

    cross = cross_section(t, st_point, ed_point)
    cross_Temp = cross.set_coords(('lat', 'lon'))

    cross_Td = mpcalc.dewpoint_rh(cross_Temp['data'].values * units.celsius,
                                  cross_rh['data'].values * units.percent)

    rh, pressure = xr.broadcast(cross_rh['data'], cross_Temp['level'])
    cross_terrain = pressure - cross_psfc

    crossection_graphics.draw_Crosssection_Wind_Temp_RH(
        cross_rh=cross_rh,
        cross_Temp=cross_Temp,
        cross_u=cross_u,
        cross_v=cross_v,
        cross_terrain=cross_terrain,
        gh=gh,
        h_pos=h_pos,
        st_point=st_point,
        ed_point=ed_point,
        levels=levels,
        map_extent=map_extent,
        model=model,
        output_dir=output_dir)
예제 #13
0
def Crosssection_Wind_Temp_RH(
    initTime=None, fhour=24,
    levels=[1000, 950, 925, 900, 850, 800, 700,600,500,400,300,200],
    day_back=0,model='ECMWF',data_source='MICAPS',
    output_dir=None,
    st_point = [43.5, 111.5],
    ed_point = [33, 125.0],
    map_extent=[70,140,15,55],
    lw_ratio=[16,9],
    h_pos=[0.125, 0.665, 0.25, 0.2],**kwargs ):

    if(data_source == 'MICAPS'):
        try:
            data_dir = [utl.Cassandra_dir(data_type='high',data_source=model,var_name='RH',lvl=''),
                        utl.Cassandra_dir(data_type='high',data_source=model,var_name='UGRD',lvl=''),
                        utl.Cassandra_dir(data_type='high',data_source=model,var_name='VGRD',lvl=''),
                        utl.Cassandra_dir(data_type='high',data_source=model,var_name='TMP',lvl=''),
                        utl.Cassandra_dir(data_type='high',data_source=model,var_name='HGT',lvl='500'),
                        utl.Cassandra_dir(data_type='surface',data_source=model,var_name='PSFC')]
        except KeyError:
            raise ValueError('Can not find all directories needed')

        if(initTime != None):
            filename = utl.model_filename(initTime, fhour)
        else:
            filename=utl.filename_day_back_model(day_back=day_back,fhour=fhour)
            
        rh=get_model_3D_grid(directory=data_dir[0][0:-1],filename=filename,levels=levels, allExists=False)
        u=get_model_3D_grid(directory=data_dir[1][0:-1],filename=filename,levels=levels, allExists=False)
        v=get_model_3D_grid(directory=data_dir[2][0:-1],filename=filename,levels=levels, allExists=False)
        t=get_model_3D_grid(directory=data_dir[3][0:-1],filename=filename,levels=levels, allExists=False)
        gh=get_model_grid(data_dir[4], filename=filename)
        psfc=get_model_grid(data_dir[5], filename=filename)

    if(data_source == 'CIMISS'):
        if(initTime != None):
            filename = utl.model_filename(initTime, fhour,UTC=True)
        else:
            filename=utl.filename_day_back_model(day_back=day_back,fhour=fhour,UTC=True)
            
        try:
            rh=CMISS_IO.cimiss_model_3D_grid(init_time_str='20'+filename[0:8],valid_time=fhour,
                        data_code=utl.CMISS_data_code(data_source=model,var_name='RHU'),
                        fcst_levels=levels, fcst_ele="RHU", units='%')

            u=CMISS_IO.cimiss_model_3D_grid(init_time_str='20'+filename[0:8],valid_time=fhour,
                        data_code=utl.CMISS_data_code(data_source=model,var_name='WIU'),
                        fcst_levels=levels, fcst_ele="WIU", units='m/s')
                
            v=CMISS_IO.cimiss_model_3D_grid(init_time_str='20'+filename[0:8],valid_time=fhour,
                        data_code=utl.CMISS_data_code(data_source=model,var_name='WIV'),
                        fcst_levels=levels, fcst_ele="WIV", units='m/s')

            t=CMISS_IO.cimiss_model_3D_grid(init_time_str='20'+filename[0:8],valid_time=fhour,
                        data_code=utl.CMISS_data_code(data_source=model,var_name='TEM'),
                        fcst_levels=levels, fcst_ele="TEM", units='K')
            t['data'].values=t['data'].values-273.15

            gh=CMISS_IO.cimiss_model_by_time('20'+filename[0:8],valid_time=fhour,
                        data_code=utl.CMISS_data_code(data_source=model,var_name='GPH'),
                        fcst_level=500, fcst_ele="GPH", units='gpm')
            gh['data'].values=gh['data'].values/10.

            psfc=CMISS_IO.cimiss_model_by_time('20'+filename[0:8], valid_time=fhour,
                        data_code=utl.CMISS_data_code(data_source=model,var_name='PRS'),
                        fcst_level=0, fcst_ele="PRS", units='Pa')
            psfc['data']=psfc['data']/100.

        except KeyError:
            raise ValueError('Can not find all data needed') 

    rh = rh.metpy.parse_cf().squeeze()
    u = u.metpy.parse_cf().squeeze()
    v = v.metpy.parse_cf().squeeze()
    t = t.metpy.parse_cf().squeeze()
    psfc=psfc.metpy.parse_cf().squeeze()

    #if(psfc['lon'].values[0] != t['lon'].values[0]):
    mask1 = (
            (psfc['lon']>=t['lon'].values.min())&
            (psfc['lon']<=t['lon'].values.max())&
            (psfc['lat']>=t['lat'].values.min())&
            (psfc['lat']<=t['lat'].values.max())
            )

    t2,psfc_bdcst=xr.broadcast(t['data'],psfc['data'].where(mask1, drop=True))
    mask2=(psfc_bdcst > -10000)
    psfc_bdcst=psfc_bdcst.where(mask2, drop=True)
    #else:
    #    psfc_bdcst=psfc['data'].copy

    resolution=u['lon'][1]-u['lon'][0]
    x,y=np.meshgrid(u['lon'], u['lat'])

    dx,dy=mpcalc.lat_lon_grid_deltas(u['lon'],u['lat'])

    cross = cross_section(rh, st_point, ed_point)
    cross_rh=cross.set_coords(('lat', 'lon'))
    cross = cross_section(u, st_point, ed_point)
    cross_u=cross.set_coords(('lat', 'lon'))
    cross = cross_section(v, st_point, ed_point)
    cross_v=cross.set_coords(('lat', 'lon'))
    
    cross_psfc = cross_section(psfc_bdcst, st_point, ed_point)

    cross_u['data'].attrs['units']=units.meter/units.second
    cross_v['data'].attrs['units']=units.meter/units.second
    cross_u['t_wind'], cross_v['n_wind'] = mpcalc.cross_section_components(cross_u['data'],cross_v['data'])
    
    cross = cross_section(t, st_point, ed_point)
    cross_Temp=cross.set_coords(('lat', 'lon'))

    cross_Td = mpcalc.dewpoint_rh(cross_Temp['data'].values*units.celsius,
                cross_rh['data'].values* units.percent)

    rh,pressure = xr.broadcast(cross_rh['data'],cross_Temp['level'])
    cross_terrain=pressure-cross_psfc

    crossection_graphics.draw_Crosssection_Wind_Temp_RH(
                    cross_rh=cross_rh, cross_Temp=cross_Temp, cross_u=cross_u,
                    cross_v=cross_v,cross_terrain=cross_terrain,gh=gh,
                    h_pos=h_pos,st_point=st_point,ed_point=ed_point,lw_ratio=lw_ratio,
                    levels=levels,map_extent=map_extent,model=model,
                    output_dir=output_dir)
예제 #14
0
def Crosssection_Wind_Theta_e_Qv(
        initial_time=None,
        fhour=24,
        levels=[1000, 950, 925, 900, 850, 800, 700, 600, 500, 400, 300, 200],
        day_back=0,
        model='ECMWF',
        output_dir=None,
        st_point=[20, 120.0],
        ed_point=[50, 130.0],
        map_extent=[70, 140, 15, 55],
        h_pos=[0.125, 0.665, 0.25, 0.2]):

    # micaps data directory
    try:
        data_dir = [
            utl.Cassandra_dir(data_type='high',
                              data_source=model,
                              var_name='RH',
                              lvl=''),
            utl.Cassandra_dir(data_type='high',
                              data_source=model,
                              var_name='UGRD',
                              lvl=''),
            utl.Cassandra_dir(data_type='high',
                              data_source=model,
                              var_name='VGRD',
                              lvl=''),
            utl.Cassandra_dir(data_type='high',
                              data_source=model,
                              var_name='TMP',
                              lvl=''),
            utl.Cassandra_dir(data_type='high',
                              data_source=model,
                              var_name='HGT',
                              lvl='500')
        ]
    except KeyError:
        raise ValueError('Can not find all directories needed')

    # get filename
    if (initial_time != None):
        filename = utl.model_filename(initial_time, fhour)
    else:
        filename = utl.filename_day_back_model(day_back=day_back, fhour=fhour)

    # retrieve data from micaps server
    rh = get_model_3D_grid(directory=data_dir[0][0:-1],
                           filename=filename,
                           levels=levels,
                           allExists=False)
    if rh is None:
        return
    rh = rh.metpy.parse_cf().squeeze()

    u = get_model_3D_grid(directory=data_dir[1][0:-1],
                          filename=filename,
                          levels=levels,
                          allExists=False)
    if u is None:
        return
    u = u.metpy.parse_cf().squeeze()

    v = get_model_3D_grid(directory=data_dir[2][0:-1],
                          filename=filename,
                          levels=levels,
                          allExists=False)
    if v is None:
        return
    v = v.metpy.parse_cf().squeeze()

    v2 = get_model_3D_grid(directory=data_dir[2][0:-1],
                           filename=filename,
                           levels=levels,
                           allExists=False)
    if v2 is None:
        return
    v2 = v2.metpy.parse_cf().squeeze()

    t = get_model_3D_grid(directory=data_dir[3][0:-1],
                          filename=filename,
                          levels=levels,
                          allExists=False)
    if t is None:
        return
    t = t.metpy.parse_cf().squeeze()

    gh = get_model_grid(data_dir[4], filename=filename)
    if t is None:
        return

    resolution = u['lon'][1] - u['lon'][0]
    x, y = np.meshgrid(u['lon'], u['lat'])

    dx, dy = mpcalc.lat_lon_grid_deltas(u['lon'], u['lat'])
    for ilvl in levels:
        u2d = u.sel(level=ilvl)
        #u2d['data'].attrs['units']=units.meter/units.second
        v2d = v.sel(level=ilvl)
        #v2d['data'].attrs['units']=units.meter/units.second

        absv2d = mpcalc.absolute_vorticity(
            u2d['data'].values * units.meter / units.second,
            v2d['data'].values * units.meter / units.second, dx, dy,
            y * units.degree)

        if (ilvl == levels[0]):
            absv3d = v2
            absv3d['data'].loc[dict(level=ilvl)] = np.array(absv2d)
        else:
            absv3d['data'].loc[dict(level=ilvl)] = np.array(absv2d)
    absv3d['data'].attrs['units'] = absv2d.units

    #rh=rh.rename(dict(lat='latitude',lon='longitude'))
    cross = cross_section(rh, st_point, ed_point)
    cross_rh = cross.set_coords(('lat', 'lon'))
    cross = cross_section(u, st_point, ed_point)
    cross_u = cross.set_coords(('lat', 'lon'))
    cross = cross_section(v, st_point, ed_point)
    cross_v = cross.set_coords(('lat', 'lon'))

    cross_u['data'].attrs['units'] = units.meter / units.second
    cross_v['data'].attrs['units'] = units.meter / units.second
    cross_u['t_wind'], cross_v['n_wind'] = mpcalc.cross_section_components(
        cross_u['data'], cross_v['data'])

    cross = cross_section(t, st_point, ed_point)
    cross_t = cross.set_coords(('lat', 'lon'))
    cross = cross_section(absv3d, st_point, ed_point)

    cross_Td = mpcalc.dewpoint_rh(cross_t['data'].values * units.celsius,
                                  cross_rh['data'].values * units.percent)

    rh, pressure = xr.broadcast(cross_rh['data'], cross_t['level'])

    Qv = mpcalc.specific_humidity_from_dewpoint(cross_Td, pressure)

    cross_Qv = xr.DataArray(np.array(Qv) * 1000.,
                            coords=cross_rh['data'].coords,
                            dims=cross_rh['data'].dims,
                            attrs={'units': units('g/kg')})

    Theta_e = mpcalc.equivalent_potential_temperature(
        pressure, cross_t['data'].values * units.celsius, cross_Td)

    cross_Theta_e = xr.DataArray(np.array(Theta_e),
                                 coords=cross_rh['data'].coords,
                                 dims=cross_rh['data'].dims,
                                 attrs={'units': Theta_e.units})

    crossection_graphics.draw_Crosssection_Wind_Theta_e_Qv(
        cross_Qv=cross_Qv,
        cross_Theta_e=cross_Theta_e,
        cross_u=cross_u,
        cross_v=cross_v,
        gh=gh,
        h_pos=h_pos,
        st_point=st_point,
        ed_point=ed_point,
        levels=levels,
        map_extent=map_extent,
        output_dir=output_dir)
예제 #15
0
    'https://thredds.met.no/thredds/dodsC/mepslatest/meps_det_2_5km_%sT%sZ.ncml'
    % (date, ini_time),
    decode_times=True,
    use_cftime=True)

data = fnx.metpy.parse_cf().squeeze()

# Cross section along 69.3 latitude and between 1 and 25 longitude
# Andenes = 16deg longitude
start = (69.3, 1)
end = (69.3, 25)

cross_data = data[[
    'cloud_area_fraction_pl', 'air_temperature_pl', 'relative_humidity_pl'
]]
cross = cross_section(cross_data, start, end).set_coords(
    ('latitude', 'longitude'))
# Inverse the pressure axes (doesn't work as intended)
# cross = cross.reindex(pressure=list(reversed(cross.pressure)))

temperature, clouds, relative_humidity = xr.broadcast(
    cross['air_temperature_pl'], cross['cloud_area_fraction_pl'],
    cross['relative_humidity_pl'])

# Plot the cross section
fig, axs = plt.subplots(nrows=3,
                        ncols=3,
                        sharey=True,
                        sharex=True,
                        figsize=(14, 10))
ax = axs.ravel().tolist()
j = 0
예제 #16
0
# dimension.

data = xr.open_dataset(get_test_data('narr_example.nc', False))
data = data.metpy.parse_cf().squeeze()
print(data)

##############################
# Define start and end points:

start = (37.0, -105.0)
end = (35.5, -65.0)

##############################
# Get the cross section, and convert lat/lon to supplementary coordinates:

cross = cross_section(data, start, end)
cross.set_coords(('lat', 'lon'), True)
print(cross)

##############################
# For this example, we will be plotting potential temperature, relative humidity, and
# tangential/normal winds. And so, we need to calculate those, and add them to the dataset:

temperature, pressure, specific_humidity = xr.broadcast(
    cross['Temperature'], cross['isobaric'], cross['Specific_humidity'])

theta = mpcalc.potential_temperature(pressure, temperature)
rh = mpcalc.relative_humidity_from_specific_humidity(specific_humidity,
                                                     temperature, pressure)

# These calculations return unit arrays, so put those back into DataArrays in our Dataset
예제 #17
0
# dimension.

data = xr.open_dataset(get_test_data('narr_example.nc', False))
data = data.metpy.parse_cf().squeeze()
print(data)

##############################
# Define start and end points:

start = (37.0, -105.0)
end = (35.5, -65.0)

##############################
# Get the cross section, and convert lat/lon to supplementary coordinates:

cross = cross_section(data, start, end)
cross.set_coords(('lat', 'lon'), True)
print(cross)

##############################
# For this example, we will be plotting potential temperature, relative humidity, and
# tangential/normal winds. And so, we need to calculate those, and add them to the dataset:

temperature, pressure, specific_humidity = xr.broadcast(cross['Temperature'],
                                                        cross['isobaric'],
                                                        cross['Specific_humidity'])

theta = mpcalc.potential_temperature(pressure, temperature)
rh = mpcalc.relative_humidity_from_specific_humidity(specific_humidity, temperature, pressure)

# These calculations return unit arrays, so put those back into DataArrays in our Dataset
예제 #18
0
data = xr.open_dataset('./CFile.nc')
data["rhum"] = (['time', 'level', 'lat', 'lon'], c)
data = data.metpy.parse_cf().squeeze()

print(data)

##############################
# Define start and end points:

start = (5.0, 75.0)
end = (15.0, 80.0)

##############################
# Get the cross section, and convert lat/lon to supplementary coordinates:

cross = cross_section(data, start, end).set_coords(('lat', 'lon'))

##############################
# For this example, we will be plotting potential temperature, relative humidity, and
# tangential/normal winds. And so, we need to calculate those, and add them to the dataset:

cross['rhum'].metpy.convert_units('percent')

temperature, pressure, relative_humidity = xr.broadcast(
    cross['air'], cross['level'], cross['rhum'])

theta = mpcalc.potential_temperature(pressure, temperature)
print(max(theta.flatten()))
print(min(theta.flatten()))

# These calculations return unit arrays, so put those back into DataArrays in our Dataset
예제 #19
0
def test_cross_section_dataarray_and_linear_interp(test_ds_xy):
    """Test the cross_section function with a data array and linear interpolation."""
    data = test_ds_xy['temperature']
    start, end = ((36.46, -112.45), (42.95, -68.74))
    data_cross = cross_section(data, start, end, steps=7)
    truth_values = np.array([[[250.00095489, 251.53646673, 253.11586664, 254.73477364,
                               256.38991013, 258.0794356, 259.80334269],
                              [260.04880178, 261.58431362, 263.16371353, 264.78262053,
                               266.43775702, 268.12728249, 269.85118958],
                              [270.09664867, 271.63216051, 273.21156042, 274.83046742,
                               276.48560391, 278.17512938, 279.89903647],
                              [280.14449556, 281.6800074, 283.25940731, 284.87831431,
                               286.5334508, 288.22297627, 289.94688336],
                              [290.19234245, 291.72785429, 293.3072542, 294.9261612,
                               296.58129769, 298.27082316, 299.99473025]]])
    truth_values_x = np.array([-499495.71907062, 98404.43537514, 688589.09865512,
                               1272690.44926197, 1852009.73516881, 2427525.45740665,
                               2999932.89862589])
    truth_values_y = np.array([-1499865.98780602, -1268717.36799267, -1029139.66048478,
                               -782037.60343652, -528093.95678826, -267710.32566917,
                               -939.10769171])
    index = xr.DataArray(range(7), name='index', dims=['index'])

    data_truth_x = xr.DataArray(
        truth_values_x,
        name='x',
        coords={
            'crs': data['crs'],
            'y': (['index'], truth_values_y),
            'x': (['index'], truth_values_x),
            'index': index,
        },
        dims=['index']
    )
    data_truth_y = xr.DataArray(
        truth_values_y,
        name='y',
        coords={
            'crs': data['crs'],
            'y': (['index'], truth_values_y),
            'x': (['index'], truth_values_x),
            'index': index,
        },
        dims=['index']
    )
    data_truth = xr.DataArray(
        truth_values,
        name='temperature',
        coords={
            'time': data['time'],
            'isobaric': data['isobaric'],
            'index': index,
            'crs': data['crs'],
            'y': data_truth_y,
            'x': data_truth_x
        },
        dims=['time', 'isobaric', 'index'],
        attrs={'units': 'kelvin'}
    )

    xr.testing.assert_allclose(data_truth, data_cross)
예제 #20
0
def test_cross_section_dataarray_projection_noop(test_ds_xy):
    """Test the cross_section function with a projection dataarray."""
    data = test_ds_xy['lambert_conformal']
    start, end = ((36.46, -112.45), (42.95, -68.74))
    data_cross = cross_section(data, start, end, steps=7)
    xr.testing.assert_identical(data, data_cross)
예제 #21
0
def test_cross_section_dataarray_projection_noop(test_ds_xy):
    """Test the cross_section function with a projection dataarray."""
    data = test_ds_xy['lambert_conformal']
    start, end = ((36.46, -112.45), (42.95, -68.74))
    data_cross = cross_section(data, start, end, steps=7)
    xr.testing.assert_identical(data, data_cross)
def metpy_read_wrf_cross(fname, plevels, tidx_in, lons_out, lats_out, start,
                         end):

    ds = xr.open_dataset(fname).metpy.parse_cf().squeeze()
    ds = ds.isel(Time=tidx)
    print(ds)

    ds1 = xr.Dataset()

    p = units.Quantity(to_np(ds.p), 'hPa')
    z = units.Quantity(to_np(ds.z), 'meter')
    u = units.Quantity(to_np(ds.u), 'm/s')
    v = units.Quantity(to_np(ds.v), 'm/s')
    w = units.Quantity(to_np(ds.w), 'm/s')
    tk = units.Quantity(to_np(ds.tk), 'kelvin')
    th = units.Quantity(to_np(ds.th), 'kelvin')
    eth = units.Quantity(to_np(ds.eth), 'kelvin')
    wspd = units.Quantity(to_np(ds.wspd), 'm/s')
    omega = units.Quantity(to_np(ds.omega), 'Pa/s')

    plevels_unit = plevels * units.hPa
    z, u, v, w, tk, th, eth, wspd, omega = log_interpolate_1d(plevels_unit,
                                                              p,
                                                              z,
                                                              u,
                                                              v,
                                                              w,
                                                              tk,
                                                              th,
                                                              eth,
                                                              wspd,
                                                              omega,
                                                              axis=0)

    coords, dims = [plevs, ds.lat.values,
                    ds.lon.values], ["level", "lat", "lon"]
    for name, var in zip(
        ['z', 'u', 'v', 'w', 'tk', 'th', 'eth', 'wspd', 'omega'],
        [z, u, v, w, tk, th, eth, wspd, omega]):
        #g = ndimage.gaussian_filter(var, sigma=3, order=0)
        ds1[name] = xr.DataArray(to_np(mpcalc.smooth_n_point(var, 9)),
                                 coords=coords,
                                 dims=dims)

    dx, dy = mpcalc.lat_lon_grid_deltas(ds.lon.values * units('degrees_E'),
                                        ds.lat.values * units('degrees_N'))

    # Calculate temperature advection using metpy function
    for i, plev in enumerate(plevs):

        adv = mpcalc.advection(eth[i, :, :], [u[i, :, :], v[i, :, :]],
                               (dx, dy),
                               dim_order='yx') * units('K/sec')
        adv = ndimage.gaussian_filter(adv, sigma=3, order=0) * units('K/sec')
        ds1['eth_adv_{:03d}'.format(plev)] = xr.DataArray(
            np.array(adv),
            coords=[ds.lat.values, ds.lon.values],
            dims=["lat", "lon"])

        div = mpcalc.divergence(u[i, :, :], v[i, :, :], dx, dy, dim_order='yx')
        div = ndimage.gaussian_filter(div, sigma=3, order=0) * units('1/sec')
        ds1['div_{:03d}'.format(plev)] = xr.DataArray(
            np.array(div),
            coords=[ds.lat.values, ds.lon.values],
            dims=["lat", "lon"])

    ds1['accrain'] = xr.DataArray(ds.accrain.values,
                                  coords=[ds.lat.values, ds.lon.values],
                                  dims=["lat", "lon"])
    eth2 = mpcalc.equivalent_potential_temperature(
        ds.slp.values * units.hPa, ds.t2m.values * units('K'),
        ds.td2.values * units('celsius'))
    ds1['eth2'] = xr.DataArray(eth2,
                               coords=[ds.lat.values, ds.lon.values],
                               dims=["lat", "lon"])
    #ds1['sst'] = xr.DataArray(ndimage.gaussian_filter(ds.sst.values, sigma=3, order=0)-273.15, coords=[ds.lat.values,ds.lon.values], dims=["lat","lon"])
    ds1 = ds1.metpy.parse_cf().squeeze()

    cross = cross_section(ds1, start, end).set_coords(('lat', 'lon'))
    cross.u.attrs['units'] = 'm/s'
    cross.v.attrs['units'] = 'm/s'

    cross['t_wind'], cross['n_wind'] = mpcalc.cross_section_components(
        cross['u'], cross['v'])

    weights = np.cos(np.deg2rad(ds.lat))
    ds_weighted = ds.weighted(weights)
    weighted = ds_weighted.mean(("lat"))

    return ds1, cross, weighted
예제 #23
0
def Crosssection_Wind_Theta_e_Qv(
    initTime=None, fhour=24,
    levels=[1000, 950, 925, 900, 850, 800, 700,600,500,400,300,200],
    day_back=0,model='GRAPES_GFS',data_source='MICAPS',
    lw_ratio=[16,9],
    output_dir=None,
    st_point = [20, 120.0],
    ed_point = [50, 130.0],
    map_extent=[70,140,15,55],
    h_pos=[0.125, 0.665, 0.25, 0.2],**kwargs ):

    if(data_source == 'MICAPS'):
        try:
            data_dir = [utl.Cassandra_dir(data_type='high',data_source=model,var_name='RH',lvl=''),
                        utl.Cassandra_dir(data_type='high',data_source=model,var_name='UGRD',lvl=''),
                        utl.Cassandra_dir(data_type='high',data_source=model,var_name='VGRD',lvl=''),
                        utl.Cassandra_dir(data_type='high',data_source=model,var_name='TMP',lvl=''),
                        utl.Cassandra_dir(data_type='high',data_source=model,var_name='HGT',lvl='500'),
                        utl.Cassandra_dir(data_type='surface',data_source=model,var_name='PSFC')]
        except KeyError:
            raise ValueError('Can not find all directories needed')

        # get filename
        if(initTime != None):
            filename = utl.model_filename(initTime, fhour)
        else:
            filename=utl.filename_day_back_model(day_back=day_back,fhour=fhour)
            
        # retrieve data from micaps server
        rh=get_model_3D_grid(directory=data_dir[0][0:-1],filename=filename,levels=levels, allExists=False)
        u=get_model_3D_grid(directory=data_dir[1][0:-1],filename=filename,levels=levels, allExists=False)
        v=get_model_3D_grid(directory=data_dir[2][0:-1],filename=filename,levels=levels, allExists=False)
        v2=get_model_3D_grid(directory=data_dir[2][0:-1],filename=filename,levels=levels, allExists=False)
        t=get_model_3D_grid(directory=data_dir[3][0:-1],filename=filename,levels=levels, allExists=False)
        gh=get_model_grid(data_dir[4], filename=filename)
        psfc=get_model_grid(data_dir[5], filename=filename)
    if(data_source == 'CIMISS'):
        # get filename
        if(initTime != None):
            filename = utl.model_filename(initTime, fhour,UTC=True)
        else:
            filename=utl.filename_day_back_model(day_back=day_back,fhour=fhour,UTC=True)
        try:
            rh=CMISS_IO.cimiss_model_3D_grid(init_time_str='20'+filename[0:8],valid_time=fhour,
                        data_code=utl.CMISS_data_code(data_source=model,var_name='RHU'),
                        fcst_levels=levels, fcst_ele="RHU", units='%')

            u=CMISS_IO.cimiss_model_3D_grid(init_time_str='20'+filename[0:8],valid_time=fhour,
                        data_code=utl.CMISS_data_code(data_source=model,var_name='WIU'),
                        fcst_levels=levels, fcst_ele="WIU", units='m/s')
                
            v=CMISS_IO.cimiss_model_3D_grid(init_time_str='20'+filename[0:8],valid_time=fhour,
                        data_code=utl.CMISS_data_code(data_source=model,var_name='WIV'),
                        fcst_levels=levels, fcst_ele="WIV", units='m/s')

            v2=CMISS_IO.cimiss_model_3D_grid(init_time_str='20'+filename[0:8],valid_time=fhour,
                        data_code=utl.CMISS_data_code(data_source=model,var_name='WIV'),
                        fcst_levels=levels, fcst_ele="WIV", units='m/s')

            t=CMISS_IO.cimiss_model_3D_grid(init_time_str='20'+filename[0:8],valid_time=fhour,
                        data_code=utl.CMISS_data_code(data_source=model,var_name='TEM'),
                        fcst_levels=levels, fcst_ele="TEM", units='K')
            t['data'].values=t['data'].values-273.15

            gh=CMISS_IO.cimiss_model_by_time('20'+filename[0:8],valid_time=fhour,
                            data_code=utl.CMISS_data_code(data_source=model,var_name='GPH'),
                            fcst_level=500, fcst_ele="GPH", units='gpm')
            gh['data'].values=gh['data'].values/10.

            psfc=CMISS_IO.cimiss_model_by_time('20'+filename[0:8], valid_time=fhour,
                data_code=utl.CMISS_data_code(data_source=model,var_name='PRS'),
                fcst_level=0, fcst_ele="PRS", units='Pa')
            psfc['data']=psfc['data']/100.

        except KeyError:
            raise ValueError('Can not find all data needed')   
    rh = rh.metpy.parse_cf().squeeze()
    u = u.metpy.parse_cf().squeeze()
    v = v.metpy.parse_cf().squeeze()
    v2 = v2.metpy.parse_cf().squeeze()
    psfc=psfc.metpy.parse_cf().squeeze()
    t = t.metpy.parse_cf().squeeze()

    resolution=u['lon'][1]-u['lon'][0]
    x,y=np.meshgrid(u['lon'], u['lat'])
    # +form 3D psfc
    mask1 = (
            (psfc['lon']>=t['lon'].values.min())&
            (psfc['lon']<=t['lon'].values.max())&
            (psfc['lat']>=t['lat'].values.min())&
            (psfc['lat']<=t['lat'].values.max())
            )

    t2,psfc_bdcst=xr.broadcast(t['data'],psfc['data'].where(mask1, drop=True))
    mask2=(psfc_bdcst > -10000)
    psfc_bdcst=psfc_bdcst.where(mask2, drop=True)
    # -form 3D psfc

    dx,dy=mpcalc.lat_lon_grid_deltas(u['lon'],u['lat'])

    #rh=rh.rename(dict(lat='latitude',lon='longitude'))
    cross = cross_section(rh, st_point, ed_point)
    cross_rh=cross.set_coords(('lat', 'lon'))
    cross = cross_section(u, st_point, ed_point)
    cross_u=cross.set_coords(('lat', 'lon'))
    cross = cross_section(v, st_point, ed_point)
    cross_v=cross.set_coords(('lat', 'lon'))
    cross_psfc = cross_section(psfc_bdcst, st_point, ed_point)

    cross_u['data'].attrs['units']=units.meter/units.second
    cross_v['data'].attrs['units']=units.meter/units.second
    cross_u['t_wind'], cross_v['n_wind'] = mpcalc.cross_section_components(cross_u['data'],cross_v['data'])
    
    cross = cross_section(t, st_point, ed_point)
    cross_t=cross.set_coords(('lat', 'lon'))

    cross_Td = mpcalc.dewpoint_rh(cross_t['data'].values*units.celsius,
                cross_rh['data'].values* units.percent)

    rh,pressure = xr.broadcast(cross_rh['data'],cross_t['level'])
    pressure.attrs['units']='hPa'
    
    Qv = mpcalc.specific_humidity_from_dewpoint(cross_Td,
                pressure)

    cross_Qv = xr.DataArray(np.array(Qv)*1000.,
                    coords=cross_rh['data'].coords,
                    dims=cross_rh['data'].dims,
                    attrs={'units': units('g/kg')})

    Theta_e=mpcalc.equivalent_potential_temperature(pressure,
                                                cross_t['data'].values*units.celsius, 
                                                cross_Td)
    cross_terrain=pressure-cross_psfc

    cross_Theta_e = xr.DataArray(np.array(Theta_e),
                        coords=cross_rh['data'].coords,
                        dims=cross_rh['data'].dims,
                        attrs={'units': Theta_e.units})

    crossection_graphics.draw_Crosssection_Wind_Theta_e_Qv(
                    cross_Qv=cross_Qv, cross_Theta_e=cross_Theta_e, cross_u=cross_u,
                    cross_v=cross_v,cross_terrain=cross_terrain,gh=gh,
                    h_pos=h_pos,st_point=st_point,ed_point=ed_point,
                    levels=levels,map_extent=map_extent,lw_ratio=lw_ratio,
                    output_dir=output_dir)