ChipMappingITS.h

Go to the documentation of this file.

// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
// All rights not expressly granted are reserved.
//
// This software is distributed under the terms of the GNU General Public
// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
//
// In applying this license CERN does not waive the privileges and immunities
// granted to it by virtue of its status as an Intergovernmental Organization
// or submit itself to any jurisdiction.
 
#ifndef ALICEO2_CHIPMAPPINGITS_H
#define ALICEO2_CHIPMAPPINGITS_H
 
// \file ChipMappingITS.h
// \brief ITS chip <-> module mapping
 
#include <Rtypes.h>
#include <array>
#include <cstdlib>
#include <cstdint>
#include <string>
#include "Headers/DataHeader.h"
#include "ITSMFTReconstruction/RUInfo.h"
#include "DetectorsCommonDataFormats/DetID.h"
#include "Framework/Logger.h"
 
namespace o2
{
namespace itsmft
{
 
#define _OVERRIDE_RUID_HACK_
 
class ChipMappingITS
{
 public:
  struct Overlaps {
    enum OverlappingRow : signed char { NONE = -1,
                                        LowRow = 0,
                                        HighRow = 1,
                                        NSides = 2 };
    int16_t rowSide[2] = {NONE, NONE}; // chip overlapping from low/high row side
    OverlappingRow rowSideOverlap[2] = {NONE, NONE};
  };
 
  ChipMappingITS();
  ~ChipMappingITS() = default;
 
  static constexpr std::string_view getName() { return "ITS"; }
  static constexpr o2::header::DataOrigin getOrigin() { return o2::header::gDataOriginITS; }
  static constexpr o2::detectors::DetID::ID getDetID() { return o2::detectors::DetID::ITS; }
 
  const std::vector<uint8_t>& getCableHWFirstChip(int s) const { return mCableHWFirstChip[s]; }
 
  static constexpr std::int16_t getRUDetectorField() { return 0x0; }
 
  static constexpr int getNRUs() { return NStavesSB[IB] + NStavesSB[MB] + NStavesSB[OB]; }
 
  static constexpr int getNChips() { return NChipsSB[IB] + NChipsSB[MB] + NChipsSB[OB]; }
 
  static constexpr int getNChips(int b) { return NChipsSB[b]; }
 
  static constexpr int getNStavesOnLr(int l) { return NStavesOnLr[l]; }
 
  static constexpr int getFirstStavesOnLr(int l) { return FirstStaveOnLr[l]; }
 
  static constexpr int getNChipsPerLr(int l) { return NStavesOnLr[l] * NChipsPerStaveSB[RUTypeLr[l]]; }
 
  uint16_t composeFEEId(uint16_t lr, uint16_t ruOnLr, uint16_t link) const { return (lr << 12) + (link << 8) + (ruOnLr); }
 
  void expandFEEId(uint16_t feeID, uint16_t& lr, uint16_t& ruOnLr, uint16_t& link) const
  {
    lr = feeID >> 12;
    ruOnLr = feeID & 0x3f;
    link = (feeID >> 8) & 0x3;
#ifdef _OVERRIDE_RUID_HACK_
    ruOnLr %= NStavesOnLr[lr];
#endif
  }
 
  void imposeFEEId2RUSW(uint16_t feeID, uint16_t ruSW);
 
  uint16_t modifyLinkInFEEId(uint16_t feeID, uint16_t linkID) const
  {
    feeID &= ~(0x3 << 8);
    feeID |= (0x3 & linkID) << 8;
    return feeID;
  }
 
  void expandChipInfoSW(int idSW, int& lay, int& sta, int& ssta, int& mod, int& chipInMod) const;
 
  void expandChipInfoHW(int idSW, int& lay, int& sta, int& ssta, int& mod, int& chipInMod) const;
 
  std::string getChipNameHW(int idSW) const;
 
  void print() const;
 
  const ChipOnRUInfo* getChipOnRUInfo(int staveType, int chOnRUSW) const
  {
    return &mChipsInfo[mChipInfoEntrySB[staveType] + chOnRUSW];
  }
 
