L1MuGMTConfig.cc

Go to the documentation of this file.

//-------------------------------------------------
//
//   Class: L1MuGMTConfig
//
//   Description: Configuration parameters for L1GlobalMuonTrigger
//
//
//
//   Author :
//   N. Neumeister             CERN EP
//
//   Migrated to CMSSW:
//   I. Mikulec
//
//--------------------------------------------------

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

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

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

#include <iostream>
#include <fstream>
#include <string>

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

#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/Utilities/interface/InputTag.h"
#include "L1Trigger/GlobalMuonTrigger/src/L1MuGMTReg.h"
#include "L1Trigger/GlobalMuonTrigger/src/L1MuGMTEtaLUT.h"
#include "L1Trigger/GlobalMuonTrigger/src/L1MuGMTLFCOUDeltaEtaLUT.h"
#include "L1Trigger/GlobalMuonTrigger/src/L1MuGMTLFDeltaEtaLUT.h"
#include "L1Trigger/GlobalMuonTrigger/src/L1MuGMTLFDisableHotLUT.h"
#include "L1Trigger/GlobalMuonTrigger/src/L1MuGMTLFEtaConvLUT.h"
#include "L1Trigger/GlobalMuonTrigger/src/L1MuGMTLFMatchQualLUT.h"
#include "L1Trigger/GlobalMuonTrigger/src/L1MuGMTLFMergeRankCombineLUT.h"
#include "L1Trigger/GlobalMuonTrigger/src/L1MuGMTLFMergeRankEtaPhiLUT.h"
#include "L1Trigger/GlobalMuonTrigger/src/L1MuGMTLFMergeRankEtaQLUT.h"
#include "L1Trigger/GlobalMuonTrigger/src/L1MuGMTLFMergeRankPtQLUT.h"
#include "L1Trigger/GlobalMuonTrigger/src/L1MuGMTLFOvlEtaConvLUT.h"
#include "L1Trigger/GlobalMuonTrigger/src/L1MuGMTLFPhiProEtaConvLUT.h"
#include "L1Trigger/GlobalMuonTrigger/src/L1MuGMTLFPhiProLUT.h"
#include "L1Trigger/GlobalMuonTrigger/src/L1MuGMTLFPtMixLUT.h"
#include "L1Trigger/GlobalMuonTrigger/src/L1MuGMTLFSortRankCombineLUT.h"
#include "L1Trigger/GlobalMuonTrigger/src/L1MuGMTLFSortRankEtaPhiLUT.h"
#include "L1Trigger/GlobalMuonTrigger/src/L1MuGMTLFSortRankEtaQLUT.h"
#include "L1Trigger/GlobalMuonTrigger/src/L1MuGMTLFSortRankPtQLUT.h"
#include "L1Trigger/GlobalMuonTrigger/src/L1MuGMTMIAUEtaConvLUT.h"
#include "L1Trigger/GlobalMuonTrigger/src/L1MuGMTMIAUEtaProLUT.h"
#include "L1Trigger/GlobalMuonTrigger/src/L1MuGMTMIAUPhiPro1LUT.h"
#include "L1Trigger/GlobalMuonTrigger/src/L1MuGMTMIAUPhiPro2LUT.h"
#include "L1Trigger/GlobalMuonTrigger/src/L1MuGMTPhiLUT.h"

#include "CondFormats/L1TObjects/interface/L1MuGMTScales.h"
#include "CondFormats/L1TObjects/interface/L1MuGMTParameters.h"
#include "CondFormats/L1TObjects/interface/L1MuGMTChannelMask.h"

#include "CondFormats/L1TObjects/interface/L1CaloGeometry.h"

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

// --------------------------------
//       class L1MuGMTConfig
//---------------------------------
using namespace std;

//----------------
// Constructors --
//----------------

