GctFormatTranslateV38.cc

Go to the documentation of this file.

#include "EventFilter/GctRawToDigi/src/GctFormatTranslateV38.h"

// C++ headers
#include <iostream>
#include <cassert>
#include <algorithm>
#include <cmath>

// Framework headers
#include "FWCore/MessageLogger/interface/MessageLogger.h"

// Namespace resolution
using std::cout;
using std::endl;
using std::pair;
using std::make_pair;

// INITIALISE STATIC VARIABLES
/*** Setup BlockID to BlockLength Map ***/
const GctFormatTranslateV38::BlockLengthMap GctFormatTranslateV38::m_blockLength = {
    // Miscellaneous Blocks
    {0x000,0},      // NULL
    // ConcJet FPGA
    {0x580,12},     // ConcJet: Input TrigPathA (Jet Cands)
    {0x581,2},      // ConcJet: Input TrigPathB (HF Rings)
    {0x582,4},      // ConcJet: Input TrigPathC (MissHt)
    {0x583,8},      // ConcJet: Jet Cands and Counts Output to GT
    {0x587,4},      // ConcJet: BX & Orbit Info
    // ConcElec FPGA
    {0x680,16},     // ConcElec: Input TrigPathA (EM Cands)
    {0x681,6},      // ConcElec: Input TrigPathB (Et Sums)
    {0x682,2},      // ConcElec: Input TrigPathC (Ht Sums)
    {0x683,6},      // ConcElec: EM Cands and Energy Sums Output to GT
    {0x686,2},      // ConcElec: Test (GT Serdes Loopback)
    {0x687,4},      // ConcElec: BX & Orbit Info
    // Electron Leaf FPGAs
    {0x800,20},     // Leaf0ElecPosEtaU1: Sort Input
    {0x803,4},      // Leaf0ElecPosEtaU1: Sort Output
    {0x804,15},     // Leaf0ElecPosEtaU1: Raw Input
    {0x880,16},     // Leaf0ElecPosEtaU2: Sort Input
    {0x883,4},      // Leaf0ElecPosEtaU2: Sort Output
    {0x884,12},     // Leaf0ElecPosEtaU2: Raw Input
    {0xc00,20},     // Leaf0ElecNegEtaU1: Sort Input
    {0xc03,4},      // Leaf0ElecNegEtaU1: Sort Output
    {0xc04,15},     // Leaf0ElecNegEtaU1: Raw Input
    {0xc80,16},     // Leaf0ElecNegEtaU2: Sort Input
    {0xc83,4},      // Leaf0ElecNegEtaU2: Sort Output
    {0xc84,12},     // Leaf0ElecNegEtaU2: Raw Input
    // Wheel Pos-eta Jet FPGA
    {0x300,27},     // WheelPosEtaJet: Input TrigPathA (Jet Sort)
    {0x301,3},      // WheelPosEtaJet: Input TrigPathB (MissHt)
    {0x303,6},      // WheelPosEtaJet: Output TrigPathA (Jet Sort)
    {0x305,2},      // WheelPosEtaJet: Output TrigPathB (MissHt)
    {0x306,32},     // WheelPosEtaJet: Test (deprecated)  (Doesn't exist in V27.1 format, but does in V24 & V25, so keep for CRUZET2 data compatibility reasons)
    {0x307,4},      // WheelPosEtaJet: Info (deprecated)  (Doesn't exist in V27.1 format, but does in V24 & V25, so keep for CRUZET2 data compatibility reasons)
    // Wheel Pos-eta Energy FPGA
    {0x380,21},     // WheelPosEtaEnergy: Input TrigPathA (Et)
    {0x381,6},      // WheelPosEtaEnergy: Input TrigPathB (Ht)
    {0x383,7},      // WheelPosEtaEnergy: Output TrigPathA (Et)
    {0x385,2},      // WheelPosEtaEnergy: Output TrigPathB (Ht)
    {0x386,32},     // WheelPosEtaEnergy: Test
    {0x387,6},      // WheelPosEtaEnergy: BX & Orbit Info   (Potential data incompatibility between V24/V25 where block length=4, and V27.1 where block length=6)
    // Wheel Neg-eta Jet FPGA
    {0x700,27},     // WheelNegEtaJet: Input TrigPathA (Jet Sort)
    {0x701,3},      // WheelNegEtaJet: Input TrigPathB (MissHt)
    {0x703,6},      // WheelNegEtaJet: Output TrigPathA (Jet Sort)
    {0x705,2},      // WheelNegEtaJet: Output TrigPathB (MissHt)
    {0x706,32},     // WheelNegEtaJet: Test (deprecated)  (Doesn't exist in V27.1 format, but does in V24 & V25, so keep for CRUZET2 data compatibility reasons)
    {0x707,4},      // WheelNegEtaJet: Info (deprecated)  (Doesn't exist in V27.1 format, but does in V24 & V25, so keep for CRUZET2 data compatibility reasons)
    // Wheel Neg-eta Energy FPGA
    {0x780,21},     // WheelNegEtaEnergy: Input TrigPathA (Et)
    {0x781,6},      // WheelNegEtaEnergy: Input TrigPathB (Ht)
    {0x783,7},      // WheelNegEtaEnergy: Output TrigPathA (Et)
    {0x785,2},      // WheelNegEtaEnergy: Output TrigPathB (Ht)
    {0x786,32},     // WheelNegEtaEnergy: Test
    {0x787,6},      // WheelNegEtaEnergy: BX & Orbit Info   (Potential data incompatibility between V24/V25 where block length=4, and V27.1 where block length=6)
    // Jet Leaf FPGAs - Positive Eta 
    {0x900,13},     // Leaf1JetPosEtaU1: JF2 Input
    {0x901,3},      // Leaf1JetPosEtaU1: JF2 Shared Received
    {0x902,3},      // Leaf1JetPosEtaU1: JF2 Shared Sent
    {0x903,10},     // Leaf1JetPosEtaU1: JF2 Output
    {0x904,8},      // Leaf1JetPosEtaU1: JF2 Raw Input
    {0x908,13},     // Leaf1JetPosEtaU1: JF3 Input
    {0x909,3},      // Leaf1JetPosEtaU1: JF3 Shared Received
    {0x90a,3},      // Leaf1JetPosEtaU1: JF3 Shared Sent
    {0x90b,10},     // Leaf1JetPosEtaU1: JF3 Output
    {0x90c,8},      // Leaf1JetPosEtaU1: JF3 Raw Input
    {0x980,6},      // Leaf1JetPosEtaU2: Eta0 Input
    {0x984,6},      // Leaf1JetPosEtaU2: Eta0 Raw Input
    {0x988,13},     // Leaf1JetPosEtaU2: JF1 Input
    {0x989,3},      // Leaf1JetPosEtaU2: JF1 Shared Received
    {0x98a,3},      // Leaf1JetPosEtaU2: JF1 Shared Sent
    {0x98b,10},     // Leaf1JetPosEtaU2: JF1 Output
    {0x98c,8},      // Leaf1JetPosEtaU2: JF1 Raw Input
    {0xa00,13},     // Leaf2JetPosEtaU1: JF2 Input
    {0xa01,3},      // Leaf2JetPosEtaU1: JF2 Shared Received
    {0xa02,3},      // Leaf2JetPosEtaU1: JF2 Shared Sent
    {0xa03,10},     // Leaf2JetPosEtaU1: JF2 Output
    {0xa04,8},      // Leaf2JetPosEtaU1: JF2 Raw Input
    {0xa08,13},     // Leaf2JetPosEtaU1: JF3 Input
    {0xa09,3},      // Leaf2JetPosEtaU1: JF3 Shared Received
    {0xa0a,3},      // Leaf2JetPosEtaU1: JF3 Shared Sent
    {0xa0b,10},     // Leaf2JetPosEtaU1: JF3 Output
    {0xa0c,8},      // Leaf2JetPosEtaU1: JF3 Raw Input
    {0xa80,6},      // Leaf2JetPosEtaU2: Eta0 Input
    {0xa84,6},      // Leaf2JetPosEtaU2: Eta0 Raw Input
    {0xa88,13},     // Leaf2JetPosEtaU2: JF1 Input
    {0xa89,3},      // Leaf2JetPosEtaU2: JF1 Shared Received
    {0xa8a,3},      // Leaf2JetPosEtaU2: JF1 Shared Sent
    {0xa8b,10},     // Leaf2JetPosEtaU2: JF1 Output
    {0xa8c,8},      // Leaf2JetPosEtaU2: JF1 Raw Input
    {0xb00,13},     // Leaf3JetPosEtaU1: JF2 Input
    {0xb01,3},      // Leaf3JetPosEtaU1: JF2 Shared Received
    {0xb02,3},      // Leaf3JetPosEtaU1: JF2 Shared Sent
    {0xb03,10},     // Leaf3JetPosEtaU1: JF2 Output
    {0xb04,8},      // Leaf3JetPosEtaU1: JF2 Raw Input
    {0xb08,13},     // Leaf3JetPosEtaU1: JF3 Input
    {0xb09,3},      // Leaf3JetPosEtaU1: JF3 Shared Received
    {0xb0a,3},      // Leaf3JetPosEtaU1: JF3 Shared Sent
    {0xb0b,10},     // Leaf3JetPosEtaU1: JF3 Output
    {0xb0c,8},      // Leaf3JetPosEtaU1: JF3 Raw Input
    {0xb80,6},      // Leaf3JetPosEtaU2: Eta0 Input
    {0xb84,6},      // Leaf3JetPosEtaU2: Eta0 Raw Input
    {0xb88,13},     // Leaf3JetPosEtaU2: JF1 Input
    {0xb89,3},      // Leaf3JetPosEtaU2: JF1 Shared Received
    {0xb8a,3},      // Leaf3JetPosEtaU2: JF1 Shared Sent
    {0xb8b,10},     // Leaf3JetPosEtaU2: JF1 Output
    {0xb8c,8},      // Leaf3JetPosEtaU2: JF1 Raw Input
    // Jet Leaf FPGAs - Negative Eta 
    {0xd00,13},     // Leaf1JetNegEtaU1: JF2 Input
    {0xd01,3},      // Leaf1JetNegEtaU1: JF2 Shared Received
    {0xd02,3},      // Leaf1JetNegEtaU1: JF2 Shared Sent
    {0xd03,10},     // Leaf1JetNegEtaU1: JF2 Output
    {0xd04,8},      // Leaf1JetNegEtaU1: JF2 Raw Input
    {0xd08,13},     // Leaf1JetNegEtaU1: JF3 Input
    {0xd09,3},      // Leaf1JetNegEtaU1: JF3 Shared Received
    {0xd0a,3},      // Leaf1JetNegEtaU1: JF3 Shared Sent
    {0xd0b,10},     // Leaf1JetNegEtaU1: JF3 Output
    {0xd0c,8},      // Leaf1JetNegEtaU1: JF3 Raw Input
    {0xd80,6},      // Leaf1JetNegEtaU2: Eta0 Input
    {0xd84,6},      // Leaf1JetNegEtaU2: Eta0 Raw Input
    {0xd88,13},     // Leaf1JetNegEtaU2: JF1 Input
    {0xd89,3},      // Leaf1JetNegEtaU2: JF1 Shared Received
    {0xd8a,3},      // Leaf1JetNegEtaU2: JF1 Shared Sent
    {0xd8b,10},     // Leaf1JetNegEtaU2: JF1 Output
    {0xd8c,8},      // Leaf1JetNegEtaU2: JF1 Raw Input
    {0xe00,13},     // Leaf2JetNegEtaU1: JF2 Input
    {0xe01,3},      // Leaf2JetNegEtaU1: JF2 Shared Received
    {0xe02,3},      // Leaf2JetNegEtaU1: JF2 Shared Sent
    {0xe03,10},     // Leaf2JetNegEtaU1: JF2 Output
    {0xe04,8},      // Leaf2JetNegEtaU1: JF2 Raw Input
    {0xe08,13},     // Leaf2JetNegEtaU1: JF3 Input
    {0xe09,3},      // Leaf2JetNegEtaU1: JF3 Shared Received
    {0xe0a,3},      // Leaf2JetNegEtaU1: JF3 Shared Sent
    {0xe0b,10},     // Leaf2JetNegEtaU1: JF3 Output
    {0xe0c,8},      // Leaf2JetNegEtaU1: JF3 Raw Input
    {0xe80,6},      // Leaf2JetNegEtaU2: Eta0 Input
    {0xe84,6},      // Leaf2JetNegEtaU2: Eta0 Raw Input
    {0xe88,13},     // Leaf2JetNegEtaU2: JF1 Input
    {0xe89,3},      // Leaf2JetNegEtaU2: JF1 Shared Received
    {0xe8a,3},      // Leaf2JetNegEtaU2: JF1 Shared Sent
    {0xe8b,10},     // Leaf2JetNegEtaU2: JF1 Output
    {0xe8c,8},      // Leaf2JetNegEtaU2: JF1 Raw Input
    {0xf00,13},     // Leaf3JetNegEtaU1: JF2 Input
    {0xf01,3},      // Leaf3JetNegEtaU1: JF2 Shared Received
    {0xf02,3},      // Leaf3JetNegEtaU1: JF2 Shared Sent
    {0xf03,10},     // Leaf3JetNegEtaU1: JF2 Output
    {0xf04,8},      // Leaf3JetNegEtaU1: JF2 Raw Input
    {0xf08,13},     // Leaf3JetNegEtaU1: JF3 Input
    {0xf09,3},      // Leaf3JetNegEtaU1: JF3 Shared Received
    {0xf0a,3},      // Leaf3JetNegEtaU1: JF3 Shared Sent
    {0xf0b,10},     // Leaf3JetNegEtaU1: JF3 Output
    {0xf0c,8},      // Leaf3JetNegEtaU1: JF3 Raw Input
    {0xf80,6},      // Leaf3JetNegEtaU2: Eta0 Input
    {0xf84,6},      // Leaf3JetNegEtaU2: Eta0 Raw Input
    {0xf88,13},     // Leaf3JetNegEtaU2: JF1 Input    
    {0xf89,3},      // Leaf3JetNegEtaU2: JF1 Shared Received
    {0xf8a,3},      // Leaf3JetNegEtaU2: JF1 Shared Sent
    {0xf8b,10},     // Leaf3JetNegEtaU2: JF1 Output
    {0xf8c,8}       // Leaf3JetNegEtaU2: JF1 Raw Input
};

