L1MuGMTMatcher.cc

Go to the documentation of this file.

//-------------------------------------------------
//
//   Class: L1MuGMTMatcher
//
//   Description: Matcher
//
//
//
//   Author :
//   N. Neumeister            CERN EP
//
//   Migrated to CMSSW:
//   I. Mikulec
//
//--------------------------------------------------

//-----------------------
// This Class's Header --
//-----------------------

#include "L1Trigger/GlobalMuonTrigger/src/L1MuGMTMatcher.h"

//---------------
// C++ Headers --
//---------------

#include <iostream>
#include <iomanip>
#include <cmath>

#include <fstream>
#include <sstream>

//-------------------------------
// Collaborating Class Headers --
//-------------------------------

#include "L1Trigger/GlobalMuonTrigger/src/L1MuGMTConfig.h"
#include "L1Trigger/GlobalMuonTrigger/interface/L1MuGlobalMuonTrigger.h"
#include "L1Trigger/GlobalMuonTrigger/src/L1MuGMTPSB.h"
#include "L1Trigger/GlobalMuonTrigger/src/L1MuGMTMatrix.h"
#include "L1Trigger/GlobalMuonTrigger/src/L1MuGMTDebugBlock.h"
#include "L1Trigger/GlobalMuonTrigger/src/L1MuGMTSortRankUnit.h"
#include "L1Trigger/GlobalMuonTrigger/src/L1MuGMTLFDeltaEtaLUT.h"
#include "L1Trigger/GlobalMuonTrigger/src/L1MuGMTLFCOUDeltaEtaLUT.h"
#include "L1Trigger/GlobalMuonTrigger/src/L1MuGMTLFOvlEtaConvLUT.h"
#include "L1Trigger/GlobalMuonTrigger/src/L1MuGMTLFMatchQualLUT.h"
#include "L1Trigger/GlobalMuonTrigger/src/L1MuGMTLFDisableHotLUT.h"
#include "CondFormats/L1TObjects/interface/L1MuPacking.h"

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

// --------------------------------
//       class L1MuGMTMatcher
//---------------------------------

//----------------
// Constructors --
//----------------
L1MuGMTMatcher::L1MuGMTMatcher(const L1MuGlobalMuonTrigger& gmt, int id)
    : m_gmt(gmt),
      m_id(id),
      first(MaxMatch),
      second(MaxMatch),
      matchQuality(MaxMatch, MaxMatch, 0),
      pairMatrix(MaxMatch, MaxMatch, false) {
  first.reserve(MaxMatch);
  second.reserve(MaxMatch);
}

//--------------
// Destructor --
//--------------
L1MuGMTMatcher::~L1MuGMTMatcher() { reset(); }

//--------------
// Operations --
//--------------

//
// run Muon Matcher
//
void L1MuGMTMatcher::run() {
  load();
  match();
}

//
// clear Matcher
//
void L1MuGMTMatcher::reset() {
  matchQuality.reset(0);
  pairMatrix.reset(false);

  for (unsigned i = 0; i < MaxMatch; i++) {
    first[i] = nullptr;
    second[i] = nullptr;
  }
}

//
// print matching results
//
void L1MuGMTMatcher::print() {
  edm::LogVerbatim("GMT_Matcher_info");
  if (L1MuGMTConfig::Debug(4)) {
    edm::LogVerbatim("GMT_Matcher_info") << "MATCH Quality : ";
    matchQuality.print();
  }

  edm::LogVerbatim("GMT_Matcher_info") << "PAIR Matrix : ";
  pairMatrix.print();

  edm::LogVerbatim("GMT_Matcher_info");
}

