예제 #1
0
def test_dyn_height_shallower_pref():
    """
    Check that we can handle a p_ref that is shallower than the top of the
    cast.  To make the results from bin 1 on down independent of whether
    bin 0 has been deleted, we need to use linear interpolation.
    """
    p = cv.p_chck_cast
    CT = cv.CT_chck_cast
    SA = cv.SA_chck_cast
    strf0 = gsw.geo_strf_dyn_height(SA, CT, p, p_ref=0, interp_method='linear')
    strf1 = gsw.geo_strf_dyn_height(SA[1:], CT[1:], p[1:], p_ref=0,
                                    interp_method='linear')
    found = strf1 - strf1[0]
    expected = strf0[1:] - strf0[1]
    assert_almost_equal(found, expected)
예제 #2
0
def test_geostrophy():
    lon = cv.long_chck_cast
    lat = cv.lat_chck_cast
    p = cv.p_chck_cast
    CT = cv.CT_chck_cast
    SA = cv.SA_chck_cast
    strf = gsw.geo_strf_dyn_height(SA, CT, p)
    geovel, midlon, midlat = gsw.geostrophic_velocity(strf, lon, lat)
    assert_almost_equal(geovel, cv.geo_strf_velocity)
    assert_almost_equal(midlon, cv.geo_strf_velocity_mid_long[0])
    assert_almost_equal(midlat, cv.geo_strf_velocity_mid_lat[0])
예제 #3
0
def test_strf_no_good():
    # revised geo_strf_dyn_height requires 2 valid points
    shape = (5,)
    SA = np.ma.masked_all(shape, dtype=float)
    CT = np.ma.masked_all(shape, dtype=float)
    p = np.array([0.0, 10.0, 20.0, 30.0, 40.0])

    # No valid points.
    strf = gsw.geo_strf_dyn_height(SA, CT, p, p_ref=0, axis=0)
    expected = np.zeros(shape, float) + np.nan
    assert_array_equal(strf.filled(np.nan), expected)

    # 1 valid point: not enough.
    SA[:1] = 35
    CT[:1] = 5
    strf = gsw.geo_strf_dyn_height(SA, CT, p, p_ref=0, axis=0)
    expected = np.zeros(shape, float) + np.nan
    assert_array_equal(strf.filled(np.nan), expected)

    # 2 valid points: enough for the calculation to proceed.
    SA[:2] = 35
    CT[:2] = [5, 4]
    strf = gsw.geo_strf_dyn_height(SA, CT, p, p_ref=0, axis=0)
    assert strf.count() == 2
예제 #4
0
def geo_strf_isopycnal(SA,
                       CT,
                       p,
                       p_ref,
                       Neutral_Density,
                       p_Neutral_Density,
                       A="s2"):
    p = np.abs(np.asarray(p))

    try:
        dyn_height = gsw.geo_strf_dyn_height(SA, CT, p, p_ref)
    except:
        print("something wrong")
        print(SA, CT, p, p_ref)
        return np.nan

    p_Neutral_Density, idxs = np.unique(p_Neutral_Density, return_index=True)
    Neutral_Density = Neutral_Density[idxs]

    filt = np.where(np.isin(p, p_Neutral_Density))

    nsdyn_height = dyn_height[filt]
    nstemps = CT[filt]
    nssals = SA[filt]

    db2Pa = 1e4
    sa_iref_cast, ct_iref_cast, p_iref_cast = interp_ref_cast(
        Neutral_Density, A)
    cp0 = 3991.86795711963

    part1 = 0.5 * db2Pa * (p_Neutral_Density - p_iref_cast) * (
        gsw.specvol(nssals, nstemps, p_Neutral_Density) -
        gsw.specvol(sa_iref_cast, ct_iref_cast, p_Neutral_Density))
    part2 = 0
    part3 = (-0.225e-15) * (db2Pa * db2Pa) * (nstemps - ct_iref_cast) * (
        p_Neutral_Density - p_iref_cast) * (p_Neutral_Density - p_iref_cast)
    part4 = nsdyn_height - enthalpy_SSO_0(p_Neutral_Density)
    part5 = gsw.enthalpy(sa_iref_cast, ct_iref_cast,
                         p_Neutral_Density) - cp0 * ct_iref_cast

    return part1 + part2 + part3 + part4 + part5