L1MuGMTConfig::L1MuGMTConfig(const edm::ParameterSet& ps) {

  m_ps = &ps;

  m_DTInputTag   = m_ps->getParameter<edm::InputTag>("DTCandidates");
  m_CSCInputTag  = m_ps->getParameter<edm::InputTag>("CSCCandidates");
  m_RPCbInputTag = m_ps->getParameter<edm::InputTag>("RPCbCandidates");
  m_RPCfInputTag = m_ps->getParameter<edm::InputTag>("RPCfCandidates");
  m_MipIsoInputTag = m_ps->getParameter<edm::InputTag>("MipIsoData");

  m_debug = true;
  m_dbgLevel = m_ps->getUntrackedParameter<int>("Debug",0);

  // set min and max bunch crossing
  m_BxMin = m_ps->getParameter<int>("BX_min");
  m_BxMax = m_ps->getParameter<int>("BX_max");

  // set min and max bunch crossing for the readout
  m_BxMinRo = m_ps->getParameter<int>("BX_min_readout");
  m_BxMaxRo = m_ps->getParameter<int>("BX_max_readout");

}
  
//--------------
// Destructor --
//--------------
L1MuGMTConfig::~L1MuGMTConfig() {}


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


void L1MuGMTConfig::setDefaults() {
  
  // set weights for eta and phi
  m_EtaWeight_barrel = m_GMTParams->getEtaWeight_barrel();
  m_PhiWeight_barrel = m_GMTParams->getPhiWeight_barrel();
  m_EtaPhiThreshold_barrel = m_GMTParams->getEtaPhiThreshold_barrel();
  
  m_EtaWeight_endcap = m_GMTParams->getEtaWeight_endcap();
  m_PhiWeight_endcap = m_GMTParams->getPhiWeight_endcap();
  m_EtaPhiThreshold_endcap = m_GMTParams->getEtaPhiThreshold_endcap();
  
  m_EtaWeight_COU = m_GMTParams->getEtaWeight_COU();
  m_PhiWeight_COU = m_GMTParams->getPhiWeight_COU();
  m_EtaPhiThreshold_COU = m_GMTParams->getEtaPhiThreshold_COU();
  
  m_CaloTrigger = m_GMTParams->getCaloTrigger();
  m_IsolationCellSizeEta = m_GMTParams->getIsolationCellSizeEta();
  m_IsolationCellSizePhi = m_GMTParams->getIsolationCellSizePhi();
  
  m_DoOvlRpcAnd = m_GMTParams->getDoOvlRpcAnd();

  m_PropagatePhi = m_GMTParams->getPropagatePhi();
  
  m_VersionSortRankEtaQLUT = m_GMTParams->getVersionSortRankEtaQLUT();
  m_VersionLUTs = m_GMTParams->getVersionLUTs();

  if ( Debug(1) ) {
    stringstream stdss;
    stdss
        << endl
        << "*******************************************" << endl
        << "**** L1 Global Muon Trigger settings : ****" << endl
        << "*******************************************" << endl
        << endl

        << "L1 Global Muon Trigger : DTCandidates : " << m_DTInputTag << endl
        << "L1 Global Muon Trigger : CSCCandidates : " << m_CSCInputTag << endl
        << "L1 Global Muon Trigger : RPCbCandidates : " << m_RPCbInputTag << endl
        << "L1 Global Muon Trigger : RPCfCandidates : " << m_RPCfInputTag << endl
        << "L1 Global Muon Trigger : debug level : " << m_dbgLevel << endl
        << "L1 Global Muon Trigger : minimal bunch-crossing : " << m_BxMin << endl
        << "L1 Global Muon Trigger : maximal bunch-crossing : " << m_BxMax << endl
        << "L1 Global Muon Trigger : barrel eta weight : " << m_EtaWeight_barrel << endl
        << "L1 Global Muon Trigger : barrel phi weight : " << m_PhiWeight_barrel << endl
        << "L1 Global Muon Trigger : barrel eta-phi threshold : " << m_EtaPhiThreshold_barrel << endl
        << "L1 Global Muon Trigger : endcap eta weight : " << m_EtaWeight_endcap << endl
        << "L1 Global Muon Trigger : endcap phi weight : " << m_PhiWeight_endcap << endl
        << "L1 Global Muon Trigger : endcap eta-phi threshold : " << m_EtaPhiThreshold_endcap << endl
        << "L1 Global Muon Trigger : cancel out unit eta weight : " << m_EtaWeight_COU << endl
        << "L1 Global Muon Trigger : cancel out unit phi weight : " << m_PhiWeight_COU << endl
        << "L1 Global Muon Trigger : cancel out unit eta-phi threshold : " << m_EtaPhiThreshold_COU << endl
        << "L1 Global Muon Trigger : calorimeter trigger : " << m_CaloTrigger << endl
        << "L1 Global Muon Trigger : muon isolation cell size (eta) : " << m_IsolationCellSizeEta << endl
        << "L1 Global Muon Trigger : muon isolation cell size (phi) : " << m_IsolationCellSizePhi << endl
        << "L1 Global Muon Trigger : require confirmation by RPC in overlap region : " << m_DoOvlRpcAnd << endl
        << "L1 Global Muon Trigger : propagate phi to vertex : " << m_PropagatePhi << endl
        << "L1 Global Muon Trigger : version of low quality assignment LUT : " << m_VersionSortRankEtaQLUT << endl
        << "L1 Global Muon Trigger : general LUTs version : " << m_VersionLUTs << endl;
    edm::LogVerbatim("GMT_Config_info") << stdss.str();
  }
}

