PFMatch::TrackClusterMatcher Class Reference

Checks if a cluster should be matched to a track or not, and has methods to return list of best matches. More...

#include <PFMatcher.h>

Collaboration diagram for PFMatch::TrackClusterMatcher:

Public Member Functions
	TrackClusterMatcher (std::unique_ptr< IDistanceProvider > distanceProvider, double matchCut)
virtual	~TrackClusterMatcher ()
MatchDistance	match (ITrack *track, ICluster *cluster) const
template<class ClusterType >
MatchDistance	bestMatchDRparametrized (ITrack *track, const std::vector< ClusterType * > &clusters) const
template<class ClusterType >
std::vector< MatchDistance >	bestMatches (ITrack *track, std::vector< ClusterType * > &clusters, int nMatches, double energyThreshold) const
template<class ClusterType >
double	getDRCutSquared (ClusterType *theCluster) const

Private Member Functions
void	setDRParameters ()
	This sets the parameters in the above array. More...

Private Attributes
std::unique_ptr< IDistanceProvider >	m_distanceProvider
double	m_matchCut
float	m_drcut_par [9][3]
	This stores the parameters to vary DR cut with Pt. More...

Detailed Description

Checks if a cluster should be matched to a track or not, and has methods to return list of best matches.

Definition at line 29 of file PFMatcher.h.

Constructor & Destructor Documentation

TrackClusterMatcher()

PFMatch::TrackClusterMatcher::TrackClusterMatcher ( std::unique_ptr< IDistanceProvider >  distanceProvider, double  matchCut  )

inline

Definition at line 31 of file PFMatcher.h.

                                                                                          :
    m_distanceProvider(std::move(distanceProvider)), m_matchCut(matchCut) { setDRParameters(); }

~TrackClusterMatcher()

virtual PFMatch::TrackClusterMatcher::~TrackClusterMatcher ( )

inlinevirtual

Definition at line 34 of file PFMatcher.h.

{};

Member Function Documentation

bestMatchDRparametrized()

template<class ClusterType >

MatchDistance PFMatch::TrackClusterMatcher::bestMatchDRparametrized	(	ITrack *	track,
		const std::vector< ClusterType * > &	clusters
	)		const

Definition at line 64 of file PFMatcher.h.

                                                                                                                          {
   ClusterType* bestCluster = nullptr;
   double bestDistance(m_matchCut);
   unsigned int nClusters(clusters.size());
   for (unsigned int iCluster = 0; iCluster < nClusters; ++iCluster){
 
     ClusterType* thisCluster = clusters[iCluster];
     double thisDistance(m_distanceProvider->distanceBetween(track, clusters[iCluster]));
     double  mybestdistance = getDRCutSquared(thisCluster);
 
     if (thisDistance < mybestdistance){
       if (thisDistance < bestDistance) {
     bestDistance = thisDistance;
     bestCluster  = thisCluster;
       }
     }
   }
 
   return MatchDistance(bestCluster, bestDistance);
 }

bestMatches()

template<class ClusterType >

std::vector< MatchDistance > PFMatch::TrackClusterMatcher::bestMatches	(	ITrack *	track,
		std::vector< ClusterType * > &	clusters,
		int	nMatches,
		double	energyThreshold
	)		const

