OMTFConfiguration.cc

Go to the documentation of this file.

#include <iostream>
#include <algorithm>

#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/ParameterSet/interface/FileInPath.h"

#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/OMTFConfiguration.h"

RefHitDef::RefHitDef(unsigned int aInput, 
             int aPhiMin, int aPhiMax,
             unsigned int aRegion,
             unsigned int aRefLayer):
  iInput(aInput),
  iRegion(aRegion),
  iRefLayer(aRefLayer),
  range(std::pair<int,int>(aPhiMin,aPhiMax)){}
bool RefHitDef::fitsRange(int iPhi) const{

  return iPhi>=range.first && 
         iPhi<=range.second;

}
std::ostream & operator << (std::ostream &out, const  RefHitDef & aRefHitDef){


  out<<"iRefLayer: "<<aRefHitDef.iRefLayer
     <<" iInput: "<<aRefHitDef.iInput
     <<" iRegion: "<<aRefHitDef.iRegion
     <<" range: ("<<aRefHitDef.range.first
     <<", "<<aRefHitDef.range.second<<std::endl;

  return out;
}
void OMTFConfiguration::initCounterMatrices(){
  
  std::vector<int> aLayer1D(nInputs(),0);

  vector2D aLayer2D;
  aLayer2D.assign(nLayers(),aLayer1D);

  vector3D aLayer3D;
  aLayer3D.assign(nLogicRegions(),aLayer2D);

  measurements4D.assign(nProcessors(),aLayer3D);
  measurements4Dref.assign(nProcessors(),aLayer3D);
}
void OMTFConfiguration::configure(const L1TMuonOverlapParams *omtfParams){


  rawParams = *omtfParams;
 
  barrelMin.resize(nProcessors());
  endcap10DegMin.resize(nProcessors());
  endcap20DegMin.resize(nProcessors());

  barrelMax.resize(nProcessors());
  endcap10DegMax.resize(nProcessors());
  endcap20DegMax.resize(nProcessors());

  const std::vector<int> *connectedSectorsStartVec =  omtfParams->connectedSectorsStart();
  const std::vector<int> *connectedSectorsEndVec =  omtfParams->connectedSectorsEnd();

  std::copy(connectedSectorsStartVec->begin(), connectedSectorsStartVec->begin()+6, barrelMin.begin());  
  std::copy(connectedSectorsStartVec->begin()+6, connectedSectorsStartVec->begin()+12, endcap10DegMin.begin());
  std::copy(connectedSectorsStartVec->begin()+12, connectedSectorsStartVec->end(), endcap20DegMin.begin());

  std::copy(connectedSectorsEndVec->begin(), connectedSectorsEndVec->begin()+6, barrelMax.begin());
  std::copy(connectedSectorsEndVec->begin()+6, connectedSectorsEndVec->begin()+12, endcap10DegMax.begin());
  std::copy(connectedSectorsEndVec->begin()+12, connectedSectorsEndVec->end(), endcap20DegMax.begin());

  const std::vector<L1TMuonOverlapParams::LayerMapNode> *layerMap = omtfParams->layerMap();

  for(unsigned int iLayer=0;iLayer<nLayers();++iLayer){
    L1TMuonOverlapParams::LayerMapNode aNode = layerMap->at(iLayer);    
    hwToLogicLayer[aNode.hwNumber] = aNode.logicNumber;
    logicToHwLayer[aNode.logicNumber] = aNode.hwNumber;
    logicToLogic[aNode.logicNumber] = aNode.connectedToLayer;    
    if(aNode.bendingLayer) bendingLayers.insert(aNode.logicNumber);        
  }
  refToLogicNumber.resize(nRefLayers());
  
  const std::vector<L1TMuonOverlapParams::RefLayerMapNode> *refLayerMap = omtfParams->refLayerMap();
  for(unsigned int iRefLayer=0;iRefLayer<nRefLayers();++iRefLayer){
    L1TMuonOverlapParams::RefLayerMapNode aNode = refLayerMap->at(iRefLayer);    
    refToLogicNumber[aNode.refLayer] = aNode.logicNumber;
  }
  std::vector<int> vector1D(nRefLayers(),nPhiBins());
  processorPhiVsRefLayer.assign(nProcessors(),vector1D);

  vector1D_pair aLayer1D(nLayers());
  vector2D_pair aLayer2D;
  aLayer2D.assign(nLogicRegions(),aLayer1D);
  connections.assign(nProcessors(),aLayer2D);

  std::vector<std::pair<int,int> > aRefHit1D(nLogicRegions(),std::pair<int,int>(9999,9999));
  std::vector<std::vector<std::pair<int,int> > > aRefHit2D;
  aRefHit2D.assign(nRefLayers(),aRefHit1D);
  regionPhisVsRefLayerVsInput.assign(nInputs(),aRefHit2D);

  //Vector of ref hit definitions
  std::vector<RefHitDef> aRefHitsDefs(nRefHits());
  refHitsDefs.assign(nProcessors(),aRefHitsDefs);

  const std::vector<int> *phiStartMap =  omtfParams->globalPhiStartMap();
  const std::vector<L1TMuonOverlapParams::RefHitNode> *refHitMap = omtfParams->refHitMap();
  const std::vector<L1TMuonOverlapParams::LayerInputNode> *layerInputMap = omtfParams->layerInputMap();
  unsigned int tmpIndex = 0;  
  for(unsigned int iProcessor=0;iProcessor<nProcessors();++iProcessor){
    for(unsigned int iRefLayer=0;iRefLayer<nRefLayers();++iRefLayer){     
      int iPhiStart = phiStartMap->at(iRefLayer+iProcessor*nRefLayers());
      processorPhiVsRefLayer[iProcessor][iRefLayer] = iPhiStart;
    }
    for(unsigned int iRefHit=0;iRefHit<nRefHits();++iRefHit){
      int iPhiMin = refHitMap->at(iRefHit+iProcessor*nRefHits()).iPhiMin;
      int iPhiMax = refHitMap->at(iRefHit+iProcessor*nRefHits()).iPhiMax;
      unsigned int iInput = refHitMap->at(iRefHit+iProcessor*nRefHits()).iInput;
      unsigned int iRegion = refHitMap->at(iRefHit+iProcessor*nRefHits()).iRegion;
      unsigned int iRefLayer = refHitMap->at(iRefHit+iProcessor*nRefHits()).iRefLayer;
      regionPhisVsRefLayerVsInput[iInput][iRefLayer][iRegion] = std::pair<int,int>(iPhiMin,iPhiMax);
      refHitsDefs[iProcessor][iRefHit] = RefHitDef(iInput,iPhiMin,iPhiMax,iRegion,iRefLayer);
    }
    for(unsigned int iLogicRegion=0;iLogicRegion<nLogicRegions();++iLogicRegion){
      for(unsigned int iLayer=0;iLayer<nLayers();++iLayer){
    tmpIndex = iLayer+iLogicRegion*nLayers() + iProcessor*nLogicRegions()*nLayers();
    unsigned int iFirstInput = layerInputMap->at(tmpIndex).iFirstInput;
    unsigned int nInputsInRegion = layerInputMap->at(tmpIndex).nInputs;
    connections[iProcessor][iLogicRegion][iLayer] = std::pair<unsigned int, unsigned int>(iFirstInput,nInputsInRegion);
    if(iProcessor!=0) connections[iProcessor][iLogicRegion][iLayer] = connections[0][iLogicRegion][iLayer];
      }
    }  
  }

  initCounterMatrices();
  
}
std::ostream & operator << (std::ostream &out, const OMTFConfiguration & aConfig){


  out<<"nLayers(): "<<aConfig.nLayers()
     <<" nHitsPerLayer(): "<<aConfig.nHitsPerLayer()
     <<" nRefLayers(): "<<aConfig.nRefLayers()
     <<" nPdfAddrBits: "<<aConfig.nPdfAddrBits()
     <<" nPdfValBits: "<<aConfig.nPdfValBits()
     <<std::endl;

  for(unsigned int iProcessor = 0;iProcessor<aConfig.nProcessors(); ++iProcessor){
    out<<"Processor: "<<iProcessor;
    for(unsigned int iRefLayer=0;iRefLayer<aConfig.nRefLayers();++iRefLayer){
      out<<" "<<aConfig.processorPhiVsRefLayer[iProcessor][iRefLayer];
    }
    out<<std::endl;
  }
  
  return out;

}
bool OMTFConfiguration::isInRegionRange(int iPhiStart,
                unsigned int coneSize,
                int iPhi) const {

  if(iPhi<0) iPhi+=nPhiBins();
  if(iPhiStart<0) iPhiStart+=nPhiBins();

  if(iPhiStart+(int)coneSize<(int)nPhiBins()){
    return iPhiStart<=iPhi && iPhiStart+(int)coneSize>iPhi;
  }
  else if(iPhi>(int)nPhiBins()/2){
    return iPhiStart<=iPhi;
  }
  else if(iPhi<(int)nPhiBins()/2){
    return iPhi<iPhiStart+(int)coneSize-(int)nPhiBins();
  }
  return false;
}
unsigned int OMTFConfiguration::getRegionNumberFromMap(unsigned int iInput,
                               unsigned int iRefLayer,                             
                               int iPhi) const {

  for(unsigned int iRegion=0;iRegion<nLogicRegions();++iRegion){
    if(iPhi>=regionPhisVsRefLayerVsInput[iInput][iRefLayer][iRegion].first &&
       iPhi<=regionPhisVsRefLayerVsInput[iInput][iRefLayer][iRegion].second)
      return iRegion;
  }

  return 99;
}
int OMTFConfiguration::globalPhiStart(unsigned int iProcessor) const {

  return *std::min_element(processorPhiVsRefLayer[iProcessor].begin(),
               processorPhiVsRefLayer[iProcessor].end());

}
uint32_t OMTFConfiguration::getLayerNumber(uint32_t rawId) const {

  uint32_t aLayer = 0;
  
  DetId detId(rawId);
  if (detId.det() != DetId::Muon){
    std::cout << "PROBLEM: hit in unknown Det, detID: "<<detId.det()<<std::endl;
    return rawId;
  }

  switch (detId.subdetId()) {
  case MuonSubdetId::RPC: {
    RPCDetId aId(rawId);
    bool isBarrel = (aId.region()==0);
    if(isBarrel) aLayer = aId.station() <=2  ? 
           2*( aId.station()-1)+ aId.layer() 
           : aId.station()+2;
    else aLayer = aId.station(); 
    aLayer+= 10*(!isBarrel);
    break;
  }
  case MuonSubdetId::DT: {
    DTChamberId dt(rawId);
    aLayer = dt.station();
    break;
  }
  case MuonSubdetId::CSC: {
    CSCDetId csc(rawId);
    aLayer = csc.station();
    if(csc.ring()==2 && csc.station()==1) aLayer = 1811;//1811 = 2011 - 200, as we want to get 2011 for this chamber.
    if(csc.station()==4) aLayer = 4;
    break;
  }
  }  

  int hwNumber = aLayer+100*detId.subdetId();

  return hwNumber;
}