trklet::TrackletProcessor Class Reference

#include <TrackletProcessor.h>

Inheritance diagram for trklet::TrackletProcessor:

Public Member Functions
void	addInput (MemoryBase *memory, std::string input) override
void	addOutput (MemoryBase *memory, std::string output) override
void	addOutputProjection (TrackletProjectionsMemory *&outputProj, MemoryBase *memory)
void	execute (unsigned int iSector, double phimin, double phimax)
	TrackletProcessor (std::string name, Settings const &settings, Globals *globals)
	~TrackletProcessor () override=default
Public Member Functions inherited from trklet::TrackletCalculatorBase
void	addDiskProj (Tracklet *tracklet, int disk)
bool	addLayerProj (Tracklet *tracklet, int layer)
void	addProjection (int layer, int iphi, TrackletProjectionsMemory *trackletprojs, Tracklet *tracklet)
void	addProjectionDisk (int disk, int iphi, TrackletProjectionsMemory *trackletprojs, Tracklet *tracklet)
bool	barrelSeeding (const Stub *innerFPGAStub, const L1TStub *innerStub, const Stub *outerFPGAStub, const L1TStub *outerStub)
bool	diskSeeding (const Stub *innerFPGAStub, const L1TStub *innerStub, const Stub *outerFPGAStub, const L1TStub *outerStub)
void	exactproj (double rproj, double rinv, double phi0, double t, double z0, double &phiproj, double &zproj, double &phider, double &zder)
void	exactprojdisk (double zproj, double rinv, double phi0, double t, double z0, double &phiproj, double &rproj, double &phider, double &rder)
void	exacttracklet (double r1, double z1, double phi1, double r2, double z2, double phi2, double, double &rinv, double &phi0, double &t, double &z0, double phiproj[N_LAYER - 2], double zproj[N_LAYER - 2], double phider[N_LAYER - 2], double zder[N_LAYER - 2], double phiprojdisk[N_DISK], double rprojdisk[N_DISK], double phiderdisk[N_DISK], double rderdisk[N_DISK])
void	exacttrackletdisk (double r1, double z1, double phi1, double r2, double z2, double phi2, double, double &rinv, double &phi0, double &t, double &z0, double phiprojLayer[N_PSLAYER], double zprojLayer[N_PSLAYER], double phiderLayer[N_PSLAYER], double zderLayer[N_PSLAYER], double phiproj[N_DISK - 2], double rproj[N_DISK - 2], double phider[N_DISK - 2], double rder[N_DISK - 2])
void	exacttrackletOverlap (double r1, double z1, double phi1, double r2, double z2, double phi2, double, double &rinv, double &phi0, double &t, double &z0, double phiprojLayer[N_PSLAYER], double zprojLayer[N_PSLAYER], double phiderLayer[N_PSLAYER], double zderLayer[N_PSLAYER], double phiproj[N_DISK - 2], double rproj[N_DISK - 2], double phider[N_DISK - 2], double rder[N_DISK - 2])
bool	goodTrackPars (bool goodrinv, bool goodz0)
bool	inSector (int iphi0, int irinv, double phi0approx, double rinvapprox)
bool	overlapSeeding (const Stub *innerFPGAStub, const L1TStub *innerStub, const Stub *outerFPGAStub, const L1TStub *outerStub)
	TrackletCalculatorBase (std::string name, Settings const &settings, Globals *global)
	~TrackletCalculatorBase () 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
int	iAllStub_
std::vector< AllInnerStubsMemory * >	innerallstubs_
TrackletLUT	innerOverlapTable_
int	innerphibits_
TrackletLUT	innerTable_
int	iTC_
unsigned int	maxStep_
int	nbitsfinephi_
int	nbitsfinephidiff_
unsigned int	nbitsrfinebintable_
unsigned int	nbitsrzbin_
unsigned int	nbitszfinebintable_
std::vector< AllStubsMemory * >	outerallstubs_
int	outerphibits_
VMStubsTEMemory *	outervmstubs_
TrackletLUT	pttableinner_
TrackletLUT	pttableouter_
std::tuple< CircularBuffer< TEData >, unsigned int, unsigned int, unsigned int, unsigned int >	tebuffer_
std::vector< TrackletEngineUnit >	teunits_
TrackletLUT	useregiontable_

Additional Inherited Members
Protected Attributes inherited from trklet::TrackletCalculatorBase
unsigned int	iSector_
unsigned int	iSeed_
unsigned int	layerdisk1_
unsigned int	layerdisk2_
double	phimax_
double	phimin_
int	TCIndex_
TrackletParametersMemory *	trackletpars_
std::vector< std::vector< TrackletProjectionsMemory * > >	trackletprojdisks_
std::vector< std::vector< TrackletProjectionsMemory * > >	trackletprojlayers_
Protected Attributes inherited from trklet::ProcessBase
Globals *	globals_
std::string	name_
Settings const &	settings_

