TCCBlockFormatter.cc

Go to the documentation of this file.

#include <memory>

#include "EventFilter/EcalDigiToRaw/interface/TCCBlockFormatter.h"

#include "DataFormats/EcalDetId/interface/EcalDetIdCollections.h"

#include "EventFilter/EcalRawToDigi/interface/DCCRawDataDefinitions.h"

#include "DataFormats/FEDRawData/interface/FEDNumbering.h"

using namespace std;

TCCBlockFormatter::TCCBlockFormatter(Config const& iC, Params const& iP) : BlockFormatter(iC, iP) {
  AllTPsamples_ = false;
}

void TCCBlockFormatter::DigiToRaw(const EcalTriggerPrimitiveDigi& trigprim,
                                  FEDRawData& rawdata,
                                  const EcalElectronicsMapping* TheMapping) {
  if (debug_)
    cout << "enter in TCCBlockFormatter::DigiToRaw " << endl;

  int HEADER_SIZE = 8 * 9;
  int bx = bx_;
  int lv1 = lv1_;

  const EcalTrigTowerDetId& detid = trigprim.id();

  if ((detid.subDet() == EcalBarrel) && (!doBarrel_))
    return;
  if ((detid.subDet() == EcalEndcap) && (!doEndCap_))
    return;

  int iDCC = TheMapping->DCCid(detid);
  int TCCid = TheMapping->TCCid(detid);

  if (TCCid < EcalElectronicsMapping::MIN_TCCID || TCCid > EcalElectronicsMapping::MAX_TCCID)
    cout << "Wrong TCCid in TCCBlockFormatter::DigiToRaw " << endl;
  bool IsEndCap = ((EcalElectronicsId::MIN_DCCID_EEM <= iDCC && iDCC <= EcalElectronicsId::MAX_DCCID_EEM) ||
                   (EcalElectronicsId::MIN_DCCID_EEP <= iDCC && iDCC <= EcalElectronicsId::MAX_DCCID_EEP));

  int FEDid = FEDNumbering::MINECALFEDID + iDCC;

  // note: row is a 64 bit word
  int NTT_max = 68;    // Barrel case
  int Nrows_TCC = 17;  // Barrel case    (without the header row)
  int NTCC = 1;        // Barrel case; number of TCC blocks
  int itcc_block = 1;  // Barrel case

  if (IsEndCap) {
    Nrows_TCC = 8;         // one row is a 64 bit word
    NTCC = 4;              // 4 TTC in EndCap case. Use some custom numbering since
    int pair = TCCid % 2;  // the TCCid is written to the RawData.
    int inner = (detid.ietaAbs() >= 22) ? 1 : 0;
    itcc_block = 2 * pair + inner + 1;
    if (inner == 1)
      NTT_max = 28;
    else
      NTT_max = 16;
  }

  int nsamples = trigprim.size();
  if (!AllTPsamples_)
    nsamples = 1;

  int iTT = TheMapping->iTT(detid);  // number of tp inside a fed
  if (debug_)
    cout << "This is a TrigTower  iDCC iTT iTCCBlock TCCid " << dec << iDCC << " " << iTT << " " << itcc_block << " "
         << TCCid << endl;
  if (debug_)
    cout << "ieta iphi " << dec << detid.ieta() << " " << detid.iphi() << endl;
  if (iTT <= 0 || iTT > NTT_max) {
    cout << "invalid iTT " << iTT << endl;
    return;
  }

  int FE_index;

  // rawdata points to the block which will be built for TCC data
  if ((int)rawdata.size() != HEADER_SIZE) {
    FE_index = rawdata.size() / 8 - NTCC * (Nrows_TCC + 1);  // as far as raw data have been generated
    FE_index++;                                              // infer position in TCC block
    if (debug_)
      cout << "TCCid already there. FE_index = " << FE_index << endl;
  } else {
    if (debug_)
      cout << "New TTCid added on Raw data, TTCid = " << dec << TCCid << " 0x" << hex << TCCid << endl;
    FE_index = rawdata.size() / 8;  // size in unites of 64 bits word
    int fe_index = FE_index;
    for (int iblock = 0; iblock < NTCC; iblock++) {  // do this once per fed in EB, four times in EE
      rawdata.resize(rawdata.size() + 8);
      unsigned char* ppData = rawdata.data();  // use this to navigate and create the binary
      ppData[8 * fe_index] = TCCid & 0xFF;     // fed_index increases in units of bytes
      ppData[8 * fe_index + 2] = bx & 0xFF;    // bx takes bits 0-11: 0-7+8-11
      ppData[8 * fe_index + 3] = (bx & 0xF00) >> 8;
      ppData[8 * fe_index + 3] |= 0x60;
      ppData[8 * fe_index + 4] = lv1 & 0xFF;          // same game done for lv1, which takes bits 0-11: 0-7+8-11
      ppData[8 * fe_index + 5] = (lv1 & 0xF00) >> 8;  // lv1
      ppData[8 * fe_index + 6] = NTT_max;
      ppData[8 * fe_index + 6] |= ((nsamples & 0x1) << 7);  // nsamples: number time samples
      ppData[8 * fe_index + 7] = ((nsamples & 0xE) >> 1);
      ppData[8 * fe_index + 7] |= 0x60;
      if (iblock == 0)
        FE_index++;
      fe_index += Nrows_TCC + 1;
      rawdata.resize(rawdata.size() + 8 * Nrows_TCC);  // 17 lines of TPG data in EB, 8 in EE
    }
    if (debug_)
      cout << "Added headers and empty lines : " << endl;
    if (debug_)
      print(rawdata);

    // -- put the B011 already, since for Endcap there can be empty
    // -- lines in the TCC and the SRP blocks
    unsigned char* ppData = rawdata.data();
    for (int iline = FE_index - 1; iline < FE_index + (Nrows_TCC + 1) * NTCC - 1; iline++) {
      ppData[8 * iline + 7] |= 0x60;
      ppData[8 * iline + 3] |= 0x60;
    }
  }

  unsigned char* pData = rawdata.data();

  // -- Now the TCC Block :

  int jTT = (iTT - 1);  // jTT is the TP number insided a block;
  int irow = jTT / 4 + (itcc_block - 1) *
                           (Nrows_TCC + 1);  // you fit 4 TP's per row; move forward if you're not in the first block;
  int ival = jTT % 4;  // for each block you have to skip, move of (Nrows_TCC +1) - 1 is for the TCC header

  // RTC required TP's tp follow global phi also in EB+, thus swap them inside the single TCC
  // here you could swap ival -> 3-ival to swap phi insied EB+ supermodules
  if (NUMB_SM_EB_PLU_MIN <= iDCC && iDCC <= NUMB_SM_EB_PLU_MAX) {
    ival = 3 - ival;
  }

  FE_index += irow;  // ival is location inside a TP row; varies between 0-3

  if (debug_)
    cout << "Now add tower " << dec << iTT << " irow ival " << dec << irow << " " << dec << ival << endl;
  if (debug_)
    cout << "new data will be added at line " << dec << FE_index << endl;

  int fg = trigprim.fineGrain();
  int et = trigprim.compressedEt();
  int ttflag = trigprim.ttFlag();

  if (debug_ && (ttflag != 0)) {
    cout << "in TCCBlock : this tower has a non zero flag" << endl;
    cout << "Fedid  iTT  flag " << dec << FEDid << " " << iTT << " "
         << "0x" << hex << ttflag << endl;
  }
  pData[8 * FE_index + ival * 2] =
      et & 0xFF;  // ival is location inside a TP row; varies between 0-3; tp goes in bits 0-7
  pData[8 * FE_index + ival * 2 + 1] = (ttflag << 1) + (fg & 0x1);  // fg follows in bit 8; ttfg is in bits 9-11
  if (IsEndCap) {
    // re-write the TCCid  and N_Tower_Max :
    int ibase = 8 * (FE_index - (int)(jTT / 4) - 1);
    pData[ibase] = TCCid & 0xFF;
    pData[ibase + 6] = NTT_max;
    pData[ibase + 6] |= ((nsamples & 0x1) << 7);
    pData[ibase + 7] |= ((nsamples & 0xE) >> 1);
  }
  if (debug_)
    cout << "pData[8*FE_index + ival*2+1] = " << hex << (int)pData[8 * FE_index + ival * 2 + 1] << endl;
  if (debug_)
    cout << "ttflag ttflag<<1 " << hex << ttflag << " " << hex << (ttflag << 1) << endl;
  if (debug_)
    cout << "fg&0x1 " << hex << (fg & 0x1) << endl;
  if (debug_)
    cout << "sum " << hex << ((ttflag << 1) + (fg & 0x1)) << endl;
  if (ival % 2 == 1)
    pData[8 * FE_index + ival * 2 + 1] |= 0x60;
  if (debug_)
    cout << "ttflag et fgbit " << hex << ttflag << " " << hex << et << " " << hex << fg << endl;
  if (debug_)
    print(rawdata);
}