-Fixed rounding errors by feeding integer data to the Python model also.

libraries/dsp/correlator/tb/python/verify_correlator.py

@@ -98,19 +98,36 @@ def complex_to_int(input_lists):
             re = int(round(input_lists[input_nr][word].real))
             im = int(round(input_lists[input_nr][word].imag))
             print 'Input', input_nr, 'Channel', word, 're,im', re, im
-            re_bits = CommonBits(re, COMPLEX_WIDTH)
-            im_bits = CommonBits(im, COMPLEX_WIDTH)
+            output_list.append(complex(re,im))
+
+        output_lists.append(output_list)
+
+    return output_lists #correlator_snk_in_arr
+
+
+def concat_complex(input_lists):
+    """
+    Concatenate im&re into one integer
+    """
+    output_lists = []
+    for input_nr in range(NOF_INPUTS):
+        output_list = []
+        for word in range(NOF_CHANNELS):
+            re_bits = CommonBits(int(input_lists[input_nr][word].real), COMPLEX_WIDTH)
+            im_bits = CommonBits(int(input_lists[input_nr][word].imag), COMPLEX_WIDTH)
             concat_bits = im_bits & re_bits
             output_list.append(concat_bits.data)
         output_lists.append(output_list)
 
-    return output_lists #correlator_snk_in_arr
+    return output_lists
 
 
 def gen_correlator_snk_in_arr_hex(input_lists):
     """
     bla
     """
+    concat_input_lists = concat_complex(input_lists)
+
     # ==========================================================
     # Interleave the lists if user wants folded correlator input
     # . Note: no support for more than 1 fold yet.
@@ -118,9 +135,9 @@ def gen_correlator_snk_in_arr_hex(input_lists):
     if NOF_FOLDS==1:
         input_stream_lists = []
         for input_stream_nr in range(NOF_INPUT_STREAMS):
-            input_stream_lists.append( interleave([input_lists[2*input_stream_nr], input_lists[2*input_stream_nr+1]] ) )
+            input_stream_lists.append( interleave([concat_input_lists[2*input_stream_nr], concat_input_lists[2*input_stream_nr+1]] ) )
     elif NOF_FOLDS==0:
-        input_stream_lists = input_lists
+        input_stream_lists = concat_input_lists
     
     # ====================
     # Write the HEX files
@@ -146,6 +163,7 @@ def correlate(input_lists, accumulation_factor):
     """
     # First transpose the lists into nof_channels*nof_inputs
     inputs_per_channel = transpose(input_lists)
+
     # Feed each channel to the correlation function
     vis_per_channel = []
     for inputs in inputs_per_channel:
@@ -279,7 +297,7 @@ correlator_snk_in_arr_int = complex_to_int(correlator_snk_in_arr_complex)
 gen_correlator_snk_in_arr_hex(correlator_snk_in_arr_int)
 
 # Calculate correlator output from input lists
-correlator_src_out_arr_ref = correlate(correlator_snk_in_arr_complex, INTEGRATION_PERIOD)
+correlator_src_out_arr_ref = correlate(correlator_snk_in_arr_int, INTEGRATION_PERIOD)
 
 
 
@@ -289,12 +307,49 @@ correlator_src_out_arr_ref = correlate(correlator_snk_in_arr_complex, INTEGRATIO
 # Read test bench output file written by dp_stream_rec_play.vhd
 correlator_src_out_arr = rec_file_to_complex(REC_FILE, complex_width=CORRELATOR_OUTPUT_COMPLEX_WIDTH)
 
+def nozero(input_nr):
+    """
+    Returns a/b when b is non-zero. Otherwise returns almost zero.
+    """
+    if not(input_nr==0):
+        return input_nr
+    else:
+        return 0.00000000000000000000000000000000000001
 
+import sys
+def compare_correlator_src_out_arr(vhdl_out, model_out, max_deviation_factor):
+    """
+    Compare the VHDL correlator's output to the Python model output.
+    . A max_deviation_factor (0..1) is allowed in both the real and the imaginary
+      values -> 1% max = 0.01
+    . A too great deviation results in a False being returned.
+    """
+    passed = True
+    channel_nr = 0
+    for vhdl_channel,model_channel in zip(vhdl_out, model_out):
+        vis_nr = 0
+        for vhdl_visibility,model_visibility in zip(vhdl_channel, model_channel):
+            diff_re = abs(model_visibility.real-vhdl_visibility.real) / nozero(abs(model_visibility.real))
+            diff_im = abs(model_visibility.imag-vhdl_visibility.imag) / nozero(abs(model_visibility.imag))
+
+            if diff_re>max_deviation_factor or diff_im>max_deviation_factor:
+                print 'compare_correlator_src_out_arr: FAILED'
+                print '. channel', channel_nr, 'visibility', vis_nr
+                print '  . diff_re', diff_re
+                print '    . model_visibility.real', model_visibility.real 
+                print '    . vhdl_visibility.real', vhdl_visibility.real
+                print '  . diff_im', diff_im
+                print '    . model_visibility.imag', model_visibility.imag
+                print '    . vhdl_visibility.imag', vhdl_visibility.imag
+
+                sys.exit()
+            vis_nr+=1
+        channel_nr+=1
 
 print 'corr out', correlator_src_out_arr[0]
 print 'corr ref', correlator_src_out_arr_ref[0]
 
-
+compare_correlator_src_out_arr(correlator_src_out_arr, correlator_src_out_arr_ref, 0.001)
 
 def plot_phase_shifts(correlator_output):
     """