DataTypes.vhd

library IEEE;
use IEEE.STD_LOGIC_1164.all;
use IEEE.NUMERIC_STD.all;
use work.AlgoDataTypes.all;
 
package DataTypes is
-------------------------------------------------------------------------------
-- USEFUL TYPES
-------------------------------------------------------------------------------
  type array_std_logic_vector is array (natural range <>) of std_logic_vector;
 
-------------------------------------------------------------------------------
-- INTERNAL DATA
-------------------------------------------------------------------------------
  constant DATA_WIDTH       : integer                                   := 16;
  constant ENERGY_WIDTH     : integer                                   := 16;
  constant BDT_SCORE_WIDTH  : integer                                   := 11;
  constant BDT_N_VARIABLES  : integer                                   := 11; -- Assumption: CORE is first variable and the rest are BDT_N_VARIABLES-1 symmetric variables
  constant TOB_ENERGY_WIDTH : integer                                   := 12;
  constant COMPARE_BITS     : integer                                   := 16;
  constant ENERGY_OF        : std_logic_vector(ENERGY_WIDTH-1 downto 0) := (others => '1');
  constant ENERGY_ZERO      : std_logic_vector(ENERGY_WIDTH-1 downto 0) := (others => '0');
 
  constant PAR_WIDTH : integer := 8;
  constant REG_WIDTH : integer := 32;
 
-- Adjust the following according to the IP multiplier:
-- maximum value: PAR_WIDTH+DATA_WIDTH;
  constant MULTIPLIER_OUTPUT_WIDTH     : integer := PAR_WIDTH+DATA_WIDTH;
-- maximum value: DATA_WIDTH;
  constant MULTIPLIER_DATA_INPUT_WIDTH : integer := DATA_WIDTH;
-- maximum value: PAR_WIDTH;
  constant MULTIPLIER_PAR_INPUT_WIDTH  : integer := PAR_WIDTH;
 
 
  constant PARAMETER_RAM_ADDR_WIDTH   : integer := 6;
  constant PARAMETER_RAM_DATA_WIDTH   : integer := 256;  --must be 2^ the previous one
  constant PARAMETER_RAM_CLOCK_OFFSET : integer := 2;
 
  subtype DataWord is std_logic_vector(DATA_WIDTH-1 downto 0);
  type DataWords is array(natural range <>) of DataWord;
  subtype DataWordWithCarry is std_logic_vector(DATA_WIDTH downto 0);
  type DataWordsWithCarry is array(natural range <>) of DataWordWithCarry;
  constant ZERO_DATA_WORD : DataWord := (others => '0');
  constant ZERO_DATA_WORD_WITH_CARRY : DataWordWithCarry := (others => '0');
  constant MAX_DATA_WORD: DataWord := (others => '1'); --TODO
 
  type TriggerTower is record
    Layer0 : DataWords(LAYER0-1 downto 0);
    Layer1 : DataWords(LAYER1-1 downto 0);
    Layer2 : DataWords(LAYER2-1 downto 0);
    Layer3 : DataWords(LAYER3-1 downto 0);
    Hadron : DataWords(HADRON-1 downto 0);
  end record;
 
  constant ZERO_TRIGGER_TOWER : TriggerTower := (Layer0 => ((others => (others => '0'))),
                                                 Layer1 => ((others => (others => '0'))),
                                                 Layer2 => ((others => (others => '0'))),
                                                 Layer3 => ((others => (others => '0'))),
                                                 Hadron => ((others => (others => '0'))));
 
  type TriggerTowers is array(natural range <>) of TriggerTower;
  type TriggerTowersArray is array(natural range <>) of TriggerTowers;
 
-------------------------------------------------------------------------------
-- EFEX MODULE POSITION
-------------------------------------------------------------------------------
  constant EM_POSITION_ETA_ON_EDGE         : integer := 0;
  constant EM_POSITION_ETA_ON_LEFT_EDGE    : integer := 1;
  constant EM_POSITION_POSITIVE_ETA_LEFT   : integer := 2;
  constant EM_POSITION_POSITIVE_ETA_CENTRE : integer := 3;
  constant EM_POSITION_POSITIVE_ETA_RIGHT  : integer := 4;
  constant HADRONIC_POSITION_BIT_START      : integer := 5;
  constant HADRONIC_POSITION_BIT_END        : integer := 7;
 
