HGCGraphT< TILES > Class Template Reference

#include <HGCGraph.h>

Public Types
enum	VerbosityLevel {   None = 0, Basic, Advanced, Expert,   Guru }

Public Member Functions
bool	areTimeCompatible (int innerIdx, int outerIdx, const edm::ValueMap< std::pair< float, float >> &layerClustersTime, float maxDeltaTime)
void	clear ()
void	findNtuplets (std::vector< HGCDoublet::HGCntuplet > &foundNtuplets, std::vector< int > &seedIndices, const unsigned int minClustersPerNtuplet, const bool outInDFS, const unsigned int maxOutInHops)
std::vector< HGCDoublet > &	getAllDoublets ()
void	makeAndConnectDoublets (const TILES &h, const std::vector< TICLSeedingRegion > &regions, int nEtaBins, int nPhiBins, const std::vector< reco::CaloCluster > &layerClusters, const std::vector< float > &mask, const edm::ValueMap< std::pair< float, float >> &layerClustersTime, int deltaIEta, int deltaIPhi, float minCosThetai, float maxCosPointing, float root_doublet_max_distance_from_seed_squared, float etaLimitIncreaseWindow, int skip_layers, int maxNumberOfLayers, float maxDeltaTime)
void	setVerbosity (int level)

Private Attributes
std::vector< HGCDoublet >	allDoublets_
std::vector< std::vector< int > >	isOuterClusterOfDoublets_
std::vector< unsigned int >	theRootDoublets_
int	verbosity_

Detailed Description

template<typename TILES>
class HGCGraphT< TILES >

Definition at line 15 of file HGCGraph.h.

Member Enumeration Documentation

VerbosityLevel

template<typename TILES >

enum HGCGraphT::VerbosityLevel

Enumerator
None
Basic
Advanced
Expert
Guru

Definition at line 54 of file HGCGraph.h.

{ None = 0, Basic, Advanced, Expert, Guru };

Member Function Documentation

areTimeCompatible()

template<typename TILES >

bool HGCGraphT< TILES >::areTimeCompatible	(	int	innerIdx,
		int	outerIdx,
		const edm::ValueMap< std::pair< float, float >> &	layerClustersTime,
		float	maxDeltaTime
	)

Definition at line 210 of file HGCGraph.cc.

                                                             {
  float timeIn = layerClustersTime.get(innerIdx).first;
  float timeInE = layerClustersTime.get(innerIdx).second;
  float timeOut = layerClustersTime.get(outerIdx).first;
  float timeOutE = layerClustersTime.get(outerIdx).second;
 
  return (timeIn == -99. || timeOut == -99. ||
          std::abs(timeIn - timeOut) < maxDeltaTime * sqrt(timeInE * timeInE + timeOutE * timeOutE));
}

References funct::abs(), and mathSSE::sqrt().

clear()

template<typename TILES >

void HGCGraphT< TILES >::clear ( void  )

inline

Definition at line 45 of file HGCGraph.h.

               {
    allDoublets_.clear();
    theRootDoublets_.clear();
    isOuterClusterOfDoublets_.clear();
    allDoublets_.shrink_to_fit();
    theRootDoublets_.shrink_to_fit();
    isOuterClusterOfDoublets_.shrink_to_fit();
  }

References HGCGraphT< TILES >::allDoublets_, HGCGraphT< TILES >::isOuterClusterOfDoublets_, and HGCGraphT< TILES >::theRootDoublets_.

findNtuplets()

template<typename TILES >

void HGCGraphT< TILES >::findNtuplets	(	std::vector< HGCDoublet::HGCntuplet > &	foundNtuplets,
		std::vector< int > &	seedIndices,
		const unsigned int	minClustersPerNtuplet,
		const bool	outInDFS,
		const unsigned int	maxOutInHops
	)

Definition at line 225 of file HGCGraph.cc.

                                                               {
  HGCDoublet::HGCntuplet tmpNtuplet;
  tmpNtuplet.reserve(minClustersPerNtuplet);
  std::vector<std::pair<unsigned int, unsigned int>> outInToVisit;
  for (auto rootDoublet : theRootDoublets_) {
    tmpNtuplet.clear();
    outInToVisit.clear();
    int seedIndex = allDoublets_[rootDoublet].seedIndex();
    int outInHops = 0;
    allDoublets_[rootDoublet].findNtuplets(
        allDoublets_, tmpNtuplet, seedIndex, outInDFS, outInHops, maxOutInHops, outInToVisit);
    while (!outInToVisit.empty()) {
      allDoublets_[outInToVisit.back().first].findNtuplets(
          allDoublets_, tmpNtuplet, seedIndex, outInDFS, outInToVisit.back().second, maxOutInHops, outInToVisit);
      outInToVisit.pop_back();
    }
 
    if (tmpNtuplet.size() > minClustersPerNtuplet) {
      foundNtuplets.push_back(tmpNtuplet);
      seedIndices.push_back(seedIndex);
    }
  }
}

