trklet::VMRouterCM Class Reference

#include <VMRouterCM.h>

Inheritance diagram for trklet::VMRouterCM:

Public Member Functions
void	addInput (MemoryBase *memory, std::string input) override
void	addOutput (MemoryBase *memory, std::string output) override
void	execute (unsigned int iSector)
	VMRouterCM (std::string name, Settings const &settings, Globals *global)
	~VMRouterCM () override=default
Public Member Functions inherited from trklet::ProcessBase
unsigned int	getISeed (const std::string &name)
std::string const &	getName () const
void	initLayerDisk (unsigned int pos, int &layer, int &disk)
void	initLayerDisk (unsigned int pos, int &layer, int &disk, int &layerdisk)
unsigned int	initLayerDisk (unsigned int pos)
void	initLayerDisksandISeed (unsigned int &layerdisk1, unsigned int &layerdisk2, unsigned int &iSeed)
void	initLayerDisksandISeedDisp (unsigned int &layerdisk1, unsigned int &layerdisk2, unsigned int &layerdisk3, unsigned int &iSeed)
unsigned int	nbits (unsigned int power)
	ProcessBase (std::string name, Settings const &settings, Globals *global)
virtual	~ProcessBase ()=default

Private Attributes
std::vector< std::pair< char, AllInnerStubsMemory * > >	allinnerstubs_
std::vector< AllStubsMemory * >	allstubs_
TrackletLUT	diskTable_
TrackletLUT	diskTableOld_
TrackletLUT	innerOverlapTable_
TrackletLUT	innerTable_
TrackletLUT	innerThirdTable_
unsigned int	layerdisk_
TrackletLUT	meTable_
TrackletLUT	meTableOld_
int	nbitsrfinebintable_
int	nbitszfinebintable_
unsigned int	nextrabits_
unsigned int	nvmmebins_
unsigned int	overlapbits_
std::vector< InputLinkMemory * >	stubinputs_
std::vector< VMStubsMEMemory * >	vmstubsMEPHI_
std::vector< VMStubsTEPHICM >	vmstubsTEPHI_

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

Detailed Description

Definition at line 39 of file VMRouterCM.h.

Constructor & Destructor Documentation

VMRouterCM()

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

Definition at line 17 of file VMRouterCM.cc.

