#include <DivisiveClusterizer1D.h>

Inheritance diagram for DivisiveClusterizer1D< T >:

Public Member Functions
virtual DivisiveClusterizer1D *	clone () const

	DivisiveClusterizer1D (float zoffset=5., int ntkmin=5, bool useError=true, float zsep=0.05, bool wei=true)

std::pair< std::vector< Cluster1D< T > >, std::vector< const T * > >	operator() (const std::vector< Cluster1D< T > > &) const

	~DivisiveClusterizer1D ()

Public Member Functions inherited from Clusterizer1D< T >
virtual	~Clusterizer1D ()

Private Member Functions
void	findCandidates (const std::vector< Cluster1D< T > > &, std::vector< Cluster1D< T > > &, std::vector< Cluster1D< T > > &) const

void	insertTracks (std::vector< Cluster1D< T > > &, std::vector< Cluster1D< T > > &) const

std::vector< Cluster1D< T > >	makeCluster1Ds (std::vector< Cluster1D< T > > &, std::vector< Cluster1D< T > > &) const

Cluster1D< T >	mergeCluster1Ds (std::vector< Cluster1D< T > > &) const

std::vector< const T * >	takeTracks (const std::vector< Cluster1D< T > > &) const

Private Attributes
Cluster1DCleaner< T > *	theCleaner

Cluster1DMerger< T > *	theMerger

unsigned	theNTkMin

bool	theUseError

bool	theWei

float	theZOffSet

float	theZSeparation

Detailed Description

template<class T>
class DivisiveClusterizer1D< T >

Find the modes with a simple divisive method.

Definition at line 14 of file DivisiveClusterizer1D.h.

Constructor & Destructor Documentation

◆ DivisiveClusterizer1D()

template<class T >

DivisiveClusterizer1D< T >::DivisiveClusterizer1D	(	float	zoffset = `5.`,
		int	ntkmin = `5`,
		bool	useError = `true`,
		float	zsep = `0.05`,
		bool	wei = `true`
	)

Parameters

zoffset	maximum distance between track position and position of its cluster (depending on useError its either weighted or physical distance)
ntkmin	Minimum number of tracks required to form a cluster.
useError	physical distances or weighted distances.
zsep	Maximum distance between two adjacent tracks that belong to the same initial cluster.
wei	Compute the cluster "center" with an unweighted or a weighted average of the tracks. Weighted means weighted with the error of the data point.

Definition at line 62 of file DivisiveClusterizer1D.h.

References DivisiveClusterizer1D< T >::theCleaner, DivisiveClusterizer1D< T >::theMerger, DivisiveClusterizer1D< T >::theUseError, and DivisiveClusterizer1D< T >::theZOffSet.

     : theZOffSet(zoffset), theZSeparation(zsep), theNTkMin(ntkmin), theWei(wei), theUseError(useError) {
   //  theDiscardedTracks.clear();
   // theTotalDiscardedTracks.clear();
   //  theCluster1Ds.clear();
   TrivialWeightEstimator<T> weightEstimator;
   theMerger = new Cluster1DMerger<T>(weightEstimator);
   theCleaner = new Cluster1DCleaner<T>(theZOffSet, theUseError);
 }

◆ ~DivisiveClusterizer1D()

template<class T >

DivisiveClusterizer1D< T >::~DivisiveClusterizer1D ( )

Definition at line 73 of file DivisiveClusterizer1D.h.

                                                  {
   delete theMerger;
   delete theCleaner;
 }

Member Function Documentation

◆ clone()

template<class T >

DivisiveClusterizer1D< T > * DivisiveClusterizer1D< T >::clone ( void ) const

virtual

Implements Clusterizer1D< T >.

Definition at line 88 of file DivisiveClusterizer1D.h.

                                                                 {
   return new DivisiveClusterizer1D<T>(*this);
 }

◆ findCandidates()

template<class T >

void DivisiveClusterizer1D< T >::findCandidates	(	const std::vector< Cluster1D< T > > &	inputo,
		std::vector< Cluster1D< T > > &	finalCluster1Ds,
		std::vector< Cluster1D< T > > &	totDiscardedTracks
	)		const

private

Definition at line 93 of file DivisiveClusterizer1D.h.

References bsc_activity_cfg::clusters, input, jetUpdater_cfi::sort, and trackerHitRTTI::vector.

                                                                                                   {
   using namespace Clusterizer1DCommons;
 
   std::vector<Cluster1D<T> > input = inputo;
   std::vector<Cluster1D<T> > discardedTracks;
   if (input.size() < theNTkMin) {
     insertTracks(input, totDiscardedTracks);
     return;
   }
   sort(input.begin(), input.end(), ComparePairs<T>());
   int ncount = 0;
   std::vector<Cluster1D<T> > partOfPTracks;
   partOfPTracks.push_back(input.front());
   for (typename std::vector<Cluster1D<T> >::const_iterator ic = (input.begin()) + 1; ic != input.end(); ic++) {
     ncount++;
     if (fabs((*ic).position().value() - (*(ic - 1)).position().value()) < (double)theZSeparation) {
       partOfPTracks.push_back((*ic));
     } else {
       if (partOfPTracks.size() >= theNTkMin) {
         std::vector<Cluster1D<T> > clusters = makeCluster1Ds(partOfPTracks, discardedTracks);
         for (typename std::vector<Cluster1D<T> >::const_iterator iclus = clusters.begin(); iclus != clusters.end();
              iclus++) {
           finalCluster1Ds.push_back(*iclus);
         }
         insertTracks(discardedTracks, totDiscardedTracks);
       } else {
         insertTracks(partOfPTracks, totDiscardedTracks);
       }
       partOfPTracks.clear();
       partOfPTracks.push_back((*ic));
     }
   }
   if (partOfPTracks.size() >= theNTkMin) {
     std::vector<Cluster1D<T> > clusters = makeCluster1Ds(partOfPTracks, discardedTracks);
     for (typename std::vector<Cluster1D<T> >::const_iterator iclus = clusters.begin(); iclus != clusters.end();
          iclus++) {
       finalCluster1Ds.push_back(*iclus);
     }
     insertTracks(discardedTracks, totDiscardedTracks);
   } else {
     insertTracks(partOfPTracks, totDiscardedTracks);
   }
 
   sort(finalCluster1Ds.begin(), finalCluster1Ds.end(), ComparePairs<T>());
   // reverse(theCluster1Ds.begin(), theCluster1Ds.end());
 
   return;
 }