getAllDoublets()

template<typename TILES >

std::vector<HGCDoublet>& HGCGraphT< TILES >::getAllDoublets ( )

inline

Definition at line 39 of file HGCGraph.h.

{ return allDoublets_; }

References HGCGraphT< TILES >::allDoublets_.

makeAndConnectDoublets()

template<typename TILES >

void HGCGraphT< TILES >::makeAndConnectDoublets	(	const TILES &	h,
		const std::vector< TICLSeedingRegion > &	regions,
		int	nEtaBins,
		int	nPhiBins,
		const std::vector< reco::CaloCluster > &	layerClusters,
		const std::vector< float > &	mask,
		const edm::ValueMap< std::pair< float, float >> &	layerClustersTime,
		int	deltaIEta,
		int	deltaIPhi,
		float	minCosThetai,
		float	maxCosPointing,
		float	root_doublet_max_distance_from_seed_squared,
		float	etaLimitIncreaseWindow,
		int	skip_layers,
		int	maxNumberOfLayers,
		float	maxDeltaTime
	)

Definition at line 11 of file HGCGraph.cc.

                                                                  {
  isOuterClusterOfDoublets_.clear();
  isOuterClusterOfDoublets_.resize(layerClusters.size());
  allDoublets_.clear();
  theRootDoublets_.clear();
  bool checkDistanceRootDoubletVsSeed = root_doublet_max_distance_from_seed_squared < 9999;
  float origin_eta;
  float origin_phi;
  for (const auto &r : regions) {
    bool isGlobal = (r.index == -1);
    auto zSide = r.zSide;
    int startEtaBin, endEtaBin, startPhiBin, endPhiBin;
 
    if (isGlobal) {
      startEtaBin = 0;
      startPhiBin = 0;
      endEtaBin = nEtaBins;
      endPhiBin = nPhiBins;
      origin_eta = 0;
      origin_phi = 0;
    } else {
      auto firstLayerOnZSide = maxNumberOfLayers * zSide;
      const auto &firstLayerHisto = histo[firstLayerOnZSide];
      origin_eta = r.origin.eta();
      origin_phi = r.origin.phi();
      int entryEtaBin = firstLayerHisto.etaBin(origin_eta);
      int entryPhiBin = firstLayerHisto.phiBin(origin_phi);
      // For track-seeded iterations, if the impact point is below a certain
      // eta-threshold, i.e., it has higher eta, make the initial search
      // window bigger in both eta and phi by one bin, to contain better low
      // energy showers.
      auto etaWindow = deltaIEta;
      auto phiWindow = deltaIPhi;
      if (std::abs(origin_eta) > etaLimitIncreaseWindow) {
        etaWindow++;
        phiWindow++;
        LogDebug("HGCGraph") << "Limit of Eta for increase: " << etaLimitIncreaseWindow
                             << " reached! Increasing inner search window" << std::endl;
      }
      startEtaBin = std::max(entryEtaBin - etaWindow, 0);
      endEtaBin = std::min(entryEtaBin + etaWindow + 1, nEtaBins);
      startPhiBin = entryPhiBin - phiWindow;
      endPhiBin = entryPhiBin + phiWindow + 1;
      if (verbosity_ > Guru) {
        LogDebug("HGCGraph") << " Entrance eta, phi: " << origin_eta << ", " << origin_phi
                             << " entryEtaBin: " << entryEtaBin << " entryPhiBin: " << entryPhiBin
                             << " globalBin: " << firstLayerHisto.globalBin(origin_eta, origin_phi)
                             << " on layer: " << firstLayerOnZSide << " startEtaBin: " << startEtaBin
                             << " endEtaBin: " << endEtaBin << " startPhiBin: " << startPhiBin
                             << " endPhiBin: " << endPhiBin << " phiBin(0): " << firstLayerHisto.phiBin(0.)
                             << " phiBin(" << M_PI / 2. << "): " << firstLayerHisto.phiBin(M_PI / 2.) << " phiBin("
                             << M_PI << "): " << firstLayerHisto.phiBin(M_PI) << " phiBin(" << -M_PI / 2.
                             << "): " << firstLayerHisto.phiBin(-M_PI / 2.) << " phiBin(" << -M_PI
                             << "): " << firstLayerHisto.phiBin(-M_PI) << " phiBin(" << 2. * M_PI
                             << "): " << firstLayerHisto.phiBin(2. * M_PI) << std::endl;
      }
    }
 
    for (int il = 0; il < maxNumberOfLayers - 1; ++il) {
      for (int outer_layer = 0; outer_layer < std::min(1 + skip_layers, maxNumberOfLayers - 1 - il); ++outer_layer) {
        int currentInnerLayerId = il + maxNumberOfLayers * zSide;
        int currentOuterLayerId = currentInnerLayerId + 1 + outer_layer;
        auto const &outerLayerHisto = histo[currentOuterLayerId];
        auto const &innerLayerHisto = histo[currentInnerLayerId];
        const int etaLimitIncreaseWindowBin = innerLayerHisto.etaBin(etaLimitIncreaseWindow);
        if (verbosity_ > Advanced) {
          LogDebug("HGCGraph") << "Limit of Eta for increase: " << etaLimitIncreaseWindow
                               << " at etaBin: " << etaLimitIncreaseWindowBin << std::endl;
        }
 
        for (int ieta = startEtaBin; ieta < endEtaBin; ++ieta) {
          auto offset = ieta * nPhiBins;
          for (int iphi_it = startPhiBin; iphi_it < endPhiBin; ++iphi_it) {
            int iphi = ((iphi_it % nPhiBins + nPhiBins) % nPhiBins);
            if (verbosity_ > Guru) {
              LogDebug("HGCGraph") << "Inner Global Bin: " << (offset + iphi)
                                   << " on layers I/O: " << currentInnerLayerId << "/" << currentOuterLayerId
                                   << " with clusters: " << innerLayerHisto[offset + iphi].size() << std::endl;
            }
            for (auto innerClusterId : innerLayerHisto[offset + iphi]) {
              // Skip masked clusters
              if (mask[innerClusterId] == 0.) {
                if (verbosity_ > Advanced)
                  LogDebug("HGCGraph") << "Skipping inner masked cluster " << innerClusterId << std::endl;
                continue;
              }
 
              // For global-seeded iterations, if the inner cluster is above a certain
              // eta-threshold, i.e., it has higher eta, make the outer search
              // window bigger in both eta and phi by one bin, to contain better low
              // energy showers. Track-Seeded iterations are excluded since, in
              // that case, the inner search window has already been enlarged.
              auto etaWindow = deltaIEta;
              auto phiWindow = deltaIPhi;
              if (isGlobal && ieta > etaLimitIncreaseWindowBin) {
                etaWindow++;
                phiWindow++;
                if (verbosity_ > Advanced) {
                  LogDebug("HGCGraph") << "Eta and Phi window increased by one" << std::endl;
                }
              }
              const auto etaRangeMin = std::max(0, ieta - etaWindow);
              const auto etaRangeMax = std::min(ieta + etaWindow + 1, nEtaBins);
 
              for (int oeta = etaRangeMin; oeta < etaRangeMax; ++oeta) {
                // wrap phi bin
                for (int phiRange = 0; phiRange < 2 * phiWindow + 1; ++phiRange) {
                  // The first wrapping is to take into account the
                  // cases in which we would have to seach in
                  // negative bins. The second wrap is mandatory to
                  // account for all other cases, since we add in
                  // between a full nPhiBins slot.
                  auto ophi = ((iphi + phiRange - phiWindow) % nPhiBins + nPhiBins) % nPhiBins;
                  if (verbosity_ > Guru) {
                    LogDebug("HGCGraph") << "Outer Global Bin: " << (oeta * nPhiBins + ophi)
                                         << " on layers I/O: " << currentInnerLayerId << "/" << currentOuterLayerId
                                         << " with clusters: " << innerLayerHisto[oeta * nPhiBins + ophi].size()
                                         << std::endl;
                  }
                  for (auto outerClusterId : outerLayerHisto[oeta * nPhiBins + ophi]) {
                    // Skip masked clusters
                    if (mask[outerClusterId] == 0.) {
                      if (verbosity_ > Advanced)
                        LogDebug("HGCGraph") << "Skipping outer masked cluster " << outerClusterId << std::endl;
                      continue;
                    }
                    auto doubletId = allDoublets_.size();
                    if (maxDeltaTime != -1 &&
                        !areTimeCompatible(innerClusterId, outerClusterId, layerClustersTime, maxDeltaTime)) {
                      if (verbosity_ > Advanced)
                        LogDebug("HGCGraph") << "Rejecting doublets due to timing!" << std::endl;
                      continue;
                    }
                    allDoublets_.emplace_back(innerClusterId, outerClusterId, doubletId, &layerClusters, r.index);
                    if (verbosity_ > Advanced) {
                      LogDebug("HGCGraph")
                          << "Creating doubletsId: " << doubletId << " layerLink in-out: [" << currentInnerLayerId
                          << ", " << currentOuterLayerId << "] clusterLink in-out: [" << innerClusterId << ", "
                          << outerClusterId << "]" << std::endl;
                    }
                    isOuterClusterOfDoublets_[outerClusterId].push_back(doubletId);
                    auto &neigDoublets = isOuterClusterOfDoublets_[innerClusterId];
                    auto &thisDoublet = allDoublets_[doubletId];
                    if (verbosity_ > Expert) {
                      LogDebug("HGCGraph")
                          << "Checking compatibility of doubletId: " << doubletId
                          << " with all possible inners doublets link by the innerClusterId: " << innerClusterId
                          << std::endl;
                    }
                    bool isRootDoublet = thisDoublet.checkCompatibilityAndTag(allDoublets_,
                                                                              neigDoublets,
                                                                              r.directionAtOrigin,
                                                                              minCosTheta,
                                                                              minCosPointing,
                                                                              verbosity_ > Advanced);
                    if (isRootDoublet and checkDistanceRootDoubletVsSeed) {
                      auto dEtaSquared = (layerClusters[innerClusterId].eta() - origin_eta);
                      dEtaSquared *= dEtaSquared;
                      auto dPhiSquared = (layerClusters[innerClusterId].phi() - origin_phi);
                      dPhiSquared *= dPhiSquared;
                      if (dEtaSquared + dPhiSquared > root_doublet_max_distance_from_seed_squared)
                        isRootDoublet = false;
                    }
                    if (isRootDoublet) {
                      theRootDoublets_.push_back(doubletId);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  // #ifdef FP_DEBUG
  if (verbosity_ > None) {
    LogDebug("HGCGraph") << "number of Root doublets " << theRootDoublets_.size() << " over a total number of doublets "
                         << allDoublets_.size() << std::endl;
  }
  // #endif
}

References funct::abs(), HLTEgPhaseIITestSequence_cff::etaLimitIncreaseWindow, timingPdfMaker::histo, LEDCalibrationChannels::ieta, LEDCalibrationChannels::iphi, muons_cff::isGlobal, HLTEgPhaseIITestSequence_cff::layerClusters, LogDebug, M_PI, SiStripPI::max, min(), L1TMuonDQMOffline_cfi::nEtaBins, None, ecaldqm::binning::nPhiBins, hltrates_dqm_sourceclient-live_cfg::offset, trackingPOGFilters_cfi::phiWindow, alignCSCRings::r, HLTEgPhaseIITestSequence_cff::root_doublet_max_distance_from_seed_squared, findQualityFiles::size, and HLTEgPhaseIITestSequence_cff::skip_layers.

setVerbosity()

template<typename TILES >

void HGCGraphT< TILES >::setVerbosity ( int  level )

inline

Definition at line 53 of file HGCGraph.h.

{ verbosity_ = level; }

References personalPlayback::level, and HGCGraphT< TILES >::verbosity_.

Member Data Documentation

allDoublets_

template<typename TILES >

std::vector<HGCDoublet> HGCGraphT< TILES >::allDoublets_

private

Definition at line 57 of file HGCGraph.h.

Referenced by HGCGraphT< TILES >::clear(), and HGCGraphT< TILES >::getAllDoublets().

isOuterClusterOfDoublets_

template<typename TILES >

std::vector<std::vector<int> > HGCGraphT< TILES >::isOuterClusterOfDoublets_

private

Definition at line 59 of file HGCGraph.h.

Referenced by HGCGraphT< TILES >::clear().

theRootDoublets_

template<typename TILES >

std::vector<unsigned int> HGCGraphT< TILES >::theRootDoublets_

private

Definition at line 58 of file HGCGraph.h.

Referenced by HGCGraphT< TILES >::clear().

verbosity_

template<typename TILES >

int HGCGraphT< TILES >::verbosity_

private

Definition at line 60 of file HGCGraph.h.

Referenced by HGCGraphT< TILES >::setVerbosity().