Detailed Description

Definition at line 24 of file TrackletProcessor.h.

Constructor & Destructor Documentation

TrackletProcessor()

TrackletProcessor::TrackletProcessor	(	std::string	name,
		Settings const &	settings,
		Globals *	globals
	)

Definition at line 19 of file TrackletProcessor.cc.

    : TrackletCalculatorBase(name, settings, globals),
      tebuffer_(CircularBuffer<TEData>(3), 0, 0, 0, 0),
      pttableinner_(settings),
      pttableouter_(settings),
      useregiontable_(settings),
      innerTable_(settings),
      innerOverlapTable_(settings) {
  iAllStub_ = -1;
 
  for (unsigned int ilayer = 0; ilayer < N_LAYER; ilayer++) {
    vector<TrackletProjectionsMemory*> tmp(settings_.nallstubs(ilayer), nullptr);
    trackletprojlayers_.push_back(tmp);
  }
 
  for (unsigned int idisk = 0; idisk < N_DISK; idisk++) {
    vector<TrackletProjectionsMemory*> tmp(settings_.nallstubs(idisk + N_LAYER), nullptr);
    trackletprojdisks_.push_back(tmp);
  }
 
  outervmstubs_ = nullptr;
 
  initLayerDisksandISeed(layerdisk1_, layerdisk2_, iSeed_);
 
  double rmin = -1.0;
  double rmax = -1.0;
 
  if (iSeed_ == Seed::L1L2 || iSeed_ == Seed::L2L3 || iSeed_ == Seed::L3L4 || iSeed_ == Seed::L5L6) {
    rmin = settings_.rmean(layerdisk1_);
    rmax = settings_.rmean(layerdisk2_);
  } else {
    if (iSeed_ == Seed::L1D1) {
      rmax = settings_.rmaxdiskl1overlapvm();
      rmin = settings_.rmean(layerdisk1_);
    } else if (iSeed_ == Seed::L2D1) {
      rmax = settings_.rmaxdiskvm();
      rmin = settings_.rmean(layerdisk1_);
    } else {
      rmax = settings_.rmaxdiskvm();
      rmin = rmax * settings_.zmean(layerdisk2_ - N_LAYER - 1) / settings_.zmean(layerdisk2_ - N_LAYER);
    }
  }
 
  double dphimax = asin(0.5 * settings_.maxrinv() * rmax) - asin(0.5 * settings_.maxrinv() * rmin);
 
  //number of fine phi bins in sector
  int nfinephibins =
      settings_.nallstubs(layerdisk2_) * settings_.nvmte(1, iSeed_) * (1 << settings_.nfinephi(1, iSeed_));
  double dfinephi = settings_.dphisectorHG() / nfinephibins;
 
  nbitsfinephi_ = settings_.nbitsallstubs(layerdisk2_) + settings_.nbitsvmte(1, iSeed_) + settings_.nfinephi(1, iSeed_);
 
  int nbins = 2.0 * (dphimax / dfinephi + 1.0);
 
  nbitsfinephidiff_ = log(nbins) / log(2.0) + 1;
 
  nbitszfinebintable_ = settings_.vmrlutzbits(layerdisk1_);
  nbitsrfinebintable_ = settings_.vmrlutrbits(layerdisk1_);
 
  nbitsrzbin_ = N_RZBITS;
  if (iSeed_ == Seed::D1D2 || iSeed_ == Seed::D3D4)
    nbitsrzbin_ = 2;
 
  innerphibits_ = settings_.nfinephi(0, iSeed_);
  outerphibits_ = settings_.nfinephi(1, iSeed_);
 
  if (layerdisk1_ == LayerDisk::L1 || layerdisk1_ == LayerDisk::L2 || layerdisk1_ == LayerDisk::L3 ||
      layerdisk1_ == LayerDisk::L5 || layerdisk1_ == LayerDisk::D1 || layerdisk1_ == LayerDisk::D3) {
    innerTable_.initVMRTable(layerdisk1_, TrackletLUT::VMRTableType::inner);  //projection to next layer/disk
  }
 
  if (layerdisk1_ == LayerDisk::L1 || layerdisk1_ == LayerDisk::L2) {
    innerOverlapTable_.initVMRTable(layerdisk1_,
                                    TrackletLUT::VMRTableType::inneroverlap);  //projection to disk from layer
  }
 
  // set TC index
  iTC_ = name_[7] - 'A';
  assert(iTC_ >= 0 && iTC_ < 14);
 
  TCIndex_ = (iSeed_ << 4) + iTC_;
  assert(TCIndex_ >= 0 && TCIndex_ <= (int)settings_.ntrackletmax());
 
  maxStep_ = settings_.maxStep("TP");
}

