OMTFinputMaker.cc

Go to the documentation of this file.

#include <cmath>
#include <vector>
#include <iostream>
#include <algorithm>

#include "DataFormats/MuonDetId/interface/CSCDetId.h"
#include "DataFormats/MuonDetId/interface/RPCDetId.h"
#include "DataFormats/MuonDetId/interface/DTChamberId.h"
#include "DataFormats/MuonDetId/interface/MuonSubdetId.h"

#include "L1Trigger/L1TMuonOverlap/interface/OMTFinputMaker.h"
#include "L1Trigger/L1TMuonOverlap/interface/OMTFinput.h"
#include "L1Trigger/L1TMuonOverlap/interface/OMTFConfiguration.h"
#include "L1Trigger/L1TMuonOverlap/interface/AngleConverter.h"

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

OMTFinputMaker::OMTFinputMaker() {}
void OMTFinputMaker::initialize(const edm::EventSetup& es)
{ 
  myAngleConverter.checkAndUpdateGeometry(es);
}
OMTFinputMaker::~OMTFinputMaker(){ }
bool  OMTFinputMaker::acceptDigi(uint32_t rawId,
                 unsigned int iProcessor,
                 l1t::tftype type){

  unsigned int aMin = OMTFConfiguration::instance()->barrelMin[iProcessor];
  unsigned int aMax = OMTFConfiguration::instance()->barrelMax[iProcessor];
  unsigned int aSector = 99;

  DetId detId(rawId);
  if (detId.det() != DetId::Muon) 
    edm::LogError("Critical OMTFinputMaker") << "PROBLEM: hit in unknown Det, detID: "<<detId.det()<<std::endl;
  switch (detId.subdetId()) {
  case MuonSubdetId::RPC: {
    RPCDetId aId(rawId);
    
    if(type==l1t::tftype::omtf_pos &&
       (aId.region()<0 ||
       (aId.region()==0 && aId.ring()!=2) ||
       (aId.region()==0 && aId.station()==4) ||
       (aId.region()==0 && aId.station()==2 && aId.layer()==2 && aId.roll()==1) ||
       (aId.region()==0 && aId.station()==3 && aId.roll()==1) ||
       (aId.region()==1 && aId.station()==4) ||
       (aId.region()==1 && aId.station()>0 && aId.ring()<3))
       ) return false;

    if(type==l1t::tftype::omtf_neg &&
        (aId.region()>0 ||
    (aId.region()==0 && aId.ring()!=-2) ||
    (aId.region()==0 && aId.station()==4) ||
    (aId.region()==0 && aId.station()==2 && aId.layer()==2 && aId.roll()==1) ||
    (aId.region()==0 && aId.station()==3 && aId.roll()==1) ||
    (aId.region()==-1 && aId.station()==4) ||
     //RPC RE1/2 temporarily not used (aId.region()==1 && aId.station()==1 && aId.ring()<2) ||
    (aId.region()==-1 && aId.station()>0 && aId.ring()<3))
       ) return false;
    
    if(type==l1t::tftype::bmtf && aId.region()!=0) return false;
    
    if(type==l1t::tftype::emtf_pos &&
        (aId.region()<=0 ||
    (aId.station()==1 && aId.ring()==3))) return false;
    if(type==l1t::tftype::emtf_neg &&
        (aId.region()>=0 ||
    (aId.station()==1 && aId.ring()==3))) return false;
    if(aId.region()==0) aSector = aId.sector();
    if(aId.region()!=0){
      aSector = (aId.sector()-1)*6+aId.subsector();
      aMin = OMTFConfiguration::instance()->endcap10DegMin[iProcessor];
      aMax = OMTFConfiguration::instance()->endcap10DegMax[iProcessor];
    }
   
    break;
  }
  case MuonSubdetId::DT: {
    DTChamberId dt(rawId);

    if(type==l1t::tftype::omtf_pos && dt.wheel()!=2) return false;
    if(type==l1t::tftype::omtf_neg && dt.wheel()!=-2) return false;
    if(type==l1t::tftype::emtf_pos || type==l1t::tftype::emtf_neg) return false;
    
    aSector =  dt.sector();     
    break;
  }
  case MuonSubdetId::CSC: {

    CSCDetId csc(rawId);    
    if(type==l1t::tftype::omtf_pos &&
       (csc.endcap()==2 || csc.ring()==1 || csc.station()==4)) return false;
    if(type==l1t::tftype::omtf_neg &&
       (csc.endcap()==1 || csc.ring()==1 || csc.station()==4)) return false;

    if(type==l1t::tftype::emtf_pos &&
       (csc.endcap()==2 || (csc.station()==1 && csc.ring()==3))
       ) return false;
    if(type==l1t::tftype::emtf_neg &&
       (csc.endcap()==1 || (csc.station()==1 && csc.ring()==3))
       ) return false;

    aSector =  csc.chamber();       

    aMin = OMTFConfiguration::instance()->endcap10DegMin[iProcessor];
    aMax = OMTFConfiguration::instance()->endcap10DegMax[iProcessor];

    if( (type==l1t::tftype::emtf_pos || type==l1t::tftype::emtf_neg) &&
    csc.station()>1 && csc.ring()==1){
      aMin = OMTFConfiguration::instance()->endcap20DegMin[iProcessor];
      aMax = OMTFConfiguration::instance()->endcap20DegMax[iProcessor];
    }
    break;
  }    
  }
  
  if(aMax>aMin && aSector>=aMin && aSector<=aMax) return true;
  if(aMax<aMin && (aSector>=aMin || aSector<=aMax)) return true;

  return false;
}
unsigned int OMTFinputMaker::getInputNumber(unsigned int rawId, 
                        unsigned int iProcessor,
                        l1t::tftype type){

  unsigned int iInput = 99;
  unsigned int aSector = 99;
  int aMin = OMTFConfiguration::instance()->barrelMin[iProcessor];
  int iRoll = 1;
  int nInputsPerSector = 2;

  DetId detId(rawId);
  if (detId.det() != DetId::Muon) edm::LogError("Critical OMTFinputMaker") << "PROBLEM: hit in unknown Det, detID: "<<detId.det()<<std::endl;
  switch (detId.subdetId()) {
  case MuonSubdetId::RPC: {
    RPCDetId rpc(rawId);
    if(rpc.region()==0){
      nInputsPerSector = 4;
      aSector = rpc.sector();
      if(iProcessor==5 && aSector<3) aMin = -1;
      //Use division into rolls
      iRoll = rpc.roll();
      if(rpc.station()==2 && rpc.layer()==2 && rpc.roll()==2) iRoll = 1;
      if(rpc.station()==3){
    iRoll = 1;
    nInputsPerSector = 2;
      }
      if(type==l1t::tftype::bmtf)iRoll = 1;
    }
    if(rpc.region()!=0){
      aSector = (rpc.sector()-1)*6+rpc.subsector();
      aMin = OMTFConfiguration::instance()->endcap10DegMin[iProcessor];
      if(iProcessor==5 && aSector<5) aMin = -4;
    }    
    break;
  }
  case MuonSubdetId::DT: {
    DTChamberId dt(rawId);
    aSector = dt.sector();    
    if(iProcessor==5 && aSector<3) aMin = -1;
    break;
  }
  case MuonSubdetId::CSC: {   
    CSCDetId csc(rawId);    
    aSector = csc.chamber();    
    aMin = OMTFConfiguration::instance()->endcap10DegMin[iProcessor];       
    if(iProcessor==5 && aSector<5) aMin = -4;
    if( (type==l1t::tftype::emtf_pos || type==l1t::tftype::emtf_neg) &&
    csc.station()>1 && csc.ring()==1){
      aMin = OMTFConfiguration::instance()->endcap20DegMin[iProcessor];
      if(iProcessor==5 && aSector<3) aMin = -2;
    }
    break;
  }
  }

  iInput = (aSector - aMin)*nInputsPerSector;
  iInput+=iRoll-1;
  
  return iInput;
}
OMTFinput OMTFinputMaker::processDT(const L1MuDTChambPhContainer *dtPhDigis,
           const L1MuDTChambThContainer *dtThDigis,
           unsigned int iProcessor,
           l1t::tftype type)
{

  OMTFinput result;
  if(!dtPhDigis) return result;
  
  for (const auto digiIt: *dtPhDigis->getContainer()) {

    DTChamberId detid(digiIt.whNum(),digiIt.stNum(),digiIt.scNum()+1);

    if(!acceptDigi(detid.rawId(), iProcessor, type)) continue;
    
    // FIXME (MK): at least Ts2Tag selection is not correct! Check it
    if (digiIt.bxNum()!= 0 || digiIt.BxCnt()!= 0 || digiIt.Ts2Tag()!= 0 || digiIt.code()<4) continue;

    unsigned int hwNumber = OMTFConfiguration::instance()->getLayerNumber(detid.rawId());
    if(OMTFConfiguration::instance()->hwToLogicLayer.find(hwNumber)==OMTFConfiguration::instance()->hwToLogicLayer.end()) continue;
    
    //unsigned int iLayer = OMTFConfiguration::instance()->hwToLogicLayer[hwNumber];
    auto iter = OMTFConfiguration::instance()->hwToLogicLayer.find(hwNumber);
    unsigned int iLayer = iter->second;

    int iPhi =  myAngleConverter.getProcessorPhi(iProcessor, type, digiIt);
    int iEta =  myAngleConverter.getGlobalEta(detid.rawId(), digiIt, dtThDigis);
    unsigned int iInput= getInputNumber(detid.rawId(), iProcessor, type);    
    result.addLayerHit(iLayer,iInput,iPhi,iEta);
    result.addLayerHit(iLayer+1,iInput,digiIt.phiB(),iEta);    
  }

  return result;
  
}
OMTFinput OMTFinputMaker::processCSC(const CSCCorrelatedLCTDigiCollection *cscDigis,
           unsigned int iProcessor,
           l1t::tftype type){

  OMTFinput result;
  if(!cscDigis) return result;

  auto chamber = cscDigis->begin();
  auto chend  = cscDigis->end();
  for( ; chamber != chend; ++chamber ) {

    unsigned int rawid = (*chamber).first;
    if(!acceptDigi(rawid, iProcessor, type)) continue;
    auto digi = (*chamber).second.first;
    auto dend = (*chamber).second.second;    
    for( ; digi != dend; ++digi ) {

      if (abs(digi->getBX()- 6)>0) continue;
      
      unsigned int hwNumber = OMTFConfiguration::instance()->getLayerNumber(rawid);
      if(OMTFConfiguration::instance()->hwToLogicLayer.find(hwNumber)==OMTFConfiguration::instance()->hwToLogicLayer.end()) continue;


      //unsigned int iLayer = OMTFConfiguration::instance()->hwToLogicLayer[hwNumber];      
      auto iter = OMTFConfiguration::instance()->hwToLogicLayer.find(hwNumber);
      unsigned int iLayer = iter->second;

      int iPhi = myAngleConverter.getProcessorPhi(iProcessor, type, CSCDetId(rawid), *digi);
      int iEta = myAngleConverter.getGlobalEta(rawid, *digi);
      if(abs(iEta)>1.26/2.61*240) continue;
      unsigned int iInput= getInputNumber(rawid, iProcessor, type);      
      result.addLayerHit(iLayer,iInput,iPhi,iEta);     
    }
  }      
  return result;
}
bool rpcPrimitiveCmp(const  RPCDigi &a, const  RPCDigi &b) { return a.strip() < b.strip(); };
OMTFinput OMTFinputMaker::processRPC(const RPCDigiCollection *rpcDigis,
                unsigned int iProcessor,
                l1t::tftype type){

  OMTFinput result; 
  if(!rpcDigis) return result;
  std::stringstream str;

  const RPCDigiCollection & rpcDigiCollection = *rpcDigis;
  for (auto rollDigis : rpcDigiCollection) {
    RPCDetId roll = rollDigis.first;    
    unsigned int rawid = roll.rawId();
    if(!acceptDigi(rawid, iProcessor, type)) continue;    
    std::vector<RPCDigi> digisCopy;
    std::copy_if(rollDigis.second.first, rollDigis.second.second, std::back_inserter(digisCopy), [](const RPCDigi & aDigi){return (aDigi.bx()==0);});
    std::sort(digisCopy.begin(),digisCopy.end(),rpcPrimitiveCmp);
    typedef std::pair<unsigned int, unsigned int> Cluster;
    std::vector<Cluster> clusters;
    for(auto & digi: digisCopy) {
      if(clusters.empty()) clusters.push_back(Cluster(digi.strip(),digi.strip()));
      else if (digi.strip() - clusters.back().second == 1) clusters.back().second = digi.strip();
      else if (digi.strip() - clusters.back().second  > 1) clusters.push_back(Cluster(digi.strip(),digi.strip()));
    }

    for (auto & cluster: clusters) {
      int iPhiHalfStrip1 = myAngleConverter.getProcessorPhi(iProcessor, type, roll, cluster.first);
      int iPhiHalfStrip2 = myAngleConverter.getProcessorPhi(iProcessor, type, roll, cluster.second);
      int iPhi = (iPhiHalfStrip1+iPhiHalfStrip2)/2;
      int iEta =  myAngleConverter.getGlobalEta(rawid, cluster.first);      
      unsigned int hwNumber = OMTFConfiguration::instance()->getLayerNumber(rawid);
      //unsigned int iLayer = OMTFConfiguration::instance()->hwToLogicLayer[hwNumber];
      auto iter = OMTFConfiguration::instance()->hwToLogicLayer.find(hwNumber);
      unsigned int iLayer = iter->second;

      unsigned int iInput= getInputNumber(rawid, iProcessor, type);
      result.addLayerHit(iLayer,iInput,iPhi,iEta);

      str<<" RPC halfDigi "
           <<" begin: "<<cluster.first<<" end: "<<cluster.second
           <<" iPhi: "<<iPhi
           <<" iEta: "<<iEta
           <<" hwNumber: "<<hwNumber
           <<" iInput: "<<iInput
           <<" iLayer: "<<iLayer
           <<std::endl;      
    }
  }

  edm::LogInfo("OMTFInputMaker")<<str.str();
  return result;
}
OMTFinput OMTFinputMaker::buildInputForProcessor(const L1MuDTChambPhContainer *dtPhDigis,
                             const L1MuDTChambThContainer *dtThDigis,
                             const CSCCorrelatedLCTDigiCollection *cscDigis,
                             const RPCDigiCollection *rpcDigis,
                             unsigned int iProcessor,
                             l1t::tftype type){
  
  OMTFinput result;
  result += processDT(dtPhDigis, dtThDigis, iProcessor, type);
  result += processCSC(cscDigis, iProcessor, type);
  result += processRPC(rpcDigis, iProcessor, type);
  return result;
}