trklet::MatchProcessor Class Reference

#include <MatchProcessor.h>

Inheritance diagram for trklet::MatchProcessor:

Public Member Functions
void	addInput (MemoryBase *memory, std::string input) override
void	addOutput (MemoryBase *memory, std::string output) override
void	execute (unsigned int iSector, double phimin)
bool	matchCalculator (Tracklet *tracklet, const Stub *fpgastub, bool print, unsigned int istep)
	MatchProcessor (std::string name, Settings const &settings, Globals *global)
	~MatchProcessor () override=default
Public Member Functions inherited from trklet::ProcessBase
unsigned int	getISeed (const std::string &name)
std::string const &	getName () const
unsigned int	initLayerDisk (unsigned int pos)
void	initLayerDisk (unsigned int pos, int &layer, int &disk)
void	initLayerDisk (unsigned int pos, int &layer, int &disk, int &layerdisk)
void	initLayerDisksandISeed (unsigned int &layerdisk1, unsigned int &layerdisk2, unsigned int &iSeed)
unsigned int	nbits (unsigned int power)
	ProcessBase (std::string name, Settings const &settings, Globals *global)
virtual	~ProcessBase ()=default

Private Attributes
AllStubsMemory *	allstubs_
bool	barrel_
int	dzshift_
std::vector< FullMatchMemory * >	fullmatches_
int	ialphafactinner_ [N_DSS_MOD *2]
int	ialphafactouter_ [N_DSS_MOD *2]
int	icorrshift_
int	icorzshift_
CircularBuffer< ProjectionTemp >	inputProjBuffer_
std::vector< TrackletProjectionsMemory * >	inputprojs_
unsigned int	layerdisk_
TrackletLUT	luttable_
std::vector< MatchEngineUnit >	matchengines_
unsigned int	nMatchEngines_
int	nphiderbits_
int	nrbits_
int	nrinv_
int	nvm_
int	nvmbins_
int	nvmbits_
TrackletLUT	phimatchcuttable_
double	phimin_
unsigned int	phiregion_
int	phishift_
TrackletLUT	rcut2Stable_
TrackletLUT	rcutPStable_
TrackletLUT	rinvbendlut_
TrackletLUT	rphicut2Stable_
TrackletLUT	rphicutPStable_
std::vector< VMStubsMEMemory * >	vmstubs_
TrackletLUT	zmatchcuttable_

Additional Inherited Members
Protected Attributes inherited from trklet::ProcessBase
Globals *	globals_
std::string	name_
Settings const &	settings_

Detailed Description

Definition at line 25 of file MatchProcessor.h.

Constructor & Destructor Documentation

MatchProcessor()

MatchProcessor::MatchProcessor	(	std::string	name,
		Settings const &	settings,
		Globals *	global
	)

Definition at line 16 of file MatchProcessor.cc.

    : ProcessBase(name, settings, global),
      phimatchcuttable_(settings),
      zmatchcuttable_(settings),
      rphicutPStable_(settings),
      rphicut2Stable_(settings),
      rcutPStable_(settings),
      rcut2Stable_(settings),
      fullmatches_(12),
      rinvbendlut_(settings),
      luttable_(settings),
      inputProjBuffer_(3) {
  phiregion_ = name[8] - 'A';
 
  layerdisk_ = initLayerDisk(3);
 
  barrel_ = layerdisk_ < N_LAYER;
 
  phishift_ = settings_.nphibitsstub(N_LAYER - 1) - settings_.nphibitsstub(layerdisk_);
  dzshift_ = settings_.nzbitsstub(0) - settings_.nzbitsstub(layerdisk_);
 
  if (barrel_) {
    icorrshift_ = ilog2(settings_.kphi(layerdisk_) / (settings_.krbarrel() * settings_.kphider()));
    icorzshift_ = ilog2(settings_.kz(layerdisk_) / (settings_.krbarrel() * settings_.kzder()));
  } else {
    icorrshift_ = ilog2(settings_.kphi(layerdisk_) / (settings_.kz() * settings_.kphiderdisk()));
    icorzshift_ = ilog2(settings_.krprojshiftdisk() / (settings_.kz() * settings_.krder()));
  }
 
  luttable_.initBendMatch(layerdisk_);
 
  nrbits_ = 5;
  nphiderbits_ = 6;
 
  if (!barrel_) {
    rinvbendlut_.initProjectionBend(
        global->ITC_L1L2()->der_phiD_final.K(), layerdisk_ - N_LAYER, nrbits_, nphiderbits_);
  }
 
  nrinv_ = NRINVBITS;
 
  unsigned int region = getName()[8] - 'A';
  assert(region < settings_.nallstubs(layerdisk_));
 
  if (barrel_) {
    phimatchcuttable_.initmatchcut(layerdisk_, TrackletLUT::MatchType::barrelphi, region);
    zmatchcuttable_.initmatchcut(layerdisk_, TrackletLUT::MatchType::barrelz, region);
  } else {
    rphicutPStable_.initmatchcut(layerdisk_, TrackletLUT::MatchType::diskPSphi, region);
    rphicut2Stable_.initmatchcut(layerdisk_, TrackletLUT::MatchType::disk2Sphi, region);
    rcutPStable_.initmatchcut(layerdisk_, TrackletLUT::MatchType::diskPSr, region);
    rcut2Stable_.initmatchcut(layerdisk_, TrackletLUT::MatchType::disk2Sr, region);
  }
 
  for (unsigned int i = 0; i < N_DSS_MOD * 2; i++) {
    ialphafactinner_[i] = (1 << settings_.alphashift()) * settings_.krprojshiftdisk() * settings_.half2SmoduleWidth() /
                          (1 << (settings_.nbitsalpha() - 1)) / (settings_.rDSSinner(i) * settings_.rDSSinner(i)) /
                          settings_.kphi();
    ialphafactouter_[i] = (1 << settings_.alphashift()) * settings_.krprojshiftdisk() * settings_.half2SmoduleWidth() /
                          (1 << (settings_.nbitsalpha() - 1)) / (settings_.rDSSouter(i) * settings_.rDSSouter(i)) /
                          settings_.kphi();
  }
 
  nvm_ = settings_.nvmme(layerdisk_) * settings_.nallstubs(layerdisk_);
  nvmbins_ = settings_.nvmme(layerdisk_);
  nvmbits_ = settings_.nbitsvmme(layerdisk_) + settings_.nbitsallstubs(layerdisk_);
 
  nMatchEngines_ = 4;
  for (unsigned int iME = 0; iME < nMatchEngines_; iME++) {
    MatchEngineUnit tmpME(barrel_, layerdisk_, luttable_);
    matchengines_.push_back(tmpME);
  }
}

