git.gag.com Git - debian/gnuradio/blob - gr-gcell/src/qa_fft.py

   1 #!/usr/bin/env python
   2 #
   3 # Copyright 2008 Free Software Foundation, Inc.
   4 #
   5 # This file is part of GNU Radio
   6 #
   7 # GNU Radio is free software; you can redistribute it and/or modify
   8 # it under the terms of the GNU General Public License as published by
   9 # the Free Software Foundation; either version 3, or (at your option)
  10 # any later version.
  11 #
  12 # GNU Radio is distributed in the hope that it will be useful,
  13 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 # GNU General Public License for more details.
  16 #
  17 # You should have received a copy of the GNU General Public License along
  18 # with this program; if not, write to the Free Software Foundation, Inc.,
  19 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20 #
  21
  22 from gnuradio import gr, gr_unittest
  23 import gcell
  24 import sys
  25 import random
  26
  27 primes = (2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,
  28           59,61,67,71,73,79,83,89,97,101,103,107,109,113,127,131,
  29           137,139,149,151,157,163,167,173,179,181,191,193,197,199,211,223,
  30           227,229,233,239,241,251,257,263,269,271,277,281,283,293,307,311)
  31
  32
  33 class test_fft_filter(gr_unittest.TestCase):
  34
  35     def setUp(self):
  36         ph = gcell.program_handle_from_filename("../../gcell/lib/spu/gcell_all")
  37         opts = gcell.jm_options(ph, 1)
  38         self.mgr = gcell.job_manager(opts)
  39         gcell.set_singleton(self.mgr)
  40
  41     def tearDown(self):
  42         pass
  43
  44     def assert_fft_ok2(self, expected_result, result_data):
  45         expected_result = expected_result[:len(result_data)]
  46         self.assertComplexTuplesAlmostEqual2 (expected_result, result_data,
  47                                               abs_eps=1e-9, rel_eps=4e-4)
  48
  49     def assert_fft_float_ok2(self, expected_result, result_data, abs_eps=1e-9, rel_eps=4e-4):
  50         expected_result = expected_result[:len(result_data)]
  51         self.assertFloatTuplesAlmostEqual2 (expected_result, result_data,
  52                                             abs_eps, rel_eps)
  53
  54     def test_001(self):
  55         tb = gr.top_block()
  56         fft_size = 32
  57         src_data = tuple([complex(primes[2*i], primes[2*i+1]) for i in range(fft_size)])
  58
  59         expected_result = ((4377+4516j),
  60                            (-1706.1268310546875+1638.4256591796875j),
  61                            (-915.2083740234375+660.69427490234375j),
  62                            (-660.370361328125+381.59600830078125j),
  63                            (-499.96044921875+238.41630554199219j),
  64                            (-462.26748657226562+152.88948059082031j),
  65                            (-377.98440551757812+77.5928955078125j),
  66                            (-346.85821533203125+47.152004241943359j),
  67                            (-295+20j),
  68                            (-286.33609008789062-22.257017135620117j),
  69                            (-271.52999877929688-33.081821441650391j),
  70                            (-224.6358642578125-67.019538879394531j),
  71                            (-244.24473571777344-91.524826049804688j),
  72                            (-203.09068298339844-108.54627227783203j),
  73                            (-198.45195007324219-115.90768432617188j),
  74                            (-182.97744750976562-128.12318420410156j),
  75                            (-167-180j),
  76                            (-130.33688354492188-173.83778381347656j),
  77                            (-141.19784545898438-190.28807067871094j),
  78                            (-111.09677124023438-214.48896789550781j),
  79                            (-70.039543151855469-242.41630554199219j),
  80                            (-68.960540771484375-228.30015563964844j),
  81                            (-53.049201965332031-291.47097778320312j),
  82                            (-28.695289611816406-317.64553833007812j),
  83                            (57-300j),
  84                            (45.301143646240234-335.69509887695312j),
  85                            (91.936195373535156-373.32437133789062j),
  86                            (172.09465026855469-439.275146484375j),
  87                            (242.24473571777344-504.47515869140625j),
  88                            (387.81732177734375-666.6788330078125j),
  89                            (689.48553466796875-918.2142333984375j),
  90                            (1646.539306640625-1694.1956787109375j))
  91
  92         src = gr.vector_source_c(src_data)
  93         s2v = gr.stream_to_vector(gr.sizeof_gr_complex, fft_size)
  94         fft = gcell.fft_vcc(fft_size, True, [], False)
  95         v2s = gr.vector_to_stream(gr.sizeof_gr_complex, fft_size)
  96         dst = gr.vector_sink_c()
  97         tb.connect(src, s2v, fft, v2s, dst)
  98         tb.run()
  99         result_data = dst.data()
 100         #print 'expected:', expected_result
 101         #print 'results: ', result_data
 102         #self.assertComplexTuplesAlmostEqual (expected_result, result_data, 5)
 103         self.assert_fft_ok2(expected_result, result_data)
 104
 105     def test_002(self):
 106         tb = gr.top_block()
 107         fft_size = 32
 108
 109         tmp_data = ((4377+4516j),
 110                     (-1706.1268310546875+1638.4256591796875j),
 111                     (-915.2083740234375+660.69427490234375j),
 112                     (-660.370361328125+381.59600830078125j),
 113                     (-499.96044921875+238.41630554199219j),
 114                     (-462.26748657226562+152.88948059082031j),
 115                     (-377.98440551757812+77.5928955078125j),
 116                     (-346.85821533203125+47.152004241943359j),
 117                     (-295+20j),
 118                     (-286.33609008789062-22.257017135620117j),
 119                     (-271.52999877929688-33.081821441650391j),
 120                     (-224.6358642578125-67.019538879394531j),
 121                     (-244.24473571777344-91.524826049804688j),
 122                     (-203.09068298339844-108.54627227783203j),
 123                     (-198.45195007324219-115.90768432617188j),
 124                     (-182.97744750976562-128.12318420410156j),
 125                     (-167-180j),
 126                     (-130.33688354492188-173.83778381347656j),
 127                     (-141.19784545898438-190.28807067871094j),
 128                     (-111.09677124023438-214.48896789550781j),
 129                     (-70.039543151855469-242.41630554199219j),
 130                     (-68.960540771484375-228.30015563964844j),
 131                     (-53.049201965332031-291.47097778320312j),
 132                     (-28.695289611816406-317.64553833007812j),
 133                     (57-300j),
 134                     (45.301143646240234-335.69509887695312j),
 135                     (91.936195373535156-373.32437133789062j),
 136                     (172.09465026855469-439.275146484375j),
 137                     (242.24473571777344-504.47515869140625j),
 138                     (387.81732177734375-666.6788330078125j),
 139                     (689.48553466796875-918.2142333984375j),
 140                     (1646.539306640625-1694.1956787109375j))
 141
 142         src_data = tuple([x/fft_size for x in tmp_data])
 143
 144         expected_result = tuple([complex(primes[2*i], primes[2*i+1]) for i in range(fft_size)])
 145
 146         src = gr.vector_source_c(src_data)
 147         s2v = gr.stream_to_vector(gr.sizeof_gr_complex, fft_size)
 148         fft = gcell.fft_vcc(fft_size, False, [], False)
 149         v2s = gr.vector_to_stream(gr.sizeof_gr_complex, fft_size)
 150         dst = gr.vector_sink_c()
 151         tb.connect(src, s2v, fft, v2s, dst)
 152         tb.run()
 153         result_data = dst.data()
 154         #print 'expected:', expected_result
 155         #print 'results: ', result_data
 156         #self.assertComplexTuplesAlmostEqual (expected_result, result_data, 5)
 157         self.assert_fft_ok2(expected_result, result_data)
 158
 159
 160 if __name__ == '__main__':
 161     gr_unittest.main ()
 162