#include <DivisiveClusterizer1D.h>

Inheritance diagram for pixeltemp::DivisiveClusterizer1D< T >:

Public Member Functions
DivisiveClusterizer1D *	clone () const override

	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 override

void	setBeamSpot (const math::XYZPoint &bs)

	~DivisiveClusterizer1D () override

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
pixeltemp::Cluster1DCleaner< T > *	theCleaner

pixeltemp::Cluster1DMerger< T > *	theMerger

unsigned int	theNTkMin

bool	theUseError

bool	theWei

float	theZOffSet

float	theZSeparation

Detailed Description

template<class T>
class pixeltemp::DivisiveClusterizer1D< T >

Definition at line 19 of file DivisiveClusterizer1D.h.

Constructor & Destructor Documentation

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 70 of file DivisiveClusterizer1D.h.

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

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

template<class T >

DivisiveClusterizer1D< T >::~DivisiveClusterizer1D ( )

override

Definition at line 81 of file DivisiveClusterizer1D.h.

References pixeltemp::DivisiveClusterizer1D< T >::theCleaner, and pixeltemp::DivisiveClusterizer1D< T >::theMerger.

                                                    {
     delete theMerger;
     delete theCleaner;
   }

Member Function Documentation

template<class T >

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

overridevirtual

Implements Clusterizer1D< T >.

Definition at line 96 of file DivisiveClusterizer1D.h.

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

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 101 of file DivisiveClusterizer1D.h.

References bsc_activity_cfg::clusters, input, pixeltemp::DivisiveClusterizer1D< T >::insertTracks(), createfilelist::int, pixeltemp::DivisiveClusterizer1D< T >::makeCluster1Ds(), pixeltemp::DivisiveClusterizer1D< T >::theNTkMin, and pixeltemp::DivisiveClusterizer1D< T >::theZSeparation.

Referenced by pixeltemp::DivisiveClusterizer1D< T >::operator()(), and pixeltemp::DivisiveClusterizer1D< reco::Track >::setBeamSpot().

                                                                                                     {
     using namespace Clusterizer1DCommons;
 
     std::vector<Cluster1D<T> > input = inputo;
     std::vector<Cluster1D<T> > discardedTracks;
     if (input.size() < (unsigned int)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() >= (unsigned int)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() >= (unsigned int)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;
   }

template<class T>

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

private

Definition at line 192 of file DivisiveClusterizer1D.h.

Referenced by pixeltemp::DivisiveClusterizer1D< T >::findCandidates(), pixeltemp::DivisiveClusterizer1D< T >::makeCluster1Ds(), and pixeltemp::DivisiveClusterizer1D< reco::Track >::setBeamSpot().

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

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 153 of file DivisiveClusterizer1D.h.

References bsc_activity_cfg::clusters, pixeltemp::DivisiveClusterizer1D< T >::insertTracks(), pixeltemp::DivisiveClusterizer1D< T >::mergeCluster1Ds(), pixeltemp::DivisiveClusterizer1D< T >::theCleaner, and pixeltemp::DivisiveClusterizer1D< T >::theNTkMin.

Referenced by pixeltemp::DivisiveClusterizer1D< T >::findCandidates(), and pixeltemp::DivisiveClusterizer1D< reco::Track >::setBeamSpot().

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

template<class T>

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

private

Definition at line 225 of file DivisiveClusterizer1D.h.

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

Referenced by pixeltemp::DivisiveClusterizer1D< T >::makeCluster1Ds(), and pixeltemp::DivisiveClusterizer1D< reco::Track >::setBeamSpot().

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

template<class T>

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

overridevirtual

Implements Clusterizer1D< T >.

Definition at line 87 of file DivisiveClusterizer1D.h.

References pixeltemp::DivisiveClusterizer1D< T >::findCandidates(), input, convertSQLitetoXML_cfg::output, and pixeltemp::DivisiveClusterizer1D< T >::takeTracks().

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

template<class T>

void pixeltemp::DivisiveClusterizer1D< T >::setBeamSpot ( const math::XYZPoint & bs )

inline

Definition at line 40 of file DivisiveClusterizer1D.h.

Referenced by DivisiveVertexFinder::findVertexesAlt().

40 { theMerger->setBeamSpot(bs); }

pixeltemp::DivisiveClusterizer1D::theMerger

pixeltemp::Cluster1DMerger< T > * theMerger

Definition: DivisiveClusterizer1D.h:55

template<class T>

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

private

Definition at line 213 of file DivisiveClusterizer1D.h.

References mps_fire::i, and PDWG_EXOHSCP_cff::tracks.

Referenced by pixeltemp::DivisiveClusterizer1D< T >::operator()(), and pixeltemp::DivisiveClusterizer1D< reco::Track >::setBeamSpot().

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