tmtt::HTrphi Class Reference

#include <HTrphi.h>

Inheritance diagram for tmtt::HTrphi:

Classes
struct	ErrorMonitor

Public Types
enum	HTshape { HTshape::square, HTshape::diamond, HTshape::hexagon, HTshape::brick }

Public Member Functions
std::pair< unsigned int, unsigned int >	cell (const L1fittedTrack *fitTrk) const override
unsigned int	getMbinRange (const L1track2D &trk) const
std::pair< float, float >	helix2Dconventional (unsigned int i, unsigned int j) const override
std::pair< float, float >	helix2Dhough (unsigned int i, unsigned int j) const override
	HTrphi (const Settings *settings, unsigned int iPhiSec, unsigned int iEtaReg, float etaMinSector, float etaMaxSector, float phiCentreSector, ErrorMonitor *errMon=nullptr)
bool	mergedCell (unsigned int iQoverPtBin, unsigned int jPhiTrkBin) const
unsigned int	nReceivedStubs () const
void	store (Stub *stub, const std::vector< bool > &inEtaSubSecs)
std::pair< unsigned int, unsigned int >	trueCell (const TP *tp) const override
	~HTrphi () override=default
Public Member Functions inherited from tmtt::HTbase
virtual const matrix< std::unique_ptr< HTcell > > &	allCells () const
virtual std::vector< const L1track2D * >	assocTrackCands2D (const TP &tp) const
virtual void	disableBendFilter ()
virtual void	end ()
	HTbase (const Settings *settings, unsigned int iPhiSec, unsigned int iEtaReg, unsigned int nBinsX, unsigned int nBinsY)
virtual unsigned int	numStubsExc () const
virtual unsigned int	numStubsInc () const
virtual unsigned int	numStubsOnTrackCands2D () const
virtual unsigned int	numTrackCands2D () const
virtual void	replaceTrackCands2D (const std::list< L1track2D > &newTracks)
virtual const std::list< L1track2D > &	trackCands2D () const
virtual	~HTbase ()=default

Private Member Functions
float	calcLineGradArray (float r) const
void	countFirmwareErrors (unsigned int iQoverPtBin, unsigned int iPhiTrkBinMin, unsigned int iPhiTrkBinMax, unsigned int jPhiTrkBinMinLast, unsigned int jPhiTrkBinMaxLast)
std::pair< unsigned int, unsigned int >	iPhiRange (const Stub *stub, unsigned int iQoverPtBin, bool debug=false) const
std::list< L1track2D >	killTracksBusySec (const std::list< L1track2D > &tracks) const override
std::vector< unsigned int >	rowOrder (unsigned int numRows) const override

Private Attributes
float	binSizePhiTrkAxis_
float	binSizeQoverPtAxis_
bool	busyInputSectorKill_
unsigned int	busyInputSectorNumStubs_
bool	busySectorKill_
std::vector< unsigned int >	busySectorMbinHigh_
std::vector< unsigned int >	busySectorMbinLow_
std::vector< unsigned int >	busySectorMbinOrder_
std::vector< unsigned int >	busySectorMbinRanges_
unsigned int	busySectorNumStubs_
bool	busySectorUseMbinOrder_
bool	busySectorUseMbinRanges_
std::vector< std::vector< std::pair< float, float > > >	cellCenters_
float	chosenRofPhi_
bool	enableMerge2x2_
ErrorMonitor *	errMon_
float	invPtToDphi_
unsigned int	killSomeHTCellsRphi_
float	maxAbsPhiTrkAxis_
float	maxAbsQoverPtAxis_
float	minInvPtToMerge2x2_
unsigned int	nBinsPhiTrkAxis_
unsigned int	nBinsQoverPtAxis_
unsigned int	nReceivedStubs_
float	phiCentreSector_
HTshape	shape_

Additional Inherited Members
Protected Member Functions inherited from tmtt::HTbase
virtual std::pair< unsigned int, unsigned int >	convertCoordRangeToBinRange (std::pair< float, float > coordRange, unsigned int nBinsAxis, float coordAxisMin, float coordAxisBinSize, unsigned int killSomeHTcells) const
Protected Attributes inherited from tmtt::HTbase
matrix< std::unique_ptr< HTcell > >	htArray_
unsigned int	iEtaReg_
unsigned int	iPhiSec_
unsigned int	nBinsX_
unsigned int	nBinsY_
unsigned int	optoLinkID_
const Settings *	settings_
std::list< L1track2D >	trackCands2D_

Detailed Description

Definition at line 23 of file HTrphi.h.

Member Enumeration Documentation

HTshape

enum tmtt::HTrphi::HTshape

strong

Enumerator
square
diamond
hexagon
brick

Definition at line 25 of file HTrphi.h.

{ square, diamond, hexagon, brick };

Constructor & Destructor Documentation

HTrphi()

tmtt::HTrphi::HTrphi	(	const Settings *	settings,
		unsigned int	iPhiSec,
		unsigned int	iEtaReg,
		float	etaMinSector,
		float	etaMaxSector,
		float	phiCentreSector,
		HTrphi::ErrorMonitor *	errMon = nullptr
	)