void L1MuGMTConfig::createLUTsRegs() {

  // create Registers
  m_RegCDLConfig = new L1MuGMTRegCDLConfig();
  m_RegMMConfigPhi = new L1MuGMTRegMMConfigPhi();
  m_RegMMConfigEta = new L1MuGMTRegMMConfigEta();
  m_RegMMConfigPt = new L1MuGMTRegMMConfigPt();
  m_RegMMConfigCharge = new L1MuGMTRegMMConfigCharge();
  m_RegMMConfigMIP = new L1MuGMTRegMMConfigMIP();
  m_RegMMConfigISO = new L1MuGMTRegMMConfigISO();
  m_RegMMConfigSRK = new L1MuGMTRegMMConfigSRK();
  m_RegSortRankOffset = new L1MuGMTRegSortRankOffset();

  // create LUTs
  m_EtaLUT = new L1MuGMTEtaLUT();
  m_LFCOUDeltaEtaLUT = new L1MuGMTLFCOUDeltaEtaLUT();
  m_LFDeltaEtaLUT = new L1MuGMTLFDeltaEtaLUT();
  m_LFDisableHotLUT = new L1MuGMTLFDisableHotLUT();
  m_LFEtaConvLUT = new L1MuGMTLFEtaConvLUT();
  m_LFMatchQualLUT = new L1MuGMTLFMatchQualLUT();
  m_LFMergeRankCombineLUT = new L1MuGMTLFMergeRankCombineLUT();
  m_LFMergeRankEtaPhiLUT = new L1MuGMTLFMergeRankEtaPhiLUT();
  m_LFMergeRankEtaQLUT = new L1MuGMTLFMergeRankEtaQLUT();
  m_LFMergeRankPtQLUT = new L1MuGMTLFMergeRankPtQLUT();
  m_LFOvlEtaConvLUT = new L1MuGMTLFOvlEtaConvLUT();
  m_LFPhiProEtaConvLUT = new L1MuGMTLFPhiProEtaConvLUT();
  m_LFPhiProLUT = new L1MuGMTLFPhiProLUT();
  m_LFPtMixLUT = new L1MuGMTLFPtMixLUT();
  m_LFSortRankCombineLUT = new L1MuGMTLFSortRankCombineLUT();
  m_LFSortRankEtaPhiLUT = new L1MuGMTLFSortRankEtaPhiLUT();
  m_LFSortRankEtaQLUT = new L1MuGMTLFSortRankEtaQLUT();
  m_LFSortRankPtQLUT = new L1MuGMTLFSortRankPtQLUT();
  m_MIAUEtaConvLUT = new L1MuGMTMIAUEtaConvLUT();
  m_MIAUEtaProLUT = new L1MuGMTMIAUEtaProLUT();
  m_MIAUPhiPro1LUT = new L1MuGMTMIAUPhiPro1LUT();
  m_MIAUPhiPro2LUT = new L1MuGMTMIAUPhiPro2LUT();
  m_PhiLUT = new L1MuGMTPhiLUT();

}