References trklet::Settings::alphashift(), cms::cuda::assert(), barrel_, trklet::IMATH_TrackletCalculator::der_phiD_final, dzshift_, trklet::ProcessBase::getName(), trklet::Settings::half2SmoduleWidth(), mps_fire::i, ialphafactinner_, ialphafactouter_, icorrshift_, icorzshift_, trklet::ilog2(), trklet::TrackletLUT::initBendMatch(), trklet::ProcessBase::initLayerDisk(), trklet::TrackletLUT::initmatchcut(), trklet::TrackletLUT::initProjectionBend(), trklet::Globals::ITC_L1L2(), trklet::VarBase::K(), trklet::Settings::kphi(), trklet::Settings::kphider(), trklet::Settings::kphiderdisk(), trklet::Settings::krbarrel(), trklet::Settings::krder(), trklet::Settings::krprojshiftdisk(), trklet::Settings::kz(), trklet::Settings::kzder(), layerdisk_, luttable_, matchengines_, trklet::N_DSS_MOD, trklet::N_LAYER, trklet::Settings::nallstubs(), Skims_PA_cff::name, trklet::Settings::nbitsallstubs(), trklet::Settings::nbitsalpha(), trklet::Settings::nbitsvmme(), nMatchEngines_, trklet::Settings::nphibitsstub(), nphiderbits_, nrbits_, nrinv_, trklet::NRINVBITS, nvm_, nvmbins_, nvmbits_, trklet::Settings::nvmme(), trklet::Settings::nzbitsstub(), phimatchcuttable_, phiregion_, phishift_, rcut2Stable_, rcutPStable_, trklet::Settings::rDSSinner(), trklet::Settings::rDSSouter(), HLT_FULL_cff::region, rinvbendlut_, rphicut2Stable_, rphicutPStable_, trklet::ProcessBase::settings_, and zmatchcuttable_.

~MatchProcessor()

trklet::MatchProcessor::~MatchProcessor ( )

overridedefault

Member Function Documentation

addInput()

void MatchProcessor::addInput ( MemoryBase *  memory, std::string  input  )

overridevirtual

Implements trklet::ProcessBase.

Definition at line 107 of file MatchProcessor.cc.

                                                              {
  if (settings_.writetrace()) {
    edm::LogVerbatim("Tracklet") << "In " << name_ << " adding input from " << memory->getName() << " to input "
                                 << input;
  }
  if (input == "allstubin") {
    auto* tmp = dynamic_cast<AllStubsMemory*>(memory);
    assert(tmp != nullptr);
    allstubs_ = tmp;
    return;
  }
  if (input == "vmstubin") {
    auto* tmp = dynamic_cast<VMStubsMEMemory*>(memory);
    assert(tmp != nullptr);
    vmstubs_.push_back(tmp);  //to allow more than one stub in?  vmstubs_=tmp;
    return;
  }
  if (input == "projin") {
    auto* tmp = dynamic_cast<TrackletProjectionsMemory*>(memory);
    assert(tmp != nullptr);
    inputprojs_.push_back(tmp);
    return;
  }
  throw cms::Exception("BadConfig") << __FILE__ << " " << __LINE__ << " could not find input: " << input;
}

References allstubs_, cms::cuda::assert(), Exception, input, inputprojs_, trklet::ProcessBase::name_, trklet::ProcessBase::settings_, createJobs::tmp, vmstubs_, and trklet::Settings::writetrace().

addOutput()

void MatchProcessor::addOutput ( MemoryBase *  memory, std::string  output  )

overridevirtual

Implements trklet::ProcessBase.

Definition at line 90 of file MatchProcessor.cc.

                                                                {
  if (settings_.writetrace()) {
    edm::LogVerbatim("Tracklet") << "In " << name_ << " adding output to " << memory->getName() << " to output "
                                 << output;
  }
  if (output.find("matchout") != std::string::npos) {
    auto* tmp = dynamic_cast<FullMatchMemory*>(memory);
    assert(tmp != nullptr);
    unsigned int iSeed = getISeed(tmp->getName());
    assert(iSeed < fullmatches_.size());
    assert(fullmatches_[iSeed] == nullptr);
    fullmatches_[iSeed] = tmp;
    return;
  }
  throw cms::Exception("BadConfig") << __FILE__ << " " << __LINE__ << " could not find output: " << output;
}

References cms::cuda::assert(), Exception, fullmatches_, trklet::ProcessBase::getISeed(), trklet::ProcessBase::name_, convertSQLitetoXML_cfg::output, trklet::ProcessBase::settings_, createJobs::tmp, and trklet::Settings::writetrace().