Definition at line 29 of file HTrphi.cc.

      : HTbase(settings, iPhiSec, iEtaReg, settings->houghNbinsPt(), settings->houghNbinsPhi()),
        invPtToDphi_((settings->invPtToDphi())),
        shape_(static_cast<HTshape>(settings->shape())),  // shape of HT cells
 
        //--- Specification of HT q/Pt axis.
        maxAbsQoverPtAxis_(1. / settings->houghMinPt()),  // Max. |q/Pt| covered by  HT array.
        nBinsQoverPtAxis_(settings->houghNbinsPt()),      // No. of bins in HT array in q/Pt.
        binSizeQoverPtAxis_(2 * maxAbsQoverPtAxis_ / nBinsQoverPtAxis_),
 
        //--- Specification of HT phiTrk axis
        // (phiTrk corresponds to phi where track crosses radius = chosenRofPhi_).
        chosenRofPhi_(settings->chosenRofPhi()),
        phiCentreSector_(phiCentreSector),                           // Centre of phiTrk sector.
        maxAbsPhiTrkAxis_(M_PI / float(settings->numPhiSectors())),  // Half-width of phiTrk axis in HT array.
        nBinsPhiTrkAxis_(settings->houghNbinsPhi()),                 // No. of bins in HT array phiTrk
        binSizePhiTrkAxis_(2 * maxAbsPhiTrkAxis_ / nBinsPhiTrkAxis_),
        errMon_(errMon) {
    // Deal with unusually shaped HT cells.
    if (shape_ != HTshape::square)
      binSizeQoverPtAxis_ = 2. * maxAbsQoverPtAxis_ / (nBinsQoverPtAxis_ - 1.);
    if (shape_ == HTshape::hexagon)
      binSizePhiTrkAxis_ = 2. * maxAbsPhiTrkAxis_ / (nBinsPhiTrkAxis_ - 1. / 6.);
    else if (shape_ == HTshape::diamond)
      binSizePhiTrkAxis_ = 2. * maxAbsPhiTrkAxis_ / (nBinsPhiTrkAxis_ - 1. / 2.);
 
    // Optionally merge 2x2 neighbouring cells into a single cell at low Pt, to reduce efficiency loss due to
    // scattering. (Do this if either of options EnableMerge2x2 or MiniHTstage are enabled.
    // N.B These two options are never both enabled).
    enableMerge2x2_ = (settings->enableMerge2x2() || settings->miniHTstage());
    if (settings->miniHTstage()) {
      // Mini-HT stage cfg: Merge all bins, irrespective of Pt.
      minInvPtToMerge2x2_ = 0.;
    } else {
      // Merged cells cfg: Merge bins below specified Pt threshold.
      minInvPtToMerge2x2_ = 1. / (settings->maxPtToMerge2x2());
      if (minInvPtToMerge2x2_ > maxAbsQoverPtAxis_)
        enableMerge2x2_ = false;
    }
 
    // Merging 2x2 cells into 1 merged cell is only allowed if HT array dimensions are even.
    // (This restriction could be removed along q/Pt axis, since there are also unmerged cells there. But this
    // would require correcting the code after each called to mergedCell() below, since
    //  "if (i%2 == 1) iStore = i - 1" not correct in this case).
    if (enableMerge2x2_ && (nBinsQoverPtAxis_ % 2 != 0 || nBinsPhiTrkAxis_ % 2 != 0))
      throw cms::Exception("BadConfig") << "HTrphi: You are not allowed to set EnableMerge2x2 or MiniHTstage = True if "
                                           "you have an odd number of bins "
                                           "in r-phi HT array "
                                        << nBinsQoverPtAxis_ << " " << nBinsPhiTrkAxis_;
 
    //--- Other options used when filling the HT.
 
    // Don't fill all HT cells nominally crossed by line corresponding to stub.
    killSomeHTCellsRphi_ = settings->killSomeHTCellsRphi();
 
    // Used to kill excess stubs or tracks that can't be transmitted within time-multiplexed period.
    nReceivedStubs_ = 0;
    busyInputSectorKill_ = settings_->busyInputSectorKill();  // Kill excess stubs going fron GP to HT?
    busySectorKill_ = settings_->busySectorKill();            // Kill excess tracks flowing out of HT?
    // Max. num. of stubs that can be sent from GP to HT within TM period
    busyInputSectorNumStubs_ = settings_->busyInputSectorNumStubs();
    // Max. num. of stubs that can be sent out of HT within TM period
    busySectorNumStubs_ = settings_->busySectorNumStubs();
    // or individual m bin (=q/Pt) ranges to be output to optical links.
    busySectorMbinRanges_ = settings_->busySectorMbinRanges();
    // Specifies which m bins should be grouped together by BusySectorMbinRanges. If empty, then they are grouped in order 0,1,2,3,4,5 ...
    busySectorMbinOrder_ = settings_->busySectorMbinOrder();
    // m bin ranges option disabled if vector empty
    busySectorUseMbinRanges_ = (not busySectorMbinRanges_.empty());
    busySectorUseMbinOrder_ = (not busySectorMbinOrder_.empty());
 
    bool rescaleMbins = false;
    if (busySectorUseMbinRanges_) {
      // Check if the total number of bins specified in cfg option BusySectorMbinRanges corresponds
      // to the number of m bins (q/Pt) in the HT. If not, determine how much the ranges must be scaled
      // to make this true.
      unsigned int nTotalBins = 0;
      for (unsigned int j = 0; j < busySectorMbinRanges_.size(); j++) {
        nTotalBins += busySectorMbinRanges_[j];
      }
      rescaleMbins = (nTotalBins != nBinsQoverPtAxis_);
      // No rescaling allowed with MBinOrder option.
      if (rescaleMbins && busySectorUseMbinOrder_)
        throw cms::Exception("BadConfig") << "HTrphi: BusySectorUserMbin error";
      float rescaleFactor = rescaleMbins ? float(nBinsQoverPtAxis_) / float(nTotalBins) : 1.;
      // Find lower and upper inclusive limits of each m bin range to be sent to a separate optical link.
      busySectorMbinLow_.resize(busySectorMbinRanges_.size());
      busySectorMbinHigh_.resize(busySectorMbinRanges_.size());
      float mBinSum = 0.;
      for (unsigned int i = 0; i < busySectorMbinRanges_.size(); i++) {
        busySectorMbinLow_[i] = std::round(mBinSum);
        busySectorMbinHigh_[i] = std::round(mBinSum + rescaleFactor * busySectorMbinRanges_[i]) - 1;
        mBinSum += rescaleFactor * busySectorMbinRanges_[i];
      }
    }
    //
    for (unsigned int i = 0; i < nBinsQoverPtAxis_; i++) {
      for (unsigned int j = 0; j < nBinsPhiTrkAxis_; j++) {
        pair<float, float> helix = this->helix2Dconventional(i, j);  // Get track params at centre of cell.
        float qOverPt = helix.first;
        // Check if this cell is merged with its neighbours (as in low Pt region).
        bool mergedCell = false;
        if (enableMerge2x2_ && this->mergedCell(i, j))
          mergedCell = true;
        // Initialize each cell in HT array.
        HTbase::htArray_(i, j) =
            std::make_unique<HTcell>(settings, iPhiSec, iEtaReg, etaMinSector, etaMaxSector, qOverPt, i, mergedCell);
      }
    }
 
    std::stringstream text;
    text << "\n";
    text << "=== R-PHI HOUGH TRANSFORM AXES RANGES: abs(q/Pt) < " << maxAbsQoverPtAxis_ << " & abs(track-phi) < "
         << maxAbsPhiTrkAxis_ << " ===\n";
    text << "=== R-PHI HOUGH TRANSFORM ARRAY SIZE: q/Pt bins = " << nBinsQoverPtAxis_
         << " & track-phi bins = " << nBinsPhiTrkAxis_ << " ===\n";
    text << "=== R-PHI HOUGH TRANSFORM BIN SIZE: BIN(q/Pt) = " << binSizeQoverPtAxis_
         << " & BIN(track-phi) = " << binSizePhiTrkAxis_ << " ===\n\n";
    if (busySectorKill_ && busySectorUseMbinRanges_ && rescaleMbins) {
      text << "=== R-PHI HOUGH TRANSFORM WARNING: Rescaled m bin ranges specified by cfg parameter "
              "BusySectorMbinRanges, as they were inconsistent with total number of m bins in HT.\n";
      text << "=== Rescaled values for BusySectorMbinRanges =";
      for (unsigned int i = 0; i < busySectorMbinRanges_.size(); i++) {
        text << " " << (busySectorMbinHigh_[i] - busySectorMbinLow_[i] + 1);
      }
    }
    text << "\n";
    static std::once_flag printOnce;
    std::call_once(
        printOnce, [](string t) { PrintL1trk() << t; }, text.str());
 
    // Note helix parameters at the centre of each HT cell.
    cellCenters_.clear();
    for (unsigned int m = 0; m < nBinsQoverPtAxis_; m++) {
      std::vector<std::pair<float, float> > binCenters;
      for (unsigned int c = 0; c < nBinsPhiTrkAxis_; c++)
        binCenters.push_back(this->helix2Dhough(m, c));
      cellCenters_.push_back(binCenters);
    }
  }

