AlgoDataTypes.vhd

Go to the documentation of this file.

-------------------------------------------------------
library IEEE;
use IEEE.STD_LOGIC_1164.all;
use IEEE.NUMERIC_STD.all;
 
package AlgoDataTypes is
 
-----------------------------------------------------------------------------
-- eFEX data Parameter
-----------------------------------------------------------------------------
 
  constant INPUT_DATA_WIDTH : integer := 10;
 
  constant INPUT_COLUMNS : integer := 6;
  constant INPUT_ROWS    : integer := 10;
  constant INPUT_TOWERS  : integer := INPUT_ROWS*INPUT_COLUMNS;
 
-------------------------------------------------------------------------------
-- Trigger Tower Parameters
-------------------------------------------------------------------------------
 
  constant LAYER0 : integer := 1;
  constant LAYER1 : integer := 4;
  constant LAYER2 : integer := 4;
  constant LAYER3 : integer := 1;
  constant HADRON : integer := 1;
 
  constant LAYERS : integer := LAYER0 + LAYER1 + LAYER2 + LAYER3 + HADRON;
 
-------------------------------------------------------------------------------
-- Trigger Object Parameters
-------------------------------------------------------------------------------
 
  constant OUT_XTOB_WIDTH : integer := 64;
  constant OUT_TOB_WIDTH  : integer := 32;
  constant OUTPUT_TOBS    : integer := 8;
 
-------------------------------------------------------------------------------
-- Useful subtypes, types, constants
-------------------------------------------------------------------------------
 
  subtype BCID_t is std_logic_vector(6 downto 0);
  type BCID_array is array(59 downto 0) of BCID_t;
 
  subtype AlgoWord is std_logic_vector(INPUT_DATA_WIDTH-1 downto 0);
 
  type AlgoWords is array(natural range <>) of AlgoWord;
  
  type AlgoLayer0 is array(LAYER0-1 downto 0) of AlgoWord;
  type AlgoLayer1 is array(LAYER1-1 downto 0) of AlgoWord;
  type AlgoLayer2 is array(LAYER2-1 downto 0) of AlgoWord;
  type AlgoLayer3 is array(LAYER3-1 downto 0) of AlgoWord;
  type AlgoHadron is array(HADRON-1 downto 0) of AlgoWord;
 
  constant ZERO_ALGO_WORD : AlgoWord := (others => '0');
 
  type AlgoTower is record
    Layer0 : AlgoLayer0;
    Layer1 : AlgoLayer1;
    Layer2 : AlgoLayer2;
    Layer3 : AlgoLayer3;
    Hadron : AlgoHadron;
  end record;
 
  constant ZERO_ALGO_TOWER : AlgoTower := (Layer0 => ((others => (others => '0'))),
                                           Layer1 => ((others => (others => '0'))),
                                           Layer2 => ((others => (others => '0'))),
                                           Layer3 => ((others => (others => '0'))),
                                           Hadron => ((others => (others => '0'))));
 
  type AlgoColumn is array(INPUT_ROWS-1 downto 0) of AlgoTower;
 
-------------------------------------------------------------------------------
  type Algo2DInput is array(INPUT_COLUMNS-1 downto 0, INPUT_ROWS-1 downto 0) of AlgoTower;
-------------------------------------------------------------------------------
 
-------------------------------------------------------------------------------
  type AlgoInput is array(INPUT_COLUMNS-1 downto 0) of AlgoColumn;
  
  constant ZERO_ALGO_INPUT : AlgoInput := (others => (others => ZERO_ALGO_TOWER));
-------------------------------------------------------------------------------
 
-----------------------------------------------------------------------------
-- OUTPUT
-----------------------------------------------------------------------------
  subtype AlgoXTriggerObject is std_logic_vector(OUT_XTOB_WIDTH-1 downto 0);
  subtype AlgoTriggerObject is std_logic_vector(OUT_TOB_WIDTH-1 downto 0);
  type AlgoTriggerObjects is array (natural range <>) of AlgoTriggerObject;
  type AlgoXTriggerObjects is array (natural range <>) of AlgoXTriggerObject;
-------------------------------------------------------------------------------
  type AlgoOutput is array(OUTPUT_TOBS-1 downto 0) of AlgoTriggerObject;
  type AlgoXOutput is array(OUTPUT_TOBS-1 downto 0) of AlgoXTriggerObject;
-------------------------------------------------------------------------------
 
  constant ZERO_ALGO_TRIGGER_OBJECT  : AlgoTriggerObject  := (others => '0');
  constant ZERO_ALGO_XTRIGGER_OBJECT : AlgoXTriggerObject := (others => '0');
 
