Exemple #1
0
    def __init__(self, _grid, _power, _noiselevel, _dt):
        self.grid = _grid
        # self.dt = min([self.grid.dx**2, self.grid.dy**2]) * self.cfl
        self.dt = _dt

        SkelSimulation.__init__(self, _noiselevel, self.dt, self.grid.shape)
        self.power = _power

        # compute matrix
        self.calcmat()
        self.calcmatbc()

        # rhs and boundary conditions
        self.field = np.zeros([self.size])
        self.calcbc(self.It,self.field)
        
        if self.isimplicit:
#            self.Mat = np.linalg.inv(self.Mat)
            self.Mat = inv(self.Mat)
            
        indx = self.grid.indx
        self.staticfield = np.zeros([self.size])
        wx = 2. *  math.pi / self.grid.Lx
        wy = 2. *  math.pi / self.grid.Ly
        for i in range(self.grid.nx):
            for j in range(self.grid.ny):
                x = self.grid.coordx[i][j]
                y = self.grid.coordy[i][j]
                self.staticfield[indx(i, j)] =  math.sin(wx * x) * math.sin(wy * y)
            
        gc_clean()
Exemple #2
0
 def __init__(self, _noiselevel, _dt, _shape):
     self.noiselevel = _noiselevel
     self.dt = _dt
     self.addnoisev = np.vectorize(self.addnoise)
     self.size = np.prod(_shape)
     self.field = np.zeros(_shape)
     gc_clean()
Exemple #3
0
 def __init__(self):
     self.simulation = SkelSimulation(self.noise_sim, self.dt, [0])
     self.kalsim = SkelSimulation(self.noise_sim, self.dt, [0])
     self.dt = self.simulation.dt
     self.reality = SkelReality(self.noise_real, self.dt, [0])
     self.kalman = SkelKalmanWrapper(self.reality, self.kalsim)
     gc_clean()
Exemple #4
0
 def __init__(self):
     EDP.__init__(self)
     self.reinit()
     gc_clean()
     print("cfl = ",
           max([self.dt / (self.grid.dx**2), self.dt / (self.grid.dy**2)]))
     print("dt = ", self.dt)
     print("Norme H1 |  reality |   simu   |  kalman")
Exemple #5
0
 def __init__(self, _noiselevel, _dt, _shape):
     self.noiselevel = _noiselevel
     self.dt = _dt
     self.size = np.product(_shape)
     self.field = np.zeros(_shape)
     self.Mat = np.zeros(self.size)
     self.rhs = np.zeros(self.size)
     gc_clean()
Exemple #6
0
 def __init__(self, _grid, _power, _noiselevel, _dt):
     self.grid = _grid
     SkelReality.__init__(self, _noiselevel, _dt, _grid.shape)
     self.power = _power
     wx = 2. *  math.pi / self.grid.Lx
     wy = 2. *  math.pi / self.grid.Ly
     self.initfield = np.zeros([self.grid.nx, self.grid.ny])
     for i in range(self.grid.nx):
         for j in range(self.grid.ny):
             x = self.grid.coordx[i][j]
             y = self.grid.coordy[i][j]
             self.initfield[i][j] = math.sin(wx * x) \
                                  * math.sin(wy * y)
     gc_clean()
Exemple #7
0
    def __init__(self, _reality, _sim):
        self.reality = _reality
        self.kalsim = _sim

        self.It = self.kalsim.It
        self.nIt = self.kalsim.nIt
        self.err = self.kalsim.err
        self.dt = self.kalsim.dt
        self.size = self.kalsim.size

        _M = self.getwindow()  # Observation matrix.
        self.kalman = KalmanFilterObservator(self.kalsim, _M)
        # Initial covariance estimate.
        self.kalman.S = np.empty([self.kalman.size_s])
        # Estimated error in measurements.
        self.kalman.R = np.empty([self.kalman.size_o])
        self.kalman.R.fill(self.reality.noiselevel ** 2)
        # Estimated error in process.
        self.kalman.Q = np.empty([self.kalman.size_s])
        self.kalman.Q.fill(self.kalsim.noiselevel ** 2)
        gc_clean()
Exemple #8
0
    def __init__(self, _reality, _sim):
        SkelKalmanWrapper.__init__(self, _reality, _sim)
        self.size = self.kalsim.size
        _M = self.getwindow()  # Observation matrix.
        self.kalman = KalmanFilterObservator(self.kalsim, _M)
        indx = self.kalsim.grid.indx

#        # Initial covariance estimate.
#        self.kalman.S = np.eye(self.kalman.size_s) * \
#            0. ** 2

#        # Estimated error in measurements.
#        self.kalman.R = np.eye(self.kalman.size_o) * \
#            self.reality.noiselevel ** 2

        # Estimated error in process.
        # G = np.zeros([self.kalman.size_s, 1])
        # for i in range(self.kalsim.grid.nx):
        #     for j in range(self.kalsim.grid.ny):
        #         G[indx(i, j)] = self.kalsim.grid.dx ** 4 / 24. \
        #                       + self.kalsim.grid.dy ** 4 / 24. \
        #                       + self.kalsim.dt ** 2 / 2.
        #         # G[indx(i, j)] = self.kalsim.dt
        #
        # self.kalman.Q = G.dot(np.transpose(G)) * self.kalsim.noiselevel ** 2

#        self.kalman.Q = np.eye(self.kalman.size_s) * \
#            self.kalnoise ** 2

        self.kalman.S = np.empty([self.kalman.size_s])
        self.kalman.R = np.empty([self.kalman.size_o])
        self.kalman.Q = np.empty([self.kalman.size_s])
        self.kalman.R.fill(self.reality.noiselevel ** 2)
        self.kalman.Q.fill(self.reality.noiselevel ** 2)
            
        gc_clean()