  void getChipInfoSW(int chipSW, ChipInfo& chInfo) const
  {
    chInfo.id = chipSW;
    if (chipSW > NChipsSB[IB] + NChipsSB[MB] - 1) { // OB
      chipSW -= NChipsSB[IB] + NChipsSB[MB];
      chInfo.ruType = OB;
      auto dvRU = std::div(chipSW, NChipsPerStaveSB[OB]);
      chInfo.ru = NStavesSB[IB] + NStavesSB[MB] + dvRU.quot; // RU ID == stave ID
      chInfo.chOnRU = getChipOnRUInfo(OB, dvRU.rem);
    } else if (chipSW > NChipsSB[IB] - 1) { // MB
      chipSW -= NChipsSB[IB];
      chInfo.ruType = MB;
      auto dvRU = std::div(chipSW, NChipsPerStaveSB[MB]);
      chInfo.ru = NStavesSB[IB] + dvRU.quot; // RU ID == stave ID
      chInfo.chOnRU = getChipOnRUInfo(MB, dvRU.rem);
    } else { // IB
      chInfo.ruType = IB;
      auto dvRU = std::div(chipSW, NChipsPerStaveSB[IB]);
      chInfo.ru = dvRU.quot; // RU ID == stave ID = module ID
      chInfo.chOnRU = getChipOnRUInfo(IB, dvRU.rem);
    }
  }
 
  uint16_t getLocalChipID(uint16_t globalID, int cableHW, const RUInfo& ruInfo)
    const
  {
    if (cableHW <= MaxHWCableID[ruInfo.ruType] && globalID != 0xffff) {
      uint16_t chipOnRU = globalID - ruInfo.firstChipIDSW;
      switch (ruInfo.ruType) {
        case IB:
          return chipOnRU;
        case MB:
          for (int ihw = 0; ihw < 15; ihw++) {
            if (HWCableHWChip2ChipOnRU_MB[cableHW][ihw] == chipOnRU)
              return ihw;
          }
          break;
        case OB:
          for (int ihw = 0; ihw < 15; ihw++) {
            if (HWCableHWChip2ChipOnRU_OB[cableHW][ihw] == chipOnRU)
              return ihw;
          }
          break;
      }
    }
    return 0xffff;
  }
 
  uint16_t getGlobalChipID(uint16_t chOnModuleHW, int cableHW,
                           const RUInfo& ruInfo) const
  {
    if (chOnModuleHW < MaxHWChipIDPerModuleSB[ruInfo.ruType] &&
        cableHW <= MaxHWCableID[ruInfo.ruType]) {
      uint16_t chipOnRU = 0xff;
      switch (ruInfo.ruType) {
        case IB:
          if (cableHW == chOnModuleHW)
            chipOnRU = cableHW;
          break;
        case MB:
          chipOnRU = HWCableHWChip2ChipOnRU_MB[cableHW][chOnModuleHW];
          break;
        case OB:
          chipOnRU = HWCableHWChip2ChipOnRU_OB[cableHW][chOnModuleHW];
          break;
      }
      return chipOnRU < 0xff ? ruInfo.firstChipIDSW + chipOnRU : 0xffff;
    }
    return 0xffff;
  }
 
  uint16_t getGlobalChipIDSW(int lay, int staSW, int modSW, int chipInModSW) const
  {
    uint16_t id = getFirstChipsOnLayer(lay) + (staSW - getFirstStavesOnLr(lay)) * NChipsPerStaveSB[RUTypeLr[lay]] + chipInModSW;
    if (RUTypeLr[lay] != 0) {
      id += modSW * NChipsPerModuleSB[RUTypeLr[lay]];
    }
    return id;
  }
 
  uint8_t FEEId2RUSW(uint16_t hw) const
  {
#ifdef _OVERRIDE_RUID_HACK_
    uint16_t lr, ruOnLr, link;
    expandFEEId(hw, lr, ruOnLr, link);
    hw = composeFEEId(lr, ruOnLr, link);
#endif
    return mFEEId2RUSW[hw];
  }
 
  uint16_t RUSW2FEEId(uint16_t sw, uint16_t linkID = 0) const
  {
    uint16_t feeID = mStavesInfo[sw].idHW; // this is valid for link 0 only
    return linkID ? modifyLinkInFEEId(feeID, linkID) : feeID;
  }
 
  uint16_t RUSW2Layer(uint16_t sw) const { return mStavesInfo[sw].layer; }
 