/*** Setup BlockID to BlockName Map ***/
const GctFormatTranslateV38::BlockNameMap GctFormatTranslateV38::m_blockName = {
    // Miscellaneous Blocks
    {0x000,"NULL"},
    // ConcJet FPGA
    {0x580,"ConcJet: Input TrigPathA (Jet Cands)"},
    {0x581,"ConcJet: Input TrigPathB (HF Rings)"},
    {0x582,"ConcJet: Input TrigPathC (MissHt)"},
    {0x583,"ConcJet: Jet Cands and Counts Output to GT"},
    {0x587,"ConcJet: BX & Orbit Info"},
    // ConcElec FPGA
    {0x680,"ConcElec: Input TrigPathA (EM Cands)"},
    {0x681,"ConcElec: Input TrigPathB (Et Sums)"},
    {0x682,"ConcElec: Input TrigPathC (Ht Sums)"},
    {0x683,"ConcElec: EM Cands and Energy Sums Output to GT"},
    {0x686,"ConcElec: Test (GT Serdes Loopback)"},
    {0x687,"ConcElec: BX & Orbit Info"},
    // Electron Leaf FPGAs
    {0x800,"Leaf0ElecPosEtaU1: Sort Input"},
    {0x803,"Leaf0ElecPosEtaU1: Sort Output"},
    {0x804,"Leaf0ElecPosEtaU1: Raw Input"},
    {0x880,"Leaf0ElecPosEtaU2: Sort Input"},
    {0x883,"Leaf0ElecPosEtaU2: Sort Output"},
    {0x884,"Leaf0ElecPosEtaU2: Raw Input"},
    {0xc00,"Leaf0ElecNegEtaU1: Sort Input"},
    {0xc03,"Leaf0ElecNegEtaU1: Sort Output"},
    {0xc04,"Leaf0ElecNegEtaU1: Raw Input"},
    {0xc80,"Leaf0ElecNegEtaU2: Sort Input"},
    {0xc83,"Leaf0ElecNegEtaU2: Sort Output"},
    {0xc84,"Leaf0ElecNegEtaU2: Raw Input"},
    // Wheel Pos-eta Jet FPGA
    {0x300,"WheelPosEtaJet: Input TrigPathA (Jet Sort)"},
    {0x301,"WheelPosEtaJet: Input TrigPathB (MissHt)"},  
    {0x303,"WheelPosEtaJet: Output TrigPathA (Jet Sort)"},
    {0x305,"WheelPosEtaJet: Output TrigPathB (MissHt)"},
    {0x306,"WheelPosEtaJet: Test (deprecated)"},  // (Doesn't exist in V27.1 format, but does in V24 & V25, so keep for CRUZET2 data compatibility reasons)
    {0x307,"WheelPosEtaJet: Info (deprecated)"},  // (Doesn't exist in V27.1 format, but does in V24 & V25, so keep for CRUZET2 data compatibility reasons)
    // Wheel Pos-eta Energy FPGA
    {0x380,"WheelPosEtaEnergy: Input TrigPathA (Et)"},
    {0x381,"WheelPosEtaEnergy: Input TrigPathB (Ht)"},
    {0x383,"WheelPosEtaEnergy: Output TrigPathA (Et)"},
    {0x385,"WheelPosEtaEnergy: Output TrigPathB (Ht)"},
    {0x386,"WheelPosEtaEnergy: Test"},
    {0x387,"WheelPosEtaEnergy: BX & Orbit Info"},
    // Wheel Neg-eta Jet FPGA
    {0x700,"WheelNegEtaJet: Input TrigPathA (Jet Sort)"},
    {0x701,"WheelNegEtaJet: Input TrigPathB (MissHt)"},
    {0x703,"WheelNegEtaJet: Output TrigPathA (Jet Sort)"},
    {0x705,"WheelNegEtaJet: Output TrigPathB (MissHt)"},
    {0x706,"WheelNegEtaJet: Test (deprecated)"},  // (Doesn't exist in V27.1 format, but does in V24 & V25, so keep for CRUZET2 data compatibility reasons)
    {0x707,"WheelNegEtaJet: Info (deprecated)"},  // (Doesn't exist in V27.1 format, but does in V24 & V25, so keep for CRUZET2 data compatibility reasons)
    // Wheel Neg-eta Energy FPGA
    {0x780,"WheelNegEtaEnergy: Input TrigPathA (Et)"},
    {0x781,"WheelNegEtaEnergy: Input TrigPathB (Ht)"},
    {0x783,"WheelNegEtaEnergy: Output TrigPathA (Et)"},
    {0x785,"WheelNegEtaEnergy: Output TrigPathB (Ht)"},
    {0x786,"WheelNegEtaEnergy: Test"},
    {0x787,"WheelNegEtaEnergy: BX & Orbit Info"},
    // Jet Leaf FPGAs - Positive Eta
    {0x900,"Leaf1JetPosEtaU1: JF2 Input"},
    {0x901,"Leaf1JetPosEtaU1: JF2 Shared Received"},
    {0x902,"Leaf1JetPosEtaU1: JF2 Shared Sent"},
    {0x903,"Leaf1JetPosEtaU1: JF2 Output"},
    {0x904,"Leaf1JetPosEtaU1: JF2 Raw Input"},
    {0x908,"Leaf1JetPosEtaU1: JF3 Input"},
    {0x909,"Leaf1JetPosEtaU1: JF3 Shared Received"},
    {0x90a,"Leaf1JetPosEtaU1: JF3 Shared Sent"},
    {0x90b,"Leaf1JetPosEtaU1: JF3 Output"},
    {0x90c,"Leaf1JetPosEtaU1: JF3 Raw Input"},
    {0x980,"Leaf1JetPosEtaU2: Eta0 Input"},  // Next Leaf Start
    {0x984,"Leaf1JetPosEtaU2: Eta0 Raw Input"},
    {0x988,"Leaf1JetPosEtaU2: JF1 Input"},
    {0x989,"Leaf1JetPosEtaU2: JF1 Shared Received"},
    {0x98a,"Leaf1JetPosEtaU2: JF1 Shared Sent"},
    {0x98b,"Leaf1JetPosEtaU2: JF1 Output"},
    {0x98c,"Leaf1JetPosEtaU2: JF1 Raw Input"},
    {0xa00,"Leaf2JetPosEtaU1: JF2 Input"},  // Next Leaf Start
    {0xa01,"Leaf2JetPosEtaU1: JF2 Shared Received"},
    {0xa02,"Leaf2JetPosEtaU1: JF2 Shared Sent"},
    {0xa03,"Leaf2JetPosEtaU1: JF2 Output"},
    {0xa04,"Leaf2JetPosEtaU1: JF2 Raw Input"},
    {0xa08,"Leaf2JetPosEtaU1: JF3 Input"},
    {0xa09,"Leaf2JetPosEtaU1: JF3 Shared Received"},
    {0xa0a,"Leaf2JetPosEtaU1: JF3 Shared Sent"},
    {0xa0b,"Leaf2JetPosEtaU1: JF3 Output"},
    {0xa0c,"Leaf2JetPosEtaU1: JF3 Raw Input"},
    {0xa80,"Leaf2JetPosEtaU2: Eta0 Input"},  // Next Leaf Start
    {0xa84,"Leaf2JetPosEtaU2: Eta0 Raw Input"},
    {0xa88,"Leaf2JetPosEtaU2: JF1 Input"},
    {0xa89,"Leaf2JetPosEtaU2: JF1 Shared Received"},
    {0xa8a,"Leaf2JetPosEtaU2: JF1 Shared Sent"},
    {0xa8b,"Leaf2JetPosEtaU2: JF1 Output"},
    {0xa8c,"Leaf2JetPosEtaU2: JF1 Raw Input"},
    {0xb00,"Leaf3JetPosEtaU1: JF2 Input"},  // Next Leaf Start
    {0xb01,"Leaf3JetPosEtaU1: JF2 Shared Received"},
    {0xb02,"Leaf3JetPosEtaU1: JF2 Shared Sent"},
    {0xb03,"Leaf3JetPosEtaU1: JF2 Output"},
    {0xb04,"Leaf3JetPosEtaU1: JF2 Raw Input"},
    {0xb08,"Leaf3JetPosEtaU1: JF3 Input"},
    {0xb09,"Leaf3JetPosEtaU1: JF3 Shared Received"},
    {0xb0a,"Leaf3JetPosEtaU1: JF3 Shared Sent"},
    {0xb0b,"Leaf3JetPosEtaU1: JF3 Output"},
    {0xb0c,"Leaf3JetPosEtaU1: JF3 Raw Input"},
    {0xb80,"Leaf3JetPosEtaU2: Eta0 Input"},  // Next Leaf Start
    {0xb84,"Leaf3JetPosEtaU2: Eta0 Raw Input"},
    {0xb88,"Leaf3JetPosEtaU2: JF1 Input"},
    {0xb89,"Leaf3JetPosEtaU2: JF1 Shared Received"},
    {0xb8a,"Leaf3JetPosEtaU2: JF1 Shared Sent"},
    {0xb8b,"Leaf3JetPosEtaU2: JF1 Output"},
    {0xb8c,"Leaf3JetPosEtaU2: JF1 Raw Input"},
    // Jet Leaf FPGAs - Negative Eta
    {0xd00,"Leaf1JetNegEtaU1: JF2 Input"},       // START OF NEG ETA JET LEAVES
    {0xd01,"Leaf1JetNegEtaU1: JF2 Shared Received"},
    {0xd02,"Leaf1JetNegEtaU1: JF2 Shared Sent"},
    {0xd03,"Leaf1JetNegEtaU1: JF2 Output"},
    {0xd04,"Leaf1JetNegEtaU1: JF2 Raw Input"},
    {0xd08,"Leaf1JetNegEtaU1: JF3 Input"},
    {0xd09,"Leaf1JetNegEtaU1: JF3 Shared Received"},
    {0xd0a,"Leaf1JetNegEtaU1: JF3 Shared Sent"},
    {0xd0b,"Leaf1JetNegEtaU1: JF3 Output"},
    {0xd0c,"Leaf1JetNegEtaU1: JF3 Raw Input"},
    {0xd80,"Leaf1JetNegEtaU2: Eta0 Input"},  // Next Leaf Start
    {0xd84,"Leaf1JetNegEtaU2: Eta0 Raw Input"},
    {0xd88,"Leaf1JetNegEtaU2: JF1 Input"},
    {0xd89,"Leaf1JetNegEtaU2: JF1 Shared Received"},
    {0xd8a,"Leaf1JetNegEtaU2: JF1 Shared Sent"},
    {0xd8b,"Leaf1JetNegEtaU2: JF1 Output"},
    {0xd8c,"Leaf1JetNegEtaU2: JF1 Raw Input"},
    {0xe00,"Leaf2JetNegEtaU1: JF2 Input"},  // Next Leaf Start
    {0xe01,"Leaf2JetNegEtaU1: JF2 Shared Received"},
    {0xe02,"Leaf2JetNegEtaU1: JF2 Shared Sent"},
    {0xe03,"Leaf2JetNegEtaU1: JF2 Output"},
    {0xe04,"Leaf2JetNegEtaU1: JF2 Raw Input"},
    {0xe08,"Leaf2JetNegEtaU1: JF3 Input"},
    {0xe09,"Leaf2JetNegEtaU1: JF3 Shared Received"},
    {0xe0a,"Leaf2JetNegEtaU1: JF3 Shared Sent"},
    {0xe0b,"Leaf2JetNegEtaU1: JF3 Output"},
    {0xe0c,"Leaf2JetNegEtaU1: JF3 Raw Input"},
    {0xe80,"Leaf2JetNegEtaU2: Eta0 Input"},  // Next Leaf Start
    {0xe84,"Leaf2JetNegEtaU2: Eta0 Raw Input"},
    {0xe88,"Leaf2JetNegEtaU2: JF1 Input"},
    {0xe89,"Leaf2JetNegEtaU2: JF1 Shared Received"},
    {0xe8a,"Leaf2JetNegEtaU2: JF1 Shared Sent"},
    {0xe8b,"Leaf2JetNegEtaU2: JF1 Output"},
    {0xe8c,"Leaf2JetNegEtaU2: JF1 Raw Input"},
    {0xf00,"Leaf3JetNegEtaU1: JF2 Input"},  // Next Leaf Start
    {0xf01,"Leaf3JetNegEtaU1: JF2 Shared Received"},
    {0xf02,"Leaf3JetNegEtaU1: JF2 Shared Sent"},
    {0xf03,"Leaf3JetNegEtaU1: JF2 Output"},
    {0xf04,"Leaf3JetNegEtaU1: JF2 Raw Input"},
    {0xf08,"Leaf3JetNegEtaU1: JF3 Input"},
    {0xf09,"Leaf3JetNegEtaU1: JF3 Shared Received"},
    {0xf0a,"Leaf3JetNegEtaU1: JF3 Shared Sent"},
    {0xf0b,"Leaf3JetNegEtaU1: JF3 Output"},
    {0xf0c,"Leaf3JetNegEtaU1: JF3 Raw Input"},
    {0xf80,"Leaf3JetNegEtaU2: Eta0 Input"},  // Next Leaf Start
    {0xf84,"Leaf3JetNegEtaU2: Eta0 Raw Input"},
    {0xf88,"Leaf3JetNegEtaU2: JF1 Input"},
    {0xf89,"Leaf3JetNegEtaU2: JF1 Shared Received"},
    {0xf8a,"Leaf3JetNegEtaU2: JF1 Shared Sent"},
    {0xf8b,"Leaf3JetNegEtaU2: JF1 Output"},
    {0xf8c,"Leaf3JetNegEtaU2: JF1 Raw Input"}
};