References cms::cuda::assert(), trklet::D3, trklet::D4, diskTable_, diskTableOld_, trklet::ProcessBase::initLayerDisk(), trklet::TrackletLUT::initVMRTable(), SurfaceOrientation::inner, innerOverlapTable_, innerTable_, innerThirdTable_, PixelRegions::L1, PixelRegions::L2, PixelRegions::L3, trklet::L5, layerdisk_, hlt_dqm_clientPB-live_cfg::me, meTable_, meTableOld_, trklet::N_LAYER, trklet::Settings::nallstubs(), mergeVDriftHistosByStation::name, trklet::Settings::nbitsallstubs(), nbitsrfinebintable_, trklet::Settings::nbitsvmme(), nbitszfinebintable_, nextrabits_, trklet::Settings::NLONGVMBINS(), nvmmebins_, overlapbits_, nano_mu_digi_cff::region, trklet::ProcessBase::settings_, trklet::Settings::vmrlutrbits(), and trklet::Settings::vmrlutzbits().

    : ProcessBase(name, settings, global),
      meTable_(settings),
      diskTable_(settings),
      meTableOld_(settings),
      diskTableOld_(settings),
      innerTable_(settings),
      innerOverlapTable_(settings),
      innerThirdTable_(settings) {
  layerdisk_ = initLayerDisk(4);

  unsigned int region = name[9] - 'A';
  assert(region < settings_.nallstubs(layerdisk_));

  overlapbits_ = 7;
  nextrabits_ = overlapbits_ - (settings_.nbitsallstubs(layerdisk_) + settings_.nbitsvmme(layerdisk_));

  // The TrackletProcessorDisplaced currently uses the older LUTs that were
  // used with the non-combined modules. To maintain compatibility, we
  // initialize these older LUTs below, which are used for the triplet seeds in
  // the "execute" method. Once the TrackletProcessorDisplaced is updated,
  // these can be removed.

  meTable_.initVMRTable(layerdisk_, TrackletLUT::VMRTableType::me, region);            //used for ME and outer TE barrel
  meTableOld_.initVMRTable(layerdisk_, TrackletLUT::VMRTableType::me, region, false);  //used for ME and outer TE barrel

  if (layerdisk_ == LayerDisk::D1 || layerdisk_ == LayerDisk::D2 || layerdisk_ == LayerDisk::D4) {
    diskTable_.initVMRTable(layerdisk_, TrackletLUT::VMRTableType::disk, region);  //outer disk used by D1, D2, and D4
    diskTableOld_.initVMRTable(
        layerdisk_, TrackletLUT::VMRTableType::disk, region, false);  //outer disk used by D1, D2, and D4
  }

  if (layerdisk_ == LayerDisk::L1 || layerdisk_ == LayerDisk::L2 || layerdisk_ == LayerDisk::L3 ||
      layerdisk_ == LayerDisk::L5 || layerdisk_ == LayerDisk::D1 || layerdisk_ == LayerDisk::D3) {
    innerTable_.initVMRTable(
        layerdisk_, TrackletLUT::VMRTableType::inner, region, false);  //projection to next layer/disk
  }

  if (layerdisk_ == LayerDisk::L1 || layerdisk_ == LayerDisk::L2) {
    innerOverlapTable_.initVMRTable(
        layerdisk_, TrackletLUT::VMRTableType::inneroverlap, region, false);  //projection to disk from layer
  }

  if (layerdisk_ == LayerDisk::L2 || layerdisk_ == LayerDisk::L3 || layerdisk_ == LayerDisk::L5 ||
      layerdisk_ == LayerDisk::D1) {
    innerThirdTable_.initVMRTable(
        layerdisk_, TrackletLUT::VMRTableType::innerthird, region, false);  //projection to third layer/disk
  }

  nbitszfinebintable_ = settings_.vmrlutzbits(layerdisk_);
  nbitsrfinebintable_ = settings_.vmrlutrbits(layerdisk_);

  nvmmebins_ = settings_.NLONGVMBINS() * ((layerdisk_ >= N_LAYER) ? 2 : 1);  //number of long z/r bins in VM
}

~VMRouterCM()

trklet::VMRouterCM::~VMRouterCM ( )

overridedefault

Member Function Documentation

addInput()

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

overridevirtual

Implements trklet::ProcessBase.

Definition at line 171 of file VMRouterCM.cc.

References cms::cuda::assert(), Exception, input, mps_setup::memory, trklet::ProcessBase::name_, trklet::ProcessBase::settings_, stubinputs_, and trklet::Settings::writetrace().

                                                          {
  if (settings_.writetrace()) {
    edm::LogVerbatim("Tracklet") << "In " << name_ << " adding input from " << memory->getName() << " to input "
                                 << input;
  }
  if (input == "stubin") {
    InputLinkMemory* tmp1 = dynamic_cast<InputLinkMemory*>(memory);
    assert(tmp1 != nullptr);
    if (tmp1 != nullptr) {
      stubinputs_.push_back(tmp1);
    }
    return;
  }
  throw cms::Exception("BadConfig") << __FILE__ << " " << __LINE__ << " Could not find input : " << input;
}

addOutput()

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

overridevirtual

Implements trklet::ProcessBase.

Definition at line 72 of file VMRouterCM.cc.

