#include <TrackletEngine.h>

Inheritance diagram for trklet::TrackletEngine:

Public Member Functions
void	addInput (MemoryBase *memory, std::string input) override

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

void	execute ()

void	setVMPhiBin ()

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

	~TrackletEngine () 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
unsigned int	innerphibits_

TrackletLUT	innerptlut_

VMStubsTEMemory *	innervmstubs_

unsigned int	iSeed_

unsigned int	layerdisk1_

unsigned int	layerdisk2_

unsigned int	outerphibits_

TrackletLUT	outerptlut_

VMStubsTEMemory *	outervmstubs_

StubPairsMemory *	stubpairs_

Additional Inherited Members
Protected Attributes inherited from trklet::ProcessBase
Globals *	globals_

std::string	name_

Settings const &	settings_

Detailed Description

Definition at line 18 of file TrackletEngine.h.

Constructor & Destructor Documentation

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

Definition at line 16 of file TrackletEngine.cc.

References trklet::ProcessBase::initLayerDisksandISeed(), innerphibits_, innervmstubs_, iSeed_, layerdisk1_, layerdisk2_, trklet::Settings::nfinephi(), outerphibits_, outervmstubs_, and stubpairs_.

     : ProcessBase(name, settings, global), innerptlut_(settings), outerptlut_(settings) {
   stubpairs_ = nullptr;
   innervmstubs_ = nullptr;
   outervmstubs_ = nullptr;
 
   initLayerDisksandISeed(layerdisk1_, layerdisk2_, iSeed_);
 
   innerphibits_ = settings.nfinephi(0, iSeed_);
   outerphibits_ = settings.nfinephi(1, iSeed_);
 }

trklet::TrackletEngine::~TrackletEngine ( )

overridedefault

Member Function Documentation

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

overridevirtual

Implements trklet::ProcessBase.

Definition at line 42 of file TrackletEngine.cc.

References cms::cuda::assert(), Exception, trklet::MemoryBase::getName(), innervmstubs_, input, trklet::ProcessBase::name_, outervmstubs_, trklet::ProcessBase::settings_, setVMPhiBin(), createJobs::tmp, and trklet::Settings::writetrace().

                                                               {
   if (settings_.writetrace()) {
     edm::LogVerbatim("Tracklet") << "In " << name_ << " adding input from " << memory->getName() << " to input "
                                  << input;
   }
   if (input == "innervmstubin") {
     VMStubsTEMemory* tmp = dynamic_cast<VMStubsTEMemory*>(memory);
     assert(tmp != nullptr);
     innervmstubs_ = tmp;
     setVMPhiBin();
     return;
   }
   if (input == "outervmstubin") {
     VMStubsTEMemory* tmp = dynamic_cast<VMStubsTEMemory*>(memory);
     assert(tmp != nullptr);
     outervmstubs_ = tmp;
     setVMPhiBin();
     return;
   }
   throw cms::Exception("BadConfig") << __FILE__ << " " << __LINE__ << " Could not find input : " << input;
 }

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

overridevirtual

Implements trklet::ProcessBase.

Definition at line 28 of file TrackletEngine.cc.

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

                                                                 {
   if (settings_.writetrace()) {
     edm::LogVerbatim("Tracklet") << "In " << name_ << " adding output to " << memory->getName() << " to output "
                                  << output;
   }
   if (output == "stubpairout") {
     StubPairsMemory* tmp = dynamic_cast<StubPairsMemory*>(memory);
     assert(tmp != nullptr);
     stubpairs_ = tmp;
     return;
   }
   throw cms::Exception("BadConfig") << __FILE__ << " " << __LINE__ << " Could not find output : " << output;
 }

void TrackletEngine::execute ( void )

Definition at line 64 of file TrackletEngine.cc.