References cms::cuda::assert(), trklet::D1D2, trklet::D3, trklet::D3D4, trklet::Settings::dphisectorHG(), iAllStub_, trklet::ProcessBase::initLayerDisksandISeed(), trklet::TrackletLUT::initVMRTable(), SurfaceOrientation::inner, innerOverlapTable_, innerphibits_, innerTable_, trklet::TrackletCalculatorBase::iSeed_, iTC_, PixelRegions::L1, trklet::L1D1, trklet::L1L2, PixelRegions::L2, trklet::L2D1, trklet::L2L3, PixelRegions::L3, trklet::L3L4, trklet::L5, trklet::L5L6, trklet::TrackletCalculatorBase::layerdisk1_, trklet::TrackletCalculatorBase::layerdisk2_, dqm-mbProfile::log, trklet::Settings::maxrinv(), trklet::Settings::maxStep(), maxStep_, trklet::N_DISK, trklet::N_LAYER, trklet::N_RZBITS, trklet::Settings::nallstubs(), trklet::ProcessBase::name_, LaserClient_cfi::nbins, trklet::Settings::nbitsallstubs(), nbitsfinephi_, nbitsfinephidiff_, nbitsrfinebintable_, nbitsrzbin_, trklet::Settings::nbitsvmte(), nbitszfinebintable_, trklet::Settings::nfinephi(), trklet::Settings::ntrackletmax(), trklet::Settings::nvmte(), outerphibits_, outervmstubs_, trklet::Settings::rmaxdiskl1overlapvm(), trklet::Settings::rmaxdiskvm(), trklet::Settings::rmean(), trklet::ProcessBase::settings_, trklet::TrackletCalculatorBase::TCIndex_, createJobs::tmp, trklet::TrackletCalculatorBase::trackletprojdisks_, trklet::TrackletCalculatorBase::trackletprojlayers_, trklet::Settings::vmrlutrbits(), trklet::Settings::vmrlutzbits(), and trklet::Settings::zmean().

~TrackletProcessor()

trklet::TrackletProcessor::~TrackletProcessor ( )

overridedefault

Member Function Documentation

addInput()

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

overridevirtual

Implements trklet::ProcessBase.

Definition at line 152 of file TrackletProcessor.cc.

                                                                 {
  if (settings_.writetrace()) {
    edm::LogVerbatim("Tracklet") << "In " << name_ << " adding input from " << memory->getName() << " to input "
                                 << input;
  }
 
  if (input == "outervmstubin") {
    auto* tmp = dynamic_cast<VMStubsTEMemory*>(memory);
    assert(tmp != nullptr);
    outervmstubs_ = tmp;
    iAllStub_ = tmp->getName()[11] - 'A';
    if (iSeed_ == Seed::L2L3)
      iAllStub_ = tmp->getName()[11] - 'I';
    if (iSeed_ == Seed::L1D1 || iSeed_ == Seed::L2D1) {
      if (tmp->getName()[11] == 'X')
        iAllStub_ = 0;
      if (tmp->getName()[11] == 'Y')
        iAllStub_ = 1;
      if (tmp->getName()[11] == 'Z')
        iAllStub_ = 2;
      if (tmp->getName()[11] == 'W')
        iAllStub_ = 3;
    }
 
    unsigned int iTP = getName()[7] - 'A';
 
    pttableinner_.initTPlut(true, iSeed_, layerdisk1_, layerdisk2_, nbitsfinephidiff_, iTP);
    pttableouter_.initTPlut(false, iSeed_, layerdisk1_, layerdisk2_, nbitsfinephidiff_, iTP);
 
    //need iAllStub_ set before building the table
 
    useregiontable_.initTPregionlut(
        iSeed_, layerdisk1_, layerdisk2_, iAllStub_, nbitsfinephidiff_, nbitsfinephi_, pttableinner_, iTP);
 
    TrackletEngineUnit teunit(&settings_,
                              nbitsfinephi_,
                              layerdisk1_,
                              layerdisk2_,
                              iSeed_,
                              nbitsfinephidiff_,
                              iAllStub_,
                              &pttableinner_,
                              &pttableouter_,
                              outervmstubs_);
 
    teunits_.resize(settings_.teunits(iSeed_), teunit);
 
    return;
  }
 
  if (input == "innerallstubin") {
    auto* tmp = dynamic_cast<AllInnerStubsMemory*>(memory);
    assert(tmp != nullptr);
    if (innerallstubs_.size() == 2) {  //FIXME this should be done with better logic with reading the input stubs
      innerallstubs_.insert(innerallstubs_.begin(), tmp);
    } else {
      innerallstubs_.push_back(tmp);
    }
 
    //FIXME should be done once after all inputs are added
    tebuffer_ = tuple<CircularBuffer<TEData>, unsigned int, unsigned int, unsigned int, unsigned int>(
        CircularBuffer<TEData>(3), 0, 0, 0, innerallstubs_.size());
 
    return;
  }
  if (input == "outerallstubin") {
    auto* tmp = dynamic_cast<AllStubsMemory*>(memory);
    assert(tmp != nullptr);
    outerallstubs_.push_back(tmp);
    return;
  }
  throw cms::Exception("BadConfig") << __FILE__ << " " << __LINE__ << " Could not find input : " << input;
}