예제 #5
0
def calc_geostrophic_velocity(var_w_sa_ct_p_lon_lat):
    import numpy as np
    import xarray as xr
    import gsw

    # need geostrophic stream function first
    temp = var_w_sa_ct_p_lon_lat.sortby('z', ascending=False)
    temp['geo_height'] = xr.full_like(
        temp.SA, fill_value=np.nan)  # make empty dataarray
    temp.geo_height.values = gsw.geo_strf_dyn_height(temp.SA,
                                                     temp.CT,
                                                     temp.Pressure,
                                                     p_ref=10.1325,
                                                     axis=1)
    temp['geo_velocity'] = xr.full_like(
        temp.geo_height, fill_value=np.nan)  # make empty dataarray
    temp.geo_velocity[0:-1, :] = np.transpose(
        gsw.geostrophic_velocity(temp.geo_height.T.values, temp.lon,
                                 temp.lat)[0])
    var_w_sa_ct_p_lon_lat = temp.sortby('z', ascending=True)

    return var_w_sa_ct_p_lon_lat
예제 #6
0
# DYNAMIC HEIGHT and depth
nanarray = np.empty((ctd['P'].shape[0], len(transects[nts])))
nanarray[:] = np.nan
SA, CT, g, depth, pt, nprof = nanarray.copy(), nanarray.copy(), nanarray.copy(), nanarray.copy(), nanarray.copy(), nanarray.copy()
for i, profile in enumerate(transects[nts]):
    nprof[:, i] = profile
    SA[:, i] = SA_from_SP(ctd['S'][:, profile], P, ctd['lon'][0, profile], ctd['lat'][0, profile])
    CT[:, i] = CT_from_t(SA[:, i], ctd['T'][:, profile], P)
    g[:, i] = grav(ctd['lat'][0, profile], P)
    depth[:, i] = abs(z_from_p(P, ctd['lat'][0, profile]))
    pt[:, i] = pt_from_t(SA[:, i], ctd['T'][:, profile], P, p_ref)
sig0 = sigma0(SA, CT)

# for i

deltaD = geo_strf_dyn_height(SA, CT, P, p_ref=p_ref) / g
deltaD500 = np.tile(deltaD[i500], (deltaD.shape[0],1))

# g_p = grav(ctd['lat'][0, profile], P)
# SA = SA_from_SP(ctd['S'][:, profile], P, ctd['lon'][0, profile], ctd['lat'][0, profile])
# CT = CT_from_t(SA, ctd['T'][:, profile], P)
# pt = pt_from_t(SA, ctd['T'][:, profile], P, 0)
# depth = abs(z_from_p(P, ctd['lat'][0, profile]))
# deltaD = geo_strf_dyn_height(SA, CT, P)