References trklet::StubPairsMemory::addStubPair(), cms::cuda::assert(), trklet::VMStubTE::bend(), trklet::Settings::benddecode(), trklet::FPGAWord::bits(), trklet::Settings::debugTracklet(), trklet::Stub::disk(), trklet::VMStubTE::finephi(), trklet::ProcessBase::getName(), trklet::VMStubsTEMemory::getVMStubTE(), trklet::VMStubsTEMemory::getVMStubTEBinned(), trklet::ProcessBase::globals_, mps_fire::i, innerptlut_, innervmstubs_, iSeed_, trklet::VMStubTE::isPSmodule(), dqmiolumiharvest::j, dqmdumpme::last, layerdisk1_, layerdisk2_, trklet::TrackletLUT::lookup(), trklet::Settings::maxStep(), trklet::ProcessBase::nbits(), trklet::FPGAWord::nbits(), GetRecoTauVFromDQM_MC_cff::next, trklet::VMStubsTEMemory::nVMStubs(), trklet::VMStubsTEMemory::nVMStubsBinned(), trklet::Globals::ofstream(), outerphibits_, outerptlut_, outervmstubs_, trklet::ProcessBase::settings_, command_line::start, trklet::VMStubTE::stub(), stubpairs_, trklet::Settings::useSeed(), trklet::FPGAWord::value(), trklet::VMStubTE::vmbits(), and trklet::Settings::writeMonitorData().

                              {
   if (!settings_.useSeed(iSeed_))
     return;
 
   unsigned int countall = 0;
   unsigned int countpass = 0;
 
   assert(innervmstubs_ != nullptr);
   assert(outervmstubs_ != nullptr);
 
   for (unsigned int i = 0; i < innervmstubs_->nVMStubs(); i++) {
     const VMStubTE& innervmstub = innervmstubs_->getVMStubTE(i);
     FPGAWord lookupbits = innervmstub.vmbits();
 
     unsigned int nbits = 7;
     if (iSeed_ == 4 || iSeed_ == 5)
       nbits = 6;
     int rzdiffmax = lookupbits.bits(nbits, lookupbits.nbits() - nbits);
     int rzbinfirst = lookupbits.bits(0, 3);
     int start = lookupbits.bits(4, nbits - 4);
     int next = lookupbits.bits(3, 1);
 
     if ((iSeed_ == 4 || iSeed_ == 5) && innervmstub.stub()->disk().value() < 0) {  //TODO - need to store negative disk
       start += 4;
     }
     int last = start + next;
 
     for (int ibin = start; ibin <= last; ibin++) {
       for (unsigned int j = 0; j < outervmstubs_->nVMStubsBinned(ibin); j++) {
         if (countall >= settings_.maxStep("TE"))
           break;
         countall++;
         const VMStubTE& outervmstub = outervmstubs_->getVMStubTEBinned(ibin, j);
 
         int rzbin = outervmstub.vmbits().bits(0, 3);
 
         FPGAWord iphiinnerbin = innervmstub.finephi();
         FPGAWord iphiouterbin = outervmstub.finephi();
 
         unsigned int index = (iphiinnerbin.value() << outerphibits_) + iphiouterbin.value();
 
         if (iSeed_ >= 4) {  //Also use r-position
           int ir = ((ibin & 3) << 1) + (rzbin >> 2);
           index = (index << 3) + ir;
         }
 
         if (start != ibin)
           rzbin += 8;
         if ((rzbin < rzbinfirst) || (rzbin - rzbinfirst > rzdiffmax)) {
           continue;
         }
 
         FPGAWord innerbend = innervmstub.bend();
         FPGAWord outerbend = outervmstub.bend();
 
         int ptinnerindex = (index << innerbend.nbits()) + innerbend.value();
         int ptouterindex = (index << outerbend.nbits()) + outerbend.value();
 
         if (!(innerptlut_.lookup(ptinnerindex) && outerptlut_.lookup(ptouterindex))) {
           if (settings_.debugTracklet()) {
             edm::LogVerbatim("Tracklet") << "Stub pair rejected because of stub pt cut bends : "
                                          << settings_.benddecode(
                                                 innervmstub.bend().value(), layerdisk1_, innervmstub.isPSmodule())
                                          << " "
                                          << settings_.benddecode(
                                                 outervmstub.bend().value(), layerdisk2_, outervmstub.isPSmodule());
           }
           continue;
         }
 
         if (settings_.debugTracklet())
           edm::LogVerbatim("Tracklet") << "Adding stub pair in " << getName();
 
         stubpairs_->addStubPair(innervmstub, outervmstub);
         countpass++;
       }
     }
   }
 
   if (settings_.writeMonitorData("TE")) {
     globals_->ofstream("trackletengine.txt") << getName() << " " << countall << " " << countpass << endl;
   }
 }

void TrackletEngine::setVMPhiBin ( )

Definition at line 148 of file TrackletEngine.cc.

References trklet::MemoryBase::getName(), trklet::VMStubsTEMemory::getPhiRange(), trklet::TrackletLUT::initteptlut(), innerphibits_, innerptlut_, innervmstubs_, iSeed_, layerdisk1_, layerdisk2_, outerphibits_, outerptlut_, outervmstubs_, trklet::VMStubsTEMemory::setbendtable(), trklet::VMStubsTEMemory::setother(), and trklet::ProcessBase::settings_.

Referenced by addInput().

                                  {
   if (innervmstubs_ == nullptr || outervmstubs_ == nullptr)
     return;
 
   innervmstubs_->setother(outervmstubs_);
   outervmstubs_->setother(innervmstubs_);
 
   double innerphimin, innerphimax;
   innervmstubs_->getPhiRange(innerphimin, innerphimax, iSeed_, 0);
 
   double outerphimin, outerphimax;
   outervmstubs_->getPhiRange(outerphimin, outerphimax, iSeed_, 1);
 
   string innermem = innervmstubs_->getName().substr(6);
   string outermem = outervmstubs_->getName().substr(6);
 
   innerptlut_.initteptlut(true,
                           false,
                           iSeed_,
                           layerdisk1_,
                           layerdisk2_,
                           innerphibits_,
                           outerphibits_,
                           innerphimin,
                           innerphimax,
                           outerphimin,
                           outerphimax,
                           innermem,
                           outermem);
 
   outerptlut_.initteptlut(false,
                           false,
                           iSeed_,
                           layerdisk1_,
                           layerdisk2_,
                           innerphibits_,
                           outerphibits_,
                           innerphimin,
                           innerphimax,
                           outerphimin,
                           outerphimax,
                           innermem,
                           outermem);
 
   TrackletLUT innertememlut(settings_);
   TrackletLUT outertememlut(settings_);
 
   innertememlut.initteptlut(true,
                             true,
                             iSeed_,
                             layerdisk1_,
                             layerdisk2_,
                             innerphibits_,
                             outerphibits_,
                             innerphimin,
                             innerphimax,
                             outerphimin,
                             outerphimax,
                             innermem,
                             outermem);
 
   outertememlut.initteptlut(false,
                             true,
                             iSeed_,
                             layerdisk1_,
                             layerdisk2_,
                             innerphibits_,
                             outerphibits_,
                             innerphimin,
                             innerphimax,
                             outerphimin,
                             outerphimax,
                             innermem,
                             outermem);
 
   innervmstubs_->setbendtable(innertememlut);
   outervmstubs_->setbendtable(outertememlut);
 }