-------------------------------------------------------------------------------
-- Trigger Object
-------------------------------------------------------------------------------
  constant RETA_WIDTH : integer := 2;
  constant WS_WIDTH   : integer := 2;
  constant HAD_WIDTH  : integer := 2;
 
  constant JET_OR_BDT_WIDTH  : integer := 2;
  constant FRAC_WIDTH : integer := 2;
 
  type TriggerObjectCore_eg is record
    LocalMax  : std_logic;
    Max       : std_logic;
    Energy    : std_logic_vector(ENERGY_WIDTH - 1 downto 0);
    EnergyOF  : std_logic;
    REta      : std_logic_vector(RETA_WIDTH - 1 downto 0);
    ws        : std_logic_vector(WS_WIDTH - 1 downto 0);
    Had       : std_logic_vector(HAD_WIDTH - 1 downto 0);
    UpNotDown : std_logic;
    Seed      : std_logic_vector(1 downto 0);
    Version   : std_logic_vector(1 downto 0);
  end record;
 
  type TriggerObjectCore_tau is record
    IsMax     : std_logic;
    Energy    : std_logic_vector(ENERGY_WIDTH - 1 downto 0);
    EnergyOF  : std_logic;
    JetOrBDT  : std_logic_vector(JET_OR_BDT_WIDTH - 1 downto 0);
    Frac      : std_logic_vector(FRAC_WIDTH - 1 downto 0);
    UpNotDown : std_logic;
    Seed      : std_logic_vector(1 downto 0);
    BDT       : std_logic_vector(BDT_SCORE_WIDTH - 1 downto 0);
    Version   : std_logic_vector(1 downto 0);
  end record;
 
  type TriggerObjectPosition is record
    Eta : std_logic_vector(2 downto 0);  -- 0 to 4 column left to right
    Phi : std_logic_vector(2 downto 0);  -- 0 to 7 row bottom up
  end record;
 
  type TriggerObject_eg is record
    Core     : TriggerObjectCore_eg;
    Position : TriggerObjectPosition;
  end record;
 
  type TriggerObject_tau is record
    Core     : TriggerObjectCore_tau;
    Position : TriggerObjectPosition;
  end record;
 
  constant ZERO_TRIGGER_OBJECT_EG : TriggerObject_eg := (
    Core        => (
      LocalMax  => '0',
      Max       => '0',
      Energy    => (others => '0'),
      EnergyOF  => '0',
      REta      => (others => '0'),
      ws        => (others => '0'),
      Had       => (others => '0'),
      UpNotDown => '0',
      Seed      => (others => '0'),
      Version  => (others => '0')),
 
    Position    => (
      Eta       => (others => '0'),
      Phi       => (others => '0'))
    );
 
  constant ZERO_TRIGGER_OBJECT_TAU : TriggerObject_tau := (
    Core        => (
      IsMax     => '0',
      Energy    => (others => '0'),
      EnergyOF  => '0',
      JetOrBDT  => (others => '0'),
      Frac      => (others => '0'),
      UpNotDown => '0',
      Seed      => (others => '0'),
      BDT       => (others => '0'),
      Version   => (others => '0')),
    Position    => (
      Eta       => (others => '0'),
      Phi       => (others => '0'))
    );
 
 
  type TriggerObjects_eg is array(natural range <>) of TriggerObject_eg;
  type TriggerObjects_tau is array(natural range <>) of TriggerObject_tau;
 
  subtype AlgoParameter is std_logic_vector(PAR_WIDTH-1 downto 0);
  type AlgoParameters is array(natural range <>) of AlgoParameter;
 
  subtype AlgoRegister is std_logic_vector(REG_WIDTH-1 downto 0);
  type AlgoRegisters is array(natural range <>) of AlgoRegister;
 
  subtype TriggerTowerMatrix is TriggerTowersArray(INPUT_COLUMNS-1 downto 0)(INPUT_ROWS-1 downto 0);
 