◆ insertTracks()

template<class T >

void DivisiveClusterizer1D< T >::insertTracks	(	std::vector< Cluster1D< T > > &	clusou,
		std::vector< Cluster1D< T > > &	cludest
	)		const

private

Definition at line 184 of file DivisiveClusterizer1D.h.

References trackerHitRTTI::vector.

                                                                                      {
   if (clusou.empty())
     return;
   for (typename std::vector<Cluster1D<T> >::const_iterator iclu = clusou.begin(); iclu != clusou.end(); iclu++) {
     cludest.push_back(*iclu);
   }
   /*
     for ( typename std::vector< Cluster1D<T> >::const_iterator iclu = clu.begin(); 
     iclu != clu.end(); iclu++){
       if (total) {
         theTotalDiscardedTracks.push_back(*iclu);
       }else { 
         theDiscardedTracks.push_back(*iclu);
       }
     }
     */
   return;
 }

◆ makeCluster1Ds()

template<class T >

std::vector< Cluster1D< T > > DivisiveClusterizer1D< T >::makeCluster1Ds	(	std::vector< Cluster1D< T > > &	clusters,
		std::vector< Cluster1D< T > > &	discardedTracks
	)		const

private

Definition at line 145 of file DivisiveClusterizer1D.h.

References bsc_activity_cfg::clusters.

                                                                                                                      {
   std::vector<Cluster1D<T> > finalCluster1Ds;
   discardedTracks.clear();
   std::vector<Cluster1D<T> > pvClu0 = clusters;
   std::vector<Cluster1D<T> > pvCluNew = pvClu0;
   bool stop = false;
   while (!stop) {
     int nDiscardedAtIteration = 100;
     while (nDiscardedAtIteration != 0) {
       pvCluNew = theCleaner->clusters(pvClu0);
       std::vector<Cluster1D<T> > tracksAtIteration = theCleaner->discardedCluster1Ds();
       nDiscardedAtIteration = tracksAtIteration.size();
       if (nDiscardedAtIteration != 0) {
         insertTracks(tracksAtIteration, discardedTracks);
         pvClu0 = pvCluNew;
       }
     }  // while nDiscardedAtIteration
     unsigned ntkclus = pvCluNew.size();
     unsigned ndiscard = discardedTracks.size();
 
     if (ntkclus >= theNTkMin) {
       //save the cluster
       finalCluster1Ds.push_back(mergeCluster1Ds(pvCluNew));
       if (ndiscard >= theNTkMin) {  //make a new cluster and reset
         pvClu0 = discardedTracks;
         discardedTracks.clear();
       } else {  //out of loop
         stop = true;
       }
     } else {
       insertTracks(pvCluNew, discardedTracks);
       stop = true;
     }
   }  // while stop
   return finalCluster1Ds;
 }

◆ mergeCluster1Ds()

template<class T >

Cluster1D< T > DivisiveClusterizer1D< T >::mergeCluster1Ds ( std::vector< Cluster1D< T > > & clusters ) const

private

Definition at line 217 of file DivisiveClusterizer1D.h.

References bsc_activity_cfg::clusters, mps_fire::result, and trackerHitRTTI::vector.

                                                                                                {
   Cluster1D<T> result = clusters.front();
   for (typename std::vector<Cluster1D<T> >::iterator iclu = (clusters.begin()) + 1; iclu != clusters.end(); iclu++) {
     Cluster1D<T> old = result;
     result = (*theMerger)(old, *iclu);
   }
   return result;
 }

◆ operator()()

template<class T >

std::pair< std::vector< Cluster1D< T > >, std::vector< const T * > > DivisiveClusterizer1D< T >::operator() ( const std::vector< Cluster1D< T > > & input ) const

virtual

Implements Clusterizer1D< T >.

Definition at line 79 of file DivisiveClusterizer1D.h.

References input, and convertSQLitetoXML_cfg::output.

                                                  {
   std::vector<Cluster1D<T> > discardedCluster1Ds;
   std::vector<Cluster1D<T> > output;
   findCandidates(input, output, discardedCluster1Ds);
   return std::pair<std::vector<Cluster1D<T> >, std::vector<const T*> >(output, takeTracks(discardedCluster1Ds));
 }

◆ takeTracks()

template<class T >

std::vector< const T * > DivisiveClusterizer1D< T >::takeTracks ( const std::vector< Cluster1D< T > > & clu ) const

private

Definition at line 205 of file DivisiveClusterizer1D.h.

References mps_fire::i, tracks, and trackerHitRTTI::vector.

                                                                                                   {
   std::vector<const T*> tracks;
   for (typename std::vector<Cluster1D<T> >::const_iterator iclu = clu.begin(); iclu != clu.end(); iclu++) {
     std::vector<const T*> clutks = iclu->tracks();
     for (typename std::vector<const T*>::const_iterator i = clutks.begin(); i != clutks.end(); ++i) {
       tracks.push_back(*i);
     }
   }
   return tracks;
 }