#include <HGCDoublet.h>

Public Types
using	HGCntuplet = std::vector< unsigned int >

Public Member Functions
int	areAligned (double xi, double yi, double zi, double xo, double yo, double zo, float minCosTheta, float minCosPointing, const GlobalVector &refDir, bool debug=false) const

bool	checkCompatibilityAndTag (std::vector< HGCDoublet > &allDoublets, const std::vector< int > &innerDoublets, const GlobalVector &refDir, float minCosTheta, float minCosPointing=1., bool debug=false)

void	findNtuplets (std::vector< HGCDoublet > &allDoublets, HGCntuplet &tmpNtuplet, int seedIndex, const bool outInDFS, const unsigned int outInHops, const unsigned int maxOutInHops, std::vector< std::pair< unsigned int, unsigned int > > &outInToVisit)

	HGCDoublet (const int innerClusterId, const int outerClusterId, const int doubletId, const std::vector< reco::CaloCluster > *layerClusters, const int seedIndex)

int	innerClusterId () const

double	innerR () const

double	innerX () const

double	innerY () const

double	innerZ () const

int	outerClusterId () const

double	outerR () const

double	outerX () const

double	outerY () const

double	outerZ () const

int	seedIndex () const

void	setVisited (bool visited)

void	tagAsInnerNeighbor (unsigned int otherDoublet)

void	tagAsOuterNeighbor (unsigned int otherDoublet)

Private Attributes
bool	alreadyVisited_

const int	innerClusterId_

std::vector< int >	innerNeighbors_

const double	innerR_

const double	innerX_

const double	innerY_

const double	innerZ_

const std::vector < reco::CaloCluster > *	layerClusters_

const int	outerClusterId_

std::vector< int >	outerNeighbors_

const double	outerR_

const double	outerX_

const double	outerY_

const double	outerZ_

int	seedIndex_

const int	theDoubletId_

Detailed Description

Definition at line 14 of file HGCDoublet.h.

Member Typedef Documentation

using HGCDoublet::HGCntuplet = std::vector<unsigned int>

Definition at line 16 of file HGCDoublet.h.

Constructor & Destructor Documentation

HGCDoublet::HGCDoublet	(	const int	innerClusterId,
		const int	outerClusterId,
		const int	doubletId,
		const std::vector< reco::CaloCluster > *	layerClusters,
		const int	seedIndex
	)

inline

Definition at line 18 of file HGCDoublet.h.

       : layerClusters_(layerClusters),
         theDoubletId_(doubletId),
         innerClusterId_(innerClusterId),
         outerClusterId_(outerClusterId),
         innerR_((*layerClusters)[innerClusterId].position().r()),
         outerR_((*layerClusters)[outerClusterId].position().r()),
         innerX_((*layerClusters)[innerClusterId].x()),
         outerX_((*layerClusters)[outerClusterId].x()),
         innerY_((*layerClusters)[innerClusterId].y()),
         outerY_((*layerClusters)[outerClusterId].y()),
         innerZ_((*layerClusters)[innerClusterId].z()),
         outerZ_((*layerClusters)[outerClusterId].z()),
         seedIndex_(seedIndex),
         alreadyVisited_(false) {}

Member Function Documentation

int HGCDoublet::areAligned	(	double	xi,
		double	yi,
		double	zi,
		double	xo,
		double	yo,
		double	zo,
		float	minCosTheta,
		float	minCosPointing,
		const GlobalVector &	refDir,
		bool	debug = `false`
	)		const

Definition at line 64 of file HGCDoublet.cc.

References Vector3DBase< T, FrameTag >::dot(), dot(), innerX(), innerY(), innerZ(), LogDebug, PV3DBase< T, PVType, FrameType >::mag2(), and seedIndex_.

Referenced by checkCompatibilityAndTag().

                                              {
   auto dx1 = xo - xi;
   auto dy1 = yo - yi;
   auto dz1 = zo - zi;
 
   auto dx2 = innerX() - xi;
   auto dy2 = innerY() - yi;
   auto dz2 = innerZ() - zi;
 
   // inner product
   auto dot = dx1 * dx2 + dy1 * dy2 + dz1 * dz2;
   auto dotsq = dot * dot;
   // magnitudes
   auto mag1sq = dx1 * dx1 + dy1 * dy1 + dz1 * dz1;
   auto mag2sq = dx2 * dx2 + dy2 * dy2 + dz2 * dz2;
 
   auto minCosTheta_sq = minCosTheta * minCosTheta;
   bool isWithinLimits = (dotsq > minCosTheta_sq * mag1sq * mag2sq);
 
   if (debug) {
     LogDebug("HGCDoublet") << "-- Are Aligned -- dotsq: " << dotsq << " mag1sq: " << mag1sq << " mag2sq: " << mag2sq
                            << "minCosTheta_sq:" << minCosTheta_sq << " isWithinLimits: " << isWithinLimits << std::endl;
   }
 
   // Now check the compatibility with the pointing origin.
   // Pointing origin is a vector obtained by the seed (track extrapolation i.e.)
   // or the direction wrt (0,0,0)
   // The compatibility is checked only for the innermost doublets: the
   // one with the outer doublets comes in by the alignment requirement of
   // the doublets themeselves
 
   const GlobalVector firstDoublet(dx2, dy2, dz2);
   const GlobalVector pointingDir = (seedIndex_ == -1) ? GlobalVector(innerX(), innerY(), innerZ()) : refDir;
 
   auto dot_pointing = pointingDir.dot(firstDoublet);
   auto dot_pointing_sq = dot_pointing * dot_pointing;
   auto mag_pointing_sq = pointingDir.mag2();
   auto minCosPointing_sq = minCosPointing * minCosPointing;
   bool isWithinLimitsPointing = (dot_pointing_sq > minCosPointing_sq * mag_pointing_sq * mag2sq);
   if (debug) {
     LogDebug("HGCDoublet") << "Pointing direction: " << pointingDir << std::endl;
     LogDebug("HGCDoublet") << "-- Are Aligned -- dot_pointing_sq: " << dot_pointing_sq
                            << " mag_pointing_sq: " << mag_pointing_sq << " mag2sq: " << mag2sq
                            << " isWithinLimitsPointing: " << isWithinLimitsPointing << std::endl;
   }
   // by squaring cosTheta and multiplying by the squares of the magnitudes
   // an equivalent comparison is made without the division and square root which are costly FP ops.
   return isWithinLimits && isWithinLimitsPointing;
 }