//
// load Matcher (get data from data buffer)
//
void L1MuGMTMatcher::load() {
  // barrel matcher gets DTBX and barrel RPC muons
  if (m_id == 0) {
    for (unsigned idt = 0; idt < L1MuGMTConfig::MAXDTBX; idt++) {
      first[idt] = m_gmt.Data()->DTBXMuon(idt);
    }
    for (unsigned irpc = 0; irpc < L1MuGMTConfig::MAXRPCbarrel; irpc++) {
      second[irpc] = m_gmt.Data()->RPCMuon(irpc);
    }
  }

  // endcap matcher gets CSC and endcap RPC muons
  if (m_id == 1) {
    for (unsigned icsc = 0; icsc < L1MuGMTConfig::MAXCSC; icsc++) {
      first[icsc] = m_gmt.Data()->CSCMuon(icsc);
    }
    for (unsigned irpc = 0; irpc < L1MuGMTConfig::MAXRPCendcap; irpc++) {
      second[irpc] = m_gmt.Data()->RPCMuon(irpc + 4);
    }
  }

  // matcher in DT/CSC cancel-out unit gets DTBX and CSC muons
  if (m_id == 2) {
    for (unsigned idt = 0; idt < L1MuGMTConfig::MAXDTBX; idt++) {
      first[idt] = m_gmt.Data()->DTBXMuon(idt);
    }
    for (unsigned icsc = 0; icsc < L1MuGMTConfig::MAXCSC; icsc++) {
      second[icsc] = m_gmt.Data()->CSCMuon(icsc);
    }
  }

  // matcher in CSC/DT cancel-out unit gets CSC and DTBX muons
  if (m_id == 3) {
    for (unsigned icsc = 0; icsc < L1MuGMTConfig::MAXCSC; icsc++) {
      first[icsc] = m_gmt.Data()->CSCMuon(icsc);
    }
    for (unsigned idt = 0; idt < L1MuGMTConfig::MAXDTBX; idt++) {
      second[idt] = m_gmt.Data()->DTBXMuon(idt);
    }
  }

  // bRPC/CSC gets barrel RPC and CSC muons
  if (m_id == 4) {
    for (unsigned irpc = 0; irpc < L1MuGMTConfig::MAXRPCbarrel; irpc++) {
      first[irpc] = m_gmt.Data()->RPCMuon(irpc);
    }
    for (unsigned icsc = 0; icsc < L1MuGMTConfig::MAXCSC; icsc++) {
      second[icsc] = m_gmt.Data()->CSCMuon(icsc);
    }
  }

  // bRPC/DT matcher gets forward RPC and DTBX muons
  if (m_id == 5) {
    for (unsigned irpc = 0; irpc < L1MuGMTConfig::MAXRPCendcap; irpc++) {
      first[irpc] = m_gmt.Data()->RPCMuon(irpc + 4);
    }
    for (unsigned idt = 0; idt < L1MuGMTConfig::MAXDTBX; idt++) {
      second[idt] = m_gmt.Data()->DTBXMuon(idt);
    }
  }
}

//
// match muons
//
void L1MuGMTMatcher::match() {
  L1MuGMTMatrix<bool> maxMatrix(MaxMatch, MaxMatch, false);
  L1MuGMTMatrix<bool> disableMatrix(MaxMatch, MaxMatch, false);

  // loop over all combinations

  unsigned i, j;
  for (i = 0; i < MaxMatch; i++)
    for (j = 0; j < MaxMatch; j++)
      matchQuality(i, j) = lookup_mq(i, j);

  // store in debug block
  m_gmt.DebugBlockForFill()->SetMQMatrix(m_id, matchQuality);

  // fill MAX matrix

  for (i = 0; i < MaxMatch; i++)
    for (j = 0; j < MaxMatch; j++)
      maxMatrix(i, j) = matchQuality.isMax(i, j) && (matchQuality(i, j) != 0);

  // fill disable matrix

  for (i = 0; i < MaxMatch; i++)
    for (j = 0; j < MaxMatch; j++) {
      for (unsigned i1 = 0; i1 < MaxMatch; i1++)
        if (i1 != i)
          disableMatrix(i, j) = disableMatrix(i, j) || maxMatrix(i1, j);

      for (unsigned j1 = 0; j1 < MaxMatch; j1++)
        if (j1 != j)
          disableMatrix(i, j) = disableMatrix(i, j) || maxMatrix(i, j1);
    }

  // fill pair matrix

  for (i = 0; i < MaxMatch; i++) {
    for (j = 0; j < MaxMatch; j++) {
      bool max = true;

      for (unsigned i1 = 0; i1 < i; i1++) {
        max = max && ((matchQuality(i, j) > matchQuality(i1, j)) || disableMatrix(i1, j));
      }

      for (unsigned i1 = i + 1; i1 < MaxMatch; i1++) {
        max = max && ((matchQuality(i, j) >= matchQuality(i1, j)) || disableMatrix(i1, j));
      }

      for (unsigned j1 = 0; j1 < j; j1++) {
        max = max && ((matchQuality(i, j) > matchQuality(i, j1)) || disableMatrix(i, j1));
      }

      for (unsigned j1 = j + 1; j1 < MaxMatch; j1++) {
        max = max && ((matchQuality(i, j) >= matchQuality(i, j1)) || disableMatrix(i, j1));
      }

      pairMatrix(i, j) = max && (matchQuality(i, j) != 0);
    }
  }

  // store in debug block
  m_gmt.DebugBlockForFill()->SetPairMatrix(m_id, pairMatrix);
}