/*** Setup BlockID to Unpack-Function Map ***/
const GctFormatTranslateV38::BlockIdToUnpackFnMap GctFormatTranslateV38::m_blockUnpackFn = {
    // Miscellaneous Blocks
    {0x000 , &GctFormatTranslateV38::blockDoNothing},                    // NULL
    // ConcJet FPGA                                                             
    {0x580 , &GctFormatTranslateV38::blockToGctTrigObjects},             // ConcJet: Input TrigPathA (Jet Cands)
    {0x581 , &GctFormatTranslateV38::blockToGctInternRingSums},          // ConcJet: Input TrigPathB (HF Rings)
    {0x582 , &GctFormatTranslateV38::blockToGctInternHtMissPostWheel},   // ConcJet: Input TrigPathC (MissHt)
    {0x583 , &GctFormatTranslateV38::blockToGctJetCandsAndCounts},       // ConcJet: Jet Cands and Counts Output to GT
    {0x587 , &GctFormatTranslateV38::blockDoNothing},                    // ConcJet: BX & Orbit Info
    // ConcElec FPGA                                                            
    {0x680 , &GctFormatTranslateV38::blockToGctInternEmCand},            // ConcElec: Input TrigPathA (EM Cands)
    {0x681 , &GctFormatTranslateV38::blockToGctInternEtSums},            // ConcElec: Input TrigPathB (Et Sums)
    {0x682 , &GctFormatTranslateV38::blockToGctInternEtSums},            // ConcElec: Input TrigPathC (Ht Sums)
    {0x683 , &GctFormatTranslateV38::blockToGctEmCandsAndEnergySums},    // ConcElec: EM Cands and Energy Sums Output to GT
    {0x686 , &GctFormatTranslateV38::blockDoNothing},                    // ConcElec: Test (GT Serdes Loopback)
    {0x687 , &GctFormatTranslateV38::blockDoNothing},                    // ConcElec: BX & Orbit Info
    // Electron Leaf FPGAs                                                      
    {0x800 , &GctFormatTranslateV38::blockToGctInternEmCand},            // Leaf0ElecPosEtaU1: Sort Input
    {0x803 , &GctFormatTranslateV38::blockToGctInternEmCand},            // Leaf0ElecPosEtaU1: Sort Output
    {0x804 , &GctFormatTranslateV38::blockToFibresAndToRctEmCand},       // Leaf0ElecPosEtaU1: Raw Input
    {0x880 , &GctFormatTranslateV38::blockToGctInternEmCand},            // Leaf0ElecPosEtaU2: Sort Input
    {0x883 , &GctFormatTranslateV38::blockToGctInternEmCand},            // Leaf0ElecPosEtaU2: Sort Output
    {0x884 , &GctFormatTranslateV38::blockToFibresAndToRctEmCand},       // Leaf0ElecPosEtaU2: Raw Input
    {0xc00 , &GctFormatTranslateV38::blockToGctInternEmCand},            // Leaf0ElecNegEtaU1: Sort Input
    {0xc03 , &GctFormatTranslateV38::blockToGctInternEmCand},            // Leaf0ElecNegEtaU1: Sort Output
    {0xc04 , &GctFormatTranslateV38::blockToFibresAndToRctEmCand},       // Leaf0ElecNegEtaU1: Raw Input
    {0xc80 , &GctFormatTranslateV38::blockToGctInternEmCand},            // Leaf0ElecNegEtaU2: Sort Input
    {0xc83 , &GctFormatTranslateV38::blockToGctInternEmCand},            // Leaf0ElecNegEtaU2: Sort Output
    {0xc84 , &GctFormatTranslateV38::blockToFibresAndToRctEmCand},       // Leaf0ElecNegEtaU2: Raw Input
    // Wheel Pos-eta Jet FPGA                                                   
    {0x300 , &GctFormatTranslateV38::blockToGctJetClusterMinimal},       // WheelPosEtaJet: Input TrigPathA (Jet Sort)
    {0x301 , &GctFormatTranslateV38::blockToGctInternHtMissPreWheel},    // WheelPosEtaJet: Input TrigPathB (MissHt)
    {0x303 , &GctFormatTranslateV38::blockToGctTrigObjects},             // WheelPosEtaJet: Output TrigPathA (Jet Sort)
    {0x305 , &GctFormatTranslateV38::blockToGctInternHtMissPostWheel},   // WheelPosEtaJet: Output TrigPathB (MissHt)
    {0x306 , &GctFormatTranslateV38::blockDoNothing},                    // WheelPosEtaJet: Test (deprecated)  (Doesn't exist in V27.1 format, but does in V24 & V25, so keep for CRUZET2 data compatibility reasons)
    {0x307 , &GctFormatTranslateV38::blockDoNothing},                    // WheelPosEtaJet: Info (deprecated)  (Doesn't exist in V27.1 format, but does in V24 & V25, so keep for CRUZET2 data compatibility reasons)
    // Wheel Pos-eta Energy FPGA                                                
    {0x380 , &GctFormatTranslateV38::blockToGctWheelInputInternEtAndRingSums},     // WheelPosEtaEnergy: Input TrigPathA (Et)
    {0x381 , &GctFormatTranslateV38::blockToGctInternEtSums},            // WheelPosEtaEnergy: Input TrigPathB (Ht)
    {0x383 , &GctFormatTranslateV38::blockToGctWheelOutputInternEtAndRingSums},     // WheelPosEtaEnergy: Output TrigPathA (Et)
    {0x385 , &GctFormatTranslateV38::blockToGctInternEtSums},            // WheelPosEtaEnergy: Output TrigPathB (Ht)
    {0x386 , &GctFormatTranslateV38::blockDoNothing},                    // WheelPosEtaEnergy: Test
    {0x387 , &GctFormatTranslateV38::blockDoNothing},                    // WheelPosEtaEnergy: BX & Orbit Info   (Potential data incompatibility between V24/V25 where block length=4, and V27.1 where block length=6)
    // Wheel Neg-eta Jet FPGA                                                   
    {0x700 , &GctFormatTranslateV38::blockToGctJetClusterMinimal},       // WheelNegEtaJet: Input TrigPathA (Jet Sort)
    {0x701 , &GctFormatTranslateV38::blockToGctInternHtMissPreWheel},    // WheelNegEtaJet: Input TrigPathB (MissHt)
    {0x703 , &GctFormatTranslateV38::blockToGctTrigObjects},             // WheelNegEtaJet: Output TrigPathA (Jet Sort)
    {0x705 , &GctFormatTranslateV38::blockToGctInternHtMissPostWheel},   // WheelNegEtaJet: Output TrigPathB (MissHt)    
    {0x706 , &GctFormatTranslateV38::blockDoNothing},                    // WheelNegEtaJet: Test (deprecated)  (Doesn't exist in V27.1 format, but does in V24 & V25, so keep for CRUZET2 data compatibility reasons)
    {0x707 , &GctFormatTranslateV38::blockDoNothing},                    // WheelNegEtaJet: Info (deprecated)  (Doesn't exist in V27.1 format, but does in V24 & V25, so keep for CRUZET2 data compatibility reasons)
    // Wheel Neg-eta Energy FPGA                                                
    {0x780 , &GctFormatTranslateV38::blockToGctWheelInputInternEtAndRingSums},     // WheelNegEtaEnergy: Input TrigPathA (Et)
    {0x781 , &GctFormatTranslateV38::blockToGctInternEtSums},            // WheelNegEtaEnergy: Input TrigPathB (Ht)
    {0x783 , &GctFormatTranslateV38::blockToGctWheelOutputInternEtAndRingSums},     // WheelNegEtaEnergy: Output TrigPathA (Et)
    {0x785 , &GctFormatTranslateV38::blockToGctInternEtSums},            // WheelNegEtaEnergy: Output TrigPathB (Ht)
    {0x786 , &GctFormatTranslateV38::blockDoNothing},                    // WheelNegEtaEnergy: Test
    {0x787 , &GctFormatTranslateV38::blockDoNothing},                    // WheelNegEtaEnergy: BX & Orbit Info   (Potential data incompatibility between V24/V25 where block length=4, and V27.1 where block length=6)
    // Jet Leaf FPGAs - Positive Eta
    {0x900 , &GctFormatTranslateV38::blockToRctCaloRegions},             // Leaf1JetPosEtaU1: JF2 Input
    {0x901 , &GctFormatTranslateV38::blockToGctJetPreCluster},           // Leaf1JetPosEtaU1: JF2 Shared Received
    {0x902 , &GctFormatTranslateV38::blockToGctJetPreCluster},           // Leaf1JetPosEtaU1: JF2 Shared Sent
    {0x903 , &GctFormatTranslateV38::blockToGctInternEtSumsAndJetCluster},// Leaf1JetPosEtaU1: JF2 Output
    {0x904 , &GctFormatTranslateV38::blockToFibres},                     // Leaf1JetPosEtaU1: JF2 Raw Input
    {0x908 , &GctFormatTranslateV38::blockToRctCaloRegions},             // Leaf1JetPosEtaU1: JF3 Input
    {0x909 , &GctFormatTranslateV38::blockToGctJetPreCluster},           // Leaf1JetPosEtaU1: JF3 Shared Received
    {0x90a , &GctFormatTranslateV38::blockToGctJetPreCluster},           // Leaf1JetPosEtaU1: JF3 Shared Sent
    {0x90b , &GctFormatTranslateV38::blockToGctInternEtSumsAndJetCluster},// Leaf1JetPosEtaU1: JF3 Output
    {0x90c , &GctFormatTranslateV38::blockToFibres},                     // Leaf1JetPosEtaU1: JF3 Raw Input
    {0x980 , &GctFormatTranslateV38::blockDoNothing},                    // Leaf1JetPosEtaU2: Eta0 Input
    {0x984 , &GctFormatTranslateV38::blockToFibres},                     // Leaf1JetPosEtaU2: Eta0 Raw Input
    {0x988 , &GctFormatTranslateV38::blockToRctCaloRegions},             // Leaf1JetPosEtaU2: JF1 Input
    {0x989 , &GctFormatTranslateV38::blockToGctJetPreCluster},           // Leaf1JetPosEtaU2: JF1 Shared Received
    {0x98a , &GctFormatTranslateV38::blockToGctJetPreCluster},           // Leaf1JetPosEtaU2: JF1 Shared Sent
    {0x98b , &GctFormatTranslateV38::blockToGctInternEtSumsAndJetCluster},// Leaf1JetPosEtaU2: JF1 Output
    {0x98c , &GctFormatTranslateV38::blockToFibres},                     // Leaf1JetPosEtaU2: JF1 Raw Input
    {0xa00 , &GctFormatTranslateV38::blockToRctCaloRegions},             // Leaf2JetPosEtaU1: JF2 Input
    {0xa01 , &GctFormatTranslateV38::blockToGctJetPreCluster},           // Leaf2JetPosEtaU1: JF2 Shared Received
    {0xa02 , &GctFormatTranslateV38::blockToGctJetPreCluster},           // Leaf2JetPosEtaU1: JF2 Shared Sent
    {0xa03 , &GctFormatTranslateV38::blockToGctInternEtSumsAndJetCluster},// Leaf2JetPosEtaU1: JF2 Output
    {0xa04 , &GctFormatTranslateV38::blockToFibres},                     // Leaf2JetPosEtaU1: JF2 Raw Input
    {0xa08 , &GctFormatTranslateV38::blockToRctCaloRegions},             // Leaf2JetPosEtaU1: JF3 Input
    {0xa09 , &GctFormatTranslateV38::blockToGctJetPreCluster},           // Leaf2JetPosEtaU1: JF3 Shared Received
    {0xa0a , &GctFormatTranslateV38::blockToGctJetPreCluster},           // Leaf2JetPosEtaU1: JF3 Shared Sent
    {0xa0b , &GctFormatTranslateV38::blockToGctInternEtSumsAndJetCluster},// Leaf2JetPosEtaU1: JF3 Output
    {0xa0c , &GctFormatTranslateV38::blockToFibres},                     // Leaf2JetPosEtaU1: JF3 Raw Input
    {0xa80 , &GctFormatTranslateV38::blockDoNothing},                    // Leaf2JetPosEtaU2: Eta0 Input
    {0xa84 , &GctFormatTranslateV38::blockToFibres},                     // Leaf2JetPosEtaU2: Eta0 Raw Input
    {0xa88 , &GctFormatTranslateV38::blockToRctCaloRegions},             // Leaf2JetPosEtaU2: JF1 Input
    {0xa89 , &GctFormatTranslateV38::blockToGctJetPreCluster},           // Leaf2JetPosEtaU2: JF1 Shared Received
    {0xa8a , &GctFormatTranslateV38::blockToGctJetPreCluster},           // Leaf2JetPosEtaU2: JF1 Shared Sent
    {0xa8b , &GctFormatTranslateV38::blockToGctInternEtSumsAndJetCluster},// Leaf2JetPosEtaU2: JF1 Output
    {0xa8c , &GctFormatTranslateV38::blockToFibres},                     // Leaf2JetPosEtaU2: JF1 Raw Input
    {0xb00 , &GctFormatTranslateV38::blockToRctCaloRegions},             // Leaf3JetPosEtaU1: JF2 Input
    {0xb01 , &GctFormatTranslateV38::blockToGctJetPreCluster},           // Leaf3JetPosEtaU1: JF2 Shared Received
    {0xb02 , &GctFormatTranslateV38::blockToGctJetPreCluster},           // Leaf3JetPosEtaU1: JF2 Shared Sent
    {0xb03 , &GctFormatTranslateV38::blockToGctInternEtSumsAndJetCluster},// Leaf3JetPosEtaU1: JF2 Output
    {0xb04 , &GctFormatTranslateV38::blockToFibres},                     // Leaf3JetPosEtaU1: JF2 Raw Input
    {0xb08 , &GctFormatTranslateV38::blockToRctCaloRegions},             // Leaf3JetPosEtaU1: JF3 Input
    {0xb09 , &GctFormatTranslateV38::blockToGctJetPreCluster},           // Leaf3JetPosEtaU1: JF3 Shared Received
    {0xb0a , &GctFormatTranslateV38::blockToGctJetPreCluster},           // Leaf3JetPosEtaU1: JF3 Shared Sent
    {0xb0b , &GctFormatTranslateV38::blockToGctInternEtSumsAndJetCluster},// Leaf3JetPosEtaU1: JF3 Output
    {0xb0c , &GctFormatTranslateV38::blockToFibres},                     // Leaf3JetPosEtaU1: JF3 Raw Input
    {0xb80 , &GctFormatTranslateV38::blockDoNothing},                    // Leaf3JetPosEtaU2: Eta0 Input
    {0xb84 , &GctFormatTranslateV38::blockToFibres},                     // Leaf3JetPosEtaU2: Eta0 Raw Input
    {0xb88 , &GctFormatTranslateV38::blockToRctCaloRegions},             // Leaf3JetPosEtaU2: JF1 Input
    {0xb89 , &GctFormatTranslateV38::blockToGctJetPreCluster},           // Leaf3JetPosEtaU2: JF1 Shared Received
    {0xb8a , &GctFormatTranslateV38::blockToGctJetPreCluster},           // Leaf3JetPosEtaU2: JF1 Shared Sent
    {0xb8b , &GctFormatTranslateV38::blockToGctInternEtSumsAndJetCluster},// Leaf3JetPosEtaU2: JF1 Output
    {0xb8c , &GctFormatTranslateV38::blockToFibres},                     // Leaf3JetPosEtaU2: JF1 Raw Input
    // Jet Leaf FPGAs - Negative Eta
    {0xd00 , &GctFormatTranslateV38::blockToRctCaloRegions},             // Leaf1JetNegEtaU1: JF2 Input
    {0xd01 , &GctFormatTranslateV38::blockToGctJetPreCluster},           // Leaf1JetNegEtaU1: JF2 Shared Received
    {0xd02 , &GctFormatTranslateV38::blockToGctJetPreCluster},           // Leaf1JetNegEtaU1: JF2 Shared Sent
    {0xd03 , &GctFormatTranslateV38::blockToGctInternEtSumsAndJetCluster},// Leaf1JetNegEtaU1: JF2 Output
    {0xd04 , &GctFormatTranslateV38::blockToFibres},                     // Leaf1JetNegEtaU1: JF2 Raw Input
    {0xd08 , &GctFormatTranslateV38::blockToRctCaloRegions},             // Leaf1JetNegEtaU1: JF3 Input
    {0xd09 , &GctFormatTranslateV38::blockToGctJetPreCluster},           // Leaf1JetNegEtaU1: JF3 Shared Received
    {0xd0a , &GctFormatTranslateV38::blockToGctJetPreCluster},           // Leaf1JetNegEtaU1: JF3 Shared Sent
    {0xd0b , &GctFormatTranslateV38::blockToGctInternEtSumsAndJetCluster},// Leaf1JetNegEtaU1: JF3 Output
    {0xd0c , &GctFormatTranslateV38::blockToFibres},                     // Leaf1JetNegEtaU1: JF3 Raw Input
    {0xd80 , &GctFormatTranslateV38::blockDoNothing},                    // Leaf1JetNegEtaU2: Eta0 Input
    {0xd84 , &GctFormatTranslateV38::blockToFibres},                     // Leaf1JetNegEtaU2: Eta0 Raw Input
    {0xd88 , &GctFormatTranslateV38::blockToRctCaloRegions},             // Leaf1JetNegEtaU2: JF1 Input
    {0xd89 , &GctFormatTranslateV38::blockToGctJetPreCluster},           // Leaf1JetNegEtaU2: JF1 Shared Received
    {0xd8a , &GctFormatTranslateV38::blockToGctJetPreCluster},           // Leaf1JetNegEtaU2: JF1 Shared Sent
    {0xd8b , &GctFormatTranslateV38::blockToGctInternEtSumsAndJetCluster},// Leaf1JetNegEtaU2: JF1 Output
    {0xd8c , &GctFormatTranslateV38::blockToFibres},                     // Leaf1JetNegEtaU2: JF1 Raw Input
    {0xe00 , &GctFormatTranslateV38::blockToRctCaloRegions},             // Leaf2JetNegEtaU1: JF2 Input
    {0xe01 , &GctFormatTranslateV38::blockToGctJetPreCluster},           // Leaf2JetNegEtaU1: JF2 Shared Received
    {0xe02 , &GctFormatTranslateV38::blockToGctJetPreCluster},           // Leaf2JetNegEtaU1: JF2 Shared Sent
    {0xe03 , &GctFormatTranslateV38::blockToGctInternEtSumsAndJetCluster},// Leaf2JetNegEtaU1: JF2 Output
    {0xe04 , &GctFormatTranslateV38::blockToFibres},                     // Leaf2JetNegEtaU1: JF2 Raw Input
    {0xe08 , &GctFormatTranslateV38::blockToRctCaloRegions},             // Leaf2JetNegEtaU1: JF3 Input
    {0xe09 , &GctFormatTranslateV38::blockToGctJetPreCluster},           // Leaf2JetNegEtaU1: JF3 Shared Received
    {0xe0a , &GctFormatTranslateV38::blockToGctJetPreCluster},           // Leaf2JetNegEtaU1: JF3 Shared Sent
    {0xe0b , &GctFormatTranslateV38::blockToGctInternEtSumsAndJetCluster},// Leaf2JetNegEtaU1: JF3 Output
    {0xe0c , &GctFormatTranslateV38::blockToFibres},                     // Leaf2JetNegEtaU1: JF3 Raw Input
    {0xe80 , &GctFormatTranslateV38::blockDoNothing},                    // Leaf2JetNegEtaU2: Eta0 Input
    {0xe84 , &GctFormatTranslateV38::blockToFibres},                     // Leaf2JetNegEtaU2: Eta0 Raw Input
    {0xe88 , &GctFormatTranslateV38::blockToRctCaloRegions},             // Leaf2JetNegEtaU2: JF1 Input
    {0xe89 , &GctFormatTranslateV38::blockToGctJetPreCluster},           // Leaf2JetNegEtaU2: JF1 Shared Received
    {0xe8a , &GctFormatTranslateV38::blockToGctJetPreCluster},           // Leaf2JetNegEtaU2: JF1 Shared Sent
    {0xe8b , &GctFormatTranslateV38::blockToGctInternEtSumsAndJetCluster},// Leaf2JetNegEtaU2: JF1 Output
    {0xe8c , &GctFormatTranslateV38::blockToFibres},                     // Leaf2JetNegEtaU2: JF1 Raw Input
    {0xf00 , &GctFormatTranslateV38::blockToRctCaloRegions},             // Leaf3JetNegEtaU1: JF2 Input
    {0xf01 , &GctFormatTranslateV38::blockToGctJetPreCluster},           // Leaf3JetNegEtaU1: JF2 Shared Received
    {0xf02 , &GctFormatTranslateV38::blockToGctJetPreCluster},           // Leaf3JetNegEtaU1: JF2 Shared Sent
    {0xf03 , &GctFormatTranslateV38::blockToGctInternEtSumsAndJetCluster},// Leaf3JetNegEtaU1: JF2 Output
    {0xf04 , &GctFormatTranslateV38::blockToFibres},                     // Leaf3JetNegEtaU1: JF2 Raw Input
    {0xf08 , &GctFormatTranslateV38::blockToRctCaloRegions},             // Leaf3JetNegEtaU1: JF3 Input
    {0xf09 , &GctFormatTranslateV38::blockToGctJetPreCluster},           // Leaf3JetNegEtaU1: JF3 Shared Received
    {0xf0a , &GctFormatTranslateV38::blockToGctJetPreCluster},           // Leaf3JetNegEtaU1: JF3 Shared Sent
    {0xf0b , &GctFormatTranslateV38::blockToGctInternEtSumsAndJetCluster},// Leaf3JetNegEtaU1: JF3 Output
    {0xf0c , &GctFormatTranslateV38::blockToFibres},                     // Leaf3JetNegEtaU1: JF3 Raw Input
    {0xf80 , &GctFormatTranslateV38::blockDoNothing},                    // Leaf3JetNegEtaU2: Eta0 Input
    {0xf84 , &GctFormatTranslateV38::blockToFibres},                     // Leaf3JetNegEtaU2: Eta0 Raw Input
    {0xf88 , &GctFormatTranslateV38::blockToRctCaloRegions},             // Leaf3JetNegEtaU2: JF1 Input
    {0xf89 , &GctFormatTranslateV38::blockToGctJetPreCluster},           // Leaf3JetNegEtaU2: JF1 Shared Received
    {0xf8a , &GctFormatTranslateV38::blockToGctJetPreCluster},           // Leaf3JetNegEtaU2: JF1 Shared Sent
    {0xf8b , &GctFormatTranslateV38::blockToGctInternEtSumsAndJetCluster},// Leaf3JetNegEtaU2: JF1 Output
    {0xf8c , &GctFormatTranslateV38::blockToFibres},                     // Leaf3JetNegEtaU2: JF1 Raw Input
};

