예제 #1
0
    def test_trans_dct(self):
        print('\nChecking transposed DCT')
        Ns = np.arange(4, 15, 1)
        for dim, Ni in itertools.product([2], Ns):
            N = np.array(dim * [
                Ni,
            ], dtype=np.int)
            print(N)
            u = Chebyshev_element(name='u', N=N, shape=(), multype='scal')
            u.set_nodal_coord()
            u.val = np.random.rand(N[0], N[1]) * 1
            u.Fourier = True
            u.idct()

            v = Chebyshev_element(name='u', N=N, shape=(), multype='scal')
            v.set_nodal_coord()
            v.val = np.random.rand(N[0], N[1]) * 1
            v.Fourier = True
            v.idct()

            def transform(a, b):
                b.dct()
                b.idct()
                scal = Chebyshev_element(name='scal',
                                         N=N,
                                         shape=(),
                                         multype='scal')
                scal.set_nodal_coord()
                scal.val = np.multiply(a.val, b.val)
                return scal.val

            def transposed_transform(a, b):
                # a.Fourier=True
                a.idct_trans()
                a.dct_trans()
                scal2 = Chebyshev_element(name='scal2',
                                          N=N,
                                          shape=(),
                                          multype='scal')
                scal2.set_nodal_coord()
                scal2.val = np.multiply(a.val, b.val)
                return scal2.val

            forward = transform(copy.deepcopy(u), copy.deepcopy(v))
            transposed = transposed_transform(copy.deepcopy(u),
                                              copy.deepcopy(v))

            #  print('  sum((u,Fv)   ={})'.format(np.sum(forward)))
            #  print('  sum((Ftu,v)   ={})'.format(np.sum(transposed)))
            #  print(' dif sum((Ftu,v)-(u,Fv))   ={})'.format(np.sum(transposed-forward)))

            self.assertTrue(np.isclose(np.sum(forward),
                                       np.sum(transposed),
                                       rtol=1e-10,
                                       atol=1e-08,
                                       equal_nan=False),
                            msg="Transposed DCT does not work correctly")
예제 #2
0
    def test_grad_transpose(self):
        print('\nChecking adjoin to gradient')
        Ns = np.arange(4, 25, 1)
        for dim, Ni in itertools.product([2], Ns):
            N = np.array(dim * [
                Ni,
            ], dtype=np.int)
            print(N)
            # u_val = lambda x: (x[0]**0 )*(x[1]**0 )

            u = Chebyshev_element(name='u', N=N, shape=(2, ), multype='scal')
            u.set_nodal_coord()
            u.val[0] = np.random.rand(N[0], N[1]) * 1
            u.val[1] = np.random.rand(N[0], N[1]) * 1
            u.Fourier = True
            u.idct()

            # u.Fourier = True

            v = Chebyshev_element(name='u', N=N, shape=(), multype='scal')
            v.set_nodal_coord()
            v.val = np.random.rand(N[0], N[1]) * 1  #u_val(u.coord)
            v.Fourier = True
            v.idct()

            #v.Fourier = True
            # u.grad_transpose()
            # print(u.val)

            def grad_forward(a, b):
                b.dct()
                b.grad()
                b.idct()

                scal = Chebyshev_element(name='scal',
                                         N=N,
                                         shape=(),
                                         multype='scal')
                scal.set_nodal_coord()
                scal.val = np.multiply(a.val, b.val)
                return scal.val

            def transposed_grad(a, b):
                # a.Fourier = True
                a.idct_trans()
                #   a.Fourier = True
                a.grad_transpose()
                #  a.Fourier = False
                a.dct_trans()
                scal2 = Chebyshev_element(name='scal2',
                                          N=N,
                                          shape=(),
                                          multype='scal')
                scal2.set_nodal_coord()
                scal2.val = np.multiply(a.val, b.val)
                return scal2.val

            forward = grad_forward(copy.deepcopy(u), copy.deepcopy(v))
            #print(forward)
            transposed = transposed_grad(copy.deepcopy(u), copy.deepcopy(v))
            #print(transposed)
            #print('  sum((u,iFGFv)   ={})'.format(np.sum(forward)))
            #print('  sum((FtGtiFtu,v)   ={})'.format(np.sum(transposed)))
            #    print(' dif sum((Ftu,v)-(u,Fv))   ={})'.format(np.sum(transposed)-np.sum(forward)))

            self.assertTrue(np.isclose(np.sum(forward),
                                       np.sum(transposed),
                                       rtol=1e-10,
                                       atol=1e-08,
                                       equal_nan=False),
                            msg="Transposed DCT does not work correctly")