-------------------------------------------------------------------------------
-- FUNCTIONS
-------------------------------------------------------------------------------
 
  function TOBEnergy (X : AlgoTriggerObject) return std_logic_vector;
 
  function to_AlgoTriggerObject (X : TriggerObject_eg; FPGA : integer) return AlgoTriggerObject;
  function to_AlgoTriggerObject (X : TriggerObject_tau; FPGA : integer) return AlgoTriggerObject;
 
  function to_AlgoXTriggerObject (X : TriggerObject_eg; FPGA : integer) return AlgoXTriggerObject;
  function to_AlgoXTriggerObject (X : TriggerObject_tau; FPGA : integer) return AlgoXTriggerObject;
 
 
  function to_TriggerObject_eg (X  : AlgoTriggerObject) return TriggerObject_eg;
  function to_TriggerObject_tau (X : AlgoTriggerObject) return TriggerObject_tau;
 
 
  function to_TriggerObjects_eg (X  : AlgoOutput) return TriggerObjects_eg;
  function to_TriggerObjects_tau (X : AlgoOutput) return TriggerObjects_tau;
 
  function to_AlgoOutput (X : TriggerObjects_eg; FPGA : integer) return AlgoOutput;
  function to_AlgoOutput (X : TriggerObjects_tau; FPGA : integer) return AlgoOutput;
 
  function to_AlgoOutput (X : AlgoTriggerObjects) return AlgoOutput;
 
  function to_AlgoXOutput (X : TriggerObjects_eg; FPGA : integer) return AlgoXOutput;
  function to_AlgoXOutput (X : TriggerObjects_tau; FPGA : integer) return AlgoXOutput;
 
 
  function is_valid_core (X : TriggerObjectCore_eg) return std_logic;
  function is_valid_core (X : TriggerObjectCore_tau) return std_logic;
 
  function is_valid_TOB (X : AlgoTriggerObject) return std_logic;
 
  function validate_core (X : TriggerObjectCore_eg) return TriggerObjectCore_eg;
  function validate_core (X : TriggerObjectCore_tau) return TriggerObjectCore_tau;
 
  function invalidate_core (X : TriggerObjectCore_eg) return TriggerObjectCore_eg;
  function invalidate_core (X : TriggerObjectCore_tau) return TriggerObjectCore_tau;
 
  function invalidate_TOB (X : AlgoTriggerObject) return AlgoTriggerObject;
 
  function to_TOBEnergy (X             : DataWord) return std_logic_vector;
  function FPGA_to_processor_number (X : integer) return std_logic_vector;
 
  function BitLeftShift(A : DataWord; B : integer) return DataWord;
 
  function EvaluateCondition (
    Pass_overflow        : std_logic;
    Fail_overflow        : std_logic;
    E_threshold          : DataWord;
    Total_Energy         : DataWord;
    Total_Energy_of      : std_logic;
    Condition_Energy     : DataWord;
    Thresholds           : DataWords(2 downto 0);
    Thresholds_overflows : std_logic_vector(2 downto 0))
    return std_logic_vector;
 
function to_SuperCellArray (X : TriggerTowers) return DataWords;
 
end package;
 
package body DataTypes is
 
  function TOBEnergy (X : AlgoTriggerObject) return std_logic_vector is
    variable Y : std_logic_vector(11 downto 0);
  begin
    Y := X(11 downto 0);
    return Y;
  end;
 
  function is_valid_core (X : TriggerObjectCore_eg) return std_logic is
    variable Y : std_logic;
  begin
    if X.LocalMax = '1' then
      Y := '1';
    else
      Y := '0';
    end if;
    return Y;
  end;
 
  function is_valid_core (X : TriggerObjectCore_tau) return std_logic is
    variable Y : std_logic;
  begin
    if X.IsMax = '1' then
      Y := '1';
    else
      Y := '0';
    end if;
    return Y;
  end;
 
 
  function is_valid_TOB (X : AlgoTriggerObject) return std_logic is
    variable Y : std_logic;
  begin
    if X(11 downto 0) = x"000" then
      Y := '0';
    else
      Y := '1';
    end if;
    return Y;
  end;
 
  function validate_core (X : TriggerObjectCore_eg) return TriggerObjectCore_eg is
    variable Y : TriggerObjectCore_eg;
  begin
    Y := X;
    if is_valid_core(X) = '0' then
      Y.Energy := (others => '0');
      Y.EnergyOF := '0';
    end if;
    return Y;
  end;
 
  function invalidate_core (X : TriggerObjectCore_tau) return TriggerObjectCore_tau is
    variable Y : TriggerObjectCore_tau;
  begin
    Y        := X;
    Y.Energy := (others => '0');
    Y.IsMax  := '0';
    Y.EnergyOF := '0';
    return Y;
  end;
 
  function validate_core (X : TriggerObjectCore_tau) return TriggerObjectCore_tau is
    variable Y : TriggerObjectCore_tau;
  begin
    Y := X;
    if is_valid_core(X) = '0' then
      Y.EnergyOF := '0';
      Y.Energy := (others => '0');
    end if;
    return Y;
  end;
 
  function invalidate_core (X : TriggerObjectCore_eg) return TriggerObjectCore_eg is
    variable Y : TriggerObjectCore_eg;
  begin
    Y          := X;
    Y.Energy   := (others => '0');
    Y.LocalMax := '0';
    Y.EnergyOF := '0';
    return Y;
  end;
 
  function invalidate_TOB (X : AlgoTriggerObject) return AlgoTriggerObject is
    variable Y : AlgoTriggerObject;
  begin
    Y              := X;
    Y(11 downto 0) := x"000";
    return Y;
  end;
 
 
 
 