void L1MuGMTConfig::clearLUTsRegs() {
  // delete Registers
  delete m_RegCDLConfig;
  delete m_RegMMConfigPhi;
  delete m_RegMMConfigEta;
  delete m_RegMMConfigPt;
  delete m_RegMMConfigCharge;
  delete m_RegMMConfigMIP;
  delete m_RegMMConfigISO;
  delete m_RegMMConfigSRK;
  delete m_RegSortRankOffset;

  // delete LUTs
  delete m_EtaLUT;
  delete m_LFCOUDeltaEtaLUT;
  delete m_LFDeltaEtaLUT;
  delete m_LFDisableHotLUT;
  delete m_LFEtaConvLUT;
  delete m_LFMatchQualLUT;
  delete m_LFMergeRankCombineLUT;
  delete m_LFMergeRankEtaPhiLUT;
  delete m_LFMergeRankEtaQLUT;
  delete m_LFMergeRankPtQLUT;
  delete m_LFOvlEtaConvLUT;
  delete m_LFPhiProEtaConvLUT;
  delete m_LFPhiProLUT;
  delete m_LFPtMixLUT;
  delete m_LFSortRankCombineLUT;
  delete m_LFSortRankEtaPhiLUT;
  delete m_LFSortRankEtaQLUT;
  delete m_LFSortRankPtQLUT;
  delete m_MIAUEtaConvLUT;
  delete m_MIAUEtaProLUT;
  delete m_MIAUPhiPro1LUT;
  delete m_MIAUPhiPro2LUT;
  delete m_PhiLUT;
}

void L1MuGMTConfig::dumpLUTs(std::string dir) {
  std::vector<L1MuGMTLUT*> theLUTs;

  theLUTs.push_back( m_LFSortRankEtaQLUT );  
  theLUTs.push_back( m_LFSortRankPtQLUT );   
  theLUTs.push_back( m_LFSortRankEtaPhiLUT );
  theLUTs.push_back( m_LFSortRankCombineLUT );

  theLUTs.push_back( m_LFDisableHotLUT );

  theLUTs.push_back( m_LFMergeRankEtaQLUT );  
  theLUTs.push_back( m_LFMergeRankPtQLUT );   
  theLUTs.push_back( m_LFMergeRankEtaPhiLUT );
  theLUTs.push_back( m_LFMergeRankCombineLUT );

  theLUTs.push_back( m_LFDeltaEtaLUT );
  theLUTs.push_back( m_LFMatchQualLUT );
  theLUTs.push_back( m_LFOvlEtaConvLUT );
  theLUTs.push_back( m_LFCOUDeltaEtaLUT );

  theLUTs.push_back( m_LFEtaConvLUT );

  theLUTs.push_back( m_LFPtMixLUT );
  theLUTs.push_back( m_LFPhiProLUT );
  theLUTs.push_back( m_LFPhiProEtaConvLUT );

  theLUTs.push_back( m_MIAUEtaConvLUT );
  theLUTs.push_back( m_MIAUPhiPro1LUT );
  theLUTs.push_back( m_MIAUPhiPro2LUT );
  theLUTs.push_back( m_MIAUEtaProLUT );

  std::vector<L1MuGMTLUT*>::iterator it = theLUTs.begin();
  for (;it != theLUTs.end(); it++) {
    edm::LogVerbatim("GMT_LUTGen_info")
     << "**** Generating " << (*it)->Name() << " LUT ****" << endl
     << "saving" << endl;
    std::string fn = dir + "/" + (*it)->Name() + ".lut";
    (*it)->Save(fn.c_str());    
  }

  edm::LogVerbatim("GMT_LUTGen_info") 
      << "Successfully created all GMT look-up tables in directory './" << dir << "'" << endl << endl;

}

