Subversion Repositories astron_wpfb

-- Author: Harm Jan Pepping : HJP at astron.nl: April 2012
--------------------------------------------------------------------------------
--
-- Copyright (C) 2012
-- ASTRON (Netherlands Institute for Radio Astronomy) <http://www.astron.nl/>
-- P.O.Box 2, 7990 AA Dwingeloo, The Netherlands
--
-- This program is free software: you can redistribute it and/or modify
-- it under the terms of the GNU General Public License as published by
-- the Free Software Foundation, either version 3 of the License, or
-- (at your option) any later version.
--
-- This program is distributed in the hope that it will be useful,
-- but WITHOUT ANY WARRANTY; without even the implied warranty of
-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-- GNU General Public License for more details.
--
-- You should have received a copy of the GNU General Public License
-- along with this program.  If not, see <http://www.gnu.org/licenses/>.
--
--------------------------------------------------------------------------------
 
--
-- Purpose: Test bench for the Wideband Poly Phase Filter Bank
--
--
-- Usage:
--   > run -all
--   > testbench is selftesting. 
--
-- Remarks:
--         . The first c_nof_spectra_in_file(= 8) spectrums are verified.
--         . The statistics are verified, based on the raw output of the DUT. 
--         . Currently only the Noise file is tested.
--
--!!!NOTE!!! This testbench has become obsolete since the quantization of 
--           the FFT algorithm is changed. The testbench still works, but 
--           the goldenfiles are not valid anymore and therefor the test-
--           bench will report that the output contains errors. 
--           The tb_wpfb_unit testbench is replaced by the tb_mmf_wpfb_unit
--           testbench, which is a co-simulation between modelsim and python.  
--                 
--
 
library ieee, common_pkg_lib, dp_pkg_lib, astron_diagnostics_lib, astron_r2sdf_fft_lib, astron_wb_fft_lib, astron_filter_lib, astron_ram_lib, astron_mm_lib;
use IEEE.std_logic_1164.all;
use IEEE.numeric_std.all;
use IEEE.std_logic_textio.all;
use STD.textio.all;
use common_pkg_lib.common_pkg.all;
use astron_ram_lib.common_ram_pkg.ALL;
use common_pkg_lib.common_lfsr_sequences_pkg.all;
use common_pkg_lib.tb_common_pkg.all;
use astron_mm_lib.tb_common_mem_pkg.ALL;
use dp_pkg_lib.dp_stream_pkg.ALL;
use astron_r2sdf_fft_lib.twiddlesPkg.all;
use astron_r2sdf_fft_lib.rTwoSDFPkg.all;
use astron_wb_fft_lib.tb_fft_pkg.all;
use astron_wb_fft_lib.fft_pkg.all;
use astron_filter_lib.fil_pkg.all;
use work.wpfb_pkg.all;
 