References allinnerstubs_, allstubs_, cms::cuda::assert(), trklet::D3, Exception, trklet::ProcessBase::getName(), mps_fire::i, SurfaceOrientation::inner, iseed, isotrackApplyRegressor::k, PixelRegions::L1, PixelRegions::L2, trklet::L2L3L4, PixelRegions::L3, trklet::L5, layerdisk_, mps_setup::memory, trklet::N_SEED, trklet::ProcessBase::name_, trklet::Settings::NLONGVMBINS(), trklet::Settings::nvmme(), nvmmebins_, trklet::Settings::nvmte(), convertSQLitetoXML_cfg::output, push_back(), trklet::ProcessBase::settings_, createJobs::tmp, vmstubsMEPHI_, vmstubsTEPHI_, and trklet::Settings::writetrace().

                                                            {
  if (settings_.writetrace()) {
    edm::LogVerbatim("Tracklet") << "In " << name_ << " adding output to " << memory->getName() << " to output "
                                 << output;
  }

  if (output == "allinnerstubout") {
    AllInnerStubsMemory* tmp = dynamic_cast<AllInnerStubsMemory*>(memory);
    assert(tmp != nullptr);
    char memtype = memory->getName().back();
    allinnerstubs_.emplace_back(memtype, tmp);
    return;
  }

  if (output.substr(0, 10) == "allstubout") {
    AllStubsMemory* tmp = dynamic_cast<AllStubsMemory*>(memory);
    allstubs_.push_back(tmp);
    return;
  }

  if (output.substr(0, 9) == "vmstubout") {
    if (memory->getName().substr(3, 2) == "TE") {
      VMStubsTEMemory* tmp = dynamic_cast<VMStubsTEMemory*>(memory);
      int i = output.find_last_of('_');
      unsigned int iseed = std::stoi(output.substr(i + 1));
      assert(iseed < N_SEED);

      // This flag is used to replicate the behavior of the old VMRouter for
      // the case of the triplet seeds.
      const bool isTripletSeed = (iseed >= L2L3L4);

      // seedtype, vmbin, and inner are only used in the case of the triplet
      // seeds.
      char seedtype = memory->getName().substr(11, 1)[0];
      unsigned int pos = 12;
      int vmbin = memory->getName().substr(pos, 1)[0] - '0';
      pos++;
      if (pos < memory->getName().size()) {
        if (memory->getName().substr(pos, 1)[0] != 'n') {
          vmbin = vmbin * 10 + memory->getName().substr(pos, 1)[0] - '0';
          pos++;
        }
      }
      unsigned int inner = 1;
      if (seedtype < 'I') {
        if (layerdisk_ == LayerDisk::L1 || layerdisk_ == LayerDisk::L3 || layerdisk_ == LayerDisk::L5 ||
            layerdisk_ == LayerDisk::D1 || layerdisk_ == LayerDisk::D3)
          inner = 0;
      } else if (seedtype < 'M') {
        if (layerdisk_ == LayerDisk::L2)
          inner = 0;
      } else if (seedtype <= 'Z') {
        if (layerdisk_ == LayerDisk::L1 || layerdisk_ == LayerDisk::L2)
          inner = 0;
      } else if (seedtype < 'o' && seedtype >= 'a') {
        if (layerdisk_ == LayerDisk::L2)
          inner = 0;
      } else if (seedtype > 'o' && seedtype <= 'z') {
        inner = 2;
      } else {
        throw cms::Exception("LogicError") << __FILE__ << " " << __LINE__ << " Invalid seeding!";
      }

      int seedindex = -1;
      for (unsigned int k = 0; k < vmstubsTEPHI_.size(); k++) {
        if (vmstubsTEPHI_[k].seednumber == iseed) {
          seedindex = k;
        }
      }
      if (seedindex == -1) {
        seedindex = vmstubsTEPHI_.size();
        vector<VMStubsTEMemory*> avectmp;
        vector<vector<VMStubsTEMemory*> > vectmp(!isTripletSeed ? 1 : settings_.nvmte(inner, iseed), avectmp);
        VMStubsTEPHICM atmp(iseed, inner, vectmp);
        vmstubsTEPHI_.push_back(atmp);
      }
      if (!isTripletSeed) {
        tmp->resize(settings_.NLONGVMBINS() * settings_.nvmte(1, iseed));
        vmstubsTEPHI_[seedindex].vmstubmem[0].push_back(tmp);
      } else {
        vmstubsTEPHI_[seedindex].vmstubmem[(vmbin - 1) & (settings_.nvmte(inner, iseed) - 1)].push_back(tmp);
      }

    } else if (memory->getName().substr(3, 2) == "ME") {
      VMStubsMEMemory* tmp = dynamic_cast<VMStubsMEMemory*>(memory);
      assert(tmp != nullptr);
      tmp->resize(nvmmebins_ * settings_.nvmme(layerdisk_));
      vmstubsMEPHI_.push_back(tmp);
    } else {
      throw cms::Exception("LogicError") << __FILE__ << " " << __LINE__ << " memory: " << memory->getName()
                                         << " => should never get here!";
    }

    return;
  }

  throw cms::Exception("BadConfig") << __FILE__ << " " << __LINE__ << " Could not find output : " << output;
}