References cms::cuda::assert(), Exception, trklet::ProcessBase::getName(), iAllStub_, trklet::TrackletLUT::initTPlut(), trklet::TrackletLUT::initTPregionlut(), innerallstubs_, input, createfilelist::int, trklet::TrackletCalculatorBase::iSeed_, trklet::L1D1, trklet::L2D1, trklet::L2L3, trklet::TrackletCalculatorBase::layerdisk1_, trklet::TrackletCalculatorBase::layerdisk2_, trklet::ProcessBase::name_, nbitsfinephi_, nbitsfinephidiff_, outerallstubs_, outervmstubs_, pttableinner_, pttableouter_, trklet::ProcessBase::settings_, tebuffer_, trklet::Settings::teunits(), teunits_, createJobs::tmp, useregiontable_, and trklet::Settings::writetrace().

addOutput()

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

overridevirtual

Implements trklet::ProcessBase.

Definition at line 110 of file TrackletProcessor.cc.

                                                                   {
  if (settings_.writetrace()) {
    edm::LogVerbatim("Tracklet") << "In " << name_ << " adding output to " << memory->getName() << " to output "
                                 << output;
  }
  if (output == "trackpar") {
    auto* tmp = dynamic_cast<TrackletParametersMemory*>(memory);
    assert(tmp != nullptr);
    trackletpars_ = tmp;
    return;
  }
 
  if (output.substr(0, 7) == "projout") {
    //output is on the form 'projoutL2PHIC' or 'projoutD3PHIB'
    auto* tmp = dynamic_cast<TrackletProjectionsMemory*>(memory);
    assert(tmp != nullptr);
 
    unsigned int layerdisk = output[8] - '1';   //layer or disk counting from 0
    unsigned int phiregion = output[12] - 'A';  //phiregion counting from 0
 
    if (output[7] == 'L') {
      assert(layerdisk < N_LAYER);
      assert(phiregion < trackletprojlayers_[layerdisk].size());
      //check that phiregion not already initialized
      assert(trackletprojlayers_[layerdisk][phiregion] == nullptr);
      trackletprojlayers_[layerdisk][phiregion] = tmp;
      return;
    }
 
    if (output[7] == 'D') {
      assert(layerdisk < N_DISK);
      assert(phiregion < trackletprojdisks_[layerdisk].size());
      //check that phiregion not already initialized
      assert(trackletprojdisks_[layerdisk][phiregion] == nullptr);
      trackletprojdisks_[layerdisk][phiregion] = tmp;
      return;
    }
  }
 
  throw cms::Exception("BadConfig") << __FILE__ << " " << __LINE__ << " Could not find output : " << output;
}

References cms::cuda::assert(), Exception, trklet::N_DISK, trklet::N_LAYER, trklet::ProcessBase::name_, convertSQLitetoXML_cfg::output, trklet::ProcessBase::settings_, findQualityFiles::size, createJobs::tmp, trklet::TrackletCalculatorBase::trackletpars_, trklet::TrackletCalculatorBase::trackletprojdisks_, trklet::TrackletCalculatorBase::trackletprojlayers_, and trklet::Settings::writetrace().

addOutputProjection()

void TrackletProcessor::addOutputProjection	(	TrackletProjectionsMemory *&	outputProj,
		MemoryBase *	memory
	)

Definition at line 105 of file TrackletProcessor.cc.

                                                                                                      {
  outputProj = dynamic_cast<TrackletProjectionsMemory*>(memory);
  assert(outputProj != nullptr);
}

References cms::cuda::assert().

execute()

void TrackletProcessor::execute	(	unsigned int	iSector,
		double	phimin,
		double	phimax
	)