Definition at line 86 of file PFMatcher.h.

                                                                                                                                                      {
 
  std::vector<MatchDistance> result;
  unsigned const nClusters(clusters.size());
 
  if (nMatches == -1) {
    for (unsigned int iCluster = 0; iCluster < nClusters; ++iCluster) {
      ClusterType* thisCluster = clusters[iCluster];
      double thisDistance(m_distanceProvider->distanceBetween(track, thisCluster));
      if (thisDistance < m_matchCut) {
        result.push_back(MatchDistance(thisCluster, thisDistance));
      }
    }
  }
 
  else{
    int nLoops = nMatches;
    std::vector<unsigned int> masked;
    std::vector<int> maskedType;
    for (int imatch = 0; imatch < nLoops; ++imatch) {
      ClusterType* bestCluster = nullptr;
      double bestDistance(m_matchCut);
      int iMasked = -1;
      for (unsigned int iCluster = 0; iCluster < nClusters; ++iCluster) {
        /* Do not consider matched ones. */
        if (masked.size() != 0 && find(masked.begin(), masked.end(), iCluster) != masked.end()) {
          continue;
        }
 
        ClusterType* thisCluster = clusters[iCluster];
 
        /* Require that first matched cluster energy is above energyThreshold (10% of track energy). */
        if(imatch == 0 && thisCluster->e() <= energyThreshold) {
          continue;
        }
 
        /* Do not consider the same type (ECAL, HCAL or FCAL) ones. */
    /* First we check if another ECAL, HCAL or FCAL cluster is found */
        if ((maskedType.size() != 0 && find(maskedType.begin(), maskedType.end(),
                        thisCluster->getEfRecCluster()->getClusterType()) != maskedType.end())
            || (thisCluster->getEfRecCluster()->getClusterType() == 4)) { /* then also veto if it is type 4, which means "unknown" type */
          continue;
        }
 
        double thisDistance(m_distanceProvider->distanceBetween(track, thisCluster));
 
        if (thisDistance < bestDistance) {
          iMasked = iCluster;
          bestDistance = thisDistance;
          bestCluster = thisCluster;
        }
      }
      if (iMasked == -1 || nullptr == bestCluster) break;
 
      masked.push_back(iMasked);
      maskedType.push_back(bestCluster->getEfRecCluster()->getClusterType());
 
      result.push_back(MatchDistance(bestCluster, bestDistance));
    }
    assert(maskedType.size() == masked.size());
  }
 
  return result;
 
 }

getDRCutSquared()

template<class ClusterType >

double PFMatch::TrackClusterMatcher::getDRCutSquared

(

ClusterType *

theCluster

)

const

Definition at line 153 of file PFMatcher.h.

                                                                           {
 
    double m_coneRSq = 1.64*1.64;
    double coneRSq = m_coneRSq;
  int ieta = -1;
  double clusEta;
 
  clusEta = theCluster->eta();
 
  if (std::abs(clusEta)<0.6) ieta=0;
  if (std::abs(clusEta)>=0.6 && std::abs(clusEta)<1.6) ieta = 1 + int((std::abs(clusEta) - 0.6)/0.2) ;
  if (std::abs(clusEta)>=1.6 && std::abs(clusEta)<2.0) ieta = 6 ;
  if (std::abs(clusEta)>=2.0 && std::abs(clusEta)<2.5) ieta = 7 ;
  if (std::abs(clusEta)>=2.5) ieta = 8 ;
 
  double clusterEnergy = theCluster->e()/1000.0;
 
  double drcut = m_drcut_par[ieta][0]+m_drcut_par[ieta][1]*exp(m_drcut_par[ieta][2]*clusterEnergy);
  coneRSq = drcut*drcut;
 
 if (coneRSq>m_coneRSq) coneRSq = m_coneRSq;
  double conemin = m_drcut_par[ieta][0]+m_drcut_par[ieta][1]*exp(m_drcut_par[ieta][2]*10);
 
  if (coneRSq<conemin*conemin) coneRSq = conemin*conemin;
  return coneRSq;
 
  }

match()

MatchDistance PFMatch::TrackClusterMatcher::match	(	ITrack *	track,
		ICluster *	cluster
	)		const

Definition at line 17 of file PFMatcher.cxx.

                                                                              {
  double distance = m_distanceProvider->distanceBetween(track, cluster);
  return MatchDistance(cluster, distance);
}

setDRParameters()

void PFMatch::TrackClusterMatcher::setDRParameters ( )

private

This sets the parameters in the above array.

Definition at line 21 of file PFMatcher.cxx.

                                         {
  std::string theFileName = PathResolver::find_file ("rmsvsdr.dat", "DATAPATH");
  std::ifstream DRPARAM(theFileName.c_str());
  for (int i=0;i<8;i++) DRPARAM>>m_drcut_par[i][0]>>m_drcut_par[i][1]>>m_drcut_par[i][2];
 
}

Member Data Documentation

m_distanceProvider

std::unique_ptr<IDistanceProvider> PFMatch::TrackClusterMatcher::m_distanceProvider

private

Definition at line 52 of file PFMatcher.h.

m_drcut_par

float PFMatch::TrackClusterMatcher::m_drcut_par[9][3]

private

This stores the parameters to vary DR cut with Pt.

Definition at line 55 of file PFMatcher.h.

m_matchCut

double PFMatch::TrackClusterMatcher::m_matchCut

private

Definition at line 53 of file PFMatcher.h.

---

The documentation for this class was generated from the following files:

• PFMatcher.h
• PFMatcher.cxx