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 "CondFormats/L1TObjects/interface/L1TMuonOverlapParams.h"

#include "L1Trigger/L1TMuonOverlap/interface/OMTFConfiguration.h"
#include "L1Trigger/L1TMuonOverlap/interface/XMLConfigReader.h"

OMTFConfiguration * OMTFConfiguration::latest_instance_ = NULL;

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;
}
OMTFConfiguration::OMTFConfiguration(const edm::ParameterSet & theConfig){
  latest_instance_ = this;

  if(theConfig.getParameter<bool>("configFromXML")){  
    if (!theConfig.exists("configXMLFile") ) return;
    std::string fName = theConfig.getParameter<edm::FileInPath>("configXMLFile").fullPath();

    XMLConfigReader myReader(this);
    myReader.setConfigFile(fName);
    configure(&myReader);
  }
}
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(XMLConfigReader *aReader){

 aReader->readConfig(this);
 initCounterMatrices();

}
void OMTFConfiguration::configure(const L1TMuonOverlapParams *omtfParams){

  minPdfVal = 0.001;
  fwVersion = omtfParams->fwVersion();  
  nPdfAddrBits = omtfParams->nPdfAddrBits();  
  nPdfValBits = omtfParams->nPdfValBits();
  nHitsPerLayer = omtfParams->nHitsPerLayer();
  nPhiBits = omtfParams->nPhiBits();
  nPhiBins = omtfParams->nPhiBins();
  nRefHits = omtfParams->nRefHits();
  nTestRefHits = omtfParams->nTestRefHits();
  nProcessors = omtfParams->nProcessors();
  nLogicRegions = omtfParams->nLogicRegions();
  nInputs = omtfParams->nInputs();
  nLayers = omtfParams->nLayers();
  nRefLayers = omtfParams->nRefLayers();
  nGoldenPatterns = omtfParams->nGoldenPatterns();

  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_A aLayer1D(nLayers);
  vector2D_A 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 nInputs = layerInputMap->at(tmpIndex).nInputs;
    connections[iProcessor][iLogicRegion][iLayer] = std::pair<unsigned int, unsigned int>(iFirstInput,nInputs);
    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;
}