Definition at line 226 of file TrackletProcessor.cc.

                                                                                  {
  bool print = (iSector == 3) && (getName() == "TP_L1L2D");
  print = false;
 
  phimin_ = phimin;
  phimax_ = phimax;
  iSector_ = iSector;
 
  if (!settings_.useSeed(iSeed_))
    return;
 
  //Not most elegant solution; but works
  int donecount = 0;
 
  //Consistency checks
  assert(iAllStub_ >= 0);
  assert(iAllStub_ < (int)settings_.nallstubs(layerdisk2_));
  assert(outervmstubs_ != nullptr);
 
  //used to collect performance data
  unsigned int countall = 0;
  unsigned int countsel = 0;
 
  unsigned int countteall = 0;
  unsigned int stubpairs = 0;
 
  unsigned int ntedata = 0;
 
  unsigned int ninnerstubs = 0;
 
  //Actual implemenation starts here
 
  //Reset the tebuffer
  std::get<0>(tebuffer_).reset();
  std::get<1>(tebuffer_) = 0;
  std::get<2>(tebuffer_) = std::get<3>(tebuffer_);
 
  //Reset the teunits
  for (auto& teunit : teunits_) {
    teunit.reset();
  }
 
  TEData tedata;
  TEData tedata__;
  TEData tedata___;
  bool goodtedata = false;
  bool goodtedata__ = false;
  bool goodtedata___ = false;
 
  bool tebuffernearfull;
 
  for (unsigned int istep = 0; istep < maxStep_; istep++) {
    // These print statements are not on by defaul but can be enabled for the
    // comparison with HLS code to track differences.
    if (print) {
      CircularBuffer<TEData>& tedatabuffer = std::get<0>(tebuffer_);
      unsigned int& istub = std::get<1>(tebuffer_);
      unsigned int& imem = std::get<2>(tebuffer_);
      cout << "istep=" << istep << " TEBuffer: " << istub << " " << imem << " " << tedatabuffer.rptr() << " "
           << tedatabuffer.wptr();
      int k = -1;
      for (auto& teunit : teunits_) {
        k++;
        cout << " [" << k << " " << teunit.rptr() << " " << teunit.wptr() << " " << teunit.idle() << "]";
      }
      cout << endl;
    }
 
    CircularBuffer<TEData>& tedatabuffer = std::get<0>(tebuffer_);
    tebuffernearfull = tedatabuffer.nearfull();
 
    //
    // First block here checks if there is a teunit with data that should should be used
    // to calculate the tracklet parameters
    //
 
    TrackletEngineUnit* teunitptr = nullptr;
 
    for (auto& teunit : teunits_) {
      teunit.setNearFull();
      if (!teunit.empty()) {
        teunitptr = &teunit;
      }
    }
 
    if (teunitptr != nullptr) {
      auto stubpair = teunitptr->read();
      stubpairs++;
 
      if (trackletpars_->nTracklets() >= settings_.ntrackletmax()) {
        edm::LogVerbatim("Tracklet") << "Will break on too many tracklets in " << getName();
        break;
      }
      countall++;
      const Stub* innerFPGAStub = stubpair.first;
      const L1TStub* innerStub = innerFPGAStub->l1tstub();
 
      const Stub* outerFPGAStub = stubpair.second;
      const L1TStub* outerStub = outerFPGAStub->l1tstub();
 
      if (settings_.debugTracklet()) {
        edm::LogVerbatim("Tracklet") << "TrackletProcessor execute " << getName() << "[" << iSector_ << "]";
      }
 
      bool accept = false;
 
      if (iSeed_ == Seed::L1L2 || iSeed_ == Seed::L2L3 || iSeed_ == Seed::L3L4 || iSeed_ == Seed::L5L6) {
        accept = barrelSeeding(innerFPGAStub, innerStub, outerFPGAStub, outerStub);
      } else if (iSeed_ == Seed::D1D2 || iSeed_ == Seed::D3D4) {
        accept = diskSeeding(innerFPGAStub, innerStub, outerFPGAStub, outerStub);
      } else {
        accept = overlapSeeding(outerFPGAStub, outerStub, innerFPGAStub, innerStub);
      }
 
      if (accept)
        countsel++;
 
      if (trackletpars_->nTracklets() >= settings_.ntrackletmax()) {
        edm::LogVerbatim("Tracklet") << "Will break on number of tracklets in " << getName();
        assert(0);
        break;
      }
 
      if (settings_.debugTracklet()) {
        edm::LogVerbatim("Tracklet") << "TrackletProcessor execute done";
      }
    }
 
    //
    // The second block fills the teunit if data in buffer and process TEUnit step
    //
    //
 
    bool notemptytebuffer = !tedatabuffer.empty();
 
    int ite = -1;
    for (auto& teunit : teunits_) {
      ite++;
      if (teunit.idle()) {
        if (notemptytebuffer) {
          teunit.init(std::get<0>(tebuffer_).read());
          notemptytebuffer = false;  //prevent initialzing another TE unit
        }
      }
      teunit.step(print, istep, ite);
    }
 
    //
    // The third block here checks if we have input stubs to process
    //
    //
 
    if (goodtedata___)
      tedatabuffer.store(tedata___);
 
    goodtedata = false;
 
    unsigned int& istub = std::get<1>(tebuffer_);
    unsigned int& imem = std::get<2>(tebuffer_);
    unsigned int imemend = std::get<4>(tebuffer_);
 
    if ((!tebuffernearfull) && imem < imemend && istub < innerallstubs_[imem]->nStubs()) {
      ninnerstubs++;
 
      const Stub* stub = innerallstubs_[imem]->getStub(istub);
 
      if (settings_.debugTracklet()) {
        edm::LogVerbatim("Tracklet") << getName() << " Have stub in " << innerallstubs_[imem]->getName();
      }
 
      bool negdisk = (stub->disk().value() < 0);  //FIXME stub needs to contain bit for +/- z disk
 
      FPGAWord phicorr = stub->phicorr();
      int innerfinephi = phicorr.bits(phicorr.nbits() - nbitsfinephi_, nbitsfinephi_);
      FPGAWord innerbend = stub->bend();
 
      //Take the top nbitszfinebintable_ bits of the z coordinate
      int indexz = (stub->z().value() >> (stub->z().nbits() - nbitszfinebintable_)) & ((1 << nbitszfinebintable_) - 1);
      int indexr = -1;
      if (layerdisk1_ > (N_LAYER - 1)) {
        if (negdisk) {
          indexz = ((1 << nbitszfinebintable_) - 1) - indexz;
        }
        indexr = stub->r().value() >> (stub->r().nbits() - nbitsrfinebintable_);
      } else {  //Take the top nbitsfinebintable_ bits of the z coordinate
        indexr = (stub->r().value() >> (stub->r().nbits() - nbitsrfinebintable_)) & ((1 << nbitsrfinebintable_) - 1);
      }
 
      int lutval = -1;
      if (iSeed_ < 6) {  //FIXME should only be one table - but will need coordination with HLS code.
        lutval = innerTable_.lookup((indexz << nbitsrfinebintable_) + indexr);
      } else {
        lutval = innerOverlapTable_.lookup((indexz << nbitsrfinebintable_) + indexr);
      }
 
      if (lutval != -1) {
        unsigned int lutwidth = settings_.lutwidthtab(0, iSeed_);
        FPGAWord lookupbits(lutval, lutwidth, true, __LINE__, __FILE__);
 
        int rzfinebinfirst = lookupbits.bits(0, NFINERZBITS);       //finerz
        int next = lookupbits.bits(NFINERZBITS, 1);                 //use next r/z bin
        int start = lookupbits.bits(NFINERZBITS + 1, nbitsrzbin_);  //rz bin
        int rzdiffmax = lookupbits.bits(NFINERZBITS + 1 + nbitsrzbin_, NFINERZBITS);
 
        if ((iSeed_ == Seed::D1D2 || iSeed_ == Seed::D3D4) && negdisk) {  //TODO - need to store negative disk
          start += (1 << nbitsrzbin_);
        }
        int last = start + next;
 
        int nbins = (1 << N_RZBITS);
 
        unsigned int useregindex = (innerfinephi << innerbend.nbits()) + innerbend.value();
        if (iSeed_ == Seed::D1D2 || iSeed_ == Seed::D3D4 || iSeed_ == Seed::L1D1 || iSeed_ == Seed::L2D1) {
          //FIXME If the lookupbits were rationally organized this would be much simpler
          unsigned int nrbits = 3;
          int ir = ((start & ((1 << (nrbits - 1)) - 1)) << 1) + (rzfinebinfirst >> (NFINERZBITS - 1));
          useregindex = (useregindex << nrbits) + ir;
        }
 
        unsigned int usereg = useregiontable_.lookup(useregindex);
 
        tedata.regions_.clear();
        tedata.stub_ = stub;
        tedata.rzbinfirst_ = rzfinebinfirst;
        tedata.start_ = start;
        tedata.innerfinephi_ = innerfinephi;
        tedata.rzdiffmax_ = rzdiffmax;
        tedata.innerbend_ = innerbend;
 
        std::string mask = "";
 
        for (int ibin = start; ibin <= last; ibin++) {
          for (unsigned int ireg = 0; ireg < settings_.nvmte(1, iSeed_); ireg++) {
            if (!(usereg & (1 << ireg))) {
              mask = "0" + mask;
              continue;
            }
 
            if (settings_.debugTracklet()) {
              edm::LogVerbatim("Tracklet") << getName() << " looking for matching stub in bin " << ibin << " with "
                                           << outervmstubs_->nVMStubsBinned(ireg * nbins + ibin) << " stubs";
            }
            assert(ireg * nbins + ibin < outervmstubs_->nBin());
            int nstubs = outervmstubs_->nVMStubsBinned(ireg * nbins + ibin);
 
            if (nstubs > 0) {
              mask = "1" + mask;
              tedata.regions_.emplace_back(tuple<int, int, int>(ibin - start, ireg, nstubs));
              countteall += nstubs;
            } else {
              mask = "0" + mask;
            }
          }
        }
 
        if (!tedata.regions_.empty()) {
          ntedata++;
          goodtedata = true;
        }
      }
      istub++;
      if (istub >= innerallstubs_[imem]->nStubs()) {
        istub = 0;
        imem++;
      }
    } else if ((!tebuffernearfull) && imem < imemend && istub == 0) {
      imem++;
    }
 
    goodtedata___ = goodtedata__;
    goodtedata__ = goodtedata;
 
    tedata___ = tedata__;
    tedata__ = tedata;
 
    //
    // stop looping over istep if done
    //
 
    bool done = true;
 
    if (imem < imemend || (!tedatabuffer.empty())) {
      done = false;
    }
 
    for (auto& teunit : teunits_) {
      if (!(teunit.idle() && teunit.empty()))
        done = false;
    }
 
    if (done) {
      donecount++;
    }
 
    //FIXME This should be done cleaner... Not too hard, but need to check fully the TEBuffer and TEUnit buffer.
    if (donecount > 4) {
      break;
    }
  }
 
  //
  // Done with processing - collect performance statistics
  //
 
  if (settings_.writeMonitorData("TP")) {
    globals_->ofstream("trackletprocessor.txt") << getName() << " " << ninnerstubs   //# inner stubs
                                                << " " << outervmstubs_->nVMStubs()  //# outer stubs
                                                << " " << countteall                 //# pairs tried in TE
                                                << " " << stubpairs                  //# stubs pairs
                                                << " " << countsel                   //# tracklets found
                                                << endl;
  }
}

