trklet::TrackletProcessorDisplaced Class Reference

#include <TrackletProcessorDisplaced.h>

Inheritance diagram for trklet::TrackletProcessorDisplaced:

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)
	TrackletProcessorDisplaced (std::string name, Settings const &settings, Globals *globals)
	~TrackletProcessorDisplaced () override=default
Public Member Functions inherited from trklet::TrackletCalculatorDisplaced
void	addDiskProj (Tracklet *tracklet, int disk)
bool	addLayerProj (Tracklet *tracklet, int layer)
void	addOutputProjection (TrackletProjectionsMemory *&outputProj, MemoryBase *memory)
void	addProjection (int layer, int iphi, TrackletProjectionsMemory *trackletprojs, Tracklet *tracklet)
void	addProjectionDisk (int disk, int iphi, TrackletProjectionsMemory *trackletprojs, Tracklet *tracklet)
void	approxproj (double halfRinv, double phi0, double d0, double t, double z0, double halfRinv_0, double d0_0, double rmean, double &phiproj, double &phiprojder, double &zproj, double &zprojder)
void	approxprojdisk (double halfRinv, double phi0, double d0, double t, double z0, double halfRinv_0, double d0_0, double zmean, double &phiproj, double &phiprojder, double &rproj, double &rprojder)
void	approxtracklet (double r1, double z1, double phi1, double r2, double z2, double phi2, double r3, double z3, double phi3, bool take3, unsigned ndisks, double &rinv, double &phi0, double &d0, double &t, double &z0, double phiproj[4], double zproj[4], double phider[4], double zder[4], double phiprojdisk[5], double rprojdisk[5], double phiderdisk[5], double rderdisk[5])
bool	DDLSeeding (const Stub *innerFPGAStub, const L1TStub *innerStub, const Stub *middleFPGAStub, const L1TStub *middleStub, const Stub *outerFPGAStub, const L1TStub *outerStub)
void	exactproj (double rproj, double rinv, double phi0, double d0, double t, double z0, double r0, double &phiproj, double &zproj, double &phider, double &zder)
void	exactprojdisk (double zproj, double rinv, double, double, double t, double z0, double x0, double y0, double &phiproj, double &rproj, double &phider, double &rder)
void	exacttracklet (double r1, double z1, double phi1, double r2, double z2, double phi2, double r3, double z3, double phi3, int take3, double &rinv, double &phi0, double &d0, double &t, double &z0, double phiproj[N_LAYER - 2], double zproj[N_LAYER - 2], double phiprojdisk[N_DISK], double rprojdisk[N_DISK], double phider[N_LAYER - 2], double zder[N_LAYER - 2], double phiderdisk[N_DISK], double rderdisk[N_DISK])
void	execute (unsigned int iSector, double phimin, double phimax)
bool	LLDSeeding (const Stub *innerFPGAStub, const L1TStub *innerStub, const Stub *middleFPGAStub, const L1TStub *middleStub, const Stub *outerFPGAStub, const L1TStub *outerStub)
bool	LLLSeeding (const Stub *innerFPGAStub, const L1TStub *innerStub, const Stub *middleFPGAStub, const L1TStub *middleStub, const Stub *outerFPGAStub, const L1TStub *outerStub)
	TrackletCalculatorDisplaced (std::string name, Settings const &settings, Globals *global)
	~TrackletCalculatorDisplaced () 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)
unsigned int	nbits (unsigned int power)
	ProcessBase (std::string name, Settings const &settings, Globals *global)
virtual	~ProcessBase ()=default

Private Attributes
int	count_
int	disk1_
int	disk2_
int	disk3_
int	firstphibits_
int	iAllStub_
TrackletLUT	innerOverlapTable_
TrackletLUT	innerTable_
TrackletLUT	innerThirdTable_
std::vector< VMStubsTEMemory * >	innervmstubs_
int	iTC_
int	layer1_
int	layer2_
int	layer3_
unsigned int	layerdisk_
unsigned int	maxStep_
int	nbitsrfinebintable_
int	nbitszfinebintable_
std::vector< VMStubsTEMemory * >	outervmstubs_
int	secondphibits_
std::map< std::string, std::vector< std::map< std::string, unsigned > > >	spTable_
std::vector< StubPairsMemory * >	stubpairs_
StubTripletsMemory *	stubtriplets_
std::vector< bool >	table_
int	thirdphibits_
std::map< std::string, std::vector< std::vector< std::string > > >	tmpSPTable_

