Exemplo n.º 1
0
    def test_vang_sym(self):
        """ Test _vang_sym function. Compare to MATLAB reference. """
        ureg = UnitRegistry()
        i_node = 1
        tc_track = TCTracks()
        tc_track.read_processed_ibtracs_csv(TEST_TRACK)
        tc_track.equal_timestep()
        tc_track.data[0]['radius_max_wind'] = (
            'time',
            tc._extra_rad_max_wind(tc_track.data[0].central_pressure.values,
                                   tc_track.data[0].radius_max_wind.values,
                                   ureg))
        r_arr = np.array([
            286.4938638337190, 290.5930935802884, 295.0271327746536,
            299.7811253637995, 296.8484825705515, 274.9892882245964
        ])
        v_trans = 5.2429431910897559
        v_ang = tc._vang_sym(
            tc_track.data[0].environmental_pressure.values[i_node],
            tc_track.data[0].central_pressure.values[i_node - 1:i_node + 1],
            tc_track.data[0].lat.values[i_node],
            tc_track.data[0].time_step.values[i_node],
            tc_track.data[0].radius_max_wind.values[i_node],
            r_arr,
            v_trans,
            model=0)

        to_kn = (1 * ureg.meter / ureg.second).to(ureg.knot).magnitude
        self.assertEqual(v_ang.size, 6)
        self.assertAlmostEqual(v_ang[0] * to_kn, 10.774196807905097)
        self.assertAlmostEqual(v_ang[1] * to_kn, 10.591725180482094)
        self.assertAlmostEqual(v_ang[2] * to_kn, 10.398212766600055)
        self.assertAlmostEqual(v_ang[3] * to_kn, 10.195108683240084)
        self.assertAlmostEqual(v_ang[4] * to_kn, 10.319869893291429)
        self.assertAlmostEqual(v_ang[5] * to_kn, 11.305188714213809)
Exemplo n.º 2
0
    def test_windfield(self):
        """ Test _windfield function. Compare to MATLAB reference. """
        ureg = UnitRegistry()
        tc_track = TCTracks()
        tc_track.read_processed_ibtracs_csv(TEST_TRACK)
        tc_track.equal_timestep()
        tc_track.data[0]['radius_max_wind'] = (
            'time',
            tc._extra_rad_max_wind(tc_track.data[0].central_pressure.values,
                                   tc_track.data[0].radius_max_wind.values,
                                   ureg))
        coast_centr = tc.coastal_centr_idx(CENTR_TEST_BRB)

        wind = tc._windfield(tc_track.data[0],
                             CENTR_TEST_BRB.coord,
                             coast_centr,
                             model=0)

        to_kn = (1 * ureg.meter / ureg.second).to(ureg.knot).magnitude
        self.assertEqual(wind.shape, (CENTR_TEST_BRB.size, ))

        wind = wind[coast_centr]
        self.assertEqual(np.nonzero(wind)[0].size, 280)
        self.assertAlmostEqual(wind[0] * to_kn, 51.16153933277889)
        self.assertAlmostEqual(wind[80] * to_kn, 64.15891933409763)
        self.assertAlmostEqual(wind[120] * to_kn, 41.43819201370903)
        self.assertAlmostEqual(wind[200] * to_kn, 57.28814245245439)
        self.assertAlmostEqual(wind[220] * to_kn, 69.62477194818004)
Exemplo n.º 3
0
    def test_vtrans_correct(self):
        """ Test _vtrans_correct function. Compare to MATLAB reference."""
        ureg = UnitRegistry()
        i_node = 1
        tc_track = TCTracks()
        tc_track.read_processed_ibtracs_csv(TEST_TRACK)
        tc_track.equal_timestep()
        tc_track.data[0]['radius_max_wind'] = (
            'time',
            tc._extra_rad_max_wind(tc_track.data[0].central_pressure.values,
                                   tc_track.data[0].radius_max_wind.values,
                                   ureg))
        r_arr = np.array([
            286.4938638337190, 290.5930935802884, 295.0271327746536,
            299.7811253637995, 296.8484825705515, 274.9892882245964
        ])

        v_trans_corr = tc._vtrans_correct(
            tc_track.data[0].lat.values[i_node:i_node + 2],
            tc_track.data[0].lon.values[i_node:i_node + 2],
            tc_track.data[0].radius_max_wind.values[i_node],
            CENTR_TEST_BRB.coord[:6, :], r_arr)

        to_kn = (1 * ureg.meter / ureg.second).to(ureg.knot).magnitude

        v_trans = 10.191466256012880 / to_kn
        v_trans_corr *= v_trans
        self.assertEqual(v_trans_corr.size, 6)
        self.assertAlmostEqual(v_trans_corr[0] * to_kn, 0.06547673730228235)
        self.assertAlmostEqual(v_trans_corr[1] * to_kn, 0.07106877437273672)
        self.assertAlmostEqual(v_trans_corr[2] * to_kn, 0.07641714650288109)
        self.assertAlmostEqual(v_trans_corr[3] * to_kn, 0.0627289214278824)
        self.assertAlmostEqual(v_trans_corr[4] * to_kn, 0.0697427233582331)
        self.assertAlmostEqual(v_trans_corr[5] * to_kn, 0.06855335593983322)