//
// compare eta and phi of two muons
//
int L1MuGMTMatcher::lookup_mq(int i, int j) {
  bool empty1 = (first[i] != nullptr) ? first[i]->empty() : true;
  bool empty2 = (second[j] != nullptr) ? second[j]->empty() : true;
  if (empty1 || empty2)
    return 0;

  //
  // (1) calculate delta-phi (integer version)
  //
  unsigned phi1 = first[i]->phi_packed();
  unsigned phi2 = second[j]->phi_packed();

  int delta_phi = ((phi1 - phi2 + 3 * 72) % 144) - 72;

  if (delta_phi < -3 || delta_phi > 3)
    delta_phi = -4;

  L1MuSignedPacking<3> DPhiPacking;
  unsigned delta_phi_packed = DPhiPacking.packedFromIdx(delta_phi);

  //
  // (2) look-up delta-eta
  //
  unsigned eta1 = first[i]->eta_packed();
  unsigned eta2 = second[j]->eta_packed();

  unsigned delta_eta_packed = 0;

  if (m_id == 0 || m_id == 1) {  // main matching units
    // first is dt/csc, second is rpc

    bool disable1 = L1MuGMTSortRankUnit::isDisabled(first[i]);
    bool disable2 = L1MuGMTSortRankUnit::isDisabled(second[j]);
    ;

    if (disable1 || disable2)
      return 0;

    L1MuGMTLFDeltaEtaLUT* de_lut = L1MuGMTConfig::getLFDeltaEtaLUT();
    delta_eta_packed = de_lut->SpecificLookup_delta_eta(m_id, eta1, eta2);
  } else {  // overlap cancel-out matching units
    // first is own chip, second is other chip
    int idx1 = first[i]->type_idx();
    int idx1_dcrr = (idx1 == 1) ? 2 : (idx1 == 2) ? 1 : idx1;

    int idx2 = second[j]->type_idx();
    int idx2_dcrr = (idx2 == 1) ? 2 : (idx2 == 2) ? 1 : idx2;

    bool disable1 = L1MuGMTSortRankUnit::isDisabled(first[i]);

    L1MuGMTLFDisableHotLUT* dishot_lut = L1MuGMTConfig::getLFDisableHotLUT();
    bool disable2 =
        dishot_lut->SpecificLookup_disable_hot(idx2_dcrr, second[j]->eta_packed(), second[j]->phi_packed()) == 1;

    if (disable1 || disable2)
      return 0;

    // convert eta to 4-bit, first
    L1MuGMTLFOvlEtaConvLUT* econv_lut = L1MuGMTConfig::getLFOvlEtaConvLUT();

    unsigned eta1_4bit = econv_lut->SpecificLookup_eta_ovl(idx1_dcrr, eta1);
    unsigned eta2_4bit = econv_lut->SpecificLookup_eta_ovl(idx2_dcrr, eta2);

    // look up delta eta
    L1MuGMTLFCOUDeltaEtaLUT* cou_de_lut = L1MuGMTConfig::getLFCOUDeltaEtaLUT();
    delta_eta_packed = cou_de_lut->SpecificLookup_delta_eta(m_id - 2, eta1_4bit, eta2_4bit);
  }

  //
  // (3) look up match quality
  //
  L1MuGMTLFMatchQualLUT* mq_lut = L1MuGMTConfig::getLFMatchQualLUT();

  unsigned mq = mq_lut->SpecificLookup_mq(m_id, delta_eta_packed, delta_phi_packed);

  return mq;
}