main_crt_vs.vhd

Go to the documentation of this file.

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
use IEEE.STD_LOGIC_ARITH.CONV_STD_LOGIC_VECTOR;

LIBRARY work;
use work.CMXpackage.all;
use work.CMX_flavor_package.all;



entity main_crt is
  generic(
    numactchan : integer := 16
    ); 
  port( 
    clk            : in     std_logic;                          -- clock
    thresholds     : in     arr_16(max_jems*25*4-1 downto 0);   -- thresholds
    datai          : in     arr_4Xword(max_jems-1 downto 0);    -- input data
    dout_lcl       : out    T_SLV60;                                    -- local output (multiplicity), excluding parity
    dout_lcl_ro    : out    T_SL;                               -- local overflow
    par_err_lcl    : in     T_SL;                               -- parity error local
    force          : in     T_SL;                                -- force
    disable_overflow_mask : in std_logic_vector(15 downto 0)
    );

end main_crt;

architecture struct of main_crt is


-- signal declarations  
  
  signal sum_internal    : T_SLV75; 
  signal thrPat          : thPatL_type(max_jems-1 downto 0);
  signal mult            : mult_type(max_jems-1 downto 0);
  signal threshold_table : threshold_type(max_jems-1 downto 0);

  signal data_high       : High_word(max_jems-1 downto 0):=(others =>(others =>(others => '0')));  
  signal data_low        : Low_word(max_jems-1 downto 0):=(others =>(others =>(others => '0')));
  signal TOBs            : arr_TOB((max_jems*max_tobs_pjem)-1 downto 0);          
  signal xpos            : xpos_type(max_jems-1 downto 0);
  signal loc             : loc_type(max_jems-1 downto 0); 

  signal overflow        : T_SLV16; 
  signal bitofw          : T_SL;
  signal bitofw_del0     : T_SL;
  signal bitofw_del1     : T_SL;
  
  signal par_err_lcl_d0  : T_SL;     -- parity error local delayed
  signal dout_lcl_tmp    : T_SLV60;  
  
begin

-- ==========================================================================================================--
--                                           Data Collector                                                  --                                                  
-- ==========================================================================================================-- 

  data_parser_0: for i in 0 to (max_jems-1) generate
    data_parser_1: for j in 0 to (max_tobs_pjem-1) generate
      data_low(i)(j) <=  datai(i)((24*j)+12 downto (25*j)-j);
      data_high(i)(j) <= datai(i)((24*j)+23 downto (24*j)+13);
    end generate data_parser_1;
  end generate data_parser_0;


  
  xpos_i: for i in 0 to (max_jems-1) generate -- 0 to 15 (JEMs)
    xpos(i) <= xpos_sort(conv_integer(data_low(i)(0)(3 downto 0)));
  end generate;

  loc_i: for i in 0 to (max_jems-1) generate -- 0 to 15 (JEMs)
    loc_j:  for j in 0 to (max_tobs_pjem-1) generate -- 0 to 3 (TOBs)
      loc(i)(j) <= xpos(i)(j) & data_low(i)(j)(11);                     
    end generate;
  end generate;


  data_map: for i in 0 to (max_jems-1) generate

    TOBs((4*i)+3).Et2  <= data_high(i)(3)(9 downto 0);
    TOBs((4*i)+3).Et1  <= data_low(i)(3)(10 downto 2);
    TOBs((4*i)+2).Et2  <= data_high(i)(2)(9 downto 0);
    TOBs((4*i)+2).Et1  <= data_low(i)(3)(1 downto 0) & data_low(i)(2)(10 downto 4);
    TOBs((4*i)+1).Et2  <= data_high(i)(1)(9 downto 0);
    TOBs((4*i)+1).Et1  <= data_low(i)(2)(3 downto 0) & data_low(i)(1)(10 downto 6);
    TOBs((4*i)+0).Et2  <= data_high(i)(0)(9 downto 0);
    TOBs((4*i)+0).Et1  <= data_low(i)(1)(5 downto 0) & data_low(i)(0)(10 downto 8);
    
  end generate;