------------------ eg TOB FORMAT definition ---------------------
  function to_AlgoTriggerObject (X : TriggerObject_eg; FPGA : integer) return AlgoTriggerObject is
    variable Y : AlgoTriggerObject;
  begin
    if X.Core.EnergyOF = '1' or X.Core.Energy(ENERGY_WIDTH-2) = '1' or X.Core.Energy(ENERGY_WIDTH-1) = '1' then
      Y(11 downto 0) := (others => '1');
    else
      -- Convert energy here
      Y(11 downto 0) := (TOB_ENERGY_WIDTH-1 downto 0 => X.Core.Energy(ENERGY_WIDTH-3 downto 2), others => '0');
    end if;
    Y(13 downto 12) := X.Core.Version;
    Y(14)           := X.Core.Max;
    Y(15)           := X.Core.UpNotDown;
    Y(17 downto 16) := X.Core.Seed;
    Y(19 downto 18) := X.Core.REta;
    Y(21 downto 20) := X.Core.ws;
    Y(23 downto 22) := X.Core.Had;
    Y(26 downto 24) := X.Position.Phi;
    Y(29 downto 27) := X.Position.Eta;
    Y(31 downto 30) := FPGA_to_processor_number(FPGA);
    return Y;
  end;
 
------------------ XTOB FORMAT definition ---------------------
  function to_AlgoXTriggerObject (X : TriggerObject_eg; FPGA : integer) return AlgoXTriggerObject is
    variable Y : AlgoXTriggerObject;
  begin
    Y(11 downto 0)  := (others => '0');
    Y(13 downto 12) := X.Core.Version;
    Y(14)           := X.Core.Max;
    Y(15)           := X.Core.UpNotDown;
    Y(17 downto 16) := X.Core.Seed;
    Y(19 downto 18) := X.Core.REta;
    Y(21 downto 20) := X.Core.ws;
    Y(23 downto 22) := X.Core.Had;
    Y(26 downto 24) := X.Position.Phi;
    Y(29 downto 27) := X.Position.Eta;
    Y(31 downto 30) := FPGA_to_processor_number(FPGA);
    if X.Core.EnergyOF = '1' then
      Y(47 downto 32) := (others => '1');
    else
      Y(47 downto 32) := X.Core.Energy;
    end if;
    Y(63 downto 48) := (others => '0');
    return Y;
  end;
 
  function to_TriggerObject_eg (X : AlgoTriggerObject) return TriggerObject_eg is
    variable Y : TriggerObject_eg;
  begin
    if X(ENERGY_WIDTH-1 downto 0) /= ENERGY_ZERO then
      Y.Core.LocalMax := '1';
    else
      Y.Core.LocalMax := '0';
    end if;
    Y.Core.Energy    := "00" & X(11 downto 0) & "00";
    Y.Core.Version   := X(13 downto 12);
    Y.Core.Max       := X(14);
    Y.Core.UpNotDown := X(15);
    Y.Core.Seed      := X(17 downto 16);
    Y.Core.REta      := X(19 downto 18);
    Y.Core.ws        := X(21 downto 20);
    Y.Core.Had       := X(23 downto 22);
    Y.Position.Phi   := X(26 downto 24);
    Y.Position.Eta   := X(29 downto 27);
    if X(ENERGY_WIDTH-1 downto 0) = ENERGY_OF then
      Y.Core.EnergyOF := '1';
    else
      Y.Core.EnergyOF := '0';
    end if;
 
    return Y;
  end;
 
 