  uint16_t RUSW2RUType(uint16_t sw) const { return mStavesInfo[sw].ruType; }
 
  const RUInfo* getRUInfoSW(int ruSW) const { return &mStavesInfo[ruSW]; }
 
  const RUInfo* getRUInfoFEEId(int feeID) const { return &mStavesInfo[FEEId2RUSW(feeID)]; }
 
  uint8_t getGBTHeaderRUType(int ruType, int cableHW) { return GBTHeaderFlagSB[ruType] + (cableHW & 0x1f); }
 
  uint8_t cableHW2Pos(uint8_t ruType, uint8_t hwid) const { return mCableHW2Pos[ruType][hwid]; }
 
  uint8_t cableHW2SW(uint8_t ruType, uint8_t hwid) const { return hwid < mCableHW2SW[ruType].size() ? mCableHW2SW[ruType][hwid] : 0xff; }
 
  uint8_t cablePos(uint8_t ruType, uint8_t id) const { return mCablePos[ruType][id]; }
 
  int getNChipsPerCable(int ruType) { return NChipsPerCableSB[ruType]; }
 
  int getNCablesOnRUType(int ruType) const { return NCablesPerStaveSB[ruType]; }
 
  int getCablesOnRUType(int ruType) const { return mCablesOnStaveSB[ruType]; }
 
  int getNChipsOnRUType(int ruType) const { return NChipsPerStaveSB[ruType]; }
 
  int getRUType(int ruID) const
  {
    if (ruID > NStavesSB[IB] + NStavesSB[MB] - 1) {
      return OB;
    }
    if (ruID > NStavesSB[IB] - 1) {
      return MB;
    }
    return IB;
  }
 
  int chipModuleIDHW2SW(int ruType, int hwIDinMod) const
  {
    return ruType == IB ? hwIDinMod : ChipOBModHW2SW[hwIDinMod];
  }
 
  int chipModuleIDSW2HW(int ruType, int swIDinMod) const
  {
    return ruType == IB ? swIDinMod : ChipOBModSW2HW[swIDinMod];
  }
 
  int getRUIDSW(int lr, int ruOnLr) const
  {
    int sid = 0;
    for (int i = 0; i < NLayers; i++) {
      if (i >= lr) {
        break;
      }
      sid += NStavesOnLr[i];
    }
    return sid + ruOnLr;
  }
 
  static constexpr int getLayer(int chipSW)
  {
    int i = 0;
    do {
      if (chipSW < FirstChipsOnLr[i] + NChipsOnLr[i]) {
        break;
      }
    } while (++i < NLayers);
    return i;
  }
  static constexpr int getNModulesPerStave(int ruType) { return NModulesPerStaveSB[ruType]; }
  static constexpr int getNChipsOnLayer(int lr) { return NChipsOnLr[lr]; }
  static constexpr int getFirstChipsOnLayer(int lr) { return FirstChipsOnLr[lr]; }
 
  std::vector<Overlaps> getOverlapsInfo() const;
 
  // sub-barrel types, their number, N layers, Max N GBT Links per RU
  static constexpr int IB = 0, MB = 1, OB = 2, NSubB = 3, NLayers = 7, NLinks = 3;
 
 private:
  static constexpr std::array<uint8_t, NSubB> GBTHeaderFlagSB = {0x1 << 5, 0x1 << 6, 0x1 << 6}; // prefixes for data GBT header byte
 
  static constexpr std::array<int, NSubB> NChipsPerCableSB = {1, 7, 7};
 
  static constexpr std::array<int, NSubB> NModulesAlongStaveSB = {1, 4, 7};
 
  static constexpr std::array<int, NSubB> NChipsPerModuleSB = {9, 14, 14};
 
  static constexpr std::array<int, NSubB> MaxHWChipIDPerModuleSB = {9, 15, 15};
 
  static constexpr std::array<int, NSubB> NCablesPerModule = {9, 2, 2}; // NChipsPerModuleSB[]/NChipsPerCableSB[]
 
  static constexpr std::array<int, NSubB> NModulesPerStaveSB = {1, 8, 14};
 
  static constexpr std::array<int, NLayers> NStavesOnLr = {12, 16, 20, 24, 30, 42, 48};
 