/*** Setup RCT Em Crate Map ***/
const GctFormatTranslateV38::BlkToRctCrateMap GctFormatTranslateV38::m_rctEmCrate = {
  {0x804 , 13},
  {0x884 , 9},
  {0xc04 , 4},
  {0xc84 , 0}
};

/*** Setup RCT jet crate map. ***/
const GctFormatTranslateV38::BlkToRctCrateMap GctFormatTranslateV38::m_rctJetCrate = {
    {0x900 , 9},  // PosEta Leaf 1 JF2
    {0x908 , 10}, // PosEta Leaf 1 JF3
    {0x988 , 17}, // PosEta Leaf 1 JF1 
    {0xa00 , 12}, // PosEta Leaf 2 JF2
    {0xa08 , 13}, // PosEta Leaf 2 JF3
    {0xa88 , 11}, // PosEta Leaf 2 JF1 
    {0xb00 , 15}, // PosEta Leaf 3 JF2
    {0xb08 , 16}, // PosEta Leaf 3 JF3
    {0xb88 , 14}, // PosEta Leaf 3 JF1 
    {0xd00 , 0},  // NegEta Leaf 1 JF2
    {0xd08 , 1},  // NegEta Leaf 1 JF3
    {0xd88 , 8},  // NegEta Leaf 1 JF1 
    {0xe00 , 3},  // NegEta Leaf 2 JF2
    {0xe08 , 4},  // NegEta Leaf 2 JF3
    {0xe88 , 2},  // NegEta Leaf 2 JF1 
    {0xf00 , 6},  // NegEta Leaf 3 JF2
    {0xf08 , 7},  // NegEta Leaf 3 JF3
    {0xf88 , 5}   // NegEta Leaf 3 JF1 
};