# fig, ax = plt.subplots(1, 2, sharex='col', sharey='row', figsize=(20, 8))
# ct0 = ax[0].contourf(deltaD500, depth, CT, cmap=cmocean.cm.thermal)
# fig.colorbar(ct0, ax=ax[0])
# ax[0].set_title('Conservative Temperature')
# ax[0].set_ylabel('Depth in m')
# ax[0].invert_yaxis()
예제 #7
0
                # change one dimension variables to two dimensions
                p, lon, lat = nc['p'][:], nc['lon'][:, 0][:, np.newaxis], nc[
                    'lat'][:, 0][:, np.newaxis]

                # convert in-situ variables to gsw variables
                p_ref = 1494  # shallowest profile (4) except (34) which goes until 1004

                SA = SA_from_SP(nc['SP'][:], p, lon, lat)
                CT = CT_from_t(SA, nc['t'][:], p)
                pt = pt_from_t(SA, nc['t'][:], p, p_ref)

                deltaD = np.ma.masked_invalid(
                    geo_strf_dyn_height(SA.data,
                                        CT.data,
                                        p,
                                        p_ref=p_ref,
                                        axis=1))

                # transect stations
                transects = {
                    1: list(reversed(range(2, 10))),
                    2: list(range(10, 18)),
                    3: list(reversed(range(18, 27))),
                    4: list(range(26, 34)),
                    5: list(reversed(range(36, 46))),
                    6: list(range(46, 57)),
                    7: list(reversed(range(56, 65))),
                    8: list(reversed(range(68, 76))),
                    9: list(range(76, 84)),
                    10: list(reversed(range(84, 91))),
예제 #8
0
                        lat_array = np.zeros(pres.shape)
                        lat_array[:] = np.NaN
                        lon_array = np.zeros(pres.shape)
                        lon_array[:] = np.NaN

                        for l in np.arange(lat_array.shape[0]):
                            lat_array[l, :] = lat[l]
                            lon_array[l, :] = lon[l]

                        SA = gsw.SA_from_SP(sal, pres, lon_array, lat_array)
                        CT = gsw.CT_from_t(SA, temp, pres)
                        oxy_eq = gsw.O2sol(SA, CT, pres, lon_array, lat_array)

                        # calculate depth
                        geo_strf = gsw.geo_strf_dyn_height(SA=SA.T,
                                                           CT=CT.T,
                                                           p=pres.T)
                        geo_strf = geo_strf.T
                        z = gsw.z_from_p(p=pres,
                                         lat=lat_array,
                                         geo_strf_dyn_height=geo_strf)
                        z = -1 * z

                        oxy_sat = doxy / oxy_eq * 100

                        # Calculate density
                        density = np.zeros(temp.shape)

                        # Calculate MLD
                        mld = np.zeros(sal.shape[0])
                        mld[:] = np.NaN
예제 #9
0
                    dict_stations['P'])
                dict_stations[station]['g'] = grav(
                    dict_stations[station]['lat'], dict_stations['P'])
                dict_stations[station]['depth'] = abs(
                    z_from_p(dict_stations['P'],
                             dict_stations[station]['lat']))
                dict_stations[station]['pt'] = pt_from_t(
                    dict_stations[station]['SA'], dict_stations[station]['T'],
                    dict_stations['P'], p_ref)
                dict_stations[station]['sigma0'] = sigma0(
                    dict_stations[station]['SA'], dict_stations[station]['CT'])
                dict_stations[station]['spiciness0'] = spiciness0(
                    dict_stations[station]['SA'], dict_stations[station]['CT'])
                dict_stations[station]['deltaD'] = geo_strf_dyn_height(
                    dict_stations[station]['SA'],
                    dict_stations[station]['CT'],
                    dict_stations['P'],
                    p_ref=p_ref)

            # save dictionary to file
            write_dict(dict_stations, path, filename,
                       protocol=2)  # protocol 2 allows python2
            print('data stored in file')

# 2) CALCULATE NEUTRAL DENSITY IN PYTHON2
if sys.version_info[0] == 2:  # python2

    from pygamman import gamman as nds

    if os.path.exists(os.path.join(path, filename + '.pkl')):
        dict_stations = read_dict(path, filename + '.pkl')
예제 #10
0
Matlab functions. Therefore we have to make our own test
values, using the current test cast inputs.

This is a minimal script for that purpose, to be run in
the tests directory in which it lives.  It should be run
only if we change to a different calculation algorithm,
or we update the cast input and general check value file.
"""

import numpy as np
import gsw
from gsw._utilities import Bunch

cv = Bunch(np.load('gsw_cv_v3_0.npz'))

dyn_height = gsw.geo_strf_dyn_height(cv.SA_chck_cast,
                                     cv.CT_chck_cast,
                                     cv.p_chck_cast,
                                     cv.pr)
np.save('geo_strf_dyn_height.npy', dyn_height)

lon = cv.long_chck_cast
lat = cv.lat_chck_cast
p = cv.p_chck_cast
CT = cv.CT_chck_cast
SA = cv.SA_chck_cast
strf = gsw.geo_strf_dyn_height(SA, CT, p)
geovel, midlon, midlat = gsw.geostrophic_velocity(strf, lon, lat)
np.save('geo_strf_velocity.npy', geovel)
# midlon, midlat are OK