------------------ TAU TOB FORMAT definition ---------------------
  function to_AlgoTriggerObject (X : TriggerObject_tau; FPGA : integer) return AlgoTriggerObject is
    variable Y : AlgoTriggerObject;
  begin
    if X.Core.EnergyOF = '1' or X.Core.Energy(ENERGY_WIDTH-2) = '1' or X.Core.Energy(ENERGY_WIDTH-1) = '1' then
      Y(11 downto 0) := (others => '1');
    else
      -- Convert energy here
      Y(11 downto 0) := (TOB_ENERGY_WIDTH-1 downto 0 => X.Core.Energy(ENERGY_WIDTH-3 downto 2), others => '0');
    end if;
    Y(13 downto 12) := X.Core.Version;
    Y(14)           := X.Core.IsMax;
    Y(15)           := X.Core.UpNotDown;
    Y(17 downto 16) := X.Core.Seed;
    Y(19 downto 18) := X.Core.JetOrBDT;
    Y(21 downto 20) := X.Core.Frac;
    Y(23 downto 22) := "00";
    Y(26 downto 24) := X.Position.Phi;
    Y(29 downto 27) := X.Position.Eta;
    Y(31 downto 30) := FPGA_to_processor_number(FPGA);
    return Y;
  end;
 
------------------ TAU XTOB FORMAT definition ---------------------
  function to_AlgoXTriggerObject (X : TriggerObject_tau; FPGA : integer) return AlgoXTriggerObject is
    variable Y : AlgoXTriggerObject;
  begin
    Y(BDT_SCORE_WIDTH - 1 downto 0)  := X.Core.BDT;
    Y(11)           := '0';
    Y(13 downto 12) := X.Core.Version;
    Y(14)           := X.Core.IsMax;
    Y(15)           := X.Core.UpNotDown;
    Y(17 downto 16) := X.Core.Seed;
    Y(19 downto 18) := X.Core.JetOrBDT;
    Y(21 downto 20) := X.Core.Frac;
    Y(23 downto 22) := "00";
    Y(26 downto 24) := X.Position.Phi;
    Y(29 downto 27) := X.Position.Eta;
    Y(31 downto 30) := FPGA_to_processor_number(FPGA);
    if X.Core.EnergyOF = '1' then
      Y(47 downto 32) := (others => '1');
    else
      Y(47 downto 32) := X.Core.Energy;
    end if;
    Y(63 downto 48) := (others => '0');
    return Y;
  end;
 
  function to_TriggerObject_tau (X : AlgoTriggerObject) return TriggerObject_tau is
    variable Y : TriggerObject_tau;
  begin
    if X(ENERGY_WIDTH-1 downto 0) /= ENERGY_ZERO then
      Y.Core.IsMax := '1';
    else
      Y.Core.IsMax := '0';
    end if;
    Y.Core.Energy    := "00" & X(11 downto 0) & "00";
    Y.Core.Version   := X(13 downto 12);
    Y.Core.UpNotDown := X(15);
    Y.Core.Seed      := X(17 downto 16);
    Y.Core.JetOrBDT  := X(19 downto 18);
    Y.Position.Phi   := X(26 downto 24);
    Y.Position.Eta   := X(29 downto 27);
    if X(ENERGY_WIDTH-1 downto 0) = ENERGY_OF then
      Y.Core.EnergyOF := '1';
    else
      Y.Core.EnergyOF := '0';
    end if;
 
    return Y;
  end;
 