/*** Setup Block ID map for pipeline payload positions of isolated Internal EM Cands. ***/
const GctFormatTranslateV38::BlockIdToEmCandIsoBoundMap GctFormatTranslateV38::m_internEmIsoBounds = {
    {0x680 , IsoBoundaryPair(8,15)},
    {0x800 , IsoBoundaryPair(0, 9)},
    {0x803 , IsoBoundaryPair(0, 1)},
    {0x880 , IsoBoundaryPair(0, 7)},
    {0x883 , IsoBoundaryPair(0, 1)},
    {0xc00 , IsoBoundaryPair(0, 9)},
    {0xc03 , IsoBoundaryPair(0, 1)},
    {0xc80 , IsoBoundaryPair(0, 7)},
    {0xc83 , IsoBoundaryPair(0, 1)}
};


// PUBLIC METHODS

GctFormatTranslateV38::GctFormatTranslateV38(bool hltMode, bool unpackSharedRegions, 
                                             unsigned numberOfGctSamplesToUnpack, 
                                             unsigned numberOfRctSamplesToUnpack):
  GctFormatTranslateBase(hltMode, unpackSharedRegions),
  m_numberOfGctSamplesToUnpack(numberOfGctSamplesToUnpack),
  m_numberOfRctSamplesToUnpack(numberOfRctSamplesToUnpack)
{
}