Exemplo n.º 4
0
    def test_vtrans_correct(self):
        """ Test _vtrans_correct function. Compare to MATLAB reference."""
        ureg = UnitRegistry()
        i_node = 1
        tc_track = TCTracks()
        tc_track.read_processed_ibtracs_csv(TEST_TRACK)
        tc_track.equal_timestep()
        tc_track.data[0]['radius_max_wind'] = ('time', tc._extra_rad_max_wind(
            tc_track.data[0].central_pressure.values,
            tc_track.data[0].radius_max_wind.values, ureg))
        coast_centr = tc.coastal_centr_idx(CENT_CLB)
        new_centr = CENT_CLB.coord[coast_centr]
        r_arr = np.array([286.4938638337190, 290.5930935802884,
                          295.0271327746536, 299.7811253637995,
                          296.8484825705515, 274.9892882245964])
        close_centr = np.array([400381, 400382, 400383, 400384, 401110,
                                1019665]) - 1

        v_trans_corr = tc._vtrans_correct(
            tc_track.data[0].lat.values[i_node:i_node+2],
            tc_track.data[0].lon.values[i_node:i_node+2],
            tc_track.data[0].radius_max_wind.values[i_node],
            new_centr[close_centr, :], r_arr)

        to_kn = (1* ureg.meter / ureg.second).to(ureg.knot).magnitude

        v_trans = 10.191466256012880 / to_kn
        v_trans_corr *= v_trans
        self.assertEqual(v_trans_corr.size, 6)
        self.assertAlmostEqual(v_trans_corr[0] * to_kn, 2.490082696506720)
        self.assertAlmostEqual(v_trans_corr[1] * to_kn, 2.418324821762491)
        self.assertAlmostEqual(v_trans_corr[2] * to_kn, 2.344175399115656)
        self.assertAlmostEqual(v_trans_corr[3] * to_kn, 2.268434724527058)
        self.assertAlmostEqual(v_trans_corr[4] * to_kn, 2.416654031976129)
        self.assertAlmostEqual(v_trans_corr[5] * to_kn, -1.394485527059995)
Exemplo n.º 5
0
    def test_extra_rad_max_wind_pass(self):
        """ Test _extra_rad_max_wind function. Compare to MATLAB reference."""
        ureg = UnitRegistry()
        tc_track = TCTracks()
        tc_track.read_processed_ibtracs_csv(TEST_TRACK)
        tc_track.equal_timestep()
        rad_max_wind = tc._extra_rad_max_wind(tc_track.data[0].central_pressure.values,
            tc_track.data[0].radius_max_wind.values, ureg)

        self.assertEqual(rad_max_wind[0], 75.536713749999905)
        self.assertAlmostEqual(rad_max_wind[10], 75.592659583328057)
        self.assertAlmostEqual(rad_max_wind[128], 46.686527832605236)
        self.assertEqual(rad_max_wind[129], 46.089211533333405)
        self.assertAlmostEqual(rad_max_wind[130], 45.672274889277276)
        self.assertEqual(rad_max_wind[189], 45.132715266666672)
        self.assertAlmostEqual(rad_max_wind[190], 45.979603999211285)
        self.assertAlmostEqual(rad_max_wind[191], 47.287173876478825)
        self.assertEqual(rad_max_wind[192], 48.875090249999985)
        self.assertAlmostEqual(rad_max_wind[200], 59.975901084074955)
Exemplo n.º 6
0
    def test_windfield(self):
        """ Test _windfield function. Compare to MATLAB reference. """
        ureg = UnitRegistry()
        tc_track = TCTracks()
        tc_track.read_processed_ibtracs_csv(TEST_TRACK)
        tc_track.equal_timestep()
        tc_track.data[0]['radius_max_wind'] = (
            'time',
            tc._extra_rad_max_wind(tc_track.data[0].central_pressure.values,
                                   tc_track.data[0].radius_max_wind.values,
                                   ureg))
        int_track = tc_track.data[0].sel(
            time=slice('1951-08-27', '1951-08-28'))
        coast_centr = tc.coastal_centr_idx(CENT_CLB)

        wind = tc._windfield(int_track, CENT_CLB.coord, coast_centr, model=0)

        to_kn = (1 * ureg.meter / ureg.second).to(ureg.knot).magnitude
        self.assertEqual(wind.shape, (CENT_CLB.size, ))

        wind = wind[coast_centr]
        self.assertEqual(np.nonzero(wind)[0].size, 5)
        self.assertTrue(
            np.array_equal(
                wind.nonzero()[0],
                np.array([1019062, 1019183, 1019304, 1019425, 1019667]) - 1))

        self.assertAlmostEqual(wind[1019061] * to_kn, 35.961499748377776, 4)
        self.assertTrue(np.isclose(35.961499748377776, wind[1019061] * to_kn))

        self.assertAlmostEqual(wind[1019182] * to_kn, 35.985591640301138, 6)
        self.assertTrue(np.isclose(35.985591640301138, wind[1019182] * to_kn))

        self.assertAlmostEqual(wind[1019303] * to_kn, 35.567653569424614, 5)
        self.assertTrue(np.isclose(35.567653569424614, wind[1019303] * to_kn))

        self.assertAlmostEqual(wind[1019424] * to_kn, 34.470214174079388, 6)
        self.assertTrue(np.isclose(34.470214174079388, wind[1019424] * to_kn))

        self.assertAlmostEqual(wind[1019666] * to_kn, 34.067538078331282, 6)
        self.assertTrue(np.isclose(34.067538078331282, wind[1019666] * to_kn))