execute()

void MatchProcessor::execute	(	unsigned int	iSector,
		double	phimin
	)

Definition at line 133 of file MatchProcessor.cc.

                                                                {
  assert(vmstubs_.size() == 1);
 
  /*
    The code is organized in three 'steps' corresponding to the PR, ME, and MC functions. The output from
    the PR step is buffered in a 'circular' buffer, and similarly the ME output is put in a circular buffer. 
    
    The implementation is done in steps, emulating what can be done in firmware. One each step we do:
    
    1) A projection is read and if there is space it is insert into the inputProjBuffer_
    
    2) Process next match in the ME - if there is an idle ME the next projection is inserted
    
    3) Readout match from ME and send to match calculator
    
  */
 
  bool print = getName() == "MP_L3PHIC" && iSector == 3;
  print = false;
 
  phimin_ = phimin;
 
  Tracklet* oldTracklet = nullptr;
 
  unsigned int countme = 0;
  unsigned int countall = 0;
  unsigned int countsel = 0;
  unsigned int countinputproj = 0;
 
  unsigned int iprojmem = 0;
  while (iprojmem < inputprojs_.size() && inputprojs_[iprojmem]->nTracklets() == 0) {
    iprojmem++;
  }
 
  unsigned int iproj = 0;
 
  inputProjBuffer_.reset();
 
  for (const auto& inputproj : inputprojs_) {
    countinputproj += inputproj->nTracklets();
  }
 
  for (auto& matchengine : matchengines_) {
    matchengine.reset();
  }
 
  ProjectionTemp tmpProj_, tmpProj__;
  bool good_ = false;
  bool good__ = false;
 
  for (unsigned int istep = 0; istep < settings_.maxStep("MP"); istep++) {
    bool projBuffNearFull = inputProjBuffer_.nearfull();
 
    // This print statement is useful for detailed comparison with the HLS code
    // It prints out detailed status information for each clock step
    /* 
    if (print) {
      cout << "istep = "<<istep<<" projBuff: "<<inputProjBuffer_.rptr()<<" "<<inputProjBuffer_.wptr()<<" "<<projBuffNearFull;
      unsigned int iMEU = 0;
      for (auto& matchengine : matchengines_) {
    cout <<" MEU"<<iMEU<<": "<<matchengine.rptr()<<" "<<matchengine.wptr()
         <<" "<<matchengine.idle()<<" "<<matchengine.empty()
         <<" "<<matchengine.have_()<<matchengine.have__()
         <<" "<<matchengine.TCID();
    iMEU++;
      }
      cout << std::endl;
    }
    */
 
    bool projdone = false;
 
    //Step 3
    //Check if we have candidate match to process
 
    unsigned int iMEbest = 0;
    int bestTCID = matchengines_[0].TCID();
    bool meactive = matchengines_[0].active();
    for (unsigned int iME = 1; iME < nMatchEngines_; iME++) {
      meactive = meactive || matchengines_[iME].active();
      int tcid = matchengines_[iME].TCID();
      if (tcid < bestTCID) {
        bestTCID = tcid;
        iMEbest = iME;
      }
    }
 
    if (!matchengines_[iMEbest].empty()) {
      std::pair<Tracklet*, const Stub*> candmatch = matchengines_[iMEbest].read();
 
      const Stub* fpgastub = candmatch.second;
      Tracklet* tracklet = candmatch.first;
 
      if (oldTracklet != nullptr) {
        //allow equal here since we can have more than one cadidate match per tracklet projection
        //cout << "old new : "<<oldTracklet->TCID()<<" "<<tracklet->TCID()<<" "<<iMEbest<<endl;
        assert(oldTracklet->TCID() <= tracklet->TCID());
      }
      oldTracklet = tracklet;
 
      bool match = matchCalculator(tracklet, fpgastub, print, istep);
 
      if (settings_.debugTracklet() && match) {
        edm::LogVerbatim("Tracklet") << getName() << " have match";
      }
 
      countall++;
      if (match)
        countsel++;
    }
 
    //Step 2
    //Check if we have ME that can process projection
 
    bool addedProjection = false;
    for (unsigned int iME = 0; iME < nMatchEngines_; iME++) {
      if (!matchengines_[iME].idle())
        countme++;
      //if match engine empty and we have queued projections add to match engine
      if ((!addedProjection) && matchengines_[iME].idle() && (!inputProjBuffer_.empty())) {
        ProjectionTemp tmpProj = inputProjBuffer_.read();
        VMStubsMEMemory* stubmem = vmstubs_[0];
 
        if (settings_.debugTracklet()) {
          edm::LogVerbatim("Tracklet") << getName() << " adding projection to match engine";
        }
 
        int nbins = (1 << N_RZBITS);
        if (layerdisk_ >= N_LAYER) {
          nbins *= 2;  //twice as many bins in disks (since there are two disks)
        }
 
        matchengines_[iME].init(stubmem,
                                nbins,
                                tmpProj.slot(),
                                tmpProj.iphi(),
                                tmpProj.shift(),
                                tmpProj.projrinv(),
                                tmpProj.projfinerz(),
                                tmpProj.projfinephi(),
                                tmpProj.use(0, 0),
                                tmpProj.use(0, 1),
                                tmpProj.use(1, 0),
                                tmpProj.use(1, 1),
                                tmpProj.isPSseed(),
                                tmpProj.proj(),
                                print && (iME == 0));
        addedProjection = true;
      } else {
        matchengines_[iME].step(print && iME == 0);
      }
    }
 
    //Step 1
    //First step here checks if we have more input projections to put into
    //the input puffer for projections
 
    if (good__) {
      inputProjBuffer_.store(tmpProj__);
    }
 
    good__ = good_;
    tmpProj__ = tmpProj_;
 
    good_ = false;
 
    if (istep < settings_.maxStep("MP")) {
      if (iprojmem < inputprojs_.size()) {
        TrackletProjectionsMemory* projMem = inputprojs_[iprojmem];
        if (!projBuffNearFull) {
          if (settings_.debugTracklet()) {
            edm::LogVerbatim("Tracklet") << getName() << " have projection in memory : " << projMem->getName();
          }
 
          Tracklet* proj = projMem->getTracklet(iproj);
 
          FPGAWord fpgaphi = proj->proj(layerdisk_).fpgaphiproj();
 
          unsigned int iphi = (fpgaphi.value() >> (fpgaphi.nbits() - nvmbits_)) & (nvmbins_ - 1);
 
          int nextrabits = 2;
          int overlapbits = nvmbits_ + nextrabits;
 
          unsigned int extrabits = fpgaphi.bits(fpgaphi.nbits() - overlapbits, nextrabits);
 
          unsigned int ivmPlus = iphi;
 
          int shift = 0;
 
          if (extrabits == ((1U << nextrabits) - 1) && iphi != ((1U << settings_.nbitsvmme(layerdisk_)) - 1)) {
            shift = 1;
            ivmPlus++;
          }
          unsigned int ivmMinus = iphi;
          if (extrabits == 0 && iphi != 0) {
            shift = -1;
            ivmMinus--;
          }
 
          int projrinv = -1;
          if (barrel_) {
            FPGAWord phider = proj->proj(layerdisk_).fpgaphiprojder();
            projrinv = (1 << (nrinv_ - 1)) - 1 - (phider.value() >> (phider.nbits() - nrinv_));
          } else {
            //The next lines looks up the predicted bend based on:
            // 1 - r projections
            // 2 - phi derivative
            // 3 - the sign - i.e. if track is forward or backward
 
            int rindex = (proj->proj(layerdisk_).fpgarzproj().value() >>
                          (proj->proj(layerdisk_).fpgarzproj().nbits() - nrbits_)) &
                         ((1 << nrbits_) - 1);
 
            int phiderindex = (proj->proj(layerdisk_).fpgaphiprojder().value() >>
                               (proj->proj(layerdisk_).fpgaphiprojder().nbits() - nphiderbits_)) &
                              ((1 << nphiderbits_) - 1);
 
            int signindex = proj->proj(layerdisk_).fpgarzprojder().value() < 0;
 
            int bendindex = (signindex << (nphiderbits_ + nrbits_)) + (rindex << (nphiderbits_)) + phiderindex;
 
            projrinv = rinvbendlut_.lookup(bendindex);
 
            proj->proj(layerdisk_).setBendIndex(projrinv);
          }
          assert(projrinv >= 0);
 
          unsigned int slot = proj->proj(layerdisk_).fpgarzbin1projvm().value();
          bool second = proj->proj(layerdisk_).fpgarzbin2projvm().value();
 
          unsigned int projfinephi =
              (fpgaphi.value() >> (fpgaphi.nbits() - (nvmbits_ + NFINEPHIBITS))) & ((1 << NFINEPHIBITS) - 1);
          int projfinerz = proj->proj(layerdisk_).fpgafinerzvm().value();
 
          bool isPSseed = proj->PSseed();
 
          int nbins = (1 << N_RZBITS);
          if (layerdisk_ >= N_LAYER) {
            nbins *= 2;  //twice as many bins in disks (since there are two disks)
          }
 
          VMStubsMEMemory* stubmem = vmstubs_[0];
          bool usefirstMinus = stubmem->nStubsBin(ivmMinus * nbins + slot) != 0;
          bool usesecondMinus = (second && (stubmem->nStubsBin(ivmMinus * nbins + slot + 1) != 0));
          bool usefirstPlus = ivmPlus != ivmMinus && stubmem->nStubsBin(ivmPlus * nbins + slot) != 0;
          bool usesecondPlus = ivmPlus != ivmMinus && (second && (stubmem->nStubsBin(ivmPlus * nbins + slot + 1) != 0));
 
          good_ = usefirstPlus || usesecondPlus || usefirstMinus || usesecondMinus;
 
          if (good_) {
            ProjectionTemp tmpProj(proj,
                                   slot,
                                   projrinv,
                                   projfinerz,
                                   projfinephi,
                                   ivmMinus,
                                   shift,
                                   usefirstMinus,
                                   usefirstPlus,
                                   usesecondMinus,
                                   usesecondPlus,
                                   isPSseed);
            tmpProj_ = tmpProj;
          }
 
          iproj++;
          if (iproj == projMem->nTracklets()) {
            iproj = 0;
            do {
              iprojmem++;
            } while (iprojmem < inputprojs_.size() && inputprojs_[iprojmem]->nTracklets() == 0);
          }
        }
 
      } else {
        projdone = true && !good_ && !good__;
      }
    }
 
    //
    //  Check if done
    //
    //
    //
 
    if ((projdone && !meactive) || (istep == settings_.maxStep("MP") - 1)) {
      if (settings_.writeMonitorData("MP")) {
        globals_->ofstream("matchprocessor.txt") << getName() << " " << istep << " " << countall << " " << countsel
                                                 << " " << countme << " " << countinputproj << endl;
      }
      break;
    }
  }
 
  if (settings_.writeMonitorData("MC")) {
    globals_->ofstream("matchcalculator.txt") << getName() << " " << countall << " " << countsel << endl;
  }
}