GctFormatTranslateV38::~GctFormatTranslateV38()
{
}

GctBlockHeader GctFormatTranslateV38::generateBlockHeader(const unsigned char * data) const
{
  // Turn the four 8-bit header words into the full 32-bit header.
  uint32_t hdr = data[0] + (data[1]<<8) + (data[2]<<16) + (data[3]<<24);

//  Bit mapping of V35 header:
//  --------------------------
//  11:0   => block_id  Unique pipeline identifier.
//   - 3:0    =>> pipe_id There can be up to 16 different pipelines per FPGA.
//   - 6:4    =>> reserved  Do not use yet. Set to zero.
//   - 11:7   =>> fpga geograpical add  The VME geographical address of the FPGA.
//  15:12  => event_id  Determined locally.  Not reset by Resync.
//  19:16  => number_of_time_samples  If time samples 15 or more then value = 15.
//  31:20  => event_bcid  The bunch crossing the data was recorded.

  unsigned blockId = hdr & 0xfff;
  unsigned blockLength = 0;  // Set to zero until we know it's a valid block
  unsigned nSamples = (hdr>>16) & 0xf;
  unsigned bxId = (hdr>>20) & 0xfff;
  unsigned eventId = (hdr>>12) & 0xf;
  bool valid = (blockLengthMap().find(blockId) != blockLengthMap().end());

  if(valid) { blockLength = blockLengthMap().find(blockId)->second; }
  
  return GctBlockHeader(blockId, blockLength, nSamples, bxId, eventId, valid);  
}

// conversion
bool GctFormatTranslateV38::convertBlock(const unsigned char * data, const GctBlockHeader& hdr)
{
  // if the block has no time samples, don't bother with it.
  if ( hdr.nSamples() < 1 ) { return true; }

  if(!checkBlock(hdr)) { return false; }  // Check the block to see if it's possible to unpack.

  // The header validity check above will protect against
  // the map::find() method returning the end of the map,
  // assuming the block header definitions are up-to-date.
  (this->*m_blockUnpackFn.find(hdr.blockId())->second)(data, hdr);  // Calls the correct unpack function, based on block ID.
  
  return true;
}


// PROTECTED METHODS

uint32_t GctFormatTranslateV38::generateRawHeader(const uint32_t blockId,
                                                  const uint32_t nSamples,
                                                  const uint32_t bxId,
                                                  const uint32_t eventId) const
{
  //  Bit mapping of V35 header:
  //  --------------------------
  //  11:0   => block_id  Unique pipeline identifier.
  //   - 3:0    =>> pipe_id There can be up to 16 different pipelines per FPGA.
  //   - 6:4    =>> reserved  Do not use yet. Set to zero.
  //   - 11:7   =>> fpga geograpical add  The VME geographical address of the FPGA.
  //  15:12  => event_id  Determined locally.  Not reset by Resync.
  //  19:16  => number_of_time_samples  If time samples 15 or more then value = 15.
  //  31:20  => event_bxId  The bunch crossing the data was recorded.

  return ((bxId & 0xfff) << 20) | ((nSamples & 0xf) << 16) | ((eventId & 0xf) << 12) | (blockId & 0xfff);
}


// PRIVATE METHODS

// Throughout the code, bx refers to the hardware definition of time-samples
// ie. if 5 time samples are unpacked, they are bx=0, 1, 2, 3, 4 in order
// what is written to digi would be -2, -1, 0, +1, +2

// Output EM Candidates unpacking
void GctFormatTranslateV38::blockToGctEmCandsAndEnergySums(const unsigned char * d, const GctBlockHeader& hdr)
{
  const unsigned int id = hdr.blockId();
  const unsigned int nSamples = hdr.nSamples();

  // Re-interpret pointer.  p16 will be pointing at the 16 bit word that
  // contains the rank0 non-isolated electron of the zeroth time-sample.
  const uint16_t * p16 = reinterpret_cast<const uint16_t *>(d);

  // UNPACK EM CANDS

  const unsigned int emCandCategoryOffset = nSamples * 4;  // Offset to jump from the non-iso electrons to the isolated ones.
  const unsigned int timeSampleOffset = nSamples * 2;  // Offset to jump to next candidate pair in the same time-sample.

  unsigned int samplesToUnpack = std::min(nSamples,m_numberOfGctSamplesToUnpack); // Unpack as many as asked for if they are in the raw data
  unsigned int centralSample = (unsigned)std::ceil((double)nSamples/2.)-1;  // think this works when nSamples is even, need to check!!!
  unsigned int firstSample = centralSample-(unsigned)std::ceil((double)samplesToUnpack/2.)+1;
  unsigned int lastSample = centralSample+(unsigned)(samplesToUnpack/2);

  LogDebug("GCT") << "Unpacking output EM.  Central sample=" << centralSample << " first=" << firstSample << " last=" << lastSample;

  for (unsigned int iso=0; iso<2; ++iso)  // loop over non-iso/iso candidate pairs
  {
    bool isoFlag = (iso==1);

    // Get the correct collection to put them in.
    L1GctEmCandCollection* em;
    if (isoFlag) { em = colls()->gctIsoEm(); }
    else { em = colls()->gctNonIsoEm(); }
    
    for (unsigned int bx=firstSample; bx<=lastSample; ++bx) // loop over samples to be unpacked
    {
      // cand0Offset will give the offset on p16 to get the rank 0 candidate
      // of the correct category and timesample.
      const unsigned int cand0Offset = iso*emCandCategoryOffset + bx*2;

      em->push_back(L1GctEmCand(p16[cand0Offset], isoFlag, id, 0, (int)bx-(int)centralSample));  // rank0 electron
      em->push_back(L1GctEmCand(p16[cand0Offset + timeSampleOffset], isoFlag, id, 1, (int)bx-(int)centralSample));  // rank1 electron
      em->push_back(L1GctEmCand(p16[cand0Offset + 1], isoFlag, id, 2, (int)bx-(int)centralSample));  // rank2 electron
      em->push_back(L1GctEmCand(p16[cand0Offset + timeSampleOffset + 1], isoFlag, id, 3, (int)bx-(int)centralSample));  // rank3 electron

      LogDebug("GCT") << "Unpacked a bunch of EG.  iso=" << iso << " bx=" << bx << std::endl;
    }
  }

  p16 += emCandCategoryOffset * 2;  // Move the pointer over the data we've already unpacked.

  // UNPACK ENERGY SUMS

  for (unsigned int bx=firstSample; bx<=lastSample; ++bx) // loop over all time samples
    {
      const unsigned int offset = bx*2;
      colls()->gctEtTot()->push_back(L1GctEtTotal(p16[offset],(int)bx-(int)centralSample));  // Et total
      colls()->gctEtHad()->push_back(L1GctEtHad(p16[offset+1],(int)bx-(int)centralSample));  // Et hadronic 
    }

  p16 += nSamples * 2;

  // 32-bit pointer for getting Missing Et.
  const uint32_t * p32 = reinterpret_cast<const uint32_t *>(p16);

  for (unsigned int bx=firstSample; bx<=lastSample; ++bx) {
    colls()->gctEtMiss()->push_back(L1GctEtMiss(p32[bx],(int)bx-(int)centralSample)); // Et Miss 
    LogDebug("GCT") << "Unpacked energy sums bx=" << bx << std::endl;   
  }


}

void GctFormatTranslateV38::blockToGctJetCandsAndCounts(const unsigned char * d, const GctBlockHeader& hdr)
{
  const unsigned int id = hdr.blockId();  // Capture block ID.
  const unsigned int nSamples = hdr.nSamples();  // Number of time-samples.

  // Re-interpret block payload pointer to 16 bits so it sees one candidate at a time.
  // p16 points to the start of the block payload, at the rank0 tau jet candidate.
  const uint16_t * p16 = reinterpret_cast<const uint16_t *>(d);

  // UNPACK JET CANDS

  const unsigned int jetCandCategoryOffset = nSamples * 4;  // Offset to jump from one jet category to the next.
  const unsigned int timeSampleOffset = nSamples * 2;  // Offset to jump to next candidate pair in the same time-sample.

  unsigned int samplesToUnpack = std::min(nSamples,m_numberOfGctSamplesToUnpack); // Unpack as many as asked for if they are in the raw data
  unsigned int centralSample = (unsigned)std::ceil((double)nSamples/2.)-1;  // think this works when nSamples is even, need to check!!!
  unsigned int firstSample = centralSample-(unsigned)std::ceil((double)samplesToUnpack/2.)+1;
  unsigned int lastSample = centralSample+(unsigned)(samplesToUnpack/2);

  LogDebug("GCT") << "Unpacking output Jets. Samples to unpack=" << samplesToUnpack << " central=" << centralSample << " first=" << firstSample << " last=" << lastSample;

  // Loop over the different catagories of jets
  for(unsigned int iCat = 0 ; iCat < NUM_JET_CATEGORIES ; ++iCat)
  {
    L1GctJetCandCollection * const jets = gctJets(iCat);
    assert(jets->empty()); // The supplied vector should be empty.

    bool tauflag = (iCat == TAU_JETS);
    bool forwardFlag = (iCat == FORWARD_JETS);

    // Loop over the different timesamples (bunch crossings).
    for(unsigned int bx = firstSample ; bx <=lastSample; ++bx)
    {
      // cand0Offset will give the offset on p16 to get the rank 0 Jet Cand of the correct category and timesample.
      const unsigned int cand0Offset = iCat*jetCandCategoryOffset + bx*2;

      // Rank 0 Jet.
      jets->push_back(L1GctJetCand(p16[cand0Offset], tauflag, forwardFlag, id, 0, (int)bx-(int)centralSample));
      // Rank 1 Jet.
      jets->push_back(L1GctJetCand(p16[cand0Offset + timeSampleOffset], tauflag, forwardFlag, id, 1, (int)bx-(int)centralSample));
      // Rank 2 Jet.
      jets->push_back(L1GctJetCand(p16[cand0Offset + 1],  tauflag, forwardFlag, id, 2, (int)bx-(int)centralSample));
      // Rank 3 Jet.
      jets->push_back(L1GctJetCand(p16[cand0Offset + timeSampleOffset + 1], tauflag, forwardFlag, id, 3, (int)bx-(int)centralSample));
    }
  }

  p16 += NUM_JET_CATEGORIES * jetCandCategoryOffset; // Move the pointer over the data we've already unpacked.

  // NOW UNPACK: HFBitCounts, HFRingEtSums and Missing Ht

  // Re-interpret block payload pointer to 32 bits so it sees six jet counts at a time.
  const uint32_t * p32 = reinterpret_cast<const uint32_t *>(p16);

  for (unsigned int bx=firstSample; bx<=lastSample; ++bx) // loop over all time samples
    {
      // Channel 0 carries both HF counts and sums
      colls()->gctHfBitCounts()->push_back(L1GctHFBitCounts::fromConcHFBitCounts(id,6,(int)bx-(int)centralSample,p32[bx])); 
      colls()->gctHfRingEtSums()->push_back(L1GctHFRingEtSums::fromConcRingSums(id,6,(int)bx-(int)centralSample,p32[bx]));
      
      // Channel 1 carries Missing HT.
      colls()->gctHtMiss()->push_back(L1GctHtMiss(p32[bx+nSamples], (int)bx-(int)centralSample));
    }
}