Additional Inherited Members
Protected Attributes inherited from trklet::TrackletCalculatorDisplaced
int	disk_
int	dproj_ [N_DISK - 2]
std::vector< AllStubsMemory * >	innerallstubs_
unsigned int	iSector_
unsigned int	iSeed_
int	layer_
int	lproj_ [N_LAYER - 2]
std::vector< AllStubsMemory * >	middleallstubs_
std::vector< AllStubsMemory * >	outerallstubs_
double	phimax_
double	phimin_
double	rproj_ [N_LAYER - 2]
double	rzmeanInv_ [N_DISK - 2]
std::vector< StubTripletsMemory * >	stubtriplets_
int	TCIndex_
std::vector< double >	toR_
std::vector< double >	toZ_
TrackletParametersMemory *	trackletpars_
std::vector< std::vector< TrackletProjectionsMemory * > >	trackletprojdisks_
std::vector< std::vector< TrackletProjectionsMemory * > >	trackletprojlayers_
double	zproj_ [N_DISK - 2]
Protected Attributes inherited from trklet::ProcessBase
Globals *	globals_
std::string	name_
Settings const &	settings_

Detailed Description

Definition at line 27 of file TrackletProcessorDisplaced.h.

Constructor & Destructor Documentation

TrackletProcessorDisplaced()

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

Definition at line 21 of file TrackletProcessorDisplaced.cc.

References cms::cuda::assert(), trklet::D3, disk1_, disk2_, disk3_, trklet::TrackletCalculatorDisplaced::disk_, trklet::ProcessBase::initLayerDisk(), trklet::TrackletLUT::initVMRTable(), SurfaceOrientation::inner, trklet::TrackletCalculatorDisplaced::innerallstubs_, innerOverlapTable_, innerTable_, innerThirdTable_, innervmstubs_, trklet::TrackletCalculatorDisplaced::iSeed_, PixelRegions::L1, PixelRegions::L2, PixelRegions::L3, trklet::L5, layer1_, layer2_, layer3_, trklet::TrackletCalculatorDisplaced::layer_, layerdisk_, trklet::TrackletCalculatorDisplaced::middleallstubs_, trklet::N_DISK, trklet::N_LAYER, trklet::Settings::nallstubs(), Skims_PA_cff::name, nbitsrfinebintable_, nbitszfinebintable_, trklet::TrackletCalculatorDisplaced::outerallstubs_, outervmstubs_, HLT_2022v15_cff::region, trklet::ProcessBase::settings_, stubpairs_, trklet::TrackletCalculatorDisplaced::TCIndex_, createJobs::tmp, trklet::TrackletCalculatorDisplaced::trackletprojdisks_, trklet::TrackletCalculatorDisplaced::trackletprojlayers_, trklet::Settings::vmrlutrbits(), and trklet::Settings::vmrlutzbits().

    : TrackletCalculatorDisplaced(name, settings, globals),
      innerTable_(settings),
      innerOverlapTable_(settings),
      innerThirdTable_(settings) {
  innerallstubs_.clear();
  middleallstubs_.clear();
  outerallstubs_.clear();
  stubpairs_.clear();
  innervmstubs_.clear();
  outervmstubs_.clear();

  const unsigned layerdiskPosInName = 4;
  const unsigned regionPosInName1 = 9;

  // iAllStub_ = -1;
  layerdisk_ = initLayerDisk(layerdiskPosInName);

  unsigned int region = name.substr(1)[regionPosInName1] - 'A';
  // assert(region < settings_.nallstubs(layerdisk_));

  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);  //projection to next layer/disk
  }

  if (layerdisk_ == LayerDisk::L1 || layerdisk_ == LayerDisk::L2) {
    innerOverlapTable_.initVMRTable(
        layerdisk_, TrackletLUT::VMRTableType::inneroverlap, region);  //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);  //projection to third layer/disk
  }

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

  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);
  }

  // initLayerDisksandISeed(layerdisk1_, layerdisk2_, iSeed_);

  layer_ = 0;
  disk_ = 0;
  layer1_ = 0;
  layer2_ = 0;
  layer3_ = 0;
  disk1_ = 0;
  disk2_ = 0;
  disk3_ = 0;

  constexpr unsigned layerPosInName1 = 4;
  constexpr unsigned diskPosInName1 = 4;
  constexpr unsigned layer1PosInName1 = 4;
  constexpr unsigned disk1PosInName1 = 4;
  constexpr unsigned layer2PosInName1 = 6;
  constexpr unsigned disk2PosInName1 = 6;

  string name1 = name.substr(1);  //this is to correct for "TPD" having one more letter then "TP"
  if (name1[3] == 'L')
    layer_ = name1[layerPosInName1] - '0';
  if (name1[3] == 'D')
    disk_ = name1[diskPosInName1] - '0';

  if (name1[3] == 'L')
    layer1_ = name1[layer1PosInName1] - '0';
  if (name1[3] == 'D')
    disk1_ = name1[disk1PosInName1] - '0';
  if (name1[5] == 'L')
    layer2_ = name1[layer2PosInName1] - '0';
  if (name1[5] == 'D')
    disk2_ = name1[disk2PosInName1] - '0';

  // set TC index
  iSeed_ = 0;

  int iTC = name1[regionPosInName1] - 'A';

  if (name1.substr(3, 6) == "L3L4L2") {
    iSeed_ = 8;
    layer3_ = 2;
  } else if (name1.substr(3, 6) == "L5L6L4") {
    iSeed_ = 9;
    layer3_ = 4;
  } else if (name1.substr(3, 6) == "L2L3D1") {
    iSeed_ = 10;
    disk3_ = 1;
  } else if (name1.substr(3, 6) == "D1D2L2") {
    iSeed_ = 11;
    layer3_ = 2;
  }
  assert(iSeed_ != 0);

  constexpr int TCIndexMin = 128;
  constexpr int TCIndexMax = 191;

  TCIndex_ = (iSeed_ << 4) + iTC;
  assert(TCIndex_ >= TCIndexMin && TCIndex_ < TCIndexMax);

  assert((layer_ != 0) || (disk_ != 0));
}