void L1MuGMTConfig::dumpRegs(std::string dir) {
  std::vector<L1MuGMTReg*> theRegs;

  theRegs.push_back( m_RegCDLConfig );
  theRegs.push_back( m_RegMMConfigPhi );
  theRegs.push_back( m_RegMMConfigEta );
  theRegs.push_back( m_RegMMConfigPt );
  theRegs.push_back( m_RegMMConfigCharge );
  theRegs.push_back( m_RegMMConfigSRK );
  theRegs.push_back( m_RegMMConfigMIP );
  theRegs.push_back( m_RegMMConfigISO );
  theRegs.push_back( m_RegSortRankOffset );


  ofstream of( (dir + "/LogicFPGARegs.cfg").c_str() );

  std::vector<L1MuGMTReg*>::iterator it = theRegs.begin();
  for (;it != theRegs.end(); it++) {

    for (unsigned int i=0; i<(*it)->getNumberOfInstances(); i++)
      of << (*it)->getName() << "[" << i << "] = " << (*it)->getValue(i) << endl;

  }

}

// static data members

const edm::ParameterSet* L1MuGMTConfig::m_ps=nullptr;

edm::InputTag L1MuGMTConfig::m_DTInputTag = edm::InputTag();
edm::InputTag L1MuGMTConfig::m_CSCInputTag = edm::InputTag();
edm::InputTag L1MuGMTConfig::m_RPCbInputTag = edm::InputTag();
edm::InputTag L1MuGMTConfig::m_RPCfInputTag = edm::InputTag();
edm::InputTag L1MuGMTConfig::m_MipIsoInputTag = edm::InputTag();
int   L1MuGMTConfig::m_dbgLevel = 0;
bool  L1MuGMTConfig::m_debug = false;
int   L1MuGMTConfig::m_BxMin = -4;
int   L1MuGMTConfig::m_BxMax = 4;
int   L1MuGMTConfig::m_BxMinRo = -2;
int   L1MuGMTConfig::m_BxMaxRo = 2;
float L1MuGMTConfig::m_EtaWeight_barrel = 0.028;
float L1MuGMTConfig::m_PhiWeight_barrel = 1.0;
float L1MuGMTConfig::m_EtaPhiThreshold_barrel = 0.062;
float L1MuGMTConfig::m_EtaWeight_endcap = 0.13;
float L1MuGMTConfig::m_PhiWeight_endcap = 1.0;
float L1MuGMTConfig::m_EtaPhiThreshold_endcap = 0.062;
float L1MuGMTConfig::m_EtaWeight_COU = 0.316;
float L1MuGMTConfig::m_PhiWeight_COU = 1.0;
float L1MuGMTConfig::m_EtaPhiThreshold_COU = 0.127;
bool  L1MuGMTConfig::m_CaloTrigger = true;
int   L1MuGMTConfig::m_IsolationCellSizeEta = 2;
int   L1MuGMTConfig::m_IsolationCellSizePhi = 2;
bool  L1MuGMTConfig::m_DoOvlRpcAnd = false;

bool  L1MuGMTConfig::m_PropagatePhi = false;
unsigned L1MuGMTConfig::m_VersionSortRankEtaQLUT = 2;
unsigned L1MuGMTConfig::m_VersionLUTs = 0;

L1MuGMTRegCDLConfig* L1MuGMTConfig::m_RegCDLConfig=nullptr;
L1MuGMTRegMMConfigPhi* L1MuGMTConfig::m_RegMMConfigPhi=nullptr;
L1MuGMTRegMMConfigEta* L1MuGMTConfig::m_RegMMConfigEta=nullptr;
L1MuGMTRegMMConfigPt* L1MuGMTConfig::m_RegMMConfigPt=nullptr;
L1MuGMTRegMMConfigCharge* L1MuGMTConfig::m_RegMMConfigCharge=nullptr;
L1MuGMTRegMMConfigMIP* L1MuGMTConfig::m_RegMMConfigMIP=nullptr;
L1MuGMTRegMMConfigISO* L1MuGMTConfig::m_RegMMConfigISO=nullptr;
L1MuGMTRegMMConfigSRK* L1MuGMTConfig::m_RegMMConfigSRK=nullptr;
L1MuGMTRegSortRankOffset* L1MuGMTConfig::m_RegSortRankOffset=nullptr;