execute()

void VMRouterCM::execute

(

unsigned int

iSector

)

Definition at line 187 of file VMRouterCM.cc.

References funct::abs(), allinnerstubs_, allstubs_, cms::cuda::assert(), trklet::Stub::bend(), newFWLiteAna::bin, trklet::D1D2, trklet::D3, trklet::Settings::debugTracklet(), trklet::Stub::disk(), diskTable_, diskTableOld_, trklet::Settings::extended(), trklet::ProcessBase::getName(), mps_fire::i, SurfaceOrientation::inner, innerOverlapTable_, innerTable_, innerThirdTable_, createfilelist::int, hcalRecHitTable_cff::iphi, trklet::Stub::iphivmFineBins(), iseed, trklet::Stub::isPSmodule(), trklet::Settings::kr(), trklet::Settings::kz(), MainPageGenerator::l, PixelRegions::L1, trklet::Stub::l1tstub(), PixelRegions::L2, trklet::L2D1, trklet::L2L3D1, trklet::L2L3L4, PixelRegions::L3, trklet::L3L4, trklet::L5, trklet::L5L6, layerdisk_, trklet::TrackletLUT::lookup(), trklet::Settings::lutwidthtab(), trklet::Settings::lutwidthtabextended(), trklet::Settings::maxStep(), meTable_, meTableOld_, trklet::N_BITSMEMADDRESS, trklet::N_DSS_MOD, trklet::N_LAYER, trklet::N_PHIBITS, trklet::Settings::nbendbitsmedisk(), trklet::FPGAWord::nbits(), trklet::TrackletLUT::nbits(), trklet::Settings::nbitsallstubs(), nbitsrfinebintable_, trklet::Settings::nbitsvmme(), trklet::Settings::nbitsvmte(), nbitszfinebintable_, trklet::Settings::nfinephi(), trklet::NFINERZBITS, trklet::Settings::NLONGVMBINS(), trklet::Settings::NLONGVMBITS(), trklet::Settings::nphireg(), nvmmebins_, trklet::Stub::phicorr(), trklet::Stub::r(), trklet::Settings::rmindiskl3overlapvm(), trklet::FPGAWord::set(), trklet::Stub::setAllStubIndex(), trklet::L1TStub::setAllStubIndex(), trklet::ProcessBase::settings_, stubinputs_, createJobs::tmp, trklet::FPGAWord::value(), trklet::VMROUTERCUTRD1D3, trklet::VMROUTERCUTZL1, trklet::VMROUTERCUTZL1L3L5, trklet::VMROUTERCUTZL2, vmstubsMEPHI_, vmstubsTEPHI_, and trklet::Stub::z().

                                     {
  unsigned int allStubCounter = 0;

  //bool print = getName() == "VMR_D1PHIB" && iSector == 3;
  //print = false;

  //Loop over the input stubs
  for (auto& stubinput : stubinputs_) {
    for (unsigned int i = 0; i < stubinput->nStubs(); i++) {
      if (allStubCounter > settings_.maxStep("VMR"))
        continue;
      if (allStubCounter >= (1 << N_BITSMEMADDRESS))
        continue;

      Stub* stub = stubinput->getStub(i);

      //Note - below information is not part of the stub, but rather from which input memory
      //we are reading
      bool negdisk = (stub->disk().value() < 0);

      //use &127 to make sure we fit into the number of bits -
      //though we should have protected against overflows above
      FPGAWord allStubIndex(allStubCounter & ((1 << N_BITSMEMADDRESS) - 1), N_BITSMEMADDRESS, true, __LINE__, __FILE__);

      //TODO - should not be needed - but need to migrate some other pieces of code before removing
      stub->setAllStubIndex(allStubCounter);
      //TODO - should not be needed - but need to migrate some other pieces of code before removing
      stub->l1tstub()->setAllStubIndex(allStubCounter);

      allStubCounter++;

      for (auto& allstub : allstubs_) {
        allstub->addStub(stub);
        if (settings_.debugTracklet()) {
          edm::LogVerbatim("Tracklet") << getName() << " adding stub to " << allstub->getName();
        }
      }

      FPGAWord iphi = stub->phicorr();
      unsigned int iphipos = iphi.bits(iphi.nbits() - (settings_.nbitsallstubs(layerdisk_) + N_PHIBITS), N_PHIBITS);

      unsigned int phicutmax = 4;
      unsigned int phicutmin = 4;

      if (layerdisk_ != 0) {
        phicutmax = 6;
        phicutmin = 2;
      }

      //Fill inner allstubs memories - in HLS this is the same write to multiple memories
      for (auto& allstub : allinnerstubs_) {
        char memtype = allstub.first;
        if (memtype == 'R' && iphipos < phicutmax)
          continue;
        if (memtype == 'L' && iphipos >= phicutmin)
          continue;
        if (memtype == 'A' && iphipos < 4)
          continue;
        if (memtype == 'B' && iphipos >= 4)
          continue;
        if (memtype == 'E' && iphipos >= 4)
          continue;
        if (memtype == 'F' && iphipos < 4)
          continue;
        if (memtype == 'C' && iphipos >= 4)
          continue;
        if (memtype == 'D' && iphipos < 4)
          continue;

        int absz = std::abs(stub->z().value());
        if (layerdisk_ == LayerDisk::L2 && absz < VMROUTERCUTZL2 / settings_.kz(layerdisk_))
          continue;
        if ((layerdisk_ == LayerDisk::L3 || layerdisk_ == LayerDisk::L5) &&
            absz > VMROUTERCUTZL1L3L5 / settings_.kz(layerdisk_))
          continue;
        if ((layerdisk_ == LayerDisk::D1 || layerdisk_ == LayerDisk::D3) &&
            stub->r().value() > VMROUTERCUTRD1D3 / settings_.kr())
          continue;
        if ((layerdisk_ == LayerDisk::D1 || layerdisk_ == LayerDisk::D3) && stub->r().value() < 2 * int(N_DSS_MOD))
          continue;
        if (layerdisk_ == LayerDisk::L1) {
          if (memtype == 'M' || memtype == 'R' || memtype == 'L') {
            if (absz < VMROUTERCUTZL1 / settings_.kz(layerdisk_))
              continue;
          } else {
            if (absz > VMROUTERCUTZL1L3L5 / settings_.kz(layerdisk_))
              continue;
          }
        }

        if (settings_.debugTracklet()) {
          edm::LogVerbatim("Tracklet") << getName() << " adding stub to " << allstub.second->getName();
        }

        allstub.second->addStub(stub);
      }

      //Fill all the ME VM memories
      unsigned int ivm =
          iphi.bits(iphi.nbits() - (settings_.nbitsallstubs(layerdisk_) + settings_.nbitsvmme(layerdisk_)),
                    settings_.nbitsvmme(layerdisk_));

      //Calculate the z and r position for the vmstub

      //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 (layerdisk_ > (N_LAYER - 1)) {
        if (negdisk) {
          indexz = ((1 << nbitszfinebintable_) - 1) - indexz;
        }
        indexr = stub->r().value();
        if (stub->isPSmodule()) {
          indexr = stub->r().value() >> (stub->r().nbits() - nbitsrfinebintable_);
        }
      } else {
        //Take the top nbitsfinebintable_ bits of the z coordinate. The & is to handle the negative z values.
        indexr = (stub->r().value() >> (stub->r().nbits() - nbitsrfinebintable_)) & ((1 << nbitsrfinebintable_) - 1);
      }

      assert(indexz >= 0);
      assert(indexr >= 0);
      assert(indexz < (1 << nbitszfinebintable_));
      assert(indexr < (1 << nbitsrfinebintable_));

      int melut = meTable_.lookup((indexz << nbitsrfinebintable_) + indexr);

      assert(melut >= 0);

      // The following indices are calculated in the same way as in the old
      // VMRouter and are only used for the triplet seeds.
      int indexzOld =
          (((1 << (stub->z().nbits() - 1)) + stub->z().value()) >> (stub->z().nbits() - nbitszfinebintable_));
      int indexrOld = -1;
      if (layerdisk_ > (N_LAYER - 1)) {
        if (negdisk) {
          indexzOld = (1 << nbitszfinebintable_) - indexzOld;
        }
        indexrOld = stub->r().value();
        if (stub->isPSmodule()) {
          indexrOld = stub->r().value() >> (stub->r().nbits() - nbitsrfinebintable_);
        }
      } else {
        //Take the top nbitsfinebintable_ bits of the z coordinate. The & is to handle the negative z values.
        indexrOld = (((1 << (stub->r().nbits() - 1)) + stub->r().value()) >> (stub->r().nbits() - nbitsrfinebintable_));
      }

      assert(indexzOld >= 0);
      assert(indexrOld >= 0);
      assert(indexzOld < (1 << nbitszfinebintable_));
      assert(indexrOld < (1 << nbitsrfinebintable_));

      int melutOld = meTableOld_.lookup((indexzOld << nbitsrfinebintable_) + indexrOld);

      assert(melutOld >= 0);

      int vmbin = melut >> NFINERZBITS;
      if (negdisk)
        vmbin += (1 << NFINERZBITS);
      int rzfine = melut & ((1 << NFINERZBITS) - 1);

      // pad disk PS bend word with a '0' in MSB so that all disk bends have 4 bits (for HLS compatibility)
      int nbendbits = stub->bend().nbits();
      if (layerdisk_ >= N_LAYER)
        nbendbits = settings_.nbendbitsmedisk();

      VMStubME vmstub(
          stub,
          stub->iphivmFineBins(settings_.nbitsallstubs(layerdisk_) + settings_.nbitsvmme(layerdisk_), NFINERZBITS),
          FPGAWord(rzfine, NFINERZBITS, true, __LINE__, __FILE__),
          FPGAWord(stub->bend().value(), nbendbits, true, __LINE__, __FILE__),
          allStubIndex);

      unsigned int nmems = vmstubsMEPHI_.size();

      for (unsigned int i = 0; i < nmems; i++) {  // allows multiple VMStubs to be written for duplicated MPs
        if (vmstubsMEPHI_[i] != nullptr)
          vmstubsMEPHI_[i]->addStub(vmstub, ivm * nvmmebins_ + vmbin);
      }

      for (auto& ivmstubTEPHI : vmstubsTEPHI_) {
        unsigned int iseed = ivmstubTEPHI.seednumber;

        // This flag is used to replicate the behavior of the old VMRouter for
        // the case of the triplet seeds.
        const bool isTripletSeed = (iseed >= L2L3L4);

        if (!isTripletSeed && layerdisk_ >= N_LAYER && (!stub->isPSmodule()))
          continue;
        unsigned int inner = (!isTripletSeed ? 1 : ivmstubTEPHI.stubposition);
        unsigned int lutwidth = settings_.lutwidthtab(inner, iseed);
        if (settings_.extended()) {
          lutwidth = settings_.lutwidthtabextended(inner, iseed);
        }

        int lutval = -999;

        if (inner > 0) {
          if (layerdisk_ < N_LAYER) {
            lutval = (!isTripletSeed ? melut : melutOld);
          } else {
            if (inner == 2 && iseed == Seed::L2L3D1) {
              lutval = 0;
              if (stub->r().value() < 10) {
                lutval = 8 * (1 + (stub->r().value() >> 2));
              } else {
                if (stub->r().value() < settings_.rmindiskl3overlapvm() / settings_.kr()) {
                  lutval = -1;
                }
              }
            } else {
              lutval = (!isTripletSeed ? diskTable_.lookup((indexz << nbitsrfinebintable_) + indexr)
                                       : diskTableOld_.lookup((indexzOld << nbitsrfinebintable_) + indexrOld));
              if (lutval == 0)
                continue;
            }
          }
          if (lutval == -1)
            continue;
        } else {
          if (iseed < Seed::L1D1 || iseed > Seed::L2D1) {
            lutval = innerTable_.lookup((indexzOld << nbitsrfinebintable_) + indexrOld);
          } else {
            lutval = innerOverlapTable_.lookup((indexzOld << nbitsrfinebintable_) + indexrOld);
          }
          if (lutval == -1)
            continue;
          if (settings_.extended() &&
              (iseed == Seed::L3L4 || iseed == Seed::L5L6 || iseed == Seed::D1D2 || iseed == Seed::L2L3D1)) {
            int lutval2 = innerThirdTable_.lookup((indexzOld << nbitsrfinebintable_) + indexrOld);
            if (lutval2 != -1) {
              const auto& lutshift = innerTable_.nbits();  // should be same for all inner tables
              lutval += (lutval2 << lutshift);
            }
          }
        }

        assert(lutval >= 0);

        FPGAWord binlookup(lutval, lutwidth, true, __LINE__, __FILE__);

        if (binlookup.value() < 0)
          continue;

        unsigned int ivmte =
            iphi.bits(iphi.nbits() - (settings_.nbitsallstubs(layerdisk_) + settings_.nbitsvmte(inner, iseed)),
                      settings_.nbitsvmte(inner, iseed));

        int bin = -1;
        if (inner != 0) {
          bin = binlookup.value() >> settings_.NLONGVMBITS();
          unsigned int tmp = binlookup.value() & (settings_.NLONGVMBINS() - 1);  //three bits in outer layers
          binlookup.set(tmp, settings_.NLONGVMBITS(), true, __LINE__, __FILE__);
        }

        FPGAWord finephi = stub->iphivmFineBins(settings_.nphireg(inner, iseed), settings_.nfinephi(inner, iseed));

        VMStubTE tmpstub(stub, finephi, stub->bend(), binlookup, allStubIndex);

        unsigned int nmem = ivmstubTEPHI.vmstubmem[!isTripletSeed ? 0 : ivmte].size();
        assert(nmem > 0);

        for (unsigned int l = 0; l < nmem; l++) {
          if (settings_.debugTracklet()) {
            edm::LogVerbatim("Tracklet") << getName() << " try adding stub to "
                                         << ivmstubTEPHI.vmstubmem[!isTripletSeed ? 0 : ivmte][l]->getName()
                                         << " bin=" << bin << " ivmte " << ivmte << " finephi " << finephi.value()
                                         << " regions bits " << settings_.nphireg(1, iseed) << " finephibits "
                                         << settings_.nfinephi(1, iseed);
          }
          if (!isTripletSeed)
            ivmstubTEPHI.vmstubmem[0][l]->addVMStub(tmpstub, bin, ivmte);
          else {
            if (inner == 0) {
              ivmstubTEPHI.vmstubmem[ivmte][l]->addVMStub(tmpstub);
            } else {
              ivmstubTEPHI.vmstubmem[ivmte][l]->addVMStub(tmpstub, bin, 0, false);
            }
          }
        }
      }
    }
  }
}