~TrackletProcessorDisplaced()

trklet::TrackletProcessorDisplaced::~TrackletProcessorDisplaced ( )

overridedefault

Member Function Documentation

addInput()

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

overridevirtual

Reimplemented from trklet::TrackletCalculatorDisplaced.

Definition at line 184 of file TrackletProcessorDisplaced.cc.

References cms::cuda::assert(), Exception, trklet::TrackletCalculatorDisplaced::innerallstubs_, innervmstubs_, input, mps_setup::memory, trklet::TrackletCalculatorDisplaced::middleallstubs_, trklet::ProcessBase::name_, trklet::TrackletCalculatorDisplaced::outerallstubs_, outervmstubs_, trklet::ProcessBase::settings_, stubpairs_, createJobs::tmp, and trklet::Settings::writetrace().

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

  if (input == "thirdallstubin") {
    auto* tmp = dynamic_cast<AllStubsMemory*>(memory);
    assert(tmp != nullptr);
    innerallstubs_.push_back(tmp);
    return;
  }
  if (input == "firstallstubin") {
    auto* tmp = dynamic_cast<AllStubsMemory*>(memory);
    assert(tmp != nullptr);
    middleallstubs_.push_back(tmp);
    return;
  }
  if (input == "secondallstubin") {
    auto* tmp = dynamic_cast<AllStubsMemory*>(memory);
    assert(tmp != nullptr);
    outerallstubs_.push_back(tmp);
    return;
  }
  if (input.substr(0, 8) == "stubpair") {
    auto* tmp = dynamic_cast<StubPairsMemory*>(memory);
    assert(tmp != nullptr);
    stubpairs_.push_back(tmp);
    return;
  }

  if (input == "thirdvmstubin") {
    auto* tmp = dynamic_cast<VMStubsTEMemory*>(memory);
    assert(tmp != nullptr);
    innervmstubs_.push_back(tmp);
    return;
  }
  if (input == "secondvmstubin") {
    auto* tmp = dynamic_cast<VMStubsTEMemory*>(memory);
    assert(tmp != nullptr);
    // outervmstubs_ = tmp;
    outervmstubs_.push_back(tmp);
    return;
  }

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

addOutput()

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

overridevirtual

Reimplemented from trklet::TrackletCalculatorDisplaced.

Definition at line 138 of file TrackletProcessorDisplaced.cc.

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

                                                                            {
  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);

    constexpr unsigned layerdiskPosInprojout = 8;
    constexpr unsigned phiPosInprojout = 12;

    unsigned int layerdisk = output[layerdiskPosInprojout] - '1';  //layer or disk counting from 0
    unsigned int phiregion = output[phiPosInprojout] - '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;
}

addOutputProjection()

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

Definition at line 133 of file TrackletProcessorDisplaced.cc.

References cms::cuda::assert(), and mps_setup::memory.

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

execute()

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

Definition at line 232 of file TrackletProcessorDisplaced.cc.