L1MuGMTEtaLUT* L1MuGMTConfig::m_EtaLUT=nullptr;
L1MuGMTLFCOUDeltaEtaLUT* L1MuGMTConfig::m_LFCOUDeltaEtaLUT=nullptr;
L1MuGMTLFDeltaEtaLUT* L1MuGMTConfig::m_LFDeltaEtaLUT=nullptr;
L1MuGMTLFDisableHotLUT* L1MuGMTConfig::m_LFDisableHotLUT=nullptr;
L1MuGMTLFEtaConvLUT* L1MuGMTConfig::m_LFEtaConvLUT=nullptr;
L1MuGMTLFMatchQualLUT* L1MuGMTConfig::m_LFMatchQualLUT=nullptr;
L1MuGMTLFMergeRankCombineLUT* L1MuGMTConfig::m_LFMergeRankCombineLUT=nullptr;
L1MuGMTLFMergeRankEtaPhiLUT* L1MuGMTConfig::m_LFMergeRankEtaPhiLUT=nullptr;
L1MuGMTLFMergeRankEtaQLUT* L1MuGMTConfig::m_LFMergeRankEtaQLUT=nullptr;
L1MuGMTLFMergeRankPtQLUT* L1MuGMTConfig::m_LFMergeRankPtQLUT=nullptr;
L1MuGMTLFOvlEtaConvLUT* L1MuGMTConfig::m_LFOvlEtaConvLUT=nullptr;
L1MuGMTLFPhiProEtaConvLUT* L1MuGMTConfig::m_LFPhiProEtaConvLUT=nullptr;
L1MuGMTLFPhiProLUT* L1MuGMTConfig::m_LFPhiProLUT=nullptr;
L1MuGMTLFPtMixLUT* L1MuGMTConfig::m_LFPtMixLUT=nullptr;
L1MuGMTLFSortRankCombineLUT* L1MuGMTConfig::m_LFSortRankCombineLUT=nullptr;
L1MuGMTLFSortRankEtaPhiLUT* L1MuGMTConfig::m_LFSortRankEtaPhiLUT=nullptr;
L1MuGMTLFSortRankEtaQLUT* L1MuGMTConfig::m_LFSortRankEtaQLUT=nullptr;
L1MuGMTLFSortRankPtQLUT* L1MuGMTConfig::m_LFSortRankPtQLUT=nullptr;
L1MuGMTMIAUEtaConvLUT* L1MuGMTConfig::m_MIAUEtaConvLUT=nullptr;
L1MuGMTMIAUEtaProLUT* L1MuGMTConfig::m_MIAUEtaProLUT=nullptr;
L1MuGMTMIAUPhiPro1LUT* L1MuGMTConfig::m_MIAUPhiPro1LUT=nullptr;
L1MuGMTMIAUPhiPro2LUT* L1MuGMTConfig::m_MIAUPhiPro2LUT=nullptr;
L1MuGMTPhiLUT* L1MuGMTConfig::m_PhiLUT=nullptr;

const L1MuGMTScales* L1MuGMTConfig::m_GMTScales=nullptr;
const L1MuTriggerScales* L1MuGMTConfig::m_TriggerScales=nullptr;
const L1MuTriggerPtScale* L1MuGMTConfig::m_TriggerPtScale=nullptr;
const L1MuGMTParameters* L1MuGMTConfig::m_GMTParams=nullptr;
const L1MuGMTChannelMask* L1MuGMTConfig::m_GMTChanMask=nullptr;

const L1CaloGeometry* L1MuGMTConfig::m_caloGeom = nullptr ;