def for_loop(self):
        idx = range(self.J)
        self.Xa[idx], xa0, self.Pa[0] \
            = self._next_time_step(self.initial_xa,
                                   self.initial_Pa,
                                   self.Xo[idx])
        self.RMSE_rea_AW[0] = np.nan
        for l in range(1, self.LMAX_for_4D):
            # self.J=5、つまり同化ウィンドウ内で5つ観測を取り込むとすると、
            # 時刻l-1に於ける解析値と時刻l, ..., l+4における観測値をもとに、
            # 時刻l, ..., l+4における解析値(self.Xa[idx])を計算する。
            # xa0というのは、時刻l-1における"再"解析値。
            # RMSE_a_AWは、時刻l+4(l-1)における「解析値」のRMSEで、
            # RMSE_rea_AWは、時刻l+4(l-1)における「再解析値」のRMSE

            # lに対応するインデックス
            idx = range(l * self.J, (l + 1) * self.J)

            self.Xa[idx], xa0, self.Pa[l] \
                = self._next_time_step(self.Xa[l * self.J - 1],
                                       self.Pa[l - 1],
                                       self.Xo[idx])
            self.RMSE_rea_AW[l] \
                = using_jit.cal_RMSE(xa0, self.Xt[l * self.J - 1])

        self.RMSE_a[:] = using_jit.cal_RMSE_2D(self.Xa, self.Xt)
        # for l in range(self.LMAX_for_4D):
        #     self.RMSE_a_AW[l] = self.RMSE_a[(l + 1) * self.J - 1]
        # 上記のコードを最適化すると以下の通り
        self.RMSE_a_AW[:] \
            = self.RMSE_a[(np.arange(self.LMAX_for_4D) + 1) * self.J - 1]
Beispiel #2
0
    def for_loop(self):
        self.Xa[0], self.Pa[0] = self._next_time_step(self.initial_xa,
                                                      self.initial_Pa,
                                                      self.Xo[1])
        for l in range(1, self.LMAX - 1):
            self.Xa[l], self.Pa[l] = self._next_time_step(
                self.Xa[l - 1], self.Pa[l - 1], self.Xo[l + 1])

        self.RMSE_a[:] = using_jit.cal_RMSE_2D(self.Xa, self.Xt)
        # 最後の1時間ステップだけは、解析値をフリーラン。
        LastL = self.LMAX - 1
        self.Xa[LastL] = self.l96.run(self.Xa[LastL - 1],
                                      days=self.assim_interval_days)
        self.RMSE_a[LastL] = using_jit.cal_RMSE(self.Xa[LastL], self.Xt[LastL])
def get_RMSE_o(obs_data, mdl_data):
    import using_jit
    T = 365 * 4
    RMSE_o = np.zeros(T)
    N = obs_data.shape[1]

    for i in range(T):
        xo = np.zeros(N)
        xo[:] = obs_data[i, :]
        xt = np.zeros(N)
        xt[:] = mdl_data[i, :]
        RMSE_o[i] = using_jit.cal_RMSE(xo, xt)  # 観測値と真値とのRMSE。

    return RMSE_o
Beispiel #4
0
    def for_loop(self):
        prev_xa = self.initial_xa
        prev_Pa = self.initial_Pa
        prev_F = self.initial_F
        self.Xo[np.isnan(self.Xo)] = 1e+5

        for l in range(self.LMAX):
            the_xa, the_Pa, the_F = self.Func(prev_xa, prev_F, prev_Pa, self.Xo[l],
                                              self.R, self.delta, self.delta_of_F,
                                              dt=self.dt, days=self.assim_interval_days,
                                              KSC=1e+5)

            self.Xa[l] = the_xa
            self.RMSE_a[l] = using_jit.cal_RMSE(the_xa, self.Xt[l])
            self.Estimating_F[l] = the_F
            prev_xa = the_xa
            prev_Pa = the_Pa
            prev_F = the_F

        self.Xo[self.Xo == 1e+5] = np.nan
Beispiel #5
0
    def steepest_descent_method(self, gradient, initial_x):
        # 最急降下法を生コードから実装します。
        # http://soy-curd.hatenablog.com/entry/2016/05/05/151517
        # http://minus9d.hatenablog.com/entry/2015/01/25/210958
        lr = 0.1
        loop_max = 1000
        eps = 1e-4

        xb = initial_x
        for i in range(loop_max):
            xa = xb - lr / np.sqrt(i + 1) * gradient(xb)
            if i % 10 == 0 and using_jit.cal_RMSE(xa, xb) < eps:
                if self.verbose_opt:
                    print('i=' + str(i))

                break

            xb = xa

        return xa