--
-- Thresholds 
--
--
  threshold_jems: for i in 0 to (max_jems-1) generate           -- 0 to 15 (JEMs)
    threshold_num:   for j in 0 to (thresholds_num-1) generate      -- 0 to 24 (Thresholds) 
      threshold_slice: for k in 0 to (max_eta_slices-1)  generate     -- 0 to 3  (Eta slices)
        threshold_table(i)(j)(k) <= thresholds(25*k+100*i+j)(10 downto 0);
      end generate threshold_slice; 
    end generate threshold_num;   
  end generate threshold_jems; 


  process (clk) 

  begin  
    if clk'event and clk = '0' then  -- falling clock edge
      
      thrPat <= (others => (others => '0'));
      for i in 0 to (max_jems-1) loop -- 0 to 15 (JEMs)
        for j in 0 to (max_tobs_pjem-1) loop -- 0 to 3 (TOBs)
          for k in 0 to (thresholds_num-1) loop  -- 0 to 24 (Thresholds)

            if threshold_table(i)(k)(conv_integer(loc(i)(j)))(10) = '1' then
              if TOBs((max_tobs_pjem*i)+j).Et1 > threshold_table(i)(k)(conv_integer(loc(i)(j)))(9 downto 0)  then   
                thrPat(i)((max_tobs_pjem*k)+j) <= '1';
              end if;

            else 
              if TOBs((max_tobs_pjem*i)+j).Et2 > threshold_table(i)(k)(conv_integer(loc(i)(j)))(9 downto 0)  then   
                thrPat(i)((max_tobs_pjem*k)+j) <= '1';
              end if;           
            end if;
            
      end loop; -- k
        end loop; -- j        
      end loop; -- i

      -- overflow 

      bitofw_del0 <= bitofw;

      -- parity error local delay

      par_err_lcl_d0 <= par_err_lcl; 

    end if;
  end process;   

  g0: for i in 0 to 15 generate -- loop over each JEMs    
    g1: for j in 0 to 24 generate -- loop over each threshold
      mult(i)(j) <= mult_i(conv_integer(thrPat(i)(4*j+3 downto 4*j)));
    end generate g1;  
  end generate g0;

  process (clk) 

    variable xsum       : xsum_type(24 downto 0);
    variable totsum     : totsum_type(24 downto 0);

  begin  
    if clk'event and clk = '1' then  -- raising clock edge
      
      for i in 0 to 24 loop -- loop over each threshold
        for j in 0 to 7 loop  -- loop over 8 pairs of JEMs
          
          xsum(i)(j) := add3x2(mult(2*j)(i),mult(2*j+1)(i));
          
        end loop;
      end loop;


      for i in 0 to 24 loop -- loop over each threshold

        totsum(i) :=   to_integer(unsigned(xsum(i)(0))) -- sum over 8 pairs of JEMs
                       + to_integer(unsigned(xsum(i)(1)))
                       + to_integer(unsigned(xsum(i)(2)))
                       + to_integer(unsigned(xsum(i)(3)))
                       + to_integer(unsigned(xsum(i)(4)))
                       + to_integer(unsigned(xsum(i)(5)))
                       + to_integer(unsigned(xsum(i)(6)))
                       + to_integer(unsigned(xsum(i)(7)));

        if (totsum(i) >= 7) then
          sum_internal((3*i)+2 downto 3*i) <= "111";
        else
          sum_internal((3*i)+2 downto 3*i) <= std_logic_vector(to_unsigned(totsum(i), 3));
        end if;

      end loop;

      -- overflow delay
      bitofw_del1 <= bitofw_del0;
      
    end if;
  end process;   

-- Output

  dout_lcl_tmp(29 downto 0) <= sum_internal(29 downto 0); -- First 10 3-bit sums are sent as-is

  Mult_out: for i in 0 to 14 generate -- Second 15 3-bit sums are converted to two-bit sums
    Conv3to2( sum_internal(30+((3*i)+2) downto (30+(3*i))), dout_lcl_tmp(30+((2*i)+1) downto (30+(2*i))) );
  end generate Mult_out;


  dout_lcl <= (others=>'1') when (par_err_lcl_d0 = '1' and force = '1') or bitofw_del1 = '1' else dout_lcl_tmp;
  
  
-- Overflow

  dout_lcl_ro <= bitofw_del1;

  overflow_i: for i in 0 to (max_jems-1) generate
    overflow(i) <= ofwntobs(conv_integer(datai(i)(7 downto 0)))(3);
  end generate;

  bitofw <= ( (not disable_overflow_mask(0) )  and overflow(0) )  or 
            ( (not disable_overflow_mask(1) )  and overflow(1) )  or
            ( (not disable_overflow_mask(2) )  and overflow(2) )  or
            ( (not disable_overflow_mask(3) )  and overflow(3) )  or
            ( (not disable_overflow_mask(4) )  and overflow(4) )  or
            ( (not disable_overflow_mask(5) )  and overflow(5) )  or
            ( (not disable_overflow_mask(6) )  and overflow(6) )  or
            ( (not disable_overflow_mask(7) )  and overflow(7) )  or
            ( (not disable_overflow_mask(8) )  and overflow(8) )  or
            ( (not disable_overflow_mask(9) )  and overflow(9) )  or
            ( (not disable_overflow_mask(10) ) and overflow(10) ) or
            ( (not disable_overflow_mask(11) ) and overflow(11) ) or
            ( (not disable_overflow_mask(12) ) and overflow(12) ) or
            ( (not disable_overflow_mask(13) ) and overflow(13) ) or
            ( (not disable_overflow_mask(14) ) and overflow(14) ) or
            ( (not disable_overflow_mask(15) )  and overflow(15));

end struct;