-------------------------------------------
 
  function to_TriggerObjects_eg (X : AlgoOutput) return TriggerObjects_eg is
    variable Y : TriggerObjects_eg(7 downto 0);
  begin
    for i in Y'range loop
      Y(i) := to_TriggerObject_eg(X(i));
    end loop;  -- i
    return Y;
  end;
 
  function to_AlgoOutput (X : TriggerObjects_eg; FPGA : integer) return AlgoOutput is
    variable Y : AlgoOutput;
  begin
    for i in Y'range loop
      Y(i) := to_AlgoTriggerObject(X(i), FPGA);
    end loop;  -- i
    return Y;
  end;
 
  function to_TriggerObjects_tau (X : AlgoOutput) return TriggerObjects_tau is
    variable Y : TriggerObjects_tau(7 downto 0);
  begin
    for i in Y'range loop
      Y(i) := to_TriggerObject_tau(X(i));
    end loop;  -- i
    return Y;
  end;
 
  function to_AlgoOutput (X : TriggerObjects_tau; FPGA : integer) return AlgoOutput is
    variable Y : AlgoOutput;
  begin
    for i in Y'range loop
      Y(i) := to_AlgoTriggerObject(X(i), FPGA);
    end loop;  -- i
    return Y;
  end;
 
 
  function to_AlgoOutput (X : AlgoTriggerObjects) return AlgoOutput is
    variable Y : AlgoOutput;
  begin
    for i in Y'range loop
      Y(i) := X(i);
    end loop;  -- i
    return Y;
  end;
 
  function to_AlgoXOutput (X : TriggerObjects_eg; FPGA : integer) return AlgoXOutput is
    variable Y : AlgoXOutput;
  begin
    for i in Y'range loop
      Y(i) := to_AlgoXTriggerObject(X(i), FPGA);
    end loop;  -- i
    return Y;
  end;
 
 
  function to_AlgoXOutput (X : TriggerObjects_tau; FPGA : integer) return AlgoXOutput is
    variable Y : AlgoXOutput;
  begin
    for i in Y'range loop
      Y(i) := to_AlgoXTriggerObject(X(i), FPGA);
    end loop;  -- i
    return Y;
  end;
 
  function to_TOBEnergy (X : DataWord) return std_logic_vector is
    variable Y : std_logic_vector(ENERGY_WIDTH - 1 downto 0);
  begin
    if (ENERGY_WIDTH - 1) /= DataWord'high then
      if unsigned(X(X'high downto ENERGY_WIDTH)) /= 0 then
        Y := (others => '1');
      else
        Y := X(ENERGY_WIDTH-1 downto 0);
      end if;
    else
      Y := X;
    end if;
 
    return Y;
  end;
 
  function FPGA_to_processor_number (X : integer) return std_logic_vector is
    variable Y : std_logic_vector(1 downto 0);
  begin
    case X is
      when 1 =>
        Y := "00";
      when 2 =>
        Y := "11";
      when 3 =>
        Y := "01";
      when 4 =>
        Y := "10";
      when others =>
        Y := "00";
    end case;
 
    return Y;
  end function;
 
  function BitLeftShift (
    A : DataWord;
    B : integer)
    return DataWord is
 
    variable Y      : DataWord;
    variable AllOne : DataWord := (others => '1');
  begin
    Y := (Y'high downto B => A(A'high - B downto 0), others => '0');
 
    if unsigned(A(A'high downto A'high -B+1)) = 0 then
      return Y;
    else
      return AllOne;
    end if;
  end function BitLeftShift;
 
  function EvaluateCondition (
    Pass_overflow        : std_logic;
    Fail_overflow        : std_logic;
    E_threshold          : DataWord;
    Total_Energy         : DataWord;
    Total_Energy_of      : std_logic;
    Condition_Energy     : DataWord;
    Thresholds           : DataWords(2 downto 0);
    Thresholds_overflows : std_logic_vector(2 downto 0))
    return std_logic_vector is
    variable Condition : std_logic_vector(1 downto 0);
  begin  -- function EvaluateCondition
 
    if Pass_overflow = '0' and Total_Energy_of = '0' and Total_Energy < E_threshold then
 
      if Fail_overflow = '0' then
 
        if (Condition_Energy < Thresholds(0) or Thresholds_overflows(0) = '1') then
          Condition := "00";
        elsif (Condition_Energy < Thresholds(1) or Thresholds_overflows(1) = '1') then
          Condition := "01";
        elsif (Condition_Energy < Thresholds(2) or Thresholds_overflows(2) = '1') then
          Condition := "10";
        else
          Condition := "11";
        end if;
      else
        -- Env sum overflow
        Condition := "00";
      end if;
    else
      -- Core overflow or energy threshold exceeded
      Condition := "11";
    end if;
 
 
    return Condition;
  end function EvaluateCondition;
 
 
  function to_SuperCellArray (X : TriggerTowers) return DataWords is
    variable Y : DataWords(98 downto 0);
  begin
    Y(0) := X(0).Layer0(0);
    Y(1) := X(1).Layer0(0);
    Y(2) := X(2).Layer0(0);
    Y(3) := X(3).Layer0(0);
    Y(4) := X(4).Layer0(0);
    Y(5) := X(5).Layer0(0);
    Y(6) := X(6).Layer0(0);
    Y(7) := X(7).Layer0(0);
    Y(8) := X(8).Layer0(0);
    Y(9) := X(0).Layer1(0);
    Y(10) := X(0).Layer1(1);
    Y(11) := X(0).Layer1(2);
    Y(12) := X(0).Layer1(3);
    Y(13) := X(1).Layer1(0);
    Y(14) := X(1).Layer1(1);
    Y(15) := X(1).Layer1(2);
    Y(16) := X(1).Layer1(3);
    Y(17) := X(2).Layer1(0);
    Y(18) := X(2).Layer1(1);
    Y(19) := X(2).Layer1(2);
    Y(20) := X(2).Layer1(3);
    Y(21) := X(3).Layer1(0);
    Y(22) := X(3).Layer1(1);
    Y(23) := X(3).Layer1(2);
    Y(24) := X(3).Layer1(3);
    Y(25) := X(4).Layer1(0);
    Y(26) := X(4).Layer1(1);
    Y(27) := X(4).Layer1(2);
    Y(28) := X(4).Layer1(3);
    Y(29) := X(5).Layer1(0);
    Y(30) := X(5).Layer1(1);
    Y(31) := X(5).Layer1(2);
    Y(32) := X(5).Layer1(3);
    Y(33) := X(6).Layer1(0);
    Y(34) := X(6).Layer1(1);
    Y(35) := X(6).Layer1(2);
    Y(36) := X(6).Layer1(3);
    Y(37) := X(7).Layer1(0);
    Y(38) := X(7).Layer1(1);
    Y(39) := X(7).Layer1(2);
    Y(40) := X(7).Layer1(3);
    Y(41) := X(8).Layer1(0);
    Y(42) := X(8).Layer1(1);
    Y(43) := X(8).Layer1(2);
    Y(44) := X(8).Layer1(3);
    Y(45) := X(0).Layer2(0);
    Y(46) := X(0).Layer2(1);
    Y(47) := X(0).Layer2(2);
    Y(48) := X(0).Layer2(3);
    Y(49) := X(1).Layer2(0);
    Y(50) := X(1).Layer2(1);
    Y(51) := X(1).Layer2(2);
    Y(52) := X(1).Layer2(3);
    Y(53) := X(2).Layer2(0);
    Y(54) := X(2).Layer2(1);
    Y(55) := X(2).Layer2(2);
    Y(56) := X(2).Layer2(3);
    Y(57) := X(3).Layer2(0);
    Y(58) := X(3).Layer2(1);
    Y(59) := X(3).Layer2(2);
    Y(60) := X(3).Layer2(3);
    Y(61) := X(4).Layer2(0);
    Y(62) := X(4).Layer2(1);
    Y(63) := X(4).Layer2(2);
    Y(64) := X(4).Layer2(3);
    Y(65) := X(5).Layer2(0);
    Y(66) := X(5).Layer2(1);
    Y(67) := X(5).Layer2(2);
    Y(68) := X(5).Layer2(3);
    Y(69) := X(6).Layer2(0);
    Y(70) := X(6).Layer2(1);
    Y(71) := X(6).Layer2(2);
    Y(72) := X(6).Layer2(3);
    Y(73) := X(7).Layer2(0);
    Y(74) := X(7).Layer2(1);
    Y(75) := X(7).Layer2(2);
    Y(76) := X(7).Layer2(3);
    Y(77) := X(8).Layer2(0);
    Y(78) := X(8).Layer2(1);
    Y(79) := X(8).Layer2(2);
    Y(80) := X(8).Layer2(3);
    Y(81) := X(0).Layer3(0);
    Y(82) := X(1).Layer3(0);
    Y(83) := X(2).Layer3(0);
    Y(84) := X(3).Layer3(0);
    Y(85) := X(4).Layer3(0);
    Y(86) := X(5).Layer3(0);
    Y(87) := X(6).Layer3(0);
    Y(88) := X(7).Layer3(0);
    Y(89) := X(8).Layer3(0);
    Y(90) := X(0).Hadron(0);
    Y(91) := X(1).Hadron(0);
    Y(92) := X(2).Hadron(0);
    Y(93) := X(3).Hadron(0);
    Y(94) := X(4).Hadron(0);
    Y(95) := X(5).Hadron(0);
    Y(96) := X(6).Hadron(0);
    Y(97) := X(7).Hadron(0);
    Y(98) := X(8).Hadron(0);
    return Y;
  end;
 
end DataTypes;