Beispiel #1
0
    def temperature(self, lat, lon):
        if not self._temperature:
            self._temperature = load_data_interpolator(
                '1510/v0_lat.npz', '1510/v0_lon.npz', '1510/v0_temp.npz',
                bicubic_2D_interpolator)

        return self._temperature(np.array([lat.ravel(),
                                           lon.ravel()]).T).reshape(lat.shape)
    def Pclw(self, lat, lon):
        if not self._Pclw:
            self._Pclw = load_data_interpolator(
                '840/v6_lat.npz', '840/v6_lon.npz',
                '840/v6_pclw.npz', bilinear_2D_interpolator, flip_ud=False)

        return self._Pclw(
            np.array([lat.ravel(), lon.ravel()]).T).reshape(lat.shape)
    def sigma(self, lat, lon):
        if not self._sigma:
            self._sigma = load_data_interpolator(
                '840/v7_lat.npz', '840/v7_lon.npz',
                '840/v7_sigma.npz', bilinear_2D_interpolator, flip_ud=False)

        return self._sigma(
            np.array([lat.ravel(), lon.ravel()]).T).reshape(lat.shape)
    def Beta(self, lat, lon):
        if not self._Beta:
            self._Beta = load_data_interpolator(
                       '837/esarain_lat_v5.npz', '837/esarain_lon_v5.npz',
                       '837/esarain_beta_v5.npz', bilinear_2D_interpolator,
                       flip_ud=False)

        return self._Beta(
            np.array([lat.ravel(), lon.ravel()]).T).reshape(lat.shape)
Beispiel #5
0
    def temperature(self, lat, lon):
        if not self._temperature:
            self._temperature = load_data_interpolator(
                '1510/v1_lat.npz', '1510/v1_lon.npz', '1510/v1_t_annual.npz',
                bilinear_2D_interpolator)

        lon[lon > 180] = lon[lon > 180] - 360
        return self._temperature(np.array([lat.ravel(),
                                           lon.ravel()]).T).reshape(lat.shape)
    def wgs4_altitude(self, lat, lon):
        if not self._wgs4_altitude:
            self._wgs4_altitude = load_data_interpolator(
                '1511/v2_lat.npz', '1511/v2_lon.npz', '1511/v2_egm2008.npz',
                bicubic_2D_interpolator)

        return self._wgs4_altitude(np.array([lat.ravel(),
                                             lon.ravel()
                                             ]).T).reshape(lat.shape)
    def altitude(self, lat, lon):
        if not self._altitude:
            self._altitude = load_data_interpolator('1511/v1_lat.npz',
                                                    '1511/v1_lon.npz',
                                                    '1511/v1_topo_0dot5.npz',
                                                    bicubic_2D_interpolator)

        return self._altitude(np.array([lat.ravel(),
                                        lon.ravel()]).T).reshape(lat.shape)
Beispiel #8
0
    def topo_alt(self, lat, lon):
        if self._topo_alt is None:
            self._topo_alt = load_data_interpolator('836/v6_topolat.npz',
                                                    '836/v6_topolon.npz',
                                                    '836/v6_topo_0dot5.npz',
                                                    bicubic_2D_interpolator)

        return self._topo_alt(np.array([lat.ravel(),
                                        lon.ravel()]).T).reshape(lat.shape)
    def M(self, lat, lon):
        if not self._M:
            self._M = load_data_interpolator(
                '840/v6_lat.npz', '840/v6_lon.npz',
                '840/v4_wred_lognormal_mean.npz', bilinear_2D_interpolator,
                flip_ud=False)

        return self._M(
            np.array([lat.ravel(), lon.ravel()]).T).reshape(lat.shape)
    def R001(self, lat, lon):
        if not self._R001:
            self._R001 = load_data_interpolator(
                       '837/v7_lat_r001.npz', '837/v7_lon_r001.npz',
                       '837/v7_r001.npz', bilinear_2D_interpolator)

        # In this recommendation the longitude is encoded with format -180 to
        # 180 whereas we always use 0 - 360 encoding
        lon = np.array(lon)
        lon[lon > 180] = lon[lon > 180] - 360
        return self._R001(
            np.array([lat.ravel(), lon.ravel()]).T).reshape(lat.shape)
Beispiel #11
0
    def month_temperature(self, lat, lon, m):
        if not self._month_temperature:
            for _m in self.__months:
                self._month_temperature[_m] = load_data_interpolator(
                    '1510/v1_lat.npz', '1510/v1_lon.npz',
                    '1510/v1_t_month{0:02d}.npz'.format(_m),
                    bilinear_2D_interpolator)

        lon[lon > 180] = lon[lon > 180] - 360
        return self._month_temperature[m](np.array([lat.ravel(),
                                                    lon.ravel()
                                                    ]).T).reshape(lat.shape)
    def isoterm_0(self, lat, lon):
        if not self._zero_isoterm_data:
            self._zero_isoterm_data = load_data_interpolator(
                '839/v4_esalat.npz',
                '839/v4_esalon.npz',
                '839/v4_esa0height.npz',
                bilinear_2D_interpolator,
                flip_ud=False)

        return self._zero_isoterm_data(np.array([lat.ravel(),
                                                 lon.ravel()
                                                 ]).T).reshape(lat.shape)
    def Lred(self, lat, lon, p):
        if not self._Lred:
            ps = [0.1, 0.2, 0.3, 0.5, 1, 2, 3, 5, 10, 20, 30,
                  50, 60, 70, 80, 90, 95]
            d_dir = os.path.join(dataset_dir, '840/v4_esawred_%s.npz')
            for p_load in ps:
                self._Lred[float(p_load)] = load_data_interpolator(
                       '840/v4_lat.npz', '840/v4_lon.npz',
                       d_dir % (str(p_load).replace('.', '')),
                       bilinear_2D_interpolator, flip_ud=False)

        return self._Lred[float(p)](
            np.array([lat.ravel(), lon.ravel()]).T).reshape(lat.shape)
    def Mt(self, lat, lon, m):
        if not self._Mt:
            for _m in self.months:
                self._Mt[_m] = load_data_interpolator(
                       '837/v7_lat_mt.npz', '837/v7_lon_mt.npz',
                       '837/v7_mt_month{0:02d}.npz'.format(_m),
                       bilinear_2D_interpolator)

        # In this recommendation the longitude is encoded with format -180 to
        # 180 whereas we always use 0 - 360 encoding
        lon = np.array(lon)
        lon[lon > 180] = lon[lon > 180] - 360
        return self._Mt[m](
            np.array([lat.ravel(), lon.ravel()]).T).reshape(lat.shape)
Beispiel #15
0
    def rho(self, lat, lon, p):
        if not self._rho:
            ps = [
                0.1, 0.2, 0.3, 0.5, 1, 2, 3, 5, 10, 20, 30, 50, 60, 70, 80, 90,
                95, 99
            ]
            d_dir = os.path.join(dataset_dir, '836/v5_rho_%s.npz')
            for p_loads in ps:
                self._rho[float(p_loads)] = load_data_interpolator(
                    '836/v5_lat.npz',
                    '836/v5_lon.npz',
                    d_dir % (str(p_loads).replace('.', '')),
                    bilinear_2D_interpolator,
                    flip_ud=False)

        return self._rho[float(p)](np.array([lat.ravel(),
                                             lon.ravel()
                                             ]).T).reshape(lat.shape)