References cms::cuda::assert(), barrel_, trklet::FPGAWord::bits(), trklet::Settings::debugTracklet(), relativeConstraints::empty, trklet::MemoryBase::getName(), trklet::ProcessBase::getName(), trklet::TrackletProjectionsMemory::getTracklet(), trklet::ProcessBase::globals_, inputProjBuffer_, inputprojs_, trklet::ProjectionTemp::iphi(), LEDCalibrationChannels::iphi, trklet::ProjectionTemp::isPSseed(), layerdisk_, trklet::TrackletLUT::lookup(), match(), matchCalculator(), matchengines_, trklet::Settings::maxStep(), trklet::N_LAYER, trklet::N_RZBITS, LaserClient_cfi::nbins, trklet::FPGAWord::nbits(), trklet::Settings::nbitsvmme(), trklet::NFINEPHIBITS, nMatchEngines_, nphiderbits_, nrbits_, nrinv_, trklet::VMStubsMEMemory::nStubsBin(), trklet::TrackletProjectionsMemory::nTracklets(), nvmbins_, nvmbits_, trklet::Globals::ofstream(), phimin, phimin_, print(), amptDefault_cfi::proj, trklet::ProjectionTemp::proj(), trklet::ProjectionTemp::projfinephi(), trklet::ProjectionTemp::projfinerz(), trklet::ProjectionTemp::projrinv(), rinvbendlut_, edm::second(), trklet::ProcessBase::settings_, edm::shift, trklet::ProjectionTemp::shift(), trklet::ProjectionTemp::slot(), trklet::Tracklet::TCID(), mitigatedMETSequence_cff::U, trklet::ProjectionTemp::use(), trklet::FPGAWord::value(), vmstubs_, and trklet::Settings::writeMonitorData().