  static constexpr std::array<int, NLayers> FirstStaveOnLr = {0, 12, 28, 48, 72, 102, 144};
 
  static constexpr std::array<int, NLayers> NChipsOnLr = {108, 144, 180, 2688, 3360, 8232, 9408};
 
  static constexpr std::array<int, NLayers> FirstChipsOnLr = {0, 108, 252, 432, 3120, 6480, 14712};
 
  static constexpr std::array<uint8_t, NLayers> RUTypeLr = {IB, IB, IB, MB, MB, OB, OB};
 
  static constexpr std::array<int, NSubB> NStavesSB = {NStavesOnLr[0] + NStavesOnLr[1] + NStavesOnLr[2],
                                                       NStavesOnLr[3] + NStavesOnLr[4],
                                                       NStavesOnLr[5] + NStavesOnLr[6]};
  static constexpr std::array<int, NSubB> NChipsPerStaveSB = {NModulesPerStaveSB[IB] * NChipsPerModuleSB[IB],
                                                              NModulesPerStaveSB[MB] * NChipsPerModuleSB[MB],
                                                              NModulesPerStaveSB[OB] * NChipsPerModuleSB[OB]};
 
  static constexpr std::array<int, NSubB> NCablesPerStaveSB = {NCablesPerModule[IB] * NModulesPerStaveSB[IB],
                                                               NCablesPerModule[MB] * NModulesPerStaveSB[MB],
                                                               NCablesPerModule[OB] * NModulesPerStaveSB[OB]};
 
  static constexpr std::array<int, NSubB> NChipsSB = {NChipsPerStaveSB[IB] * NStavesSB[IB],
                                                      NChipsPerStaveSB[MB] * NStavesSB[MB],
                                                      NChipsPerStaveSB[OB] * NStavesSB[OB]};
 
  static constexpr int NChips = NChipsSB[IB] + NChipsSB[MB] + NChipsSB[OB];
 
  /*
    SW/HW correspondence
     13/14|12/13|11/12|10/11| 9/10| 8/ 9| 7/ 8
    ----- ----- ----- ----- ----- ----- -----
     0/ 0| 1/ 1| 2/ 2| 3/ 3| 4/ 4| 5/ 5| 6/ 6
   */
  // SW ID -> HW ID within the module
  static constexpr std::uint8_t ChipOBModSW2HW[14] = {0, 1, 2, 3, 4, 5, 6, 8, 9, 10, 11, 12, 13, 14};
  // HW ID -> SW ID within the module
  static constexpr std::uint8_t ChipOBModHW2SW[15] = {0, 1, 2, 3, 4, 5, 6, 255, 7, 8, 9, 10, 11, 12, 13};
  static constexpr std::array<int, NSubB> MaxHWCableID = {8, 27, 30};
  std::array<RUInfo, NStavesSB[IB] + NStavesSB[MB] + NStavesSB[OB]> mStavesInfo;
  std::vector<uint8_t> mFEEId2RUSW; // HW RU ID -> SW ID conversion
 
  // info on chips info within the stave
  std::array<ChipOnRUInfo, NChipsPerStaveSB[IB] + NChipsPerStaveSB[MB] + NChipsPerStaveSB[OB]> mChipsInfo;
  int mChipInfoEntrySB[NSubB] = {0};
 
  std::vector<uint8_t> mCableHW2SW[NSubB];       
  std::vector<uint8_t> mCableHW2Pos[NSubB];      
  std::vector<uint8_t> mCablePos[NSubB];         
  std::vector<uint8_t> mCableHWFirstChip[NSubB]; 
 
  std::array<int, NSubB> mCablesOnStaveSB = {0}; 
  std::array<std::array<uint8_t, 15>, MaxHWCableID[MB] + 1> HWCableHWChip2ChipOnRU_MB; // mapping from HW cable ID / HW chip ID to Chip on RU, 255 means NA
  std::array<std::array<uint8_t, 15>, MaxHWCableID[OB] + 1> HWCableHWChip2ChipOnRU_OB; // mapping from HW cable ID / HW chip ID to Chip on RU, 255 means NA
 
  ClassDefNV(ChipMappingITS, 1);
};
} // namespace itsmft
} // namespace o2
 
#endif