-------------------------------------------------------------------------------
-- Conversion Functions
-------------------------------------------------------------------------------
 
  function to_AlgoInput (X   : Algo2DInput) return AlgoInput;
  function to_Algo2DInput (Y : AlgoInput) return Algo2DInput;
  function to_LogicVector (Y : AlgoInput; Z : std_logic_vector(11 downto 0)) return std_logic_vector;
  function to_AlgoInput (X   : std_logic_vector) return AlgoInput;
  function to_BCN       (X   : std_logic_vector) return std_logic_vector;
 
  function to_LogicVector (Y : AlgoOutput) return std_logic_vector;
  function to_AlgoOutput (X  : std_logic_vector) return AlgoOutput;
  function to_AlgoXOutput (X : std_logic_vector) return AlgoXOutput;
 
  function to_LogicVector (Y        : AlgoTriggerObject) return std_logic_vector;
  function to_LogicVector2 (Y       : AlgoXTriggerObject) return std_logic_vector;
  function to_AlgoTriggerObject (X  : std_logic_vector) return AlgoTriggerObject;
  function to_AlgoTriggerObjects (X : AlgoOutput) return AlgoTriggerObjects;
 
end package;
 
package body AlgoDataTypes is
 
  function to_AlgoInput (X : Algo2DInput) return AlgoInput is
    variable Y : AlgoInput;
  begin
    for i in 0 to (INPUT_COLUMNS-1) loop
      for j in 0 to (INPUT_ROWS-1) loop
        Y(i)(j) := X(i, j);
      end loop;
    end loop;
 
    return Y;
  end;
 
  function to_Algo2DInput (Y : AlgoInput) return Algo2DInput is
    variable X : Algo2DInput;
  begin
    for i in 0 to (INPUT_COLUMNS-1) loop
      for j in 0 to (INPUT_ROWS-1) loop
        X(i, j) := Y(i)(j);
      end loop;
    end loop;
 
    return X;
  end;
 
  function to_LogicVector (Y : AlgoInput; Z : std_logic_vector(11 downto 0)) return std_logic_vector is
    variable X : std_logic_vector(128*INPUT_TOWERS-1 downto 0);
  begin
    for c in 0 to (INPUT_COLUMNS-1) loop
      for r in 0 to (INPUT_ROWS-1) loop
        X(127 + 128*(c*INPUT_ROWS + r) downto 128*(c*INPUT_ROWS + r)) := "11" & Z(9 downto 0)     & Y(c)(r).Hadron(0) & Y(c)(r).Layer3(0) &
                                                                         "10" & Y(c)(r).Layer2(3) & Y(c)(r).Layer2(2) & Y(c)(r).Layer2(1) &
                                                                         "01" & Y(c)(r).Layer2(0) & Y(c)(r).Layer1(3) & Y(c)(r).Layer1(2) &
                                                                         "00" & Y(c)(r).Layer1(1) & Y(c)(r).Layer1(0) & Y(c)(r).Layer0(0);
      end loop;
    end loop;
 
    return X;
  end;
 
  function to_AlgoInput (X : std_logic_vector) return AlgoInput is
    variable Y : AlgoInput;
  begin
    for c in 0 to (INPUT_COLUMNS-1) loop
      for r in 0 to (INPUT_ROWS-1) loop
        Y(c)(r).Layer0(0) := X(INPUT_DATA_WIDTH-1 + c*INPUT_ROWS*128+INPUT_DATA_WIDTH*00+r*128+0 downto c*INPUT_ROWS*128+INPUT_DATA_WIDTH*00+r*128+0);
        Y(c)(r).Layer1(0) := X(INPUT_DATA_WIDTH-1 + c*INPUT_ROWS*128+INPUT_DATA_WIDTH*01+r*128+0 downto c*INPUT_ROWS*128+INPUT_DATA_WIDTH*01+r*128+0);
        Y(c)(r).Layer1(1) := X(INPUT_DATA_WIDTH-1 + c*INPUT_ROWS*128+INPUT_DATA_WIDTH*02+r*128+0 downto c*INPUT_ROWS*128+INPUT_DATA_WIDTH*02+r*128+0);
        Y(c)(r).Layer1(2) := X(INPUT_DATA_WIDTH-1 + c*INPUT_ROWS*128+INPUT_DATA_WIDTH*03+r*128+2 downto c*INPUT_ROWS*128+INPUT_DATA_WIDTH*03+r*128+2);
        Y(c)(r).Layer1(3) := X(INPUT_DATA_WIDTH-1 + c*INPUT_ROWS*128+INPUT_DATA_WIDTH*04+r*128+2 downto c*INPUT_ROWS*128+INPUT_DATA_WIDTH*04+r*128+2);
        Y(c)(r).Layer2(0) := X(INPUT_DATA_WIDTH-1 + c*INPUT_ROWS*128+INPUT_DATA_WIDTH*05+r*128+2 downto c*INPUT_ROWS*128+INPUT_DATA_WIDTH*05+r*128+2);
        Y(c)(r).Layer2(1) := X(INPUT_DATA_WIDTH-1 + c*INPUT_ROWS*128+INPUT_DATA_WIDTH*06+r*128+4 downto c*INPUT_ROWS*128+INPUT_DATA_WIDTH*06+r*128+4);
        Y(c)(r).Layer2(2) := X(INPUT_DATA_WIDTH-1 + c*INPUT_ROWS*128+INPUT_DATA_WIDTH*07+r*128+4 downto c*INPUT_ROWS*128+INPUT_DATA_WIDTH*07+r*128+4);
        Y(c)(r).Layer2(3) := X(INPUT_DATA_WIDTH-1 + c*INPUT_ROWS*128+INPUT_DATA_WIDTH*08+r*128+4 downto c*INPUT_ROWS*128+INPUT_DATA_WIDTH* 8+r*128+4);
        Y(c)(r).Layer3(0) := X(INPUT_DATA_WIDTH-1 + c*INPUT_ROWS*128+INPUT_DATA_WIDTH*09+r*128+6 downto c*INPUT_ROWS*128+INPUT_DATA_WIDTH* 9+r*128+6);
        Y(c)(r).Hadron(0) := X(INPUT_DATA_WIDTH-1 + c*INPUT_ROWS*128+INPUT_DATA_WIDTH*10+r*128+6 downto c*INPUT_ROWS*128+INPUT_DATA_WIDTH*10+r*128+6);
      end loop;
    end loop;
 
    return Y;
  end;
 
  function to_BCN (X : std_logic_vector) return std_logic_vector is
    variable Y : std_logic_vector(11 downto 0);
  begin
    Y := "00"& X(125 downto 116);
    return Y;
  end;
 
 
  function to_LogicVector (Y : AlgoOutput) return std_logic_vector is
    variable X : std_logic_vector(OUTPUT_TOBS*OUT_TOB_WIDTH-1 downto 0);
  begin
    for i in 0 to (OUTPUT_TOBS-1) loop
      X(i*OUT_TOB_WIDTH + OUT_TOB_WIDTH-1 downto i*OUT_TOB_WIDTH) := Y(i);
    end loop;
 
    return X;
  end;
 
  function to_AlgoOutput (X : std_logic_vector) return AlgoOutput is
    variable Y : AlgoOutput;
  begin
    for i in 0 to (OUTPUT_TOBS-1) loop
      Y(i) := X(i*OUT_TOB_WIDTH + OUT_TOB_WIDTH-1 downto i*OUT_TOB_WIDTH);
    end loop;
 
    return Y;
  end;
 
  function to_AlgoXOutput (X : std_logic_vector) return AlgoXOutput is
    variable Y : AlgoXOutput;
  begin
    for i in 0 to (OUTPUT_TOBS-1) loop
      Y(i) := X(i*OUT_TOB_WIDTH + OUT_TOB_WIDTH-1 downto i*OUT_TOB_WIDTH);
    end loop;
 
    return Y;
  end;
 
  function to_LogicVector (Y : AlgoTriggerObject) return std_logic_vector is
    variable X : std_logic_vector(OUT_TOB_WIDTH-1 downto 0);
  begin
    for i in 0 to (OUT_TOB_WIDTH-1) loop
      X(i) := Y(i);
    end loop;
 
    return X;
  end;
 
  function to_LogicVector2 (Y : AlgoXTriggerObject) return std_logic_vector is
    variable X : std_logic_vector(OUT_XTOB_WIDTH-1 downto 0);
  begin
    for i in 0 to (OUT_XTOB_WIDTH-1) loop
      X(i) := Y(i);
    end loop;
 
    return X;
  end;
 
 
 
  function to_AlgoTriggerObject (X : std_logic_vector) return AlgoTriggerObject is
    variable Y : AlgoTriggerObject;
  begin
    for i in 0 to (OUT_TOB_WIDTH-1) loop
      Y(i) := X(i);
    end loop;
 
    return Y;
  end;
 
  function to_AlgoTriggerObjects (
    X : AlgoOutput)
    return AlgoTriggerObjects is
    variable Y : AlgoTriggerObjects(OUTPUT_TOBS-1 downto 0);
  begin  -- function to_AlgoTriggerObjects
    for i in 0 to (OUTPUT_TOBS-1) loop
      Y(i) := X(i);
    end loop;
    return Y;
  end function to_AlgoTriggerObjects;
 
 
 
end AlgoDataTypes;