References binSizePhiTrkAxis_, binSizeQoverPtAxis_, tmtt::Settings::busyInputSectorKill(), busyInputSectorKill_, tmtt::Settings::busyInputSectorNumStubs(), busyInputSectorNumStubs_, tmtt::Settings::busySectorKill(), busySectorKill_, busySectorMbinHigh_, busySectorMbinLow_, tmtt::Settings::busySectorMbinOrder(), busySectorMbinOrder_, tmtt::Settings::busySectorMbinRanges(), busySectorMbinRanges_, tmtt::Settings::busySectorNumStubs(), busySectorNumStubs_, busySectorUseMbinOrder_, busySectorUseMbinRanges_, HltBtagPostValidation_cff::c, cellCenters_, diamond, tmtt::Settings::enableMerge2x2(), enableMerge2x2_, Exception, dqmMemoryStats::float, helix2Dconventional(), hexagon, tmtt::HTbase::htArray_, mps_fire::i, dqmiolumiharvest::j, tmtt::Settings::killSomeHTCellsRphi(), killSomeHTCellsRphi_, visualization-live-secondInstance_cfg::m, maxAbsPhiTrkAxis_, maxAbsQoverPtAxis_, tmtt::Settings::maxPtToMerge2x2(), mergedCell(), tmtt::Settings::miniHTstage(), minInvPtToMerge2x2_, nBinsPhiTrkAxis_, nBinsQoverPtAxis_, nReceivedStubs_, tmtt::HTbase::settings_, shape_, square, submitPVValidationJobs::t, and runonSM::text.

~HTrphi()

tmtt::HTrphi::~HTrphi ( )

overridedefault

Member Function Documentation

calcLineGradArray()

float tmtt::HTrphi::calcLineGradArray ( float  r ) const

private

Definition at line 605 of file HTrphi.cc.

                                               {
    float grad = std::abs(invPtToDphi_ * (r - chosenRofPhi_));
    // Convert it to units of bin width.
    grad *= binSizeQoverPtAxis_ / binSizePhiTrkAxis_;
    if (shape_ == HTshape::hexagon)
      grad *= 3.;
    else if (shape_ == HTshape::diamond)
      grad *= 2.;
    else if (shape_ == HTshape::brick)
      grad *= 4.;
    return grad;
  }

References funct::abs(), binSizePhiTrkAxis_, binSizeQoverPtAxis_, brick, chosenRofPhi_, diamond, hexagon, invPtToDphi_, alignCSCRings::r, and shape_.

Referenced by store().

cell()

pair< unsigned int, unsigned int > tmtt::HTrphi::cell ( const L1fittedTrack *  fitTrk ) const

overridevirtual

Implements tmtt::HTbase.

Definition at line 507 of file HTrphi.cc.

                                                                                 {
    bool beamConstraint = fitTrk->done_bcon();  // Is beam-spot constraint available? (e.g. 5 param helix fit)
    // Get HT axis variables corresponding to this fitted track.
    float qOverPt = beamConstraint ? fitTrk->qOverPt_bcon() : fitTrk->qOverPt();
    // Convert phi0 to phi at chosen radius used in HT.
    float phiTrk = fitTrk->phiAtChosenR(beamConstraint);
    // Measure phi relative to centre of sector.
    float deltaPhi = reco::deltaPhi(phiTrk, phiCentreSector_);
    // Convert to bin numbers inside HT array.
    int iQoverPt = 999999;
    int iPhiTrk = 999999;
 
    if (shape_ == HTshape::square) {
      //--- This is a traditional HT with square cells.
 
      iQoverPt = floor((qOverPt - (-maxAbsQoverPtAxis_)) / binSizeQoverPtAxis_);
      iPhiTrk = floor((deltaPhi - (-maxAbsPhiTrkAxis_)) / binSizePhiTrkAxis_);
 
      // Check if this cell was within the HT array.
      if (iQoverPt >= 0 && iQoverPt < int(nBinsQoverPtAxis_) && iPhiTrk >= 0 && iPhiTrk < int(nBinsPhiTrkAxis_)) {
        // Check if this cell is merged with its neighbours (as in low Pt region), and if so return merged cell location.
        // New: because 2nd stage mini HT may recreate tracks from merged cells with finer cell granularity, one can't predict
        //      if a merged cell was used to create a track merely by looking at its cell location.
        //      So instead ask L1track3D, which knows if it was created from a merged HT cell or not.
        ;
      } else {
        // Fitted track is not in this HT array at all. Flag this by setting "outside" bin index to 0 (Nbins-1) if outside array below (above).
        if (iQoverPt < 0)
          iQoverPt = 0;
        if (iQoverPt >= int(nBinsQoverPtAxis_))
          iQoverPt = nBinsQoverPtAxis_ - 1;
        if (iPhiTrk < 0)
          iPhiTrk = 0;
        if (iPhiTrk >= int(nBinsPhiTrkAxis_))
          iPhiTrk = nBinsPhiTrkAxis_ - 1;
      }
 
    } else {
      //--- This is are novel HT with unusual shaped cells.
 
      float minD = std::numeric_limits<float>::infinity();
      float d(0);
      unsigned int m(0);
      for (const auto& binCenters : cellCenters_) {
        unsigned int c(0);
        for (auto cellCenter : binCenters) {
          d = std::pow((cellCenter.first - qOverPt) / (float)binSizeQoverPtAxis_, 2) +
              std::pow((cellCenter.second - phiTrk) / (float)binSizePhiTrkAxis_, 2);
          if (d < minD) {
            minD = d;
            iQoverPt = m;
            iPhiTrk = c;
          }
          c++;
        }
        m++;
      }
      // Fitted track is not in this HT array at all. Flag this by setting "outside" bin index to 0 (Nbins-1) if outside array below (above).
      if (iQoverPt < 0)
        iQoverPt = 0;
      if (iQoverPt >= int(nBinsQoverPtAxis_))
        iQoverPt = nBinsQoverPtAxis_ - 1;
      if (iPhiTrk < 0)
        iPhiTrk = 0;
      if (iPhiTrk >= int(nBinsPhiTrkAxis_))
        iPhiTrk = nBinsPhiTrkAxis_ - 1;
    }
 
    return pair<unsigned int, unsigned int>(iQoverPt, iPhiTrk);
  }

References binSizePhiTrkAxis_, binSizeQoverPtAxis_, HltBtagPostValidation_cff::c, cellCenters_, ztail::d, SiPixelRawToDigiRegional_cfi::deltaPhi, reco::deltaPhi(), tmtt::L1fittedTrack::done_bcon(), infinity, visualization-live-secondInstance_cfg::m, maxAbsPhiTrkAxis_, maxAbsQoverPtAxis_, nBinsPhiTrkAxis_, nBinsQoverPtAxis_, tmtt::L1fittedTrack::phiAtChosenR(), phiCentreSector_, funct::pow(), tmtt::L1fittedTrack::qOverPt(), tmtt::L1fittedTrack::qOverPt_bcon(), shape_, and square.

countFirmwareErrors()

void tmtt::HTrphi::countFirmwareErrors ( unsigned int  iQoverPtBin, unsigned int  iPhiTrkBinMin, unsigned int  iPhiTrkBinMax, unsigned int  jPhiTrkBinMinLast, unsigned int  jPhiTrkBinMaxLast  )

private

Definition at line 379 of file HTrphi.cc.

                                                                   {
    // Only do check if stub is being stored somewhere in this HT column.
    if (jPhiTrkBinMax >= jPhiTrkBinMin) {
      //--- Remaining code below checks that firmware could successfully store this stub in this column.
      //   (a) Does cell lie NE, E or SE of cell filled in previous column?
      bool OK_a = (jPhiTrkBinMin + 1 >= jPhiTrkBinMinLast) && (jPhiTrkBinMax <= jPhiTrkBinMaxLast + 1);
      //   (b) Are no more than 2 cells filled in this column
      bool OK_b = (jPhiTrkBinMax - jPhiTrkBinMin + 1 <= 2);
 
      if (!OK_a)
        errMon_->numErrorsTypeA++;
      if (!OK_b)
        errMon_->numErrorsTypeB++;
      errMon_->numErrorsNorm++;  // No. of times a stub is added to an HT column.
    }
  }

References errMon_, tmtt::HTrphi::ErrorMonitor::numErrorsNorm, tmtt::HTrphi::ErrorMonitor::numErrorsTypeA, and tmtt::HTrphi::ErrorMonitor::numErrorsTypeB.

Referenced by store().

getMbinRange()

unsigned int tmtt::HTrphi::getMbinRange

(

const L1track2D &

trk

)

const

Definition at line 317 of file HTrphi.cc.

                                                              {
    if (busySectorUseMbinRanges_) {
      unsigned int mBin = trk.cellLocationHT().first;
      unsigned int mBinOrder;
      if (busySectorUseMbinOrder_) {
        // User wants to group bins in a wierd order.
        mBinOrder = 99999;
        for (unsigned int k = 0; k < busySectorMbinOrder_.size(); k++) {
          if (mBin == busySectorMbinOrder_[k])
            mBinOrder = k;
        }
        if (mBinOrder == 99999)
          throw cms::Exception("LogicError") << "HTrphi::getMbinRange() mBinOrder calculation wrong.";
      } else {
        // User grouping bins in numerical order 0,1,2,3,4,5...
        mBinOrder = mBin;
      }
      for (unsigned int i = 0; i < busySectorMbinRanges_.size(); i++) {
        if (mBinOrder >= busySectorMbinLow_[i] && mBinOrder <= busySectorMbinHigh_[i])
          return i;
      }
      throw cms::Exception("LogicError") << "HTrphi::getMbinRange() messed up";
    } else {
      return 0;
    }
  }

References busySectorMbinHigh_, busySectorMbinLow_, busySectorMbinOrder_, busySectorMbinRanges_, busySectorUseMbinOrder_, busySectorUseMbinRanges_, tmtt::L1track2D::cellLocationHT(), Exception, mps_fire::i, and dqmdumpme::k.

Referenced by tmtt::MuxHToutputs::exec(), and killTracksBusySec().

helix2Dconventional()

pair< float, float > tmtt::HTrphi::helix2Dconventional ( unsigned int  i, unsigned int  j  ) const

overridevirtual

Implements tmtt::HTbase.

Definition at line 460 of file HTrphi.cc.

                                                                                     {
    // Get the helix parameters corresponding to the axes definitions of the HT.
    pair<float, float> helix2Dht = this->helix2Dhough(i, j);
    // Convert to the conventionally agreed pair of helix parameters, (q/pt, phi0).
    float qOverPt = helix2Dht.first;  // easy
    // If HT defined track phi other than at r=0, must correct to get phi0. Allow for 2*pi wrapping of phi.
    float phi0 = reco::deltaPhi(helix2Dht.second + invPtToDphi_ * chosenRofPhi_ * qOverPt, 0.);
    return pair<float, float>(qOverPt, phi0);
  }

References chosenRofPhi_, reco::deltaPhi(), helix2Dhough(), invPtToDphi_, and dqmiolumiharvest::j.

Referenced by HTrphi().

helix2Dhough()

pair< float, float > tmtt::HTrphi::helix2Dhough ( unsigned int  i, unsigned int  j  ) const

overridevirtual

Implements tmtt::HTbase.

Definition at line 404 of file HTrphi.cc.

                                                                              {
    unsigned int qOverPtBin = i;
    unsigned int phiTrkBin = j;
 
    // If using merged 2x2 cells in low Pt parts of array, must correct for this.
    bool merged = false;
    if (enableMerge2x2_) {
      // Check if this cell is merged with its neighbours (as in low Pt region).
      if (this->mergedCell(i, j)) {
        merged = true;
        // Get location of cell that this cell is merged into (iStore, jStore).
        // Calculation assumes HT array has even number of bins in both dimensions.
        if (i % 2 == 1)
          qOverPtBin = i - 1;
        if (j % 2 == 1)
          phiTrkBin = j - 1;
      }
    }
 
    float qOverPtBinCenter = .5;
    float phiTrkBinCenter = .5;
 
    if (shape_ != HTshape::square) {
      qOverPtBinCenter = 0.;
 
      float evenPhiPos = 0., oddPhiPos = 0.;
      if (shape_ == HTshape::hexagon) {
        evenPhiPos = 1. / 6.;
        oddPhiPos = 2. / 3.;
      } else if (shape_ == HTshape::diamond) {
        evenPhiPos = 0.;
        oddPhiPos = 0.5;
      } else if (shape_ == HTshape::brick) {
        evenPhiPos = 0.25;
        oddPhiPos = 0.75;
      }
      phiTrkBinCenter = (qOverPtBin % 2 == 0) ? evenPhiPos : oddPhiPos;
    }
 
    float qOverPt = -maxAbsQoverPtAxis_ + (qOverPtBin + qOverPtBinCenter) * binSizeQoverPtAxis_;
    float phiTrk = -maxAbsPhiTrkAxis_ + (phiTrkBin + phiTrkBinCenter) * binSizePhiTrkAxis_;
 
    if (merged) {
      qOverPt += 0.5 * binSizeQoverPtAxis_;
      phiTrk += 0.5 * binSizePhiTrkAxis_;
    }
 
    // Correct phiTrk to centre of sector, taking care of 2*pi wrapping
    phiTrk = reco::deltaPhi(phiTrk + phiCentreSector_, 0.);
    return pair<float, float>(qOverPt, phiTrk);
  }

References binSizePhiTrkAxis_, binSizeQoverPtAxis_, brick, reco::deltaPhi(), diamond, enableMerge2x2_, hexagon, mps_fire::i, dqmiolumiharvest::j, maxAbsPhiTrkAxis_, maxAbsQoverPtAxis_, mergedCell(), phiCentreSector_, shape_, and square.

Referenced by helix2Dconventional().

iPhiRange()

pair< unsigned int, unsigned int > tmtt::HTrphi::iPhiRange ( const Stub *  stub, unsigned int  iQoverPtBin, bool  debug = false  ) const

private

Definition at line 348 of file HTrphi.cc.

                                                                                                                 {
    // Note q/Pt value corresponding to centre of this bin.
    float qOverPtBin = -maxAbsQoverPtAxis_ + (iQoverPtBin + 0.5) * binSizeQoverPtAxis_;
    // Note change in this q/Pt value needed to reach either edge of the bin.
    float qOverPtBinVar = 0.5 * binSizeQoverPtAxis_;
 
    // Reducing effective bin width can reduce fake rate.
    //qOverPtVar = 0.4*binSizeQoverPtAxis_;
 
    // Calculate range of track-phi that would allow a track in this q/Pt range to pass through the stub.
    float phiTrk = stub->phi() + invPtToDphi_ * qOverPtBin * (stub->r() - chosenRofPhi_);
    // The next line does the phiTrk calculation without the usual approximation, but it doesn't
    // improve performance.
    //float phiTrk    = stub->phi() + asin(invPtToDphi_ * qOverPtBin * stub->r()) - asin(invPtToDphi_ * qOverPtBin * chosenRofPhi_);
    float phiTrkVar = invPtToDphi_ * qOverPtBinVar * std::abs(stub->r() - chosenRofPhi_);
    float phiTrkMin = phiTrk - phiTrkVar;
    float phiTrkMax = phiTrk + phiTrkVar;
 
    float deltaPhiMin = reco::deltaPhi(phiTrkMin, phiCentreSector_);  // Offset to centre of sector.
    float deltaPhiMax = reco::deltaPhi(phiTrkMax, phiCentreSector_);
    pair<float, float> phiTrkRange(deltaPhiMin, deltaPhiMax);
 
    // Determine which HT array cell range in track-phi this range "phiTrkRange" corresponds to.
    pair<unsigned int, unsigned int> iPhiTrkBinRange = this->HTbase::convertCoordRangeToBinRange(
        phiTrkRange, nBinsPhiTrkAxis_, (-maxAbsPhiTrkAxis_), binSizePhiTrkAxis_, killSomeHTCellsRphi_);
 
    return iPhiTrkBinRange;
  }

References funct::abs(), binSizePhiTrkAxis_, binSizeQoverPtAxis_, chosenRofPhi_, tmtt::HTbase::convertCoordRangeToBinRange(), reco::deltaPhi(), invPtToDphi_, killSomeHTCellsRphi_, maxAbsPhiTrkAxis_, maxAbsQoverPtAxis_, nBinsPhiTrkAxis_, tmtt::Stub::phi(), phiCentreSector_, and tmtt::Stub::r().

Referenced by store().

killTracksBusySec()

list< L1track2D > tmtt::HTrphi::killTracksBusySec ( const std::list< L1track2D > &  tracks ) const

overrideprivatevirtual

Implements tmtt::HTbase.

Definition at line 621 of file HTrphi.cc.

                                                                               {
    list<L1track2D> outTracks;
 
    if (busySectorKill_) {
      unsigned int nStubsOut = 0;  // #stubs assigned to tracks in this sector.
      // #stubs assigned to each m bin range in this sector.
      vector<unsigned int> nStubsOutInRange(busySectorMbinRanges_.size(), 0);
 
      for (const L1track2D& trk : tracks) {
        bool keep = true;
        unsigned int nStubs = trk.numStubs();  // #stubs on this track.
        if (busySectorUseMbinRanges_) {  // Are tracks from different m bin ranges output seperately to increase bandwidth?
          unsigned int mBinRange = this->getMbinRange(trk);  // Which m bin range is this track in?
          nStubsOutInRange[mBinRange] += nStubs;
          if (nStubsOutInRange[mBinRange] > busySectorNumStubs_)
            keep = false;
        } else {
          nStubsOut += nStubs;
          if (nStubsOut > busySectorNumStubs_)
            keep = false;
        }
 
        if (keep)
          outTracks.push_back(trk);
      }
 
    } else {
      outTracks = tracks;
    }
 
    return outTracks;
  }

References busySectorKill_, busySectorMbinRanges_, busySectorNumStubs_, busySectorUseMbinRanges_, getMbinRange(), keep, and PDWG_EXOHSCP_cff::tracks.

mergedCell()

bool tmtt::HTrphi::mergedCell	(	unsigned int	iQoverPtBin,
		unsigned int	jPhiTrkBin
	)		const

Definition at line 581 of file HTrphi.cc.

                                                                                 {
    bool merge = false;
 
    if (enableMerge2x2_) {
      unsigned int i = iQoverPtBin;
      //unsigned int j = jPhiTrkBin;
 
      // Calculate number of merged bins on each q/Pt side of array.
      float fMergeBins = (maxAbsQoverPtAxis_ - minInvPtToMerge2x2_) / (2. * binSizeQoverPtAxis_);
      // Number of unmerged bins this corresponds to, which must be even, since each merged bin comprises two normal q/pt bins.
      unsigned int numQoverPtBinsToMerge = 2 * min((unsigned int)(std::round(fMergeBins)), (nBinsQoverPtAxis_ / 4));
      const float small = 0.001;
      if (minInvPtToMerge2x2_ < small && (unsigned int)(std::round(2. * fMergeBins)) % 2 == 1)
        numQoverPtBinsToMerge++;
      unsigned int iB = (nBinsQoverPtAxis_ - 1) - i;  // Count backwards across array.
      if (min(i, iB) < numQoverPtBinsToMerge)
        merge = true;
    }
 
    return merge;
  }

References binSizeQoverPtAxis_, enableMerge2x2_, mps_fire::i, maxAbsQoverPtAxis_, MatrixUtil::merge(), min(), minInvPtToMerge2x2_, and nBinsQoverPtAxis_.

Referenced by helix2Dhough(), HTrphi(), and store().

nReceivedStubs()

unsigned int tmtt::HTrphi::nReceivedStubs ( ) const

inline

Definition at line 89 of file HTrphi.h.

{ return nReceivedStubs_; }

References nReceivedStubs_.

rowOrder()

vector< unsigned int > tmtt::HTrphi::rowOrder ( unsigned int  numRows ) const

overrideprivatevirtual

Implements tmtt::HTbase.

Definition at line 658 of file HTrphi.cc.

                                                                  {
    vector<unsigned int> iOrder;
 
    // Logic slightly different depending on whether HT array has even or odd number of rows.
    const bool oddNumRows = (numRows % 2 == 1);
 
    // This selects middle rows first before moving to exterior ones.
    if (oddNumRows) {
      unsigned int middleRow = (numRows - 1) / 2;
      iOrder.push_back(middleRow);
      for (unsigned int i = 1; i <= (numRows - 1) / 2; i++) {
        iOrder.push_back(middleRow - i);  // -ve charge
        iOrder.push_back(middleRow + i);  // +ve charge
      }
    } else {
      unsigned int startRowPos = numRows / 2;
      unsigned int startRowNeg = startRowPos - 1;
      for (unsigned int i = 0; i < numRows / 2; i++) {
        iOrder.push_back(startRowNeg - i);  // -ve charge
        iOrder.push_back(startRowPos + i);  // +ve charge
      }
    }
 
    return iOrder;
  }

References mps_fire::i.

store()

void tmtt::HTrphi::store	(	Stub *	stub,
		const std::vector< bool > &	inEtaSubSecs
	)

Definition at line 179 of file HTrphi.cc.

                                                                 {
    // Optionally, only store stubs that can be sent from GP to HT within TM period.
    if ((!busyInputSectorKill_) || (nReceivedStubs_ < busyInputSectorNumStubs_)) {
      nReceivedStubs_++;
 
      unsigned int jPhiTrkBinMinLast = 0;  // Used for error checking
      unsigned int jPhiTrkBinMaxLast = 99999;
 
      // Loop over q/Pt related bins in HT array.
      for (unsigned int i = 0; i < nBinsQoverPtAxis_; i++) {
        if (shape_ == HTshape::square) {
          //--- This is a traditional HT with square cells.
 
          // In this q/Pt bin, find the range of phi bins that this stub is consistent with.
          pair<unsigned int, unsigned int> jRange = this->iPhiRange(stub, i);
          unsigned int jPhiTrkBinMin = jRange.first;
          unsigned int jPhiTrkBinMax = jRange.second;
 
          // Store stubs in these cells.
          for (unsigned int j = jPhiTrkBinMin; j <= jPhiTrkBinMax; j++) {
            bool canStoreStub = true;
            unsigned int iStore = i;
            unsigned int jStore = j;
 
            // Optionally merge 2x2 neighbouring cells into a single cell at low Pt, to reduce efficiency loss
            // due to scattering.
            if (enableMerge2x2_) {
              // Check if this cell is merged with its neighbours (as in low Pt region).
              if (this->mergedCell(i, j)) {
                // Get location of cell that this cell is merged into (iStore, jStore).
                // Calculation assumes HT array has even number of bins in both dimensions.
                if (i % 2 == 1)
                  iStore = i - 1;
                if (j % 2 == 1)
                  jStore = j - 1;
                // If this stub was already stored in this merged 2x2 cell, then don't store it again.
                if (HTbase::htArray_(iStore, jStore)->stubStoredInCell(stub))
                  canStoreStub = false;
              }
            }
 
            if (canStoreStub)
              HTbase::htArray_(iStore, jStore)->store(stub, inEtaSubSecs);  // Calls HTcell::store()
          }
 
          // Check that limitations of firmware would not prevent stub being stored correctly in this HT column.
          if (errMon_ != nullptr) {
            this->countFirmwareErrors(i, jPhiTrkBinMin, jPhiTrkBinMax, jPhiTrkBinMinLast, jPhiTrkBinMaxLast);
            jPhiTrkBinMinLast = jPhiTrkBinMin;
            jPhiTrkBinMaxLast = jPhiTrkBinMax;
          }
 
        } else {
          //--- This is are novel HT with unusual shaped cells.
 
          if (shape_ == HTshape::diamond) {
            //--- This HT has diamond shaped cells.
 
            float qOverPtBin = -maxAbsQoverPtAxis_ + i * binSizeQoverPtAxis_;
            float phiTrk = reco::deltaPhi(stub->phi(), phiCentreSector_) +
                           invPtToDphi_ * qOverPtBin * (stub->r() - chosenRofPhi_) + maxAbsPhiTrkAxis_;
            if (i % 2 == 0)
              phiTrk += binSizePhiTrkAxis_ / 2.;
            unsigned int binCenter = std::floor(phiTrk / binSizePhiTrkAxis_);
            if (binCenter < nBinsPhiTrkAxis_)
              HTbase::htArray_(i, binCenter)->store(stub, inEtaSubSecs);
 
          } else if (shape_ == HTshape::hexagon) {
            //--- This HT has hexagonal cells (with two of its sides parallel to the phi axis).
 
            float qOverPtBin = -maxAbsQoverPtAxis_ + i * binSizeQoverPtAxis_;
            float qOverPtBinVar = binSizeQoverPtAxis_;
            float phiTrk = reco::deltaPhi(stub->phi(), phiCentreSector_) +
                           invPtToDphi_ * qOverPtBin * (stub->r() - chosenRofPhi_) + maxAbsPhiTrkAxis_;
            float phiTrkVar = invPtToDphi_ * qOverPtBinVar * std::abs(stub->r() - chosenRofPhi_);
            float phiTrkMin = phiTrk - phiTrkVar;
            float phiTrkMax = phiTrk + phiTrkVar;
            if (i % 2 == 0)
              phiTrk += binSizePhiTrkAxis_ / 6.;
            else {
              phiTrk -= binSizePhiTrkAxis_ / 3.;
              phiTrkMin -= binSizePhiTrkAxis_ / 2.;
              phiTrkMax -= binSizePhiTrkAxis_ / 2.;
            }
            unsigned int iCenter = std::floor(phiTrk / binSizePhiTrkAxis_ * 3.);
            unsigned int iMin = std::floor(phiTrkMin / binSizePhiTrkAxis_ * 3.);
            unsigned int iMax = std::floor(phiTrkMax / binSizePhiTrkAxis_ * 3.);
            std::pair<bool, unsigned int> binCenter;
            std::pair<bool, unsigned int> binMin;
            std::pair<bool, unsigned int> binMax;
            binCenter.second = iCenter / 3;
            binMin.second = iMin / 3;
            binMax.second = iMax / 3;
            binCenter.first = !(iCenter % 3 == 2);
            binMin.first = (iMin % 3 == 0);
            binMax.first = (iMax % 3 == 0);
            if (binCenter.first && binCenter.second < nBinsPhiTrkAxis_)
              HTbase::htArray_(i, binCenter.second)->store(stub, inEtaSubSecs);
            else if (binMin.first && binMin.second < nBinsPhiTrkAxis_)
              HTbase::htArray_(i, binMin.second)->store(stub, inEtaSubSecs);
            else if (binMax.first && binMax.second < nBinsPhiTrkAxis_)
              HTbase::htArray_(i, binMax.second)->store(stub, inEtaSubSecs);
 
          } else if (shape_ == HTshape::brick) {
            //--- This HT has square cells with alternate rows shifted horizontally by 0.5*cell_width.
 
            float qOverPtBin = -maxAbsQoverPtAxis_ + i * binSizeQoverPtAxis_;
            float qOverPtBinVar = binSizeQoverPtAxis_;
            float phiTrk = reco::deltaPhi(stub->phi(), phiCentreSector_) +
                           invPtToDphi_ * qOverPtBin * (stub->r() - chosenRofPhi_) + maxAbsPhiTrkAxis_;
            float phiTrkVar = invPtToDphi_ * qOverPtBinVar * std::abs(stub->r() - chosenRofPhi_);
            float phiTrkMin = phiTrk - phiTrkVar;
            float phiTrkMax = phiTrk + phiTrkVar;
            unsigned int iMin = std::floor(phiTrkMin / binSizePhiTrkAxis_ * 2.);
            unsigned int iMax = std::floor(phiTrkMax / binSizePhiTrkAxis_ * 2.);
            std::pair<bool, unsigned int> binMin;
            std::pair<bool, unsigned int> binMax;
            binMin.second = iMin / 2;
            binMax.second = iMax / 2;
            binMin.first = (iMin % 2 == i % 2);
            binMax.first = (iMax % 2 == i % 2);
            if (binMin.first && binMin.second < nBinsPhiTrkAxis_)
              HTbase::htArray_(i, binMin.second)->store(stub, inEtaSubSecs);
            else if (binMax.first && binMax.second < nBinsPhiTrkAxis_)
              HTbase::htArray_(i, binMax.second)->store(stub, inEtaSubSecs);
          }
        }
      }
      // Note max. |gradient| that the line corresponding to any stub in any of the r-phi HT arrays could have.
      // Firmware assumes this should not exceed 1.0;
      if (errMon_ != nullptr) {
        errMon_->maxLineGradient = max(errMon_->maxLineGradient.load(), this->calcLineGradArray(stub->r()));
      }
    }
  }

References funct::abs(), spclusmultinvestigator_cfi::binMax, binSizePhiTrkAxis_, binSizeQoverPtAxis_, brick, busyInputSectorKill_, busyInputSectorNumStubs_, calcLineGradArray(), chosenRofPhi_, countFirmwareErrors(), reco::deltaPhi(), diamond, enableMerge2x2_, errMon_, hexagon, tmtt::HTbase::htArray_, mps_fire::i, invPtToDphi_, iPhiRange(), dqmiolumiharvest::j, SiStripPI::max, maxAbsPhiTrkAxis_, maxAbsQoverPtAxis_, tmtt::HTrphi::ErrorMonitor::maxLineGradient, mergedCell(), nBinsPhiTrkAxis_, nBinsQoverPtAxis_, nReceivedStubs_, tmtt::Stub::phi(), phiCentreSector_, tmtt::Stub::r(), shape_, and square.

trueCell()

pair< unsigned int, unsigned int > tmtt::HTrphi::trueCell ( const TP *  tp ) const

overridevirtual

Implements tmtt::HTbase.

Definition at line 473 of file HTrphi.cc.

                                                                      {
    // Get HT axis variables corresponding to this TP.
    float qOverPt = tp->qOverPt();
    float phiTrk = tp->trkPhiAtR(chosenRofPhi_);
    // Measure phi relative to centre of sector.
    float deltaPhi = reco::deltaPhi(phiTrk, phiCentreSector_);
    // Convert to bin numbers inside HT array.
    int iQoverPt = floor((qOverPt - (-maxAbsQoverPtAxis_)) / binSizeQoverPtAxis_);
    int iPhiTrk = floor((deltaPhi - (-maxAbsPhiTrkAxis_)) / binSizePhiTrkAxis_);
    // Check if this cell was within the HT array.
    if (iQoverPt >= 0 && iQoverPt < int(nBinsQoverPtAxis_) && iPhiTrk >= 0 && iPhiTrk < int(nBinsPhiTrkAxis_)) {
      // Check if this cell is merged with its neighbours (as in low Pt region), and if so return merged cell location.
      // New: because 2nd stage mini HT may recreate tracks from merged cells with finer cell granularity, one can't predict
      //      if a merged cell was used to create a track merely by looking at its cell location.
      //      So instead ask L1track3D, which knows if it was created from a merged HT cell or not.
      ;
    } else {
      // TP is not in this HT array at all. Flag this by setting "outside" bin index to 0 (Nbins) if outside array below (above).
      if (iQoverPt < 0)
        iQoverPt = 0;
      if (iQoverPt >= int(nBinsQoverPtAxis_))
        iQoverPt = nBinsQoverPtAxis_ - 1;
      if (iPhiTrk < 0)
        iPhiTrk = 0;
      if (iPhiTrk >= int(nBinsPhiTrkAxis_))
        iPhiTrk = nBinsPhiTrkAxis_ - 1;
    }
    return pair<unsigned int, unsigned int>(iQoverPt, iPhiTrk);
  }

References binSizePhiTrkAxis_, binSizeQoverPtAxis_, chosenRofPhi_, SiPixelRawToDigiRegional_cfi::deltaPhi, reco::deltaPhi(), maxAbsPhiTrkAxis_, maxAbsQoverPtAxis_, nBinsPhiTrkAxis_, nBinsQoverPtAxis_, phiCentreSector_, and cmsswSequenceInfo::tp.

Referenced by tmtt::L1track3D::cheat().

Member Data Documentation

binSizePhiTrkAxis_

float tmtt::HTrphi::binSizePhiTrkAxis_

private

Definition at line 135 of file HTrphi.h.

Referenced by calcLineGradArray(), cell(), helix2Dhough(), HTrphi(), iPhiRange(), store(), and trueCell().

binSizeQoverPtAxis_

float tmtt::HTrphi::binSizeQoverPtAxis_

private

Definition at line 129 of file HTrphi.h.

Referenced by calcLineGradArray(), cell(), helix2Dhough(), HTrphi(), iPhiRange(), mergedCell(), store(), and trueCell().

busyInputSectorKill_

bool tmtt::HTrphi::busyInputSectorKill_

private

Definition at line 145 of file HTrphi.h.

Referenced by HTrphi(), and store().

busyInputSectorNumStubs_

unsigned int tmtt::HTrphi::busyInputSectorNumStubs_

private

Definition at line 147 of file HTrphi.h.

Referenced by HTrphi(), and store().

busySectorKill_

bool tmtt::HTrphi::busySectorKill_

private

Definition at line 146 of file HTrphi.h.

Referenced by HTrphi(), and killTracksBusySec().

busySectorMbinHigh_

std::vector<unsigned int> tmtt::HTrphi::busySectorMbinHigh_

private

Definition at line 154 of file HTrphi.h.

Referenced by getMbinRange(), and HTrphi().

busySectorMbinLow_

std::vector<unsigned int> tmtt::HTrphi::busySectorMbinLow_

private

Definition at line 153 of file HTrphi.h.

Referenced by getMbinRange(), and HTrphi().

busySectorMbinOrder_

std::vector<unsigned int> tmtt::HTrphi::busySectorMbinOrder_

private

Definition at line 150 of file HTrphi.h.

Referenced by getMbinRange(), and HTrphi().

busySectorMbinRanges_

std::vector<unsigned int> tmtt::HTrphi::busySectorMbinRanges_

private

Definition at line 149 of file HTrphi.h.

Referenced by getMbinRange(), HTrphi(), and killTracksBusySec().

busySectorNumStubs_

unsigned int tmtt::HTrphi::busySectorNumStubs_

private

Definition at line 148 of file HTrphi.h.

Referenced by HTrphi(), and killTracksBusySec().

busySectorUseMbinOrder_

bool tmtt::HTrphi::busySectorUseMbinOrder_

private

Definition at line 152 of file HTrphi.h.

Referenced by getMbinRange(), and HTrphi().

busySectorUseMbinRanges_

bool tmtt::HTrphi::busySectorUseMbinRanges_

private

Definition at line 151 of file HTrphi.h.

Referenced by getMbinRange(), HTrphi(), and killTracksBusySec().

cellCenters_

std::vector<std::vector<std::pair<float, float> > > tmtt::HTrphi::cellCenters_

private

Definition at line 123 of file HTrphi.h.

Referenced by cell(), and HTrphi().

chosenRofPhi_

float tmtt::HTrphi::chosenRofPhi_

private

Definition at line 131 of file HTrphi.h.

Referenced by calcLineGradArray(), helix2Dconventional(), iPhiRange(), store(), and trueCell().

enableMerge2x2_

bool tmtt::HTrphi::enableMerge2x2_

private

Definition at line 137 of file HTrphi.h.

Referenced by helix2Dhough(), HTrphi(), mergedCell(), and store().

errMon_

ErrorMonitor* tmtt::HTrphi::errMon_

private

Definition at line 161 of file HTrphi.h.

Referenced by countFirmwareErrors(), and store().

invPtToDphi_

float tmtt::HTrphi::invPtToDphi_

private

Definition at line 120 of file HTrphi.h.

Referenced by calcLineGradArray(), helix2Dconventional(), iPhiRange(), and store().

killSomeHTCellsRphi_

unsigned int tmtt::HTrphi::killSomeHTCellsRphi_

private

Definition at line 143 of file HTrphi.h.

Referenced by HTrphi(), and iPhiRange().

maxAbsPhiTrkAxis_

float tmtt::HTrphi::maxAbsPhiTrkAxis_

private

Definition at line 133 of file HTrphi.h.

Referenced by cell(), helix2Dhough(), HTrphi(), iPhiRange(), store(), and trueCell().

maxAbsQoverPtAxis_

float tmtt::HTrphi::maxAbsQoverPtAxis_

private

Definition at line 127 of file HTrphi.h.

Referenced by cell(), helix2Dhough(), HTrphi(), iPhiRange(), mergedCell(), store(), and trueCell().

minInvPtToMerge2x2_

float tmtt::HTrphi::minInvPtToMerge2x2_

private

Definition at line 138 of file HTrphi.h.

Referenced by HTrphi(), and mergedCell().

nBinsPhiTrkAxis_

unsigned int tmtt::HTrphi::nBinsPhiTrkAxis_

private

Definition at line 134 of file HTrphi.h.

Referenced by cell(), HTrphi(), iPhiRange(), store(), and trueCell().

nBinsQoverPtAxis_

unsigned int tmtt::HTrphi::nBinsQoverPtAxis_

private

Definition at line 128 of file HTrphi.h.

Referenced by cell(), HTrphi(), mergedCell(), store(), and trueCell().

nReceivedStubs_

unsigned int tmtt::HTrphi::nReceivedStubs_

private

Definition at line 158 of file HTrphi.h.

Referenced by HTrphi(), nReceivedStubs(), and store().

phiCentreSector_

float tmtt::HTrphi::phiCentreSector_

private

Definition at line 132 of file HTrphi.h.

Referenced by cell(), helix2Dhough(), iPhiRange(), store(), and trueCell().

shape_

HTshape tmtt::HTrphi::shape_

private

Definition at line 122 of file HTrphi.h.

Referenced by calcLineGradArray(), cell(), helix2Dhough(), HTrphi(), and store().