entity tb_wpfb_unit is
  generic(
    -- generics for tb
    g_use_uniNoise_file  : boolean  := true;  
    g_use_sinus_file     : boolean  := false;  
    g_use_sinNoise_file  : boolean  := false;  
    g_use_impulse_file   : boolean  := false;
 
    --  type t_wpfb is record  
    --  -- General parameters for the wideband poly phase filter
    --  wb_factor         : natural;        -- = default 4, wideband factor
    --  nof_points        : natural;        -- = 1024, N point FFT (Also the number of subbands for the filetr part)
    --  nof_chan          : natural;        -- = default 0, defines the number of channels (=time-multiplexed input signals): nof channels = 2**nof_chan     
    --  nof_streams       : natural;        -- = 1, the number of parallel streams. The filter coefficients are shared on every stream. 
    --  
    --  -- Parameters for the poly phase filter
    --  nof_taps          : natural;        -- = 16, the number of FIR taps per subband
    --  fil_backoff_w     : natural;        -- = 0, number of bits for input backoff to avoid output overflow
    --  fil_in_dat_w      : natural;        -- = 8, number of input bits
    --  fil_out_dat_w     : natural;        -- = 16, number of output bits
    --  coef_dat_w        : natural;        -- = 16, data width of the FIR coefficients
    --                                    
    --  -- Parameters for the FFT         
    --  use_reorder       : boolean;        -- = false for bit-reversed output, true for normal output
    --  use_fft_shift     : boolean;        -- = false for [0, pos, neg] bin frequencies order, true for [neg, 0, pos] bin frequencies order in case of complex input
    --  use_separate      : boolean;        -- = false for complex input, true for two real inputs
    --  fft_in_dat_w      : natural;        -- = 16, number of input bits
    --  fft_out_dat_w     : natural;        -- = 13, number of output bits
    --  fft_out_gain_w    : natural;        -- = 0, output gain factor applied after the last stage output, before requantization to out_dat_w
    --  stage_dat_w       : natural;        -- = 18, number of bits that are used inter-stage
    --  guard_w           : natural;        -- = 2
    --  guard_enable      : boolean;        -- = true
    --
    --  -- Parameters for the statistics
    --  stat_data_w       : positive;       -- = 56
    --  stat_data_sz      : positive;       -- = 2
    --  nof_blk_per_sync  : natural;        -- = 800000, number of FFT output blocks per sync interval
    --
    --  -- Pipeline parameters for both poly phase filter and FFT. These are heritaged from the filter and fft libraries.  
    --  pft_pipeline      : t_fft_pipeline;     -- Pipeline settings for the pipelined FFT
    --  fft_pipeline      : t_fft_pipeline;     -- Pipeline settings for the parallel FFT
    --  fil_pipeline      : t_fil_ppf_pipeline; -- Pipeline settings for the filter units 
    --  
    --  end record;
 
    g_wpfb   : t_wpfb  := (4, 1024, 0, 1,                                        
                           16, 0, 8, 16, 16,                                  
                           true, false, true, 16, 16, 0, 18, 2, true, 56, 2, 10,
                           c_fft_pipeline, c_fft_pipeline, c_fil_ppf_pipeline);
 
    g_coefs_file_prefix : string            := "data/coefs_wide"      
 
  );
 
end entity tb_wpfb_unit;
 