Member Data Documentation

allinnerstubs_

std::vector<std::pair<char, AllInnerStubsMemory*> > trklet::VMRouterCM::allinnerstubs_

private

Definition at line 80 of file VMRouterCM.h.

Referenced by addOutput(), and execute().

allstubs_

std::vector<AllStubsMemory*> trklet::VMRouterCM::allstubs_

private

Definition at line 79 of file VMRouterCM.h.

Referenced by addOutput(), and execute().

diskTable_

TrackletLUT trklet::VMRouterCM::diskTable_

private

Definition at line 65 of file VMRouterCM.h.

Referenced by execute(), and VMRouterCM().

diskTableOld_

TrackletLUT trklet::VMRouterCM::diskTableOld_

private

Definition at line 70 of file VMRouterCM.h.

Referenced by execute(), and VMRouterCM().

innerOverlapTable_

TrackletLUT trklet::VMRouterCM::innerOverlapTable_

private

Definition at line 72 of file VMRouterCM.h.

Referenced by execute(), and VMRouterCM().

innerTable_

TrackletLUT trklet::VMRouterCM::innerTable_

private

Definition at line 71 of file VMRouterCM.h.

Referenced by execute(), and VMRouterCM().

innerThirdTable_

TrackletLUT trklet::VMRouterCM::innerThirdTable_