// Internal EM Candidates unpacking
void GctFormatTranslateV38::blockToGctInternEmCand(const unsigned char * d, const GctBlockHeader& hdr)
{
  // Don't want to do this in HLT optimisation mode!
  if(hltMode()) { LogDebug("GCT") << "HLT mode - skipping unpack of internal EM Cands"; return; }

  unsigned int id = hdr.blockId();
  unsigned int nSamples = hdr.nSamples();
  unsigned int numCandPairs = hdr.blockLength();

  // Debug assertion to prevent problems if definitions not up to date.
  auto found = internEmIsoBounds().find(id);
  assert(found != internEmIsoBounds().end());  

  unsigned int lowerIsoPairBound = found->second.first;
  unsigned int upperIsoPairBound = found->second.second;

  // Re-interpret pointer to 16 bits so it sees one candidate at a time.
  const uint16_t * p = reinterpret_cast<const uint16_t *>(d);

  // Loop over timesamples (i.e. bunch crossings)
  for(unsigned int bx=0; bx < nSamples; ++bx)
  {
    // Loop over candidate pairs (i.e. each iteration unpacks a pair of candidates)
    for(unsigned int candPair = 0 ; candPair < numCandPairs ; ++candPair)
    {
      // Is the candidate electron pair an isolated pair or not?
      bool iso = ((candPair>=lowerIsoPairBound) && (candPair<=upperIsoPairBound));
      
      // Loop over the two electron candidates in each pair
      for(unsigned int i = 0 ; i < 2 ; ++i)
      { 
        unsigned offset = 2*(bx + candPair*nSamples) + i;
        uint16_t candRaw = p[offset]; 
        colls()->gctInternEm()->push_back( L1GctInternEmCand(candRaw, iso, id, candPair*2 + i, bx) );
      }
    }
  }
}


// Input EM Candidates unpacking
// this is the last time I deal the RCT bit assignment travesty!!!
void GctFormatTranslateV38::blockToRctEmCand(const unsigned char * d, const GctBlockHeader& hdr)
{
  // Don't want to do this in HLT optimisation mode!
  if(hltMode()) { LogDebug("GCT") << "HLT mode - skipping unpack of RCT EM Cands"; return; }

  unsigned int id = hdr.blockId();
  unsigned int nSamples = hdr.nSamples();
  unsigned int length = hdr.blockLength();

  // re-interpret pointer
  const uint16_t * p = reinterpret_cast<const uint16_t *>(d);

  // arrays of source card data
  uint16_t sfp[2][4]; // [ cycle ] [ SFP ]
  uint16_t eIsoRank[4];
  uint16_t eIsoCard[4];
  uint16_t eIsoRgn[4];
  uint16_t eNonIsoRank[4];
  uint16_t eNonIsoCard[4];
  uint16_t eNonIsoRgn[4];
  uint16_t MIPbits[7][2];
  uint16_t QBits[7][2];

  unsigned int bx = 0;

  auto found = rctEmCrateMap().find(id);
  assert(found != rctEmCrateMap().end());
  // loop over crates
  for (unsigned int crate=found->second; crate<found->second+length/3; ++crate) {

    // read SC SFP words
    for (unsigned short iSfp=0 ; iSfp<4 ; ++iSfp) {
      for (unsigned short cyc=0 ; cyc<2 ; ++cyc) {
        if (iSfp==0) { sfp[cyc][iSfp] = 0; } // muon bits
        else {                               // EM candidate
          sfp[cyc][iSfp] = *p;
          ++p;
        }
      }
      p = p + 2*(nSamples-1);
    }

    // fill SC arrays
    srcCardRouting().SFPtoEMU(eIsoRank, eIsoCard, eIsoRgn, eNonIsoRank, eNonIsoCard, eNonIsoRgn, MIPbits, QBits, sfp);
    
    // create EM cands
    for (unsigned short int i=0; i<4; ++i) {
      colls()->rctEm()->push_back( L1CaloEmCand( eIsoRank[i], eIsoRgn[i], eIsoCard[i], crate, true, i, bx) );
    }
    for (unsigned short int i=0; i<4; ++i) {
      colls()->rctEm()->push_back( L1CaloEmCand( eNonIsoRank[i], eNonIsoRgn[i], eNonIsoCard[i], crate, false, i, bx) );
    }
  }
}

// Input RCT region unpacking
void GctFormatTranslateV38::blockToRctCaloRegions(const unsigned char * d, const GctBlockHeader& hdr)
{
  // Don't want to do this in HLT optimisation mode!
  if(hltMode()) { LogDebug("GCT") << "HLT mode - skipping unpack of RCT Regions"; return; }

  unsigned int id = hdr.blockId();
  unsigned int nSamples = hdr.nSamples();
  unsigned int length = hdr.blockLength();

  // Debug assertion to prevent problems if definitions not up to date.
  auto found = rctJetCrateMap().find(id);
  assert(found != rctJetCrateMap().end());  
  
  // get crate (need this to get ieta and iphi)
  unsigned int crate=found->second;

  // re-interpret pointer
  const uint16_t * p = reinterpret_cast<const uint16_t *>(d);
  
  // eta and phi
  unsigned int ieta; 
  unsigned int iphi; 
  
  for (unsigned int i=0; i<length; ++i)
  { 
    for (uint16_t bx=0; bx<nSamples; ++bx)
    {
      // First figure out eta and phi
      if (crate<9) { // negative eta
          ieta = 12-i; 
          iphi = 2*((11-crate)%9);
      }
      else { // positive eta
        ieta = 9+i;
        iphi = 2*((20-crate)%9);
      }
      
      // Skip the first four regions (i.e. where i<2) which are duplicates (shared data).
      if (i>1) { 
        // First region is phi=0
        colls()->rctCalo()->push_back( L1CaloRegion::makeRegionFromUnpacker(*p, ieta, iphi, id, i, bx) );
        ++p;
        // Second region is phi=1
        if (iphi>0) { iphi-=1; }
        else { iphi = 17; }
        colls()->rctCalo()->push_back( L1CaloRegion::makeRegionFromUnpacker(*p, ieta, iphi, id, i, bx) );
        ++p;
      }
      // Unpack the shared data if asked for debugging
      else if (unpackSharedRegions()){
        // First region is phi=0
        colls()->rctCalo()->push_back( L1CaloRegion::makeRegionFromUnpacker(*p, ieta, iphi, id, i, bx) );
        ++p;
        // Second region is phi=1
        if (iphi>0) { iphi-=1; }
        else { iphi = 17; }
        colls()->rctCalo()->push_back( L1CaloRegion::makeRegionFromUnpacker(*p, ieta, iphi, id, i, bx) );
        ++p;
        
      } else { // Skip the shared data  
        ++p;
        ++p;
      }
    }
  } 
}  


// Fibre unpacking
void GctFormatTranslateV38::blockToFibres(const unsigned char * d, const GctBlockHeader& hdr)
{
  // Don't want to do this in HLT optimisation mode!
  if(hltMode()) { LogDebug("GCT") << "HLT mode - skipping unpack of GCT Fibres"; return; }
  
  unsigned int id = hdr.blockId();
  unsigned int nSamples = hdr.nSamples();
  unsigned int length = hdr.blockLength();

  // re-interpret pointer
  const uint32_t * p = reinterpret_cast<const uint32_t *>(d);

  for (unsigned int i=0; i<length; ++i) {
    for (unsigned int bx=0; bx<nSamples; ++bx) {
      colls()->gctFibres()->push_back( L1GctFibreWord(*p, id, i, bx) );
      ++p;
    }
  } 
}

void GctFormatTranslateV38::blockToFibresAndToRctEmCand(const unsigned char * d, const GctBlockHeader& hdr)
{
  this->blockToRctEmCand(d, hdr);
  this->blockToFibres(d, hdr);
}

void GctFormatTranslateV38::blockToGctInternEtSums(const unsigned char * d, const GctBlockHeader& hdr)
{
  // Don't want to do this in HLT optimisation mode!                                                                                                                           
  
  if(hltMode()) { LogDebug("GCT") << "HLT mode - skipping unpack of internal Et Sums"; return; }

  unsigned int id = hdr.blockId();
  unsigned int nSamples = hdr.nSamples();
  unsigned int length = hdr.blockLength();

  // Re-interpret pointer to 32 bits 
  const uint32_t * p = reinterpret_cast<const uint32_t *>(d);

  for (unsigned int i=0; i<length; ++i) {
    // Loop over timesamples (i.e. bunch crossings)                                                                                                                            
    for (unsigned int bx=0; bx<nSamples; ++bx) {
      colls()->gctInternEtSums()->push_back(L1GctInternEtSum::fromTotalEtOrHt(id,i,bx,*p));
      ++p;
    }
  }
}