architecture tb of tb_wpfb_unit is
 
  constant c_clk_period : time    := 100 ns;   
 
  constant c_fft        : t_fft   := (g_wpfb.use_reorder,
                                      g_wpfb.use_fft_shift,  
                                      g_wpfb.use_separate,  
                                      0,                                            
                                      g_wpfb.wb_factor,
                                      0,
                                      g_wpfb.nof_points, 
                                      g_wpfb.fft_in_dat_w, 
                                      g_wpfb.fft_out_dat_w,
                                      g_wpfb.fft_out_gain_w,
                                      g_wpfb.stage_dat_w,
                                      g_wpfb.guard_w,
                                      g_wpfb.guard_enable,
                                      g_wpfb.stat_data_w, 
                                      g_wpfb.stat_data_sz); 
 
  -- input/output data width
  constant c_in_dat_w   : natural := g_wpfb.fil_in_dat_w;   
  constant c_twiddle_w  : natural := 16;
  constant c_out_dat_w  : natural := g_wpfb.fft_out_dat_w; --   g_rtwo_fft.in_dat_w + natural((ceil_log2(g_rtwo_fft.nof_points))/2 + 2);  -- bit growth
 
  -- input/output files
  constant c_nof_spectra_in_file : natural := 8;
  constant c_file_len            : natural := c_nof_spectra_in_file*g_wpfb.nof_points;
  constant c_nof_spectra_to_output_file : natural := 8; 
 
  -- block generator  
  constant c_bg_mem_size           : natural := g_wpfb.nof_points/g_wpfb.wb_factor;
  constant c_bg_addr_w             : natural := ceil_log2(c_bg_mem_size);
  constant c_nof_samples_in_packet : natural := c_bg_mem_size;
  constant c_gap                   : natural := 0;    -- Gapsize is set to 0 in order to generate a continuous stream of packets. 
  constant c_nof_accum_per_sync    : natural := g_wpfb.nof_blk_per_sync;
  constant c_bsn_init              : natural := 32; 
  constant c_bg_prefix             : string  := "UNUSED";
  constant c_nof_sync_periods      : natural := 10; 
  constant c_bst_skip_nof_sync     : natural := 3;  
 
  constant c_nof_bands_per_chn     : natural := g_wpfb.nof_points/g_wpfb.wb_factor;
  constant c_normal                : boolean := true; 
 
  -- input from uniform noise file created automatically by MATLAB testFFT_input.m
  constant c_noiseInputFile    : string := "data/uniNoise_in.txt";
  constant c_noiseGoldenFile   : string := "data/uniNoise_p" & natural'image(g_wpfb.nof_points)& "_t"& natural'image(g_wpfb.nof_taps) & "_gold.txt";
  constant c_noiseOutputFile   : string := "data/uniNoise_out.txt";
 
  constant c_inputFile  : string := c_noiseInputFile;
 
  constant c_goldenFile : string := c_noiseGoldenFile;
 
  constant c_outputFile : string := c_noiseOutputFile;
 
  constant c_coefs_file_prefix : string := g_coefs_file_prefix & natural'image(g_wpfb.wb_factor) & "_p"& natural'image(g_wpfb.nof_points) & "_t"& natural'image(g_wpfb.nof_taps);
 
  -- signal definitions
  signal tb_end         : std_logic := '0';
  signal clk            : std_logic := '0';
  signal rst            : std_logic := '0';
 
  signal out_sync       : std_logic:= '0';
  signal out_val        : std_logic:= '0';
  signal out_re_arr     : t_fft_slv_arr(g_wpfb.wb_factor-1 downto 0);
  signal out_im_arr     : t_fft_slv_arr(g_wpfb.wb_factor-1 downto 0);
 
  signal in_file_data   : t_integer_matrix(0 to c_file_len-1, 1 to 2) := (others=>(others=>0));  -- [re, im]
  signal in_file_sync   : std_logic_vector(0 to c_file_len-1):= (others=>'0');
  signal in_file_val    : std_logic_vector(0 to c_file_len-1):= (others=>'0');
 
  signal gold_file_data : t_integer_matrix(0 to c_file_len-1, 1 to 2) := (others=>(others=>0));  -- [re, im]
  signal gold_file_sync : std_logic_vector(0 to c_file_len-1):= (others=>'0');
  signal gold_file_val  : std_logic_vector(0 to c_file_len-1):= (others=>'0');
 
  signal gold_sync      : std_logic;
  signal gold_re_arr    : t_integer_arr(g_wpfb.wb_factor-1 downto 0);
  signal gold_im_arr    : t_integer_arr(g_wpfb.wb_factor-1 downto 0);    
 
  signal init_waveforms_done   : std_logic;
 
  signal in_sosi_arr     : t_dp_sosi_arr(g_wpfb.wb_factor-1 downto 0);
  signal in_siso_arr     : t_dp_siso_arr(g_wpfb.wb_factor-1 downto 0);
 
  type   t_dp_sosi_matrix  is array (integer range <>) of t_dp_sosi_arr(0 downto 0);
  type   t_dp_siso_matrix  is array (integer range <>) of t_dp_siso_arr(0 downto 0);
 
  signal in_sosi_matrix  : t_dp_sosi_matrix(g_wpfb.wb_factor-1 downto 0);  
  signal in_siso_matrix  : t_dp_siso_matrix(g_wpfb.wb_factor-1 downto 0);  
 
  signal result_sosi_arr : t_dp_sosi_arr(g_wpfb.wb_factor-1 downto 0);
 
  signal ram_sst_mosi    : t_mem_mosi := c_mem_mosi_rst;
  signal ram_sst_miso    : t_mem_miso := c_mem_miso_rst; 
 
  signal ram_coefs_mosi  : t_mem_mosi := c_mem_mosi_rst;  
  signal ram_coefs_miso  : t_mem_miso := c_mem_miso_rst;  
  signal coefs_arr       : t_integer_arr (c_nof_bands_per_chn-1 downto 0); 
 
  signal ram_bg_data_mosi_arr : t_mem_mosi_arr(g_wpfb.wb_factor-1 downto 0) := (others => c_mem_mosi_rst );  
  signal reg_bg_ctrl_mosi     : t_mem_mosi; 
 
  signal reg_diag_bg_dut_mosi : t_mem_mosi := c_mem_mosi_rst; 
  signal reg_diag_bg_dut_miso : t_mem_miso := c_mem_miso_rst; 
 
  signal ram_diag_bg_dut_mosi : t_mem_mosi := c_mem_mosi_rst; 
  signal ram_diag_bg_dut_miso : t_mem_miso := c_mem_miso_rst;  
 
  -- Subband Statistics output
  -- . DUT result
  signal result_sst_arr_temp   : t_slv_64_arr(c_nof_samples_in_packet-1 downto 0);
  signal result_sst_arr        : t_slv_64_arr(g_wpfb.nof_points-1 downto 0);
  -- . Expected result
  signal expected_sst_arr      : t_slv_64_arr(g_wpfb.nof_points-1 downto 0) := (others => (others => '0'));
 
  signal coefs_mem_write : boolean := FALSE;                             
  signal temp_reg        : integer;
 