References accept(), cms::cuda::assert(), trklet::TrackletCalculatorBase::barrelSeeding(), trklet::Stub::bend(), trklet::FPGAWord::bits(), gather_cfg::cout, trklet::D1D2, trklet::D3D4, trklet::Settings::debugTracklet(), trklet::Stub::disk(), trklet::TrackletCalculatorBase::diskSeeding(), fileCollector::done, trklet::CircularBuffer< T >::empty(), trklet::ProcessBase::getName(), trklet::ProcessBase::globals_, iAllStub_, innerallstubs_, trklet::TEData::innerbend_, trklet::TEData::innerfinephi_, innerOverlapTable_, innerTable_, trklet::TrackletCalculatorBase::iSector_, trklet::TrackletCalculatorBase::iSeed_, dqmdumpme::k, trklet::L1D1, trklet::L1L2, trklet::Stub::l1tstub(), trklet::L2D1, trklet::L2L3, trklet::L3L4, trklet::L5L6, dqmdumpme::last, trklet::TrackletCalculatorBase::layerdisk1_, trklet::TrackletCalculatorBase::layerdisk2_, trklet::TrackletLUT::lookup(), trklet::Settings::lutwidthtab(), maxStep_, trklet::N_LAYER, trklet::N_RZBITS, trklet::Settings::nallstubs(), PFElectronDQMAnalyzer_cfi::nBin, LaserClient_cfi::nbins, trklet::FPGAWord::nbits(), nbitsfinephi_, nbitsrfinebintable_, nbitsrzbin_, nbitszfinebintable_, trklet::CircularBuffer< T >::nearfull(), GetRecoTauVFromDQM_MC_cff::next, trklet::NFINERZBITS, trklet::Settings::ntrackletmax(), trklet::TrackletParametersMemory::nTracklets(), trklet::VMStubsTEMemory::nVMStubs(), trklet::VMStubsTEMemory::nVMStubsBinned(), trklet::Settings::nvmte(), trklet::Globals::ofstream(), outervmstubs_, trklet::TrackletCalculatorBase::overlapSeeding(), trklet::Stub::phicorr(), phimax, trklet::TrackletCalculatorBase::phimax_, phimin, trklet::TrackletCalculatorBase::phimin_, print(), trklet::Stub::r(), readEcalDQMStatus::read, trklet::TrackletEngineUnit::read(), trklet::TEData::regions_, trklet::CircularBuffer< T >::rptr(), trklet::TEData::rzbinfirst_, trklet::TEData::rzdiffmax_, trklet::TrackletEngineUnit::setNearFull(), trklet::ProcessBase::settings_, command_line::start, trklet::TEData::start_, trklet::CircularBuffer< T >::store(), AlCaHLTBitMon_QueryRunRegistry::string, trklet::TEData::stub_, tebuffer_, teunits_, trklet::TrackletCalculatorBase::trackletpars_, useregiontable_, trklet::Settings::useSeed(), trklet::FPGAWord::value(), trklet::CircularBuffer< T >::wptr(), trklet::Settings::writeMonitorData(), and trklet::Stub::z().