void GctFormatTranslateV38::blockToGctInternEtSumsAndJetCluster(const unsigned char * d, const GctBlockHeader& hdr)
{
  // Don't want to do this in HLT optimisation mode!
  if(hltMode()) { LogDebug("GCT") << "HLT mode - skipping unpack of internal Jet Cands"; return; }

  unsigned int id = hdr.blockId();
  unsigned int nSamples = hdr.nSamples();
  unsigned int length = hdr.blockLength();

  // Re-interpret pointer to 32 bits 
  const uint32_t * p = reinterpret_cast<const uint32_t *>(d);

  for (unsigned int i=0; i<length; ++i) {
    // Loop over timesamples (i.e. bunch crossings)
    for (unsigned int bx=0; bx<nSamples; ++bx) {
      if (i<2) colls()->gctInternEtSums()->push_back(L1GctInternEtSum::fromJetMissEt(id,i,bx,*p));
      if (i==3){
        colls()->gctInternEtSums()->push_back(L1GctInternEtSum::fromJetTotEt(id,i,bx,*p));
        colls()->gctInternEtSums()->push_back(L1GctInternEtSum::fromJetTotHt(id,i,bx,*p));
      } 
      if (i>4) colls()->gctInternJets()->push_back(L1GctInternJetData::fromJetCluster(L1CaloRegionDetId(0,0),id,i,bx,*p));
      ++p;
    }  
  }
}

void GctFormatTranslateV38::blockToGctTrigObjects(const unsigned char * d, const GctBlockHeader& hdr)
{
  // Don't want to do this in HLT optimisation mode!
  if(hltMode()) { LogDebug("GCT") << "HLT mode - skipping unpack of internal Jet Cands"; return; }

  unsigned int id = hdr.blockId();
  unsigned int nSamples = hdr.nSamples();
  unsigned int length = hdr.blockLength();

  // Re-interpret pointer to 16 bits so it sees one candidate at a time.
  const uint16_t * p = reinterpret_cast<const uint16_t *>(d);

  for (unsigned int i=0; i<length; ++i) {
    // Loop over timesamples (i.e. bunch crossings)
    for (unsigned int bx=0; bx<nSamples; ++bx) {
      colls()->gctInternJets()->push_back( L1GctInternJetData::fromGctTrigObject(L1CaloRegionDetId(0,0),id,i,bx,*p));
      ++p;
      colls()->gctInternJets()->push_back( L1GctInternJetData::fromGctTrigObject(L1CaloRegionDetId(0,0),id,i,bx,*p));
      ++p;
    }
  } 
}

void GctFormatTranslateV38::blockToGctJetClusterMinimal(const unsigned char * d, const GctBlockHeader& hdr)
{
  // Don't want to do this in HLT optimisation mode!
  if(hltMode()) { LogDebug("GCT") << "HLT mode - skipping unpack of internal Jet Cands"; return; }

  unsigned int id = hdr.blockId();
  unsigned int nSamples = hdr.nSamples();
  unsigned int length = hdr.blockLength();

  // Re-interpret pointer to 16 bits so it sees one candidate at a time.
  const uint16_t * p = reinterpret_cast<const uint16_t *>(d);

  for (unsigned int i=0; i<length; ++i) {
    // Loop over timesamples (i.e. bunch crossings)
    for (unsigned int bx=0; bx<nSamples; ++bx) {
      colls()->gctInternJets()->push_back( L1GctInternJetData::fromJetClusterMinimal(L1CaloRegionDetId(0,0),id,i,bx,*p));
      ++p;
      colls()->gctInternJets()->push_back( L1GctInternJetData::fromJetClusterMinimal(L1CaloRegionDetId(0,0),id,i,bx,*p));
      ++p;
    }
  } 
}

void GctFormatTranslateV38::blockToGctJetPreCluster(const unsigned char * d, const GctBlockHeader& hdr)
{
  // Don't want to do this in HLT optimisation mode!
  if(hltMode()) { LogDebug("GCT") << "HLT mode - skipping unpack of internal Jet Cands"; return; }

  unsigned int id = hdr.blockId();
  unsigned int nSamples = hdr.nSamples();
  unsigned int length = hdr.blockLength();

  // Re-interpret pointer to 16 bits so it sees one candidate at a time.
  const uint16_t * p = reinterpret_cast<const uint16_t *>(d);

  for (unsigned int i=0; i<length; ++i) {
    // Loop over timesamples (i.e. bunch crossings)
    for (unsigned int bx=0; bx<nSamples; ++bx) {
      colls()->gctInternJets()->push_back( L1GctInternJetData::fromJetPreCluster(L1CaloRegionDetId(0,0),id,i,bx,*p));
      ++p;
      colls()->gctInternJets()->push_back( L1GctInternJetData::fromJetPreCluster(L1CaloRegionDetId(0,0),id,i,bx,*p));
      ++p;
    }
  } 
}

void GctFormatTranslateV38::blockToGctInternRingSums(const unsigned char * d, const GctBlockHeader& hdr)
{
  // Don't want to do this in HLT optimisation mode!
  if(hltMode()) { LogDebug("GCT") << "HLT mode - skipping unpack of internal HF ring data"; return; }

  unsigned int id = hdr.blockId();
  unsigned int nSamples = hdr.nSamples();
  unsigned int length = hdr.blockLength();

  // Re-interpret pointer to 32 bits 
  const uint32_t * p = reinterpret_cast<const uint32_t *>(d);

  for (unsigned int i=0; i<length/2; ++i) {
    // Loop over timesamples (i.e. bunch crossings)
    for (unsigned int bx=0; bx<nSamples; ++bx) {
      colls()->gctInternHFData()->push_back(L1GctInternHFData::fromConcRingSums(id,i,bx,*p));
      ++p;
    }
    for (unsigned int bx=0; bx<nSamples; ++bx) {
      colls()->gctInternHFData()->push_back(L1GctInternHFData::fromConcBitCounts(id,i,bx,*p));
      ++p;
    }  
  }
}

void GctFormatTranslateV38::blockToGctWheelInputInternEtAndRingSums(const unsigned char * d, const GctBlockHeader& hdr)
{
  // Don't want to do this in HLT optimisation mode!
  if(hltMode()) { LogDebug("GCT") << "HLT mode - skipping unpack of wheel input internal Et sums and HF ring data"; return; }

  unsigned int id = hdr.blockId();
  unsigned int nSamples = hdr.nSamples();
  unsigned int length = hdr.blockLength();

  // Re-interpret pointer to 32 bits 
  const uint32_t * p = reinterpret_cast<const uint32_t *>(d);

  for (unsigned int i=0; i<length; ++i) {
    // Loop over timesamples (i.e. bunch crossings)
    for (unsigned int bx=0; bx<nSamples; ++bx) {
      if (i<3){
        colls()->gctInternEtSums()->push_back(L1GctInternEtSum::fromTotalEtOrHt(id,i,bx,*p));
      } else if (i>2 && i<9) {
        colls()->gctInternEtSums()->push_back(L1GctInternEtSum::fromMissEtxOrEty(id,i,bx,*p));
      } else if (i>8 && i<15) {
        colls()->gctInternHFData()->push_back(L1GctInternHFData::fromWheelRingSums(id,i,bx,*p));
      } else if (i>14){
        colls()->gctInternHFData()->push_back(L1GctInternHFData::fromWheelBitCounts(id,i,bx,*p));
      }
      ++p;
    }
  }
}

void GctFormatTranslateV38::blockToGctWheelOutputInternEtAndRingSums(const unsigned char * d, const GctBlockHeader& hdr)
{
  // Don't want to do this in HLT optimisation mode!
  if(hltMode()) { LogDebug("GCT") << "HLT mode - skipping unpack of wheel output internal Et sums and HF ring data"; return; }

  unsigned int id = hdr.blockId();
  unsigned int nSamples = hdr.nSamples();
  unsigned int length = hdr.blockLength();

  // Re-interpret pointer to 32 bits 
  const uint32_t * p = reinterpret_cast<const uint32_t *>(d);

  for (unsigned int i=0; i<length; ++i) {
    // Loop over timesamples (i.e. bunch crossings)
    for (unsigned int bx=0; bx<nSamples; ++bx) {
      if (i<1){
        colls()->gctInternEtSums()->push_back(L1GctInternEtSum::fromTotalEtOrHt(id,i,bx,*p));
      } else if (i>0 && i<3) {
        colls()->gctInternEtSums()->push_back(L1GctInternEtSum::fromMissEtxOrEty(id,i,bx,*p));
      } else if (i>2 && i<5) {
        colls()->gctInternHFData()->push_back(L1GctInternHFData::fromWheelRingSums(id,i,bx,*p));
      } else if (i>4){
        colls()->gctInternHFData()->push_back(L1GctInternHFData::fromWheelBitCounts(id,i,bx,*p));
      }
      ++p;
    }
  }
}

void GctFormatTranslateV38::blockToGctInternHtMissPreWheel(const unsigned char* d, const GctBlockHeader& hdr)
{
  // Don't want to do this in HLT optimisation mode!
  if(hltMode()) { LogDebug("GCT") << "HLT mode - skipping unpack of pre-wheel internal Missing Ht data"; return; }

  unsigned int id = hdr.blockId();
  unsigned int nSamples = hdr.nSamples();
  unsigned int length = hdr.blockLength();

  // Re-interpret pointer to 32 bits 
  const uint32_t * p = reinterpret_cast<const uint32_t *>(d);
  
  for (unsigned int iLength=0; iLength < length; ++iLength)
  {
    // Loop over timesamples (i.e. bunch crossings)
    for (unsigned int bx=0; bx<nSamples; ++bx) 
    {
      colls()->gctInternHtMiss()->push_back(L1GctInternHtMiss::unpackerMissHtxHty(id, iLength, bx, *p));
      ++p;
    }
  }
}

void GctFormatTranslateV38::blockToGctInternHtMissPostWheel(const unsigned char* d, const GctBlockHeader& hdr)
{
  // Don't want to do this in HLT optimisation mode!
  if(hltMode()) { LogDebug("GCT") << "HLT mode - skipping unpack of post-wheel internal Missing Ht data"; return; }

  unsigned int id = hdr.blockId();
  unsigned int nSamples = hdr.nSamples();
  unsigned int length = hdr.blockLength();

  // Re-interpret pointer to 32 bits 
  const uint32_t * p = reinterpret_cast<const uint32_t *>(d);

  for (unsigned int iLength=0; iLength < length; ++iLength)
  {
    // Loop over timesamples (i.e. bunch crossings)
    for (unsigned int bx=0; bx<nSamples; ++bx)
    {
      if(iLength % 2) { colls()->gctInternHtMiss()->push_back(L1GctInternHtMiss::unpackerMissHty(id, iLength, bx, *p)); }  // Hty on odd numbers
      else { colls()->gctInternHtMiss()->push_back(L1GctInternHtMiss::unpackerMissHtx(id, iLength, bx, *p)); } // Htx on even numbers
      ++p;
    }
  }
}

//  LocalWords:  rctJetCrate