TTClusterAlgorithm_official< T > Class Template Reference

Class for "official" algorithm to be used in TTClusterBuilder. More...

#include <TTClusterAlgorithm_official.h>

Inheritance diagram for TTClusterAlgorithm_official< T >:

Public Member Functions
template<>
void	Cluster (std::vector< std::vector< Ref_Phase2TrackerDigi_ > > &output, const std::vector< Ref_Phase2TrackerDigi_ > &input, bool isPS) const
	Clustering operations. More...
void	Cluster (std::vector< std::vector< T > > &output, const std::vector< T > &input, bool isPS) const override
	Clustering operations. More...
template<>
void	Cluster (std::vector< std::vector< Ref_Phase2TrackerDigi_ > > &output, const std::vector< Ref_Phase2TrackerDigi_ > &input, bool isPS) const
	Clustering operations. More...
	TTClusterAlgorithm_official (int aWidthCut)
	Constructor. More...
	~TTClusterAlgorithm_official () override
	Destructor. More...
Public Member Functions inherited from TTClusterAlgorithm< T >
virtual std::string	AlgorithmName () const
	Algorithm name. More...
virtual void	Cluster (std::vector< std::vector< T > > &output, const std::vector< T > &input) const
	Basic version common to all the algorithms but official. More...
	TTClusterAlgorithm (std::string fName)
	Constructors. More...
virtual	~TTClusterAlgorithm ()
	Destructor. More...

Private Member Functions
template<>
bool	CompareClusters (const Ref_Phase2TrackerDigi_ &a, const Ref_Phase2TrackerDigi_ &b)
	Implementation of methods of TTClusterAlgorithm_official. More...
template<>
bool	CompareClusters (const Ref_Phase2TrackerDigi_ &a, const Ref_Phase2TrackerDigi_ &b)
	Close class. More...

Static Private Member Functions
static bool	CompareClusters (const T &a, const T &b)
	Cluster max width. More...

Private Attributes
int	mWidthCut
	Data members. More...

Additional Inherited Members
Protected Attributes inherited from TTClusterAlgorithm< T >
std::string	className_
	Data members. More...

Detailed Description

template<typename T>
class TTClusterAlgorithm_official< T >

Class for "official" algorithm to be used in TTClusterBuilder.

2D clusters: make 1D and then attach them to each other if their pixels are close to each other, CW cut at the end After moving from SimDataFormats to DataFormats, the template structure of the class was maintained in order to accomodate any types other than PixelDigis in case there is such a need in the future.

Author

Nicola Pozzobon

Date

2013, Jul 12

Definition at line 32 of file TTClusterAlgorithm_official.h.

Constructor & Destructor Documentation

template<typename T>

TTClusterAlgorithm_official< T >::TTClusterAlgorithm_official ( int  aWidthCut )

inline

Constructor.

Definition at line 43 of file TTClusterAlgorithm_official.h.

: TTClusterAlgorithm<T>(__func__) { mWidthCut = aWidthCut; }

template<typename T>

TTClusterAlgorithm_official< T >::~TTClusterAlgorithm_official ( )

inlineoverride

Destructor.

Definition at line 46 of file TTClusterAlgorithm_official.h.

References a, b, TTClusterAlgorithm_official< T >::Cluster(), TTClusterAlgorithm_official< T >::CompareClusters(), input, and convertSQLitetoXML_cfg::output.

{}

Member Function Documentation

template<>

void TTClusterAlgorithm_official< Ref_Phase2TrackerDigi_ >::Cluster	(	std::vector< std::vector< Ref_Phase2TrackerDigi_ > > &	output,
		const std::vector< Ref_Phase2TrackerDigi_ > &	input,
		bool	isPS
	)		const

Clustering operations.

Prepare the output

Prepare a proper hit container

Map all the hits by column index

1D Clusters must be stored properly <column, first row index>

Loop over the mapped hits

Collect hits sharing column index and differing by 1 in row index

Loop over single column

Nested loop

Check col/row and add to the cluster

End of nested loop

Sort the vector elements by row index

Put the cluster in the map

End of loop over single column

End of loop over mapped hits

Cluster over the second dimension only in PS modules!

Add the hits

Loop over the other elements of the map

Skip same element

Skip non-contiguous column

Column is contiguous Update the "last column index" This should be safe as maps are sorted structures by construction

Check that the cluster is good to be clustered Get first row

Get the max row in the cluster

Check if they overlap

If so, add the hits to the cluster!

End of nested loop

Check output Sort the vector by row index

one should add 1 to use <=

End of isPS

Check output Sort the vector by row index

one should add 1 to use <=

End of non-PS case

End of loop over mapped 1D Clusters

Definition at line 21 of file TTClusterAlgorithm_official.cc.

References funct::abs(), convertSQLitetoXML_cfg::output, and groupFilesInBlocks::temp.

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

template<typename T>

void TTClusterAlgorithm_official< T >::Cluster ( std::vector< std::vector< T > > &  output, const std::vector< T > &  input, bool  isPS  ) const

overridevirtual

Clustering operations.

Reimplemented from TTClusterAlgorithm< T >.

Referenced by TTClusterAlgorithm_official< T >::~TTClusterAlgorithm_official().

template<>

void TTClusterAlgorithm_official< Ref_Phase2TrackerDigi_ >::Cluster	(	std::vector< std::vector< Ref_Phase2TrackerDigi_ > > &	output,
		const std::vector< Ref_Phase2TrackerDigi_ > &	input,
		bool	isPS
	)		const

Clustering operations.

template<>

bool TTClusterAlgorithm_official< Ref_Phase2TrackerDigi_ >::CompareClusters ( const Ref_Phase2TrackerDigi_ &  a, const Ref_Phase2TrackerDigi_ &  b  )

private

Implementation of methods of TTClusterAlgorithm_official.

Here, in the source file, the methods which do depend on the specific type <T> that can fit the template.

Author

Nicola Pozzobon

Date

2013, Jul 12Function to compare clusters and sort them by row

Definition at line 14 of file TTClusterAlgorithm_official.cc.

                                                                                                           {
  return (a->row() < b->row());
}

template<typename T>

static bool TTClusterAlgorithm_official< T >::CompareClusters ( const T &  a, const T &  b  )

staticprivate

Cluster max width.

Function to compare clusters and sort them by row

Referenced by TTClusterAlgorithm_official< T >::~TTClusterAlgorithm_official().

template<>

bool TTClusterAlgorithm_official< Ref_Phase2TrackerDigi_ >::CompareClusters ( const Ref_Phase2TrackerDigi_ &  a, const Ref_Phase2TrackerDigi_ &  b  )

private

Close class.

Implementation of methods

Here, in the header file, the methods which do not depend on the specific type <T> that can fit the template. Other methods, with type-specific features, are implemented in the source file.Function to compare clusters and sort them by row

Member Data Documentation

template<typename T>

int TTClusterAlgorithm_official< T >::mWidthCut

private

Data members.

Definition at line 35 of file TTClusterAlgorithm_official.h.

Referenced by ES_TTClusterAlgorithm_official< T >::produce().