bool HGCDoublet::checkCompatibilityAndTag	(	std::vector< HGCDoublet > &	allDoublets,
		const std::vector< int > &	innerDoublets,
		const GlobalVector &	refDir,
		float	minCosTheta,
		float	minCosPointing = `1.`,
		bool	debug = `false`
	)

Definition at line 3 of file HGCDoublet.cc.

References areAligned(), mps_fire::i, innerNeighbors_, dqmiolumiharvest::j, LogDebug, heppy_loop::loop, convertSQLiteXML::ok, outerX(), outerY(), outerZ(), seedIndex_, and theDoubletId_.

                                                       {
   int nDoublets = innerDoublets.size();
   int constexpr VSIZE = 4;
   int ok[VSIZE];
   double xi[VSIZE];
   double yi[VSIZE];
   double zi[VSIZE];
   int seedi[VSIZE];
   auto xo = outerX();
   auto yo = outerY();
   auto zo = outerZ();
   unsigned int doubletId = theDoubletId_;
 
   auto loop = [&](int i, int vs) {
     for (int j = 0; j < vs; ++j) {
       auto otherDoubletId = innerDoublets[i + j];
       auto &otherDoublet = allDoublets[otherDoubletId];
       xi[j] = otherDoublet.innerX();
       yi[j] = otherDoublet.innerY();
       zi[j] = otherDoublet.innerZ();
       seedi[j] = otherDoublet.seedIndex();
       if (debug) {
         LogDebug("HGCDoublet") << i + j << " is doublet " << otherDoubletId << std::endl;
       }
     }
     for (int j = 0; j < vs; ++j) {
       if (seedi[j] != seedIndex_) {
         ok[j] = 0;
         continue;
       }
       ok[j] = areAligned(xi[j], yi[j], zi[j], xo, yo, zo, minCosTheta, minCosPointing, refDir, debug);
       if (debug) {
         LogDebug("HGCDoublet") << "Are aligned for InnerDoubletId: " << i + j << " is " << ok[j] << std::endl;
       }
     }
     for (int j = 0; j < vs; ++j) {
       auto otherDoubletId = innerDoublets[i + j];
       auto &otherDoublet = allDoublets[otherDoubletId];
       if (ok[j]) {
         otherDoublet.tagAsOuterNeighbor(doubletId);
         allDoublets[doubletId].tagAsInnerNeighbor(otherDoubletId);
       }
     }
   };
   auto lim = VSIZE * (nDoublets / VSIZE);
   for (int i = 0; i < lim; i += VSIZE)
     loop(i, VSIZE);
   loop(lim, nDoublets - lim);
 
   if (debug) {
     LogDebug("HGCDoublet") << "Found " << innerNeighbors_.size() << " compatible doublets out of " << nDoublets
                            << " considered" << std::endl;
   }
   return innerNeighbors_.empty();
 }

void HGCDoublet::findNtuplets	(	std::vector< HGCDoublet > &	allDoublets,
		HGCntuplet &	tmpNtuplet,
		int	seedIndex,
		const bool	outInDFS,
		const unsigned int	outInHops,
		const unsigned int	maxOutInHops,
		std::vector< std::pair< unsigned int, unsigned int > > &	outInToVisit
	)

Definition at line 123 of file HGCDoublet.cc.

References alreadyVisited_, mps_fire::i, innerNeighbors_, outerNeighbors_, seedIndex_, and theDoubletId_.

                                                                                              {
   if (!alreadyVisited_ && seedIndex == seedIndex_) {
     alreadyVisited_ = true;
     tmpNtuplet.push_back(theDoubletId_);
     unsigned int numberOfOuterNeighbors = outerNeighbors_.size();
     for (unsigned int i = 0; i < numberOfOuterNeighbors; ++i) {
       allDoublets[outerNeighbors_[i]].findNtuplets(
           allDoublets, tmpNtuplet, seedIndex, outInDFS, outInHops, maxOutInHops, outInToVisit);
     }
     if (outInDFS && outInHops < maxOutInHops) {
       for (auto inN : innerNeighbors_) {
         outInToVisit.emplace_back(inN, outInHops + 1);
       }
     }
   }
 }