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 );
      }
    } 
  } 
}