begin
 
  clk <= (not clk) or tb_end after c_clk_period/2;
  rst <= '1', '0' after c_clk_period*7;
 
  ---------------------------------------------------------------
  -- WRITE AND READ THE COEFFICIENTS TO THE COEFS MEMORY
  ---------------------------------------------------------------  
  p_coefs_memory_write : process    
  begin
    coefs_mem_write <= FALSE;                           
    ram_coefs_mosi  <= c_mem_mosi_rst;             -- Reset the master out interface
    -- Write the coefficients
    for L in 0 to c_nof_complex loop               -- There are two filters in the DUT: real and imaginary
      for K in 0 to g_wpfb.wb_factor-1 loop
        for J in 0 to g_wpfb.nof_taps-1 loop
          proc_common_read_mif_file(c_coefs_file_prefix & "_" & integer'image(k*g_wpfb.nof_taps+J) & ".mif", coefs_arr); 
          wait for 1 ns; 
          for I in 0 to c_nof_bands_per_chn-1 loop 
            proc_mem_mm_bus_wr(L*g_wpfb.nof_points*g_wpfb.nof_taps + K*c_nof_bands_per_chn*g_wpfb.nof_taps + J*c_nof_bands_per_chn + I, coefs_arr(I), clk, ram_coefs_mosi); -- Write the coefficient to the memory       
          end loop;
        end loop; 
      end loop;
    end loop;                
    -- Read the coefficients back and verify
    for L in 0 to c_nof_complex loop               -- There are two filters in the DUT: real and imaginary
      for K in 0 to g_wpfb.wb_factor-1 loop
        for J in 0 to g_wpfb.nof_taps-1 loop
          proc_common_read_mif_file(c_coefs_file_prefix & "_" & integer'image(k*g_wpfb.nof_taps+J) & ".mif", coefs_arr); 
          wait for 1 ns; 
          for I in 0 to c_nof_bands_per_chn-1 loop 
            proc_mem_mm_bus_rd(L*g_wpfb.nof_points*g_wpfb.nof_taps + K*c_nof_bands_per_chn*g_wpfb.nof_taps + J*c_nof_bands_per_chn + I, clk, ram_coefs_miso, ram_coefs_mosi); -- Read the coefficient from the memory       
            temp_reg <= coefs_arr(I);
            if(ram_coefs_miso.rdval = '1') then 
              assert temp_reg = TO_UINT(ram_coefs_miso.rddata(g_wpfb.coef_dat_w-1 downto 0))  report "Read data from memory error" severity error;
            end if; 
          end loop;
          proc_common_wait_some_cycles(clk, 1); 
        end loop; 
      end loop;
    end loop;                
 
    coefs_mem_write <= TRUE;                           
    wait;
  end process;
 
  ---------------------------------------------------------------
  -- READ STIMULI DATA FROM INPUT FILE
  ---------------------------------------------------------------  
  proc_read_input_file(clk, in_file_data, c_inputFile); 
 
  ------------------------------------------------------------------------------
  -- WRITE THE WAVEFORMS INTO MEMORY FOR EACH INPUT STREAM.
  ------------------------------------------------------------------------------
  gen_init_waveforms : for I in 0 to g_wpfb.wb_factor-1 generate
    p_init_waveforms_memory : process
      variable v_mem_data : std_logic_vector(c_nof_complex*g_wpfb.fil_in_dat_w-1 downto 0);
    begin
      init_waveforms_done <= '0';
 
      proc_common_wait_until_low(clk, rst);      -- Wait until reset has finished
      proc_common_wait_some_cycles(clk, 10);     -- Wait an additional amount of cycles
 
      for J in 0 to c_bg_mem_size-1 loop
        v_mem_data := (others => '0');
        v_mem_data := TO_SVEC(in_file_data(I+J*g_wpfb.wb_factor, 2), g_wpfb.fil_in_dat_w) & TO_SVEC(in_file_data(I+J*g_wpfb.wb_factor, 1), g_wpfb.fil_in_dat_w); 
        proc_mem_mm_bus_wr(J, v_mem_data, clk, ram_bg_data_mosi_arr(I));
      end loop;
 
      init_waveforms_done <= '1';
      wait;
    end process;    
  end generate;
 
  ------------------------------------------------------------------------------
  -- CONFIGURE AND ENABLE THE BLOCK GENERATORS (Start Stimuli)
  ------------------------------------------------------------------------------
  p_control_input_stream : process
  begin   
    reg_bg_ctrl_mosi <= c_mem_mosi_rst;  
 
    -- Wait until reset is done
    proc_common_wait_until_high(clk, rst);
    proc_common_wait_some_cycles(clk, 10);
    wait until init_waveforms_done = '1';       -- Wait until the waveform data is written. 
    wait until coefs_mem_write     = TRUE;      -- Wait until the coefficients are written. 
 
    -- Set and enable the waveform generators. All generators are controlled by the same registers
    proc_mem_mm_bus_wr(1, c_nof_samples_in_packet, clk, reg_bg_ctrl_mosi);  -- Set the number of samples per block
    proc_mem_mm_bus_wr(2, c_nof_accum_per_sync,    clk, reg_bg_ctrl_mosi);  -- Set the number of blocks per sync
    proc_mem_mm_bus_wr(3, c_gap,                   clk, reg_bg_ctrl_mosi);  -- Set the gapsize
    proc_mem_mm_bus_wr(4, 0,                       clk, reg_bg_ctrl_mosi);  -- Set the start address of the memory
    proc_mem_mm_bus_wr(5, c_bg_mem_size-1,         clk, reg_bg_ctrl_mosi);  -- Set the end address of the memory
    proc_mem_mm_bus_wr(6, c_bsn_init,              clk, reg_bg_ctrl_mosi);  -- Set the BSNInit low  value
    proc_mem_mm_bus_wr(7, 0,                       clk, reg_bg_ctrl_mosi);  -- Set the BSNInit high value
    proc_mem_mm_bus_wr(0, 1,                       clk, reg_bg_ctrl_mosi);  -- Enable the BG
 
    -- Run time is defined by:
    --   * the number of sync periods
    --   * the number of packets in a sync period (c_nof_accum_per_sync)
    --   * the number of samples in a packet
    --   * the gap size
    proc_common_wait_some_cycles(clk, c_nof_sync_periods*c_nof_accum_per_sync*(c_nof_samples_in_packet+c_gap));
 
    -- Disable the BG
    proc_mem_mm_bus_wr(0, 0, clk, reg_bg_ctrl_mosi);              
 
    -- Wait some additional time in order to let release the pipline stages of the FFT. 
    proc_common_wait_some_cycles(clk, 4*g_wpfb.nof_points);
    tb_end <= '1';
 
    wait;    
  end process;
 
  ---------------------------------------------------------------  
  -- GENERATE BLOCK GENERATORS FOR STIMULI GENERATION
  ---------------------------------------------------------------  
  gen_block_gen : for I in 0 to g_wpfb.wb_factor-1 generate
    u_block_generator : entity astron_diagnostics_lib.mms_diag_block_gen 
    generic map(    
      g_nof_streams        => 1,
      g_buf_dat_w          => c_nof_complex*g_wpfb.fil_in_dat_w, 
      g_buf_addr_w         => c_bg_addr_w,  
      g_file_name_prefix   => c_bg_prefix
    )
    port map(
     -- Clocks and Reset
      mm_rst           => rst, 
      mm_clk           => clk, 
      dp_rst           => rst, 
      dp_clk           => clk,
      en_sync          => '1',
      ram_bg_data_mosi => ram_bg_data_mosi_arr(I), 
      ram_bg_data_miso => open, 
      reg_bg_ctrl_mosi => reg_bg_ctrl_mosi, 
      reg_bg_ctrl_miso => open, 
      out_siso_arr     => in_siso_matrix(I),
      out_sosi_arr     => in_sosi_matrix(I)
    ); 
    in_sosi_arr(I)       <= in_sosi_matrix(I)(0);
    in_siso_matrix(I)(0) <= c_dp_siso_rdy;
  end generate;
 
  ------------------------------------------------------------------------------  
  -- READ THE BEAMLET STATISTICS AND VERIFY  
  ------------------------------------------------------------------------------
  -- Read statistics from the memory interface once every sync interval.
  p_read_sst_memory : process
    variable c_sync_cnt : natural;
  begin
    proc_common_wait_until_low(clk, rst);    -- Wait until reset has finished
 
    -- Skip reading for the initial syncs to save simulation time
    for J in 0 to c_bst_skip_nof_sync-2 loop
      wait until result_sosi_arr(0).sync = '1';
      wait until result_sosi_arr(0).sync = '0';
    end loop;
 
    while(true) loop
      wait until result_sosi_arr(0).sync = '1';
      proc_common_wait_some_cycles(clk, c_nof_samples_in_packet+6);
 
      for I in 0 to g_wpfb.wb_factor-1 loop
        proc_fft_read_subband_statistics_memory(I, c_fft, clk, ram_sst_mosi, ram_sst_miso, result_sst_arr_temp);
        result_sst_arr((I+1)*c_nof_samples_in_packet-1 downto I*c_nof_samples_in_packet) <= result_sst_arr_temp;  -- can not use result_bst_arr2(I) directly as argument in proc_bf_read_beamlet_statistics_memory()
      end loop;
 
      proc_common_wait_some_cycles(clk, 10);
 
      assert expected_sst_arr  = result_sst_arr   report "Output statistics error"  severity error;
      assert expected_sst_arr /= result_sst_arr   report "Output statistics OK!!!!" severity note;
 
    end loop;
  end process;
 
  ---------------------------------------------------------------  
  -- DUT = Device Under Test
  ---------------------------------------------------------------  
  u_dut : entity work.wpfb_unit
  generic map (
    g_wpfb              => g_wpfb,
    g_use_bg            => FALSE,         
    g_coefs_file_prefix => c_coefs_file_prefix 
  )
  port map (
    dp_rst             => rst,
    dp_clk             => clk,
    mm_rst             => rst,
    mm_clk             => clk,  
    ram_fil_coefs_mosi => ram_coefs_mosi,
    ram_fil_coefs_miso => ram_coefs_miso,
    ram_st_sst_mosi    => ram_sst_mosi,
    ram_st_sst_miso    => ram_sst_miso, 
    reg_bg_ctrl_mosi   => reg_diag_bg_dut_mosi,
    reg_bg_ctrl_miso   => reg_diag_bg_dut_miso,
    ram_bg_data_mosi   => ram_diag_bg_dut_mosi,
    ram_bg_data_miso   => ram_diag_bg_dut_miso,
    in_sosi_arr        => in_sosi_arr,     
    out_sosi_arr       => result_sosi_arr
  );
 
  ---------------------------------------------------------------  
  -- REARRANGE THE OUTPUT-DATA FOR VERIFICATION
  ---------------------------------------------------------------  
  gen_extract_data : for I in 0 to g_wpfb.wb_factor-1 generate
    out_re_arr(I) <= RESIZE_SVEC(result_sosi_arr(I).re, out_re_arr(I)'length);
    out_im_arr(I) <= RESIZE_SVEC(result_sosi_arr(I).im, out_im_arr(I)'length);
  end generate;
  out_val <= result_sosi_arr(0).valid; 
 
  ---------------------------------------------------------------  
  -- READ GOLDEN FILE WITH THE EXPECTED DUT OUTPUT
  ---------------------------------------------------------------  
  proc_read_input_file(clk, gold_file_data, c_goldenFile);   
 
  ---------------------------------------------------------------  
  -- CALCULATE THE STATISTICS, BASED ON THE RAW OUTPUT DATA 
  -- OF THE DUT
  ---------------------------------------------------------------  
  p_calculate_stats_reference_array : process    
    constant c_sst_in_w       : natural := 18;
    variable v_nof_outs       : natural := g_wpfb.nof_points/g_wpfb.wb_factor;
    variable v_int_time       : integer := 0;   
    variable v_subband_cnt    : integer := 0;   
 
    variable v_sum_re         : std_logic_vector(c_sst_in_w-1 downto 0);  
    variable v_sum_im         : std_logic_vector(c_sst_in_w-1 downto 0);
 
    variable v_sum_pwr        : std_logic_vector(g_wpfb.stat_data_w-1 downto 0) := (others => '0');
    variable v_acc_pwr_arr    : t_slv_64_arr(g_wpfb.nof_points-1 downto 0) := (others => (others => '0'));
  begin
    wait until rising_edge(clk); 
    if(out_val = '1') then 
      for I in 0 to g_wpfb.wb_factor-1 loop
        -- Calculate the auto correlation power:
        v_sum_re := RESIZE_SVEC(SHIFT_SVEC(out_re_arr(I), g_wpfb.fft_out_dat_w-c_sst_in_w), v_sum_re'length);
        v_sum_im := RESIZE_SVEC(SHIFT_SVEC(out_im_arr(I), g_wpfb.fft_out_dat_w-c_sst_in_w), v_sum_im'length);
        v_sum_pwr(32 downto 0) := func_complex_multiply(v_sum_re, v_sum_im, v_sum_re, v_sum_im, c_normal, "RE", 33); 
        v_acc_pwr_arr(I*v_nof_outs + v_subband_cnt) := ADD_UVEC(v_acc_pwr_arr(I*v_nof_outs + v_subband_cnt), v_sum_pwr);
      end loop;           
 
      if(v_subband_cnt = v_nof_outs-1) then 
        v_subband_cnt := 0;
      else 
        v_subband_cnt := v_subband_cnt + 1;
      end if;
 
      ------------------------------------------------------------------------
      -- Latch the expected accumulated statistics to the output at the sync
      ------------------------------------------------------------------------
      if(v_int_time = c_nof_accum_per_sync*v_nof_outs-1) then 
        v_int_time := 0;
        -- Output the expected BST array
        expected_sst_arr <= v_acc_pwr_arr;
        v_acc_pwr_arr    :=(others => (others => '0')); 
      else
        v_int_time := v_int_time + 1;
      end if;      
    end if;
 
  end process; 
 
  ---------------------------------------------------------------  
  -- CREATE THE GOLDEN ARRAY FOR VERIFICATION
  ---------------------------------------------------------------  
  p_create_golden_array : process    
    constant c_sst_in_w       : natural := 16;
    variable v_nof_outs       : natural := g_wpfb.nof_points/g_wpfb.wb_factor;
    variable v_bin_index      : natural := 0;
    variable v_spectrum_index : natural := 0;  
    variable v_list_index     : natural := 0;  
  begin
    wait until rising_edge(clk); 
    if(out_val = '1') then 
      if(v_spectrum_index = v_nof_outs - 1) then
        v_spectrum_index := 0; 
        v_bin_index := v_bin_index + g_wpfb.nof_points - v_nof_outs;
      else 
        v_spectrum_index := v_spectrum_index + 1;   
      end if;
      v_bin_index := v_bin_index + 1; 
 
      if(v_list_index = c_file_len/g_wpfb.wb_factor-1) then 
        v_bin_index    := 0; 
        v_list_index   := 0;
      else 
        v_list_index := v_list_index + 1;
      end if;    
 
    end if;
 
    for I in 0 to g_wpfb.wb_factor-1 loop
      gold_re_arr(I) <= gold_file_data(v_bin_index + I*v_nof_outs, 1);
      gold_im_arr(I) <= gold_file_data(v_bin_index + I*v_nof_outs, 2);
    end loop;  
 
    gold_sync  <= gold_file_sync(v_bin_index);  
 
  end process; 
 
  -- Verify the output of the DUT with the expected output from the golden reference file
  p_verify_output : process(clk)
    variable v_output_cnt : integer := 0;
  begin
    -- Compare
    if rising_edge(clk) then
      if (out_val='1' and v_output_cnt < (c_nof_spectra_in_file*g_wpfb.nof_points/g_wpfb.wb_factor)) then
        -- only write when out_val='1', because then the file is independent of cycles with invalid out_dat
        -- only check the first c_nof_spectra_in_file spectrums. 
        assert out_sync = gold_sync report "Output sync error"  severity error;
        for I in 0 to g_wpfb.wb_factor-1 loop
          assert TO_SINT(out_re_arr(I)) = gold_re_arr(I)   report "Output real data error" severity error;
          assert TO_SINT(out_im_arr(I)) = gold_im_arr(I)   report "Output imag data error" severity error;
        end loop;
        v_output_cnt := v_output_cnt + 1;
      end if;
    end if;
  end process;
 
  -- Write to default output file, this allows using command line diff or graphical diff viewer to compare it with the golden result file
  p_write_output_file : process(clk)
    file     v_output        : text open WRITE_MODE is c_outputFile;
    variable v_line          : line;
    constant c_nof_bins      : natural := g_wpfb.nof_points/g_wpfb.wb_factor;
    variable v_out_re_matrix : t_integer_matrix(g_wpfb.wb_factor-1 downto 0, c_nof_bins-1 downto 0); 
    variable v_out_im_matrix : t_integer_matrix(g_wpfb.wb_factor-1 downto 0, c_nof_bins-1 downto 0);     
    variable v_bin_cnt       : integer := 0;
    variable v_spectra_cnt   : integer := 0;
  begin
    if rising_edge(clk) then
      if out_val='1' then
        -- only write when out_val='1', because then the file is independent of cycles with invalid out_dat
        for I in 0 to g_wpfb.wb_factor-1 loop
          v_out_re_matrix(I, v_bin_cnt) := TO_SINT(out_re_arr(I));
          v_out_im_matrix(I, v_bin_cnt) := TO_SINT(out_im_arr(I)); 
        end loop;
 
        if(v_bin_cnt = c_nof_bins-1) then  
          if (v_spectra_cnt < c_nof_spectra_to_output_file) then 
            for K in 0 to g_wpfb.wb_factor-1 loop
              for L in 0 to c_nof_bins-1 loop
                write(v_line, v_out_re_matrix(K,L));
                write(v_line, string'(","));
                write(v_line, v_out_im_matrix(K,L));
                writeline(v_output, v_line);
              end loop;
            end loop;      
          end if; 
          v_spectra_cnt := v_spectra_cnt + 1;
          v_bin_cnt     := 0;
        else 
          v_bin_cnt := v_bin_cnt + 1;
        end if;
      end if;
    end if;
  end process;
 
end tb;