private

Definition at line 73 of file VMRouterCM.h.

Referenced by execute(), and VMRouterCM().

layerdisk_

unsigned int trklet::VMRouterCM::layerdisk_

private

Definition at line 52 of file VMRouterCM.h.

Referenced by addOutput(), execute(), and VMRouterCM().

meTable_

TrackletLUT trklet::VMRouterCM::meTable_

private

Definition at line 64 of file VMRouterCM.h.

Referenced by execute(), and VMRouterCM().

meTableOld_

TrackletLUT trklet::VMRouterCM::meTableOld_

private

Definition at line 69 of file VMRouterCM.h.

Referenced by execute(), and VMRouterCM().

nbitsrfinebintable_

int trklet::VMRouterCM::nbitsrfinebintable_

private

Definition at line 60 of file VMRouterCM.h.

Referenced by execute(), and VMRouterCM().

nbitszfinebintable_

int trklet::VMRouterCM::nbitszfinebintable_

private

Definition at line 59 of file VMRouterCM.h.

Referenced by execute(), and VMRouterCM().

nextrabits_

unsigned int trklet::VMRouterCM::nextrabits_

private

Definition at line 57 of file VMRouterCM.h.

Referenced by VMRouterCM().

nvmmebins_

unsigned int trklet::VMRouterCM::nvmmebins_

private

Definition at line 62 of file VMRouterCM.h.

Referenced by addOutput(), execute(), and VMRouterCM().

overlapbits_

unsigned int trklet::VMRouterCM::overlapbits_

private

Definition at line 56 of file VMRouterCM.h.

Referenced by VMRouterCM().

stubinputs_

std::vector<InputLinkMemory*> trklet::VMRouterCM::stubinputs_

private

Definition at line 76 of file VMRouterCM.h.

Referenced by addInput(), and execute().

vmstubsMEPHI_

std::vector<VMStubsMEMemory*> trklet::VMRouterCM::vmstubsMEPHI_

private

Definition at line 83 of file VMRouterCM.h.

Referenced by addOutput(), and execute().

vmstubsTEPHI_

std::vector<VMStubsTEPHICM> trklet::VMRouterCM::vmstubsTEPHI_

private

Definition at line 86 of file VMRouterCM.h.

Referenced by addOutput(), and execute().