References accept(), cms::cuda::assert(), newFWLiteAna::bin, count_, trklet::D1D2L2, trklet::TrackletCalculatorDisplaced::DDLSeeding(), trklet::Settings::debugTracklet(), trklet::Stub::disk(), disk1_, disk2_, disk3_, Exception, trklet::Settings::extended(), trklet::ProcessBase::getName(), SurfaceOrientation::inner, trklet::TrackletCalculatorDisplaced::innerallstubs_, innerOverlapTable_, innerTable_, innerThirdTable_, innervmstubs_, createfilelist::int, trklet::TrackletCalculatorDisplaced::iSector_, trklet::TrackletCalculatorDisplaced::iSeed_, trklet::Stub::isPSmodule(), dqmiolumiharvest::j, dqmdumpme::k, cmsLHEtoEOSManager::l, trklet::Stub::l1tstub(), trklet::L2D1, trklet::L2L3D1, trklet::L2L3L4, trklet::L4L5L6, dqmdumpme::last, layer1_, layer2_, layer3_, trklet::Stub::layerdisk(), layerdisk_, trklet::TrackletCalculatorDisplaced::LLDSeeding(), trklet::TrackletCalculatorDisplaced::LLLSeeding(), trklet::TrackletLUT::lookup(), trklet::Settings::lutwidthtab(), trklet::Settings::lutwidthtabextended(), visualization-live-secondInstance_cfg::m, trklet::TrackletCalculatorDisplaced::middleallstubs_, trklet::N_LAYER, trklet::FPGAWord::nbits(), nbitsrfinebintable_, nbitszfinebintable_, trklet::Settings::NLONGVMBINS(), trklet::TrackletCalculatorDisplaced::outerallstubs_, outervmstubs_, phimax, trklet::TrackletCalculatorDisplaced::phimax_, phimin, trklet::TrackletCalculatorDisplaced::phimin_, trklet::Stub::r(), trklet::ProcessBase::settings_, trklet::Stub::strbare(), trklet::VMStubTE::stub(), stubpairs_, trklet::L1TStub::stubword(), trklet::FPGAWord::value(), trklet::VMStubTE::vmbits(), and trklet::Stub::z().

                                                                                           {
  unsigned int countall = 0;
  unsigned int countall_ = 0;
  unsigned int countsel = 0;
  unsigned int countpass = 0;
  unsigned int countpass_ = 0;
  // unsigned int nThirdStubs = 0;
  unsigned int nInnerStubs = 0;
  // unsigned int nOuterStubs = 0;
  count_ = 0;

  phimin_ = phimin;
  phimax_ = phimax;
  iSector_ = iSector;

  for (unsigned int iInnerMem = 0; iInnerMem < middleallstubs_.size();
       nInnerStubs += middleallstubs_.at(iInnerMem)->nStubs(), iInnerMem++)
    ;

  assert(!innerallstubs_.empty());
  assert(!middleallstubs_.empty());
  assert(!outerallstubs_.empty());
  assert(!innervmstubs_.empty());
  assert(!outervmstubs_.empty());
  assert(stubpairs_.empty());

  for (auto& iInnerMem : middleallstubs_) {
    assert(iInnerMem->nStubs() == iInnerMem->nStubs());
    for (unsigned int j = 0; j < iInnerMem->nStubs(); j++) {
      const Stub* firstallstub = iInnerMem->getStub(j);

      if (settings_.debugTracklet()) {
        edm::LogVerbatim("Tracklet") << "In " << getName() << " have first stub\n";
      }

      int inner = 0;
      bool negdisk = (firstallstub->disk().value() < 0);
      int indexz = (((1 << (firstallstub->z().nbits() - 1)) + firstallstub->z().value()) >>
                    (firstallstub->z().nbits() - nbitszfinebintable_));
      int indexr = -1;
      if (layerdisk_ > (N_LAYER - 1)) {
        if (negdisk) {
          indexz = (1 << nbitszfinebintable_) - indexz;
        }
        indexr = firstallstub->r().value();
        if (firstallstub->isPSmodule()) {
          indexr = firstallstub->r().value() >> (firstallstub->r().nbits() - nbitsrfinebintable_);
        }
      } else {
        //Take the top nbitsfinebintable_ bits of the z coordinate. The & is to handle the negative z values.
        indexr = (((1 << (firstallstub->r().nbits() - 1)) + firstallstub->r().value()) >>
                  (firstallstub->r().nbits() - nbitsrfinebintable_));
      }

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

      // int melut = meTable_.lookup((indexz << nbitsrfinebintable_) + indexr);
      // assert(melut >= 0);

      unsigned int lutwidth = settings_.lutwidthtab(inner, iSeed_);
      if (settings_.extended()) {
        lutwidth = settings_.lutwidthtabextended(inner, iSeed_);
      }

      int lutval = -999;

      if (iSeed_ < Seed::L1D1 || iSeed_ > Seed::L2D1) {
        lutval = innerTable_.lookup((indexz << nbitsrfinebintable_) + indexr);
      } else {
        lutval = innerOverlapTable_.lookup((indexz << nbitsrfinebintable_) + indexr);
      }

      if (lutval == -1)
        continue;
      if (settings_.extended() &&
          (iSeed_ == Seed::L2L3L4 || iSeed_ == Seed::L4L5L6 || iSeed_ == Seed::D1D2L2 || iSeed_ == Seed::L2L3D1)) {
        int lutval2 = innerThirdTable_.lookup((indexz << nbitsrfinebintable_) + indexr);
        if (lutval2 != -1)
          lutval += (lutval2 << 10);
      }

      assert(lutval >= 0);
      // assert(lutwidth > 0);

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

      if ((layer1_ == 3 && layer2_ == 4) || (layer1_ == 5 && layer2_ == 6)) {
        if (settings_.debugTracklet()) {
          edm::LogVerbatim("Tracklet") << getName() << " Layer-layer pair\n";
        }

        constexpr int andlookupbits = 1023;
        constexpr int shiftzdiffmax = 7;
        constexpr int andnewbin = 127;
        constexpr int divbin = 8;
        constexpr int andzbinfirst = 7;
        constexpr int shiftstart = 1;
        constexpr int andlast = 1;
        constexpr int maxlast = 8;

        int lookupbits = binlookup.value() & andlookupbits;
        int zdiffmax = (lookupbits >> shiftzdiffmax);
        int newbin = (lookupbits & andnewbin);
        int bin = newbin / divbin;

        int zbinfirst = newbin & andzbinfirst;

        int start = (bin >> shiftstart);
        int last = start + (bin & andlast);

        assert(last < maxlast);

        if (settings_.debugTracklet()) {
          edm::LogVerbatim("Tracklet") << "Will look in zbins " << start << " to " << last << endl;
        }

        for (int ibin = start; ibin <= last; ibin++) {
          for (unsigned int m = 0; m < outervmstubs_.size(); m++) {
            for (unsigned int j = 0; j < outervmstubs_.at(m)->nVMStubsBinned(ibin); j++) {
              if (settings_.debugTracklet()) {
                edm::LogVerbatim("Tracklet")
                    << "In " << getName() << " have second stub(1) " << ibin << " " << j << endl;
              }

              const VMStubTE& secondvmstub = outervmstubs_.at(m)->getVMStubTEBinned(ibin, j);

              int zbin = (secondvmstub.vmbits().value() & 7);
              if (start != ibin)
                zbin += 8;
              if (zbin < zbinfirst || zbin - zbinfirst > zdiffmax) {
                if (settings_.debugTracklet()) {
                  edm::LogVerbatim("Tracklet") << "Stubpair rejected because of wrong zbin";
                }
                continue;
              }

              countpass++;

              if ((layer2_ == 4 && layer3_ == 2) || (layer2_ == 6 && layer3_ == 4)) {
                constexpr int vmbitshift = 10;
                constexpr int andlookupbits_ = 1023;
                constexpr int andnewbin_ = 127;
                constexpr int divbin_ = 8;
                constexpr int shiftstart_ = 1;
                constexpr int andlast_ = 1;

                int lookupbits_ = (int)((binlookup.value() >> vmbitshift) & andlookupbits_);
                int newbin_ = (lookupbits_ & andnewbin_);
                int bin_ = newbin_ / divbin_;

                int start_ = (bin_ >> shiftstart_);
                int last_ = start_ + (bin_ & andlast_);

                if (settings_.debugTracklet()) {
                  edm::LogVerbatim("Tracklet")
                      << "Will look in zbins for third stub" << start_ << " to " << last_ << endl;
                }

                for (int ibin_ = start_; ibin_ <= last_; ibin_++) {
                  for (unsigned int k = 0; k < innervmstubs_.size(); k++) {
                    for (unsigned int l = 0; l < innervmstubs_.at(k)->nVMStubsBinned(ibin_); l++) {
                      if (settings_.debugTracklet()) {
                        edm::LogVerbatim("Tracklet") << "In " << getName() << " have third stub\n";
                      }

                      countall_++;

                      const VMStubTE& thirdvmstub = innervmstubs_.at(k)->getVMStubTEBinned(ibin_, l);

                      countpass_++;

                      const Stub* innerFPGAStub = firstallstub;
                      const Stub* middleFPGAStub = secondvmstub.stub();
                      const Stub* outerFPGAStub = thirdvmstub.stub();

                      const L1TStub* innerStub = innerFPGAStub->l1tstub();
                      const L1TStub* middleStub = middleFPGAStub->l1tstub();
                      const L1TStub* outerStub = outerFPGAStub->l1tstub();

                      if (settings_.debugTracklet()) {
                        edm::LogVerbatim("Tracklet")
                            << "LLL seeding\n"
                            << innerFPGAStub->strbare() << middleFPGAStub->strbare() << outerFPGAStub->strbare()
                            << innerStub->stubword() << middleStub->stubword() << outerStub->stubword()
                            << innerFPGAStub->layerdisk() << middleFPGAStub->layerdisk() << outerFPGAStub->layerdisk();
                      }

                      if (settings_.debugTracklet()) {
                        edm::LogVerbatim("Tracklet")
                            << "TrackletCalculatorDisplaced execute " << getName() << "[" << iSector_ << "]";
                      }

                      if (innerFPGAStub->layerdisk() < N_LAYER && middleFPGAStub->layerdisk() < N_LAYER &&
                          outerFPGAStub->layerdisk() < N_LAYER) {
                        bool accept =
                            LLLSeeding(outerFPGAStub, outerStub, innerFPGAStub, innerStub, middleFPGAStub, middleStub);

                        if (accept)
                          countsel++;
                      } else if (innerFPGAStub->layerdisk() >= N_LAYER && middleFPGAStub->layerdisk() >= N_LAYER &&
                                 outerFPGAStub->layerdisk() >= N_LAYER) {
                        throw cms::Exception("LogicError") << __FILE__ << " " << __LINE__ << " Invalid seeding!";
                      }

                      if (settings_.debugTracklet()) {
                        edm::LogVerbatim("Tracklet") << "TrackletCalculatorDisplaced execute done";
                      }
                    }
                  }
                }
              }
            }
          }
        }

      } else if (layer1_ == 2 && layer2_ == 3) {
        if (settings_.debugTracklet()) {
          edm::LogVerbatim("Tracklet") << getName() << " Layer-layer pair";
        }

        constexpr int andlookupbits = 1023;
        constexpr int shiftzdiffmax = 7;
        constexpr int andnewbin = 127;
        constexpr int divbin = 8;
        constexpr int andzbinfirst = 7;
        constexpr int shiftstart = 1;
        constexpr int andlast = 1;
        constexpr int maxlast = 8;

        int lookupbits = binlookup.value() & andlookupbits;
        int zdiffmax = (lookupbits >> shiftzdiffmax);
        int newbin = (lookupbits & andnewbin);
        int bin = newbin / divbin;

        int zbinfirst = newbin & andzbinfirst;

        int start = (bin >> shiftstart);
        int last = start + (bin & andlast);

        assert(last < maxlast);

        if (settings_.debugTracklet()) {
          edm::LogVerbatim("Tracklet") << "Will look in zbins " << start << " to " << last;
        }

        for (int ibin = start; ibin <= last; ibin++) {
          for (unsigned int m = 0; m < outervmstubs_.size(); m++) {
            for (unsigned int j = 0; j < outervmstubs_.at(m)->nVMStubsBinned(ibin); j++) {
              if (settings_.debugTracklet()) {
                edm::LogVerbatim("Tracklet") << "In " << getName() << " have second stub(1) " << ibin << " " << j;
              }

              countall++;
              const VMStubTE& secondvmstub = outervmstubs_.at(m)->getVMStubTEBinned(ibin, j);

              int zbin = (secondvmstub.vmbits().value() & 7);
              if (start != ibin)
                zbin += 8;
              if (zbin < zbinfirst || zbin - zbinfirst > zdiffmax) {
                if (settings_.debugTracklet()) {
                  edm::LogVerbatim("Tracklet") << "Stubpair rejected because of wrong zbin";
                }
                continue;
              }

              if (layer2_ == 3 && disk3_ == 1) {
                constexpr int vmbitshift = 10;
                constexpr int andlookupbits_ = 1023;
                constexpr int andnewbin_ = 127;
                constexpr int divbin_ = 8;
                constexpr int shiftstart_ = 1;
                constexpr int andlast_ = 1;

                int lookupbits_ = (int)((binlookup.value() >> vmbitshift) & andlookupbits_);
                int newbin_ = (lookupbits_ & andnewbin_);
                int bin_ = newbin_ / divbin_;

                int start_ = (bin_ >> shiftstart_);
                int last_ = start_ + (bin_ & andlast_);

                for (int ibin_ = start_; ibin_ <= last_; ibin_++) {
                  for (unsigned int k = 0; k < innervmstubs_.size(); k++) {
                    for (unsigned int l = 0; l < innervmstubs_.at(k)->nVMStubsBinned(ibin_); l++) {
                      if (settings_.debugTracklet()) {
                        edm::LogVerbatim("Tracklet") << "In " << getName() << " have third stub";
                      }

                      countall_++;

                      const VMStubTE& thirdvmstub = innervmstubs_.at(k)->getVMStubTEBinned(ibin_, l);

                      countpass_++;

                      const Stub* innerFPGAStub = firstallstub;
                      const Stub* middleFPGAStub = secondvmstub.stub();
                      const Stub* outerFPGAStub = thirdvmstub.stub();

                      const L1TStub* innerStub = innerFPGAStub->l1tstub();
                      const L1TStub* middleStub = middleFPGAStub->l1tstub();
                      const L1TStub* outerStub = outerFPGAStub->l1tstub();

                      if (settings_.debugTracklet()) {
                        edm::LogVerbatim("Tracklet")
                            << "LLD seeding\n"
                            << innerFPGAStub->strbare() << middleFPGAStub->strbare() << outerFPGAStub->strbare()
                            << innerStub->stubword() << middleStub->stubword() << outerStub->stubword()
                            << innerFPGAStub->layerdisk() << middleFPGAStub->layerdisk() << outerFPGAStub->layerdisk();
                      }

                      if (settings_.debugTracklet()) {
                        edm::LogVerbatim("Tracklet")
                            << "TrackletCalculatorDisplaced execute " << getName() << "[" << iSector_ << "]";
                      }

                      bool accept =
                          LLDSeeding(outerFPGAStub, outerStub, innerFPGAStub, innerStub, middleFPGAStub, middleStub);

                      if (accept)
                        countsel++;

                      if (settings_.debugTracklet()) {
                        edm::LogVerbatim("Tracklet") << "TrackletCalculatorDisplaced execute done";
                      }
                    }
                  }
                }
              }
            }
          }
        }

      } else if (disk1_ == 1 && disk2_ == 2) {
        if (settings_.debugTracklet())
          edm::LogVerbatim("Tracklet") << getName() << " Disk-disk pair";

        constexpr int andlookupbits = 511;
        constexpr int shiftrdiffmax = 6;
        constexpr int andnewbin = 63;
        constexpr int divbin = 8;
        constexpr int andrbinfirst = 7;
        constexpr int shiftstart = 1;
        constexpr int andlast = 1;
        constexpr int maxlast = 8;

        int lookupbits = binlookup.value() & andlookupbits;
        bool negdisk = firstallstub->disk().value() < 0;
        int rdiffmax = (lookupbits >> shiftrdiffmax);
        int newbin = (lookupbits & andnewbin);
        int bin = newbin / divbin;

        int rbinfirst = newbin & andrbinfirst;

        int start = (bin >> shiftstart);
        if (negdisk)
          start += 4;
        int last = start + (bin & andlast);
        assert(last < maxlast);

        for (int ibin = start; ibin <= last; ibin++) {
          for (unsigned int m = 0; m < outervmstubs_.size(); m++) {
            if (settings_.debugTracklet()) {
              edm::LogVerbatim("Tracklet")
                  << getName() << " looking for matching stub in " << outervmstubs_.at(m)->getName()
                  << " in bin = " << ibin << " with " << outervmstubs_.at(m)->nVMStubsBinned(ibin) << " stubs";
            }

            for (unsigned int j = 0; j < outervmstubs_.at(m)->nVMStubsBinned(ibin); j++) {
              countall++;

              const VMStubTE& secondvmstub = outervmstubs_.at(m)->getVMStubTEBinned(ibin, j);
              int rbin = (secondvmstub.vmbits().value() & 7);
              if (start != ibin)
                rbin += 8;
              if (rbin < rbinfirst)
                continue;
              if (rbin - rbinfirst > rdiffmax)
                continue;

              if (disk2_ == 2 && layer3_ == 2) {
                constexpr int vmbitshift = 10;
                constexpr int andlookupbits_ = 1023;
                constexpr int andnewbin_ = 127;
                constexpr int divbin_ = 8;
                constexpr int shiftstart_ = 1;
                constexpr int andlast_ = 1;

                int lookupbits_ = (int)((binlookup.value() >> vmbitshift) & andlookupbits_);
                int newbin_ = (lookupbits_ & andnewbin_);
                int bin_ = newbin_ / divbin_;

                int start_ = (bin_ >> shiftstart_);
                int last_ = start_ + (bin_ & andlast_);

                if (firstallstub->disk().value() < 0) {  //TODO - negative disk should come from memory
                  start_ = settings_.NLONGVMBINS() - last_ - 1;
                  last_ = settings_.NLONGVMBINS() - start_ - 1;
                }

                for (int ibin_ = start_; ibin_ <= last_; ibin_++) {
                  for (unsigned int k = 0; k < innervmstubs_.size(); k++) {
                    for (unsigned int l = 0; l < innervmstubs_.at(k)->nVMStubsBinned(ibin_); l++) {
                      if (settings_.debugTracklet()) {
                        edm::LogVerbatim("Tracklet") << "In " << getName() << " have third stub";
                      }

                      countall_++;

                      const VMStubTE& thirdvmstub = innervmstubs_.at(k)->getVMStubTEBinned(ibin_, l);

                      countpass_++;

                      const Stub* innerFPGAStub = firstallstub;
                      const Stub* middleFPGAStub = secondvmstub.stub();
                      const Stub* outerFPGAStub = thirdvmstub.stub();

                      const L1TStub* innerStub = innerFPGAStub->l1tstub();
                      const L1TStub* middleStub = middleFPGAStub->l1tstub();
                      const L1TStub* outerStub = outerFPGAStub->l1tstub();

                      if (settings_.debugTracklet()) {
                        edm::LogVerbatim("Tracklet")
                            << "DDL seeding\n"
                            << innerFPGAStub->strbare() << middleFPGAStub->strbare() << outerFPGAStub->strbare()
                            << innerStub->stubword() << middleStub->stubword() << outerStub->stubword()
                            << innerFPGAStub->layerdisk() << middleFPGAStub->layerdisk() << outerFPGAStub->layerdisk();
                      }

                      if (settings_.debugTracklet()) {
                        edm::LogVerbatim("Tracklet")
                            << "TrackletCalculatorDisplaced execute " << getName() << "[" << iSector_ << "]";
                      }

                      bool accept =
                          DDLSeeding(outerFPGAStub, outerStub, innerFPGAStub, innerStub, middleFPGAStub, middleStub);

                      if (accept)
                        countsel++;

                      if (settings_.debugTracklet()) {
                        edm::LogVerbatim("Tracklet") << "TrackletCalculatorDisplaced execute done";
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
}

Member Data Documentation

count_

int trklet::TrackletProcessorDisplaced::count_

private

Definition at line 45 of file TrackletProcessorDisplaced.h.

Referenced by execute().

disk1_

int trklet::TrackletProcessorDisplaced::disk1_

private

Definition at line 51 of file TrackletProcessorDisplaced.h.

Referenced by execute(), and TrackletProcessorDisplaced().

disk2_

int trklet::TrackletProcessorDisplaced::disk2_

private

Definition at line 52 of file TrackletProcessorDisplaced.h.

Referenced by execute(), and TrackletProcessorDisplaced().

disk3_

int trklet::TrackletProcessorDisplaced::disk3_

private

Definition at line 53 of file TrackletProcessorDisplaced.h.

Referenced by execute(), and TrackletProcessorDisplaced().

firstphibits_

int trklet::TrackletProcessorDisplaced::firstphibits_

private

Definition at line 55 of file TrackletProcessorDisplaced.h.

iAllStub_

int trklet::TrackletProcessorDisplaced::iAllStub_

private

Definition at line 43 of file TrackletProcessorDisplaced.h.

innerOverlapTable_

TrackletLUT trklet::TrackletProcessorDisplaced::innerOverlapTable_

private

Definition at line 63 of file TrackletProcessorDisplaced.h.

Referenced by execute(), and TrackletProcessorDisplaced().

innerTable_

TrackletLUT trklet::TrackletProcessorDisplaced::innerTable_

private

Definition at line 62 of file TrackletProcessorDisplaced.h.

Referenced by execute(), and TrackletProcessorDisplaced().

innerThirdTable_

TrackletLUT trklet::TrackletProcessorDisplaced::innerThirdTable_

private

Definition at line 64 of file TrackletProcessorDisplaced.h.

Referenced by execute(), and TrackletProcessorDisplaced().

innervmstubs_

std::vector<VMStubsTEMemory*> trklet::TrackletProcessorDisplaced::innervmstubs_

private

Definition at line 68 of file TrackletProcessorDisplaced.h.

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

iTC_

int trklet::TrackletProcessorDisplaced::iTC_

private

Definition at line 42 of file TrackletProcessorDisplaced.h.

layer1_

int trklet::TrackletProcessorDisplaced::layer1_

private

Definition at line 48 of file TrackletProcessorDisplaced.h.

Referenced by execute(), and TrackletProcessorDisplaced().

layer2_

int trklet::TrackletProcessorDisplaced::layer2_

private

Definition at line 49 of file TrackletProcessorDisplaced.h.

Referenced by execute(), and TrackletProcessorDisplaced().

layer3_

int trklet::TrackletProcessorDisplaced::layer3_

private

Definition at line 50 of file TrackletProcessorDisplaced.h.

Referenced by execute(), and TrackletProcessorDisplaced().

layerdisk_

unsigned int trklet::TrackletProcessorDisplaced::layerdisk_

private

Definition at line 46 of file TrackletProcessorDisplaced.h.

Referenced by execute(), and TrackletProcessorDisplaced().

maxStep_

unsigned int trklet::TrackletProcessorDisplaced::maxStep_

private

Definition at line 44 of file TrackletProcessorDisplaced.h.

nbitsrfinebintable_

int trklet::TrackletProcessorDisplaced::nbitsrfinebintable_

private

Definition at line 60 of file TrackletProcessorDisplaced.h.

Referenced by execute(), and TrackletProcessorDisplaced().

nbitszfinebintable_

int trklet::TrackletProcessorDisplaced::nbitszfinebintable_

private

Definition at line 59 of file TrackletProcessorDisplaced.h.

Referenced by execute(), and TrackletProcessorDisplaced().

outervmstubs_

std::vector<VMStubsTEMemory*> trklet::TrackletProcessorDisplaced::outervmstubs_

private

Definition at line 69 of file TrackletProcessorDisplaced.h.

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

secondphibits_

int trklet::TrackletProcessorDisplaced::secondphibits_

private

Definition at line 56 of file TrackletProcessorDisplaced.h.

spTable_

std::map<std::string, std::vector<std::map<std::string, unsigned> > > trklet::TrackletProcessorDisplaced::spTable_

private

Definition at line 74 of file TrackletProcessorDisplaced.h.

stubpairs_

std::vector<StubPairsMemory*> trklet::TrackletProcessorDisplaced::stubpairs_

private

Definition at line 66 of file TrackletProcessorDisplaced.h.

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

stubtriplets_

StubTripletsMemory* trklet::TrackletProcessorDisplaced::stubtriplets_

private

Definition at line 71 of file TrackletProcessorDisplaced.h.

table_

std::vector<bool> trklet::TrackletProcessorDisplaced::table_

private

Definition at line 75 of file TrackletProcessorDisplaced.h.

thirdphibits_

int trklet::TrackletProcessorDisplaced::thirdphibits_

private

Definition at line 57 of file TrackletProcessorDisplaced.h.

tmpSPTable_

std::map<std::string, std::vector<std::vector<std::string> > > trklet::TrackletProcessorDisplaced::tmpSPTable_

private

Definition at line 73 of file TrackletProcessorDisplaced.h.