Member Data Documentation

iAllStub_

int trklet::TrackletProcessor::iAllStub_

private

Definition at line 40 of file TrackletProcessor.h.

Referenced by addInput(), execute(), and TrackletProcessor().

innerallstubs_

std::vector<AllInnerStubsMemory*> trklet::TrackletProcessor::innerallstubs_

private

Definition at line 51 of file TrackletProcessor.h.

Referenced by addInput(), and execute().

innerOverlapTable_

TrackletLUT trklet::TrackletProcessor::innerOverlapTable_

private

Definition at line 70 of file TrackletProcessor.h.

Referenced by execute(), and TrackletProcessor().

innerphibits_

int trklet::TrackletProcessor::innerphibits_

private

Definition at line 61 of file TrackletProcessor.h.

Referenced by TrackletProcessor().

innerTable_

TrackletLUT trklet::TrackletProcessor::innerTable_

private

Definition at line 69 of file TrackletProcessor.h.

Referenced by execute(), and TrackletProcessor().

iTC_

int trklet::TrackletProcessor::iTC_

private

Definition at line 39 of file TrackletProcessor.h.

Referenced by TrackletProcessor().

maxStep_

unsigned int trklet::TrackletProcessor::maxStep_

private

Definition at line 42 of file TrackletProcessor.h.

Referenced by execute(), and TrackletProcessor().

nbitsfinephi_

int trklet::TrackletProcessor::nbitsfinephi_

private

Definition at line 58 of file TrackletProcessor.h.

Referenced by addInput(), execute(), and TrackletProcessor().

nbitsfinephidiff_

int trklet::TrackletProcessor::nbitsfinephidiff_

private

Definition at line 59 of file TrackletProcessor.h.

Referenced by addInput(), and TrackletProcessor().

nbitsrfinebintable_

unsigned int trklet::TrackletProcessor::nbitsrfinebintable_

private

Definition at line 65 of file TrackletProcessor.h.

Referenced by execute(), and TrackletProcessor().

nbitsrzbin_

unsigned int trklet::TrackletProcessor::nbitsrzbin_

private

Definition at line 67 of file TrackletProcessor.h.

Referenced by execute(), and TrackletProcessor().

nbitszfinebintable_

unsigned int trklet::TrackletProcessor::nbitszfinebintable_

private

Definition at line 64 of file TrackletProcessor.h.

Referenced by execute(), and TrackletProcessor().

outerallstubs_

std::vector<AllStubsMemory*> trklet::TrackletProcessor::outerallstubs_

private

Definition at line 52 of file TrackletProcessor.h.

Referenced by addInput().

outerphibits_

int trklet::TrackletProcessor::outerphibits_

private

Definition at line 62 of file TrackletProcessor.h.

Referenced by TrackletProcessor().

outervmstubs_

VMStubsTEMemory* trklet::TrackletProcessor::outervmstubs_

private

Definition at line 44 of file TrackletProcessor.h.

Referenced by addInput(), execute(), and TrackletProcessor().

pttableinner_

TrackletLUT trklet::TrackletProcessor::pttableinner_

private

Definition at line 54 of file TrackletProcessor.h.

Referenced by addInput().

pttableouter_

TrackletLUT trklet::TrackletProcessor::pttableouter_

private

Definition at line 55 of file TrackletProcessor.h.

Referenced by addInput().

tebuffer_

std::tuple<CircularBuffer<TEData>, unsigned int, unsigned int, unsigned int, unsigned int> trklet::TrackletProcessor::tebuffer_

private

Definition at line 47 of file TrackletProcessor.h.

Referenced by addInput(), and execute().

teunits_

std::vector<TrackletEngineUnit> trklet::TrackletProcessor::teunits_

private

Definition at line 49 of file TrackletProcessor.h.

Referenced by addInput(), and execute().

useregiontable_

TrackletLUT trklet::TrackletProcessor::useregiontable_

private

Definition at line 56 of file TrackletProcessor.h.

Referenced by addInput(), and execute().