matchCalculator()

bool MatchProcessor::matchCalculator	(	Tracklet *	tracklet,
		const Stub *	fpgastub,
		bool	print,
		unsigned int	istep
	)

Definition at line 432 of file MatchProcessor.cc.

                                                                                                 {
  const L1TStub* stub = fpgastub->l1tstub();
 
  if (layerdisk_ < N_LAYER) {
    const Projection& proj = tracklet->proj(layerdisk_);
    int ir = fpgastub->r().value();
    int iphi = proj.fpgaphiproj().value();
    int icorr = (ir * proj.fpgaphiprojder().value()) >> icorrshift_;
    iphi += icorr;
 
    int iz = proj.fpgarzproj().value();
    int izcor = (ir * proj.fpgarzprojder().value() + (1 << (icorzshift_ - 1))) >> icorzshift_;
    iz += izcor;
 
    int ideltaz = fpgastub->z().value() - iz;
    int ideltaphi = (fpgastub->phi().value() - iphi) << phishift_;
 
    //Floating point calculations
 
    double phi = stub->phi();
    double r = stub->r();
    double z = stub->z();
 
    if (settings_.useapprox()) {
      double dphi = reco::reduceRange(phi - fpgastub->phiapprox(phimin_, 0.0));
      assert(std::abs(dphi) < 0.001);
      phi = fpgastub->phiapprox(phimin_, 0.0);
      z = fpgastub->zapprox();
      r = fpgastub->rapprox();
    }
 
    if (phi < 0)
      phi += 2 * M_PI;
    phi -= phimin_;
 
    double dr = r - settings_.rmean(layerdisk_);
    assert(std::abs(dr) < settings_.drmax());
 
    double dphi = reco::reduceRange(phi - (proj.phiproj() + dr * proj.phiprojder()));
 
    double dz = z - (proj.rzproj() + dr * proj.rzprojder());
 
    double dphiapprox = reco::reduceRange(phi - (proj.phiprojapprox() + dr * proj.phiprojderapprox()));
 
    double dzapprox = z - (proj.rzprojapprox() + dr * proj.rzprojderapprox());
 
    int seedindex = tracklet->getISeed();
 
    assert(phimatchcuttable_.lookup(seedindex) > 0);
    assert(zmatchcuttable_.lookup(seedindex) > 0);
 
    if (settings_.bookHistos()) {
      bool truthmatch = tracklet->stubtruthmatch(stub);
 
      HistBase* hists = globals_->histograms();
      hists->FillLayerResidual(layerdisk_ + 1,
                               seedindex,
                               dphiapprox * settings_.rmean(layerdisk_),
                               ideltaphi * settings_.kphi1() * settings_.rmean(layerdisk_),
                               (ideltaz << dzshift_) * settings_.kz(),
                               dz,
                               truthmatch);
    }
 
    if (settings_.writeMonitorData("Residuals")) {
      double pt = 0.01 * settings_.c() * settings_.bfield() / std::abs(tracklet->rinv());
 
      globals_->ofstream("layerresiduals.txt")
          << layerdisk_ + 1 << " " << seedindex << " " << pt << " "
          << ideltaphi * settings_.kphi1() * settings_.rmean(layerdisk_) << " "
          << dphiapprox * settings_.rmean(layerdisk_) << " "
          << phimatchcuttable_.lookup(seedindex) * settings_.kphi1() * settings_.rmean(layerdisk_) << "   "
          << (ideltaz << dzshift_) * settings_.kz() << " " << dz << " "
          << zmatchcuttable_.lookup(seedindex) * settings_.kz() << endl;
    }
 
    bool imatch = (std::abs(ideltaphi) <= phimatchcuttable_.lookup(seedindex)) &&
                  (std::abs(ideltaz << dzshift_) <= zmatchcuttable_.lookup(seedindex));
 
    if (settings_.debugTracklet()) {
      edm::LogVerbatim("Tracklet") << getName() << " imatch = " << imatch << " ideltaphi cut " << ideltaphi << " "
                                   << phimatchcuttable_.lookup(seedindex) << " ideltaz<<dzshift cut "
                                   << (ideltaz << dzshift_) << " " << zmatchcuttable_.lookup(seedindex);
    }
 
    //This would catch significant consistency problems in the configuration - helps to debug if there are problems.
    if (std::abs(dphi) > 0.5 * settings_.dphisectorHG() || std::abs(dphiapprox) > 0.5 * settings_.dphisectorHG()) {
      throw cms::Exception("LogicError") << "WARNING dphi and/or dphiapprox too large : " << dphi << " " << dphiapprox
                                         << endl;
    }
 
    if (imatch) {
      tracklet->addMatch(layerdisk_,
                         ideltaphi,
                         ideltaz,
                         dphi,
                         dz,
                         dphiapprox,
                         dzapprox,
                         (phiregion_ << N_BITSMEMADDRESS) + fpgastub->stubindex().value(),
                         fpgastub);
 
      if (settings_.debugTracklet()) {
        edm::LogVerbatim("Tracklet") << "Accepted full match in layer " << getName() << " " << tracklet;
      }
 
      int iSeed = tracklet->getISeed();
      assert(fullmatches_[iSeed] != nullptr);
      fullmatches_[iSeed]->addMatch(tracklet, fpgastub);
 
      return true;
    } else {
      return false;
    }
  } else {  //disk matches
 
    //check that stubs and projections in same half of detector
    assert(stub->z() * tracklet->t() > 0.0);
 
    int sign = (tracklet->t() > 0.0) ? 1 : -1;
    int disk = sign * (layerdisk_ - N_LAYER + 1);
    assert(disk != 0);
 
    //Perform integer calculations here
 
    int iz = fpgastub->z().value();
 
    const Projection& proj = tracklet->proj(layerdisk_);
 
    int iphi = proj.fpgaphiproj().value();
    int iphicorr = (iz * proj.fpgaphiprojder().value()) >> icorrshift_;
 
    iphi += iphicorr;
 
    int ir = proj.fpgarzproj().value();
    int ircorr = (iz * proj.fpgarzprojder().value()) >> icorzshift_;
    ir += ircorr;
 
    int ideltaphi = fpgastub->phi().value() - iphi;
 
    int irstub = fpgastub->r().value();
    int ialphafact = 0;
    if (!stub->isPSmodule()) {
      assert(irstub < (int)N_DSS_MOD * 2);
      if (layerdisk_ - N_LAYER <= 1) {
        ialphafact = ialphafactinner_[irstub];
        irstub = settings_.rDSSinner(irstub) / settings_.kr();
      } else {
        ialphafact = ialphafactouter_[irstub];
        irstub = settings_.rDSSouter(irstub) / settings_.kr();
      }
    }
 
    int ideltar = (irstub * settings_.kr()) / settings_.krprojshiftdisk() - ir;
 
    if (!stub->isPSmodule()) {
      int ialpha = fpgastub->alpha().value();
      int iphialphacor = ((ideltar * ialpha * ialphafact) >> settings_.alphashift());
      ideltaphi += iphialphacor;
    }
 
    //Perform floating point calculations here
 
    double phi = stub->phi();
    double z = stub->z();
    double r = stub->r();
 
    if (settings_.useapprox()) {
      double dphi = reco::reduceRange(phi - fpgastub->phiapprox(phimin_, 0.0));
      assert(std::abs(dphi) < 0.001);
      phi = fpgastub->phiapprox(phimin_, 0.0);
      z = fpgastub->zapprox();
      r = fpgastub->rapprox();
    }
 
    if (phi < 0)
      phi += 2 * M_PI;
    phi -= phimin_;
 
    double dz = z - sign * settings_.zmean(layerdisk_ - N_LAYER);
 
    if (std::abs(dz) > settings_.dzmax()) {
      edm::LogProblem("Tracklet") << __FILE__ << ":" << __LINE__ << " " << name_ << " " << tracklet->getISeed();
      edm::LogProblem("Tracklet") << "stub " << stub->z() << " disk " << disk << " " << dz;
      assert(std::abs(dz) < settings_.dzmax());
    }
 
    double phiproj = proj.phiproj() + dz * proj.phiprojder();
    double rproj = proj.rzproj() + dz * proj.rzprojder();
    double deltar = r - rproj;
 
    double dr = stub->r() - rproj;
    double drapprox = stub->r() - (proj.rzprojapprox() + dz * proj.rzprojderapprox());
 
    double dphi = reco::reduceRange(phi - phiproj);
 
    double dphiapprox = reco::reduceRange(phi - (proj.phiprojapprox() + dz * proj.phiprojderapprox()));
 
    double drphi = dphi * stub->r();
    double drphiapprox = dphiapprox * stub->r();
 
    if (!stub->isPSmodule()) {
      double alphanorm = stub->alphanorm();
      dphi += dr * alphanorm * settings_.half2SmoduleWidth() / stub->r2();
      ;
      dphiapprox += drapprox * alphanorm * settings_.half2SmoduleWidth() / stub->r2();
 
      drphi += dr * alphanorm * settings_.half2SmoduleWidth() / stub->r();
      drphiapprox += dr * alphanorm * settings_.half2SmoduleWidth() / stub->r();
    }
 
    int seedindex = tracklet->getISeed();
 
    int idrphicut = rphicutPStable_.lookup(seedindex);
    int idrcut = rcutPStable_.lookup(seedindex);
    if (!stub->isPSmodule()) {
      idrphicut = rphicut2Stable_.lookup(seedindex);
      idrcut = rcut2Stable_.lookup(seedindex);
    }
 
    double drphicut = idrphicut * settings_.kphi() * settings_.kr();
    double drcut = idrcut * settings_.krprojshiftdisk();
 
    if (settings_.writeMonitorData("Residuals")) {
      double pt = 0.01 * settings_.c() * settings_.bfield() / std::abs(tracklet->rinv());
 
      globals_->ofstream("diskresiduals.txt")
          << layerdisk_ - N_LAYER + 1 << " " << stub->isPSmodule() << " " << tracklet->layer() << " "
          << abs(tracklet->disk()) << " " << pt << " " << ideltaphi * settings_.kphi() * stub->r() << " " << drphiapprox
          << " " << drphicut << " " << ideltar * settings_.krprojshiftdisk() << " " << deltar << " " << drcut << " "
          << endl;
    }
 
    bool match = (std::abs(drphi) < drphicut) && (std::abs(deltar) < drcut);
    bool imatch = (std::abs(ideltaphi * irstub) < idrphicut) && (std::abs(ideltar) < idrcut);
 
    if (settings_.debugTracklet()) {
      edm::LogVerbatim("Tracklet") << "imatch match disk: " << imatch << " " << match << " " << std::abs(ideltaphi)
                                   << " " << drphicut / (settings_.kphi() * stub->r()) << " " << std::abs(ideltar)
                                   << " " << drcut / settings_.krprojshiftdisk() << " r = " << stub->r();
    }
 
    if (imatch) {
      if (settings_.debugTracklet()) {
        edm::LogVerbatim("Tracklet") << "MatchCalculator found match in disk " << getName();
      }
 
      if (std::abs(dphi) >= third * settings_.dphisectorHG()) {
        edm::LogPrint("Tracklet") << "dphi " << dphi << " ISeed " << tracklet->getISeed();
      }
      assert(std::abs(dphi) < third * settings_.dphisectorHG());
      assert(std::abs(dphiapprox) < third * settings_.dphisectorHG());
 
      tracklet->addMatch(layerdisk_,
                         ideltaphi,
                         ideltar,
                         drphi / stub->r(),
                         dr,
                         drphiapprox / stub->r(),
                         drapprox,
                         (phiregion_ << N_BITSMEMADDRESS) + fpgastub->stubindex().value(),
                         fpgastub);
 
      if (settings_.debugTracklet()) {
        edm::LogVerbatim("Tracklet") << "Accepted full match in disk " << getName() << " " << tracklet;
      }
 
      int iSeed = tracklet->getISeed();
      assert(fullmatches_[iSeed] != nullptr);
      fullmatches_[iSeed]->addMatch(tracklet, fpgastub);
 
      return true;
    } else {
      return false;
    }
  }
}

References funct::abs(), trklet::Tracklet::addMatch(), trklet::Stub::alpha(), trklet::L1TStub::alphanorm(), trklet::Settings::alphashift(), cms::cuda::assert(), trklet::Settings::bfield(), trklet::Settings::bookHistos(), trklet::Settings::c(), trklet::Settings::debugTracklet(), trklet::Tracklet::disk(), trklet::Settings::dphisectorHG(), flavorHistoryFilter_cfi::dr, trklet::Settings::drmax(), PVValHelper::dz, trklet::Settings::dzmax(), dzshift_, Exception, fullmatches_, trklet::Tracklet::getISeed(), trklet::ProcessBase::getName(), trklet::ProcessBase::globals_, trklet::Settings::half2SmoduleWidth(), trklet::Globals::histograms(), compare::hists, ialphafactinner_, ialphafactouter_, icorrshift_, icorzshift_, LEDCalibrationChannels::iphi, trklet::L1TStub::isPSmodule(), trklet::Settings::kphi(), trklet::Settings::kphi1(), trklet::Settings::kr(), trklet::Settings::krprojshiftdisk(), trklet::Settings::kz(), trklet::Stub::l1tstub(), trklet::Tracklet::layer(), layerdisk_, trklet::TrackletLUT::lookup(), M_PI, match(), trklet::N_BITSMEMADDRESS, trklet::N_DSS_MOD, trklet::N_LAYER, trklet::ProcessBase::name_, trklet::Globals::ofstream(), trklet::Stub::phi(), trklet::L1TStub::phi(), trklet::Stub::phiapprox(), phimatchcuttable_, phimin_, phiregion_, phishift_, amptDefault_cfi::proj, trklet::Tracklet::proj(), DiDispStaMuonMonitor_cfi::pt, trklet::L1TStub::r(), trklet::Stub::r(), alignCSCRings::r, trklet::L1TStub::r2(), trklet::Stub::rapprox(), rcut2Stable_, rcutPStable_, trklet::Settings::rDSSinner(), trklet::Settings::rDSSouter(), reco::reduceRange(), trklet::Tracklet::rinv(), trklet::Settings::rmean(), rphicut2Stable_, rphicutPStable_, trklet::ProcessBase::settings_, Validation_hcalonly_cfi::sign, trklet::Stub::stubindex(), trklet::Tracklet::stubtruthmatch(), trklet::Tracklet::t(), trklet::third, trklet::Settings::useapprox(), trklet::FPGAWord::value(), trklet::Settings::writeMonitorData(), trklet::L1TStub::z(), trklet::Stub::z(), trklet::Stub::zapprox(), zmatchcuttable_, and trklet::Settings::zmean().

Referenced by execute().

Member Data Documentation

allstubs_

AllStubsMemory* trklet::MatchProcessor::allstubs_

private

Definition at line 65 of file MatchProcessor.h.

Referenced by addInput().

barrel_

bool trklet::MatchProcessor::barrel_

private

Definition at line 40 of file MatchProcessor.h.

Referenced by execute(), and MatchProcessor().

dzshift_

int trklet::MatchProcessor::dzshift_

private

Definition at line 49 of file MatchProcessor.h.

Referenced by matchCalculator(), and MatchProcessor().

fullmatches_

std::vector<FullMatchMemory*> trklet::MatchProcessor::fullmatches_

private

Definition at line 73 of file MatchProcessor.h.

Referenced by addOutput(), and matchCalculator().

ialphafactinner_

int trklet::MatchProcessor::ialphafactinner_[N_DSS_MOD *2]

private

Definition at line 69 of file MatchProcessor.h.

Referenced by matchCalculator(), and MatchProcessor().

ialphafactouter_

int trklet::MatchProcessor::ialphafactouter_[N_DSS_MOD *2]

private

Definition at line 70 of file MatchProcessor.h.

Referenced by matchCalculator(), and MatchProcessor().

icorrshift_

int trklet::MatchProcessor::icorrshift_

private

Definition at line 50 of file MatchProcessor.h.

Referenced by matchCalculator(), and MatchProcessor().

icorzshift_

int trklet::MatchProcessor::icorzshift_

private

Definition at line 51 of file MatchProcessor.h.

Referenced by matchCalculator(), and MatchProcessor().

inputProjBuffer_

CircularBuffer<ProjectionTemp> trklet::MatchProcessor::inputProjBuffer_

private

Definition at line 86 of file MatchProcessor.h.

Referenced by execute().

inputprojs_

std::vector<TrackletProjectionsMemory*> trklet::MatchProcessor::inputprojs_

private

Definition at line 67 of file MatchProcessor.h.

Referenced by addInput(), and execute().

layerdisk_

unsigned int trklet::MatchProcessor::layerdisk_

private

Definition at line 39 of file MatchProcessor.h.

Referenced by execute(), matchCalculator(), and MatchProcessor().

luttable_

TrackletLUT trklet::MatchProcessor::luttable_

private

Definition at line 79 of file MatchProcessor.h.

Referenced by MatchProcessor().

matchengines_

std::vector<MatchEngineUnit> trklet::MatchProcessor::matchengines_

private

Definition at line 84 of file MatchProcessor.h.

Referenced by execute(), and MatchProcessor().

nMatchEngines_

unsigned int trklet::MatchProcessor::nMatchEngines_

private

Definition at line 83 of file MatchProcessor.h.

Referenced by execute(), and MatchProcessor().

nphiderbits_

int trklet::MatchProcessor::nphiderbits_

private

Definition at line 63 of file MatchProcessor.h.

Referenced by execute(), and MatchProcessor().

nrbits_

int trklet::MatchProcessor::nrbits_

private

Definition at line 62 of file MatchProcessor.h.

Referenced by execute(), and MatchProcessor().

nrinv_

int trklet::MatchProcessor::nrinv_

private

Definition at line 47 of file MatchProcessor.h.

Referenced by execute(), and MatchProcessor().

nvm_

int trklet::MatchProcessor::nvm_

private

Definition at line 44 of file MatchProcessor.h.

Referenced by MatchProcessor().

nvmbins_

int trklet::MatchProcessor::nvmbins_

private

Definition at line 46 of file MatchProcessor.h.

Referenced by execute(), and MatchProcessor().

nvmbits_

int trklet::MatchProcessor::nvmbits_

private

Definition at line 45 of file MatchProcessor.h.

Referenced by execute(), and MatchProcessor().

phimatchcuttable_

TrackletLUT trklet::MatchProcessor::phimatchcuttable_

private

Definition at line 54 of file MatchProcessor.h.

Referenced by matchCalculator(), and MatchProcessor().

phimin_

double trklet::MatchProcessor::phimin_

private

Definition at line 81 of file MatchProcessor.h.

Referenced by execute(), and matchCalculator().

phiregion_

unsigned int trklet::MatchProcessor::phiregion_

private

Definition at line 42 of file MatchProcessor.h.

Referenced by matchCalculator(), and MatchProcessor().

phishift_

int trklet::MatchProcessor::phishift_

private

Definition at line 52 of file MatchProcessor.h.

Referenced by matchCalculator(), and MatchProcessor().

rcut2Stable_

TrackletLUT trklet::MatchProcessor::rcut2Stable_

private

Definition at line 60 of file MatchProcessor.h.

Referenced by matchCalculator(), and MatchProcessor().

rcutPStable_

TrackletLUT trklet::MatchProcessor::rcutPStable_

private

Definition at line 59 of file MatchProcessor.h.

Referenced by matchCalculator(), and MatchProcessor().

rinvbendlut_

TrackletLUT trklet::MatchProcessor::rinvbendlut_

private

Definition at line 76 of file MatchProcessor.h.

Referenced by execute(), and MatchProcessor().

rphicut2Stable_

TrackletLUT trklet::MatchProcessor::rphicut2Stable_

private

Definition at line 58 of file MatchProcessor.h.

Referenced by matchCalculator(), and MatchProcessor().

rphicutPStable_

TrackletLUT trklet::MatchProcessor::rphicutPStable_

private

Definition at line 57 of file MatchProcessor.h.

Referenced by matchCalculator(), and MatchProcessor().

vmstubs_

std::vector<VMStubsMEMemory*> trklet::MatchProcessor::vmstubs_

private

Definition at line 66 of file MatchProcessor.h.

Referenced by addInput(), and execute().

zmatchcuttable_

TrackletLUT trklet::MatchProcessor::zmatchcuttable_

private

Definition at line 55 of file MatchProcessor.h.

Referenced by matchCalculator(), and MatchProcessor().