TTClusterAlgorithm_official.cc

Go to the documentation of this file.

 
#include "L1Trigger/TrackTrigger/interface/TTClusterAlgorithm_official.h"
 
template <>
bool TTClusterAlgorithm_official<Ref_Phase2TrackerDigi_>::CompareClusters(const Ref_Phase2TrackerDigi_& a,
                                                                          const Ref_Phase2TrackerDigi_& b) {
  return (a->row() < b->row());
}
 
template <>
void TTClusterAlgorithm_official<Ref_Phase2TrackerDigi_>::Cluster(
    std::vector<std::vector<Ref_Phase2TrackerDigi_> >& output,
    const std::vector<Ref_Phase2TrackerDigi_>& input,
    bool isPS) const {
  output.clear();
 
  std::map<unsigned int, std::vector<Ref_Phase2TrackerDigi_> > mapHitsByColumn;
 
  typename std::vector<Ref_Phase2TrackerDigi_>::const_iterator inputIterator;
  inputIterator = input.begin();
  while (inputIterator != input.end()) {
    mapHitsByColumn[(**inputIterator).column()].push_back(*inputIterator);
    ++inputIterator;
  }
 
  std::map<std::pair<unsigned int, unsigned int>, std::vector<Ref_Phase2TrackerDigi_> > map1DCluByColRow;
 
  typename std::map<unsigned int, std::vector<Ref_Phase2TrackerDigi_> >::iterator mapIterHbC;
  mapIterHbC = mapHitsByColumn.begin();
  while (mapIterHbC != mapHitsByColumn.end()) {
    typename std::vector<Ref_Phase2TrackerDigi_>::iterator inputIterator;
    inputIterator = mapIterHbC->second.begin();
 
    while (inputIterator != mapIterHbC->second.end()) {
      std::vector<Ref_Phase2TrackerDigi_> temp;
      temp.push_back(*inputIterator);
      inputIterator = mapIterHbC->second.erase(inputIterator);
      typename std::vector<Ref_Phase2TrackerDigi_>::iterator inputIterator2;
      inputIterator2 = inputIterator;
 
      while (inputIterator2 != mapIterHbC->second.end()) {
        if ((temp.back()->column() == (**inputIterator2).column()) &&
            ((**inputIterator2).row() - temp.back()->row() == 1)) {
          temp.push_back(*inputIterator2);
          inputIterator2 = mapIterHbC->second.erase(inputIterator2);
        } else
          break;
 
      }  
 
      std::sort(temp.begin(), temp.end(), CompareClusters);
 
      map1DCluByColRow.insert(std::make_pair(std::make_pair(mapIterHbC->first, temp.at(0)->row()), temp));
 
      inputIterator = inputIterator2;
 
    }  
    ++mapIterHbC;
 
  }  
 
  typename std::map<std::pair<unsigned int, unsigned int>, std::vector<Ref_Phase2TrackerDigi_> >::iterator
      mapIter1DCbCR0;
  typename std::map<std::pair<unsigned int, unsigned int>, std::vector<Ref_Phase2TrackerDigi_> >::iterator
      mapIter1DCbCR1;
  mapIter1DCbCR0 = map1DCluByColRow.begin();
  unsigned int lastCol = mapIter1DCbCR0->first.first;
 
  while (mapIter1DCbCR0 != map1DCluByColRow.end()) {
    std::vector<Ref_Phase2TrackerDigi_> candCluster;
    candCluster.insert(candCluster.end(), mapIter1DCbCR0->second.begin(), mapIter1DCbCR0->second.end());
 
    if (isPS) {
      mapIter1DCbCR1 = map1DCluByColRow.begin();
 
      while (mapIter1DCbCR1 != map1DCluByColRow.end()) {
        if (mapIter1DCbCR1 == mapIter1DCbCR0) {
          ++mapIter1DCbCR1;
          continue;
        }
 
        if (std::abs((int)(mapIter1DCbCR1->first.first) - (int)lastCol) != 1) {
          ++mapIter1DCbCR1;
          continue;
        }
 
        lastCol = mapIter1DCbCR1->first.first;
 
        unsigned int iRow0 = mapIter1DCbCR0->first.second;
        unsigned int iRow1 = mapIter1DCbCR1->first.second;
 
        unsigned int jRow0 = mapIter1DCbCR0->second.back()->row();
        unsigned int jRow1 = mapIter1DCbCR1->second.back()->row();
 
        if ((iRow1 >= iRow0 && iRow1 <= jRow0) || (jRow1 >= iRow0 && jRow1 <= jRow0)) {
          candCluster.insert(candCluster.end(), mapIter1DCbCR1->second.begin(), mapIter1DCbCR1->second.end());
          map1DCluByColRow.erase(mapIter1DCbCR1++);
        } else {
          ++mapIter1DCbCR1;
        }
      }  
 
      map1DCluByColRow.erase(mapIter1DCbCR0++);
 
      std::sort(candCluster.begin(), candCluster.end(), CompareClusters);
      /*
      std::cout << candCluster.at(0)->row() - candCluster.back()->row() << " / " 
        << static_cast<int>(candCluster.at(0)->row() - candCluster.back()->row()) << " / " 
        << abs( candCluster.at(0)->row() - candCluster.back()->row() ) << " / " 
        << std::abs( candCluster.at(0)->row() - candCluster.back()->row() ) << " / " 
        << mWidthCut << std::endl;
      */
      if (std::abs(static_cast<int>(candCluster.at(0)->row() - candCluster.back()->row())) <
              mWidthCut ||  
          mWidthCut < 1) {
        output.push_back(candCluster);
      }
    }  
    else {
      map1DCluByColRow.erase(mapIter1DCbCR0++);
 
      std::sort(candCluster.begin(), candCluster.end(), CompareClusters);
 
      if (std::abs(static_cast<int>(candCluster.at(0)->row() - candCluster.back()->row())) <
              mWidthCut ||  
          mWidthCut < 1) {
        output.push_back(candCluster);
      }
    }  
  }    
}