#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	buildLUT ()

void	execute ()

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

void	writeTETable ()

	~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, unsigned int iSector)

	~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, unsigned int iSector)

virtual	~ProcessBase ()=default

Private Attributes
int	iAllStub_

std::vector< AllStubsMemory * >	innerallstubs_

int	innerphibits_

int	iTC_

int	nbitsfinephi_

int	nbitsfinephidiff_

unsigned int	nbitsrfinebintable_

unsigned int	nbitsrzbin_

unsigned int	nbitszfinebintable_

std::vector< AllStubsMemory * >	outerallstubs_

int	outerphibits_

VMStubsTEMemory *	outervmstubs_

std::map< unsigned int, std::vector< bool > >	pttableinner_

std::vector< bool >	pttableinnernew_

std::map< unsigned int, std::vector< bool > >	pttableouter_

std::vector< bool >	pttableouternew_

std::vector< std::tuple< CircularBuffer< TEData >, unsigned int, unsigned int, unsigned int, unsigned int > >	tedatabuffers_

std::vector< TrackletEngineUnit >	teunits_

std::vector< std::vector< bool > >	useregion_

VMRouterTable	vmrtable_

Additional Inherited Members
Protected Attributes inherited from trklet::TrackletCalculatorBase
unsigned int	iSeed_

unsigned int	layerdisk1_

unsigned int	layerdisk2_

int	TCIndex_

TrackletParametersMemory *	trackletpars_

std::vector< std::vector< TrackletProjectionsMemory * > >	trackletprojdisks_

std::vector< std::vector< TrackletProjectionsMemory * > >	trackletprojlayers_

Protected Attributes inherited from trklet::ProcessBase
Globals *	globals_

unsigned int	iSector_

std::string	name_

double	phimax_

double	phimin_

Settings const &	settings_

Detailed Description

Definition at line 23 of file TrackletProcessor.h.

Constructor & Destructor Documentation

◆ TrackletProcessor()

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

Definition at line 19 of file TrackletProcessor.cc.

     : TrackletCalculatorBase(name, settings, globals, iSector), vmrtable_(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_);
  
   nbitszfinebintable_ = settings_.vmrlutzbits(layerdisk1_);
   nbitsrfinebintable_ = settings_.vmrlutrbits(layerdisk1_);
  
   vmrtable_.init(layerdisk1_, getName());
  
   nbitsrzbin_ = NFINERZBITS;
   if (iSeed_ == 4 || iSeed_ == 5)
     nbitsrzbin_ = 2;
  
   innerphibits_ = settings_.nfinephi(0, iSeed_);
   outerphibits_ = settings_.nfinephi(1, iSeed_);
  
   // set TC index
   iTC_ = name_[7] - 'A';
   assert(iTC_ >= 0 && iTC_ < 14);
  
   TCIndex_ = (iSeed_ << 4) + iTC_;
   assert(TCIndex_ >= 0 && TCIndex_ <= (int)settings_.ntrackletmax());
 }

References cms::cuda::assert(), trklet::ProcessBase::getName(), iAllStub_, trklet::VMRouterTable::init(), trklet::ProcessBase::initLayerDisksandISeed(), innerphibits_, trklet::TrackletCalculatorBase::iSeed_, iTC_, trklet::TrackletCalculatorBase::layerdisk1_, trklet::TrackletCalculatorBase::layerdisk2_, trklet::N_DISK, trklet::N_LAYER, trklet::Settings::nallstubs(), trklet::ProcessBase::name_, nbitsrfinebintable_, nbitsrzbin_, nbitszfinebintable_, trklet::Settings::nfinephi(), trklet::NFINERZBITS, trklet::Settings::ntrackletmax(), outerphibits_, outervmstubs_, trklet::ProcessBase::settings_, trklet::TrackletCalculatorBase::TCIndex_, createJobs::tmp, trklet::TrackletCalculatorBase::trackletprojdisks_, trklet::TrackletCalculatorBase::trackletprojlayers_, trklet::Settings::vmrlutrbits(), trklet::Settings::vmrlutzbits(), and vmrtable_.

◆ ~TrackletProcessor()

trklet::TrackletProcessor::~TrackletProcessor ( )

overridedefault

Member Function Documentation

◆ addInput()

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

overridevirtual

Implements trklet::ProcessBase.

Definition at line 104 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_ == 1)
       iAllStub_ = tmp->getName()[11] - 'I';
     if (iSeed_ == 6 || iSeed_ == 7) {
       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;
     }
     buildLUT();  //need iAllStub_ set before building the table //FIXME should be in initiall
  
     TrackletEngineUnit teunit(&settings_,
                               nbitsfinephi_,
                               layerdisk2_,
                               iSeed_,
                               nbitsfinephidiff_,
                               iAllStub_,
                               pttableinnernew_,
                               pttableouternew_,
                               outervmstubs_);
     teunits_.resize(6, teunit);
  
     return;
   }
  
   if (input == "innerallstubin") {
     auto* tmp = dynamic_cast<AllStubsMemory*>(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
     tedatabuffers_.clear();
     CircularBuffer<TEData> tedatabuffertmp(5);
     tedatabuffertmp.reset();
  
     tedatabuffers_.emplace_back(tedatabuffertmp, 0, 0, 0, (innerallstubs_.size() + 1) / 2);
     tedatabuffers_.emplace_back(
         tedatabuffertmp, 0, (innerallstubs_.size() + 1) / 2, (innerallstubs_.size() + 1) / 2, 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(), buildLUT(), Exception, iAllStub_, innerallstubs_, input, trklet::TrackletCalculatorBase::iSeed_, trklet::TrackletCalculatorBase::layerdisk2_, trklet::ProcessBase::name_, nbitsfinephi_, nbitsfinephidiff_, outerallstubs_, outervmstubs_, pttableinnernew_, pttableouternew_, trklet::CircularBuffer< T >::reset(), trklet::ProcessBase::settings_, tedatabuffers_, teunits_, createJobs::tmp, and trklet::Settings::writetrace().

◆ addOutput()

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

overridevirtual

Implements trklet::ProcessBase.

Definition at line 62 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 57 of file TrackletProcessor.cc.

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

References cms::cuda::assert().

◆ buildLUT()

void TrackletProcessor::buildLUT ( )

Definition at line 424 of file TrackletProcessor.cc.

                                  {
   //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;
  
   double rmin = -1.0;
   double rmax = -1.0;
  
   if (iSeed_ < 4) {
     rmin = settings_.rmean(layerdisk1_);
     rmax = settings_.rmean(layerdisk2_);
   } else {
     if (iSeed_ > 5) {
       if (iSeed_ == 6) {
         rmax = settings_.rmaxdiskl1overlapvm();
       } else if (iSeed_ == 7) {
         rmax = settings_.rmaxdiskvm();
       }
       rmin = settings_.rmean(layerdisk1_);
     } else {
       rmax = settings_.rmaxdiskvm();
       rmin = rmax * settings_.zmean(layerdisk2_ - 6 - 1) / settings_.zmean(layerdisk2_ - 6);
     }
   }
  
   double dphimax = asin(0.5 * settings_.maxrinv() * rmax) - asin(0.5 * settings_.maxrinv() * rmin);
  
   int nbins = 2.0 * (dphimax / dfinephi + 1.0);
  
   nbitsfinephidiff_ = log(nbins) / log(2.0) + 1;
  
   nbitsfinephi_ = settings_.nbitsallstubs(layerdisk2_) + settings_.nbitsvmte(1, iSeed_) + settings_.nfinephi(1, iSeed_);
  
   int outerrbits = 3;
   if (iSeed_ < 4) {
     outerrbits = 0;
   }
  
   int outerrbins = (1 << outerrbits);
  
   double dphi[2];
   double router[2];
  
   unsigned int nbendbitsinner = 3;
   unsigned int nbendbitsouter = 3;
   if (iSeed_ == 2) {
     nbendbitsouter = 4;
   } else if (iSeed_ == 3) {
     nbendbitsinner = 4;
     nbendbitsouter = 4;
   }
  
   int nbinsfinephidiff = (1 << nbitsfinephidiff_);
  
   for (int iphibin = 0; iphibin < nbinsfinephidiff; iphibin++) {
     int iphidiff = iphibin;
     if (iphibin >= nbinsfinephidiff / 2) {
       iphidiff = iphibin - nbinsfinephidiff;
     }
     //min and max dphi
     dphi[0] = (iphidiff - 1.5) * dfinephi;
     dphi[1] = (iphidiff + 1.5) * dfinephi;
     for (int irouterbin = 0; irouterbin < outerrbins; irouterbin++) {
       if (iSeed_ >= 4) {
         router[0] =
             settings_.rmindiskvm() + irouterbin * (settings_.rmaxdiskvm() - settings_.rmindiskvm()) / outerrbins;
         router[1] =
             settings_.rmindiskvm() + (irouterbin + 1) * (settings_.rmaxdiskvm() - settings_.rmindiskvm()) / outerrbins;
       } else {
         router[0] = settings_.rmean(layerdisk2_);
         router[1] = settings_.rmean(layerdisk2_);
       }
  
       double bendinnermin = 20.0;
       double bendinnermax = -20.0;
       double bendoutermin = 20.0;
       double bendoutermax = -20.0;
       double rinvmin = 1.0;
       for (int i2 = 0; i2 < 2; i2++) {
         for (int i3 = 0; i3 < 2; i3++) {
           double rinner = 0.0;
           if (iSeed_ == 4 || iSeed_ == 5) {
             rinner = router[i3] * settings_.zmean(layerdisk1_ - N_LAYER) / settings_.zmean(layerdisk2_ - N_LAYER);
           } else {
             rinner = settings_.rmean(layerdisk1_);
           }
           double rinv1 = rinv(0.0, dphi[i2], rinner, router[i3]);
           double pitchinner = (rinner < settings_.rcrit()) ? settings_.stripPitch(true) : settings_.stripPitch(false);
           double pitchouter =
               (router[i3] < settings_.rcrit()) ? settings_.stripPitch(true) : settings_.stripPitch(false);
           double abendinner = -bend(rinner, rinv1, pitchinner);
           double abendouter = -bend(router[i3], rinv1, pitchouter);
           if (abendinner < bendinnermin)
             bendinnermin = abendinner;
           if (abendinner > bendinnermax)
             bendinnermax = abendinner;
           if (abendouter < bendoutermin)
             bendoutermin = abendouter;
           if (abendouter > bendoutermax)
             bendoutermax = abendouter;
           if (std::abs(rinv1) < rinvmin) {
             rinvmin = std::abs(rinv1);
           }
         }
       }
  
       bool passptcut = rinvmin < settings_.rinvcutte();
  
       for (int ibend = 0; ibend < (1 << nbendbitsinner); ibend++) {
         double bend = benddecode(ibend, nbendbitsinner == 3);
  
         bool passinner = bend - bendinnermin > -settings_.bendcutte(0, iSeed_) &&
                          bend - bendinnermax < settings_.bendcutte(0, iSeed_);
         pttableinnernew_.push_back(passinner && passptcut);
       }
  
       for (int ibend = 0; ibend < (1 << nbendbitsouter); ibend++) {
         double bend = benddecode(ibend, nbendbitsouter == 3);
  
         bool passouter = bend - bendoutermin > -settings_.bendcutte(1, iSeed_) &&
                          bend - bendoutermax < settings_.bendcutte(1, iSeed_);
         pttableouternew_.push_back(passouter && passptcut);
       }
     }
   }
  
   int nirbits = 0;
   if (iSeed_ >= 4)
     nirbits = 3;
  
   int nregmax = 0;
  
   for (int innerfinephi = 0; innerfinephi < (1 << nbitsfinephi_); innerfinephi++) {
     for (int innerbend = 0; innerbend < (1 << nbendbitsinner); innerbend++) {
       for (int ir = 0; ir < (1 << nirbits); ir++) {
         int nreg = 0;
         vector<bool> usereg;
         for (unsigned int ireg = 0; ireg < settings_.nvmte(1, iSeed_); ireg++) {
           bool match = false;
           for (int ifinephiouter = 0; ifinephiouter < (1 << settings_.nfinephi(1, iSeed_)); ifinephiouter++) {
             int outerfinephi = iAllStub_ * (1 << (nbitsfinephi_ - settings_.nbitsallstubs(layerdisk2_))) +
                                ireg * (1 << settings_.nfinephi(1, iSeed_)) + ifinephiouter;
             int idphi = outerfinephi - innerfinephi;
             bool inrange = (idphi < (1 << (nbitsfinephidiff_ - 1))) && (idphi >= -(1 << (nbitsfinephidiff_ - 1)));
             if (idphi < 0)
               idphi = idphi + (1 << nbitsfinephidiff_);
             int idphi1 = idphi;
             if (iSeed_ >= 4)
               idphi1 = (idphi << 3) + ir;
             int ptinnerindexnew = (idphi1 << nbendbitsinner) + innerbend;
             match = match || (inrange && pttableinnernew_[ptinnerindexnew]);
           }
           if (match && ir < 3)
             nreg++;
           usereg.push_back(match);
         }
  
         useregion_.push_back(usereg);
         if (nreg > nregmax)
           nregmax = nreg;
       }
     }
   }
 }

Referenced by addInput().

◆ execute()

void TrackletProcessor::execute ( void )

Definition at line 172 of file TrackletProcessor.cc.

                                 {
   if (!settings_.useSeed(iSeed_))
     return;
  
   //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 tebuffers
   for (auto& tebuffer : tedatabuffers_) {
     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();
   }
  
   for (unsigned int istep = 0; istep < settings_.maxStep("TP"); istep++) {
     for (auto& tebuffer : tedatabuffers_) {
       CircularBuffer<TEData>& tedatabuffer = std::get<0>(tebuffer);
       unsigned int& istub = std::get<1>(tebuffer);
       unsigned int& imem = std::get<2>(tebuffer);
       unsigned int imemend = std::get<4>(tebuffer);
  
       if ((!tedatabuffer.full()) && imem < imemend && istub < innerallstubs_[imem]->nStubs()) {
         ninnerstubs++;
  
         const Stub* stub = innerallstubs_[imem]->getStub(istub);
  
         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 =
             (((1 << (stub->z().nbits() - 1)) + stub->z().value()) >> (stub->z().nbits() - nbitszfinebintable_));
         int indexr = -1;
         if (layerdisk1_ > (N_LAYER - 1)) {
           if (negdisk) {
             indexz = (1 << nbitszfinebintable_) - 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
           indexr = (((1 << (stub->r().nbits() - 1)) + stub->r().value()) >> (stub->r().nbits() - nbitsrfinebintable_));
         }
  
         int lutval = -1;
         if (iSeed_ < 6) {  //FIXME should only be one table...
           lutval = vmrtable_.lookupinner(indexz, indexr);
         } else {
           lutval = vmrtable_.lookupinneroverlap(indexz, indexr);
         }
  
         if (lutval != -1) {
           unsigned int lutwidth = settings_.lutwidthtab(0, iSeed_);
           FPGAWord lookupbits(lutval, lutwidth, true, __LINE__, __FILE__);
  
           int rzfinebinfirst = lookupbits.bits(0, 3);  //finephi
           int next = lookupbits.bits(3, 1);            //next r/z bin
           int start = lookupbits.bits(4, nbitsrzbin_);
           int rzdiffmax = lookupbits.bits(lookupbits.nbits() - 3, 3);
  
           if ((iSeed_ == 4 || iSeed_ == 5) && negdisk) {  //TODO - need to store negative disk
             start += 4;
           }
           int last = start + next;
  
           int nbins = 8;
  
           unsigned int useregindex = (innerfinephi << innerbend.nbits()) + innerbend.value();
           if (iSeed_ >= 4) {
             //FIXME If the lookupbits were rationally organized this would be much simpler
             int ir = ((start & 3) << 1) + (rzfinebinfirst >> 2);
             useregindex = (useregindex << 3) + ir;
           }
  
           assert(useregindex < useregion_.size());
           vector<bool> usereg = useregion_[useregindex];
  
           TEData tedata;
           tedata.stub_ = stub;
           tedata.rzbinfirst_ = rzfinebinfirst;
           tedata.start_ = start;
           tedata.innerfinephi_ = innerfinephi;
           tedata.rzdiffmax_ = rzdiffmax;
           tedata.innerbend_ = innerbend;
  
           for (unsigned int ireg = 0; ireg < settings_.nvmte(1, iSeed_); ireg++) {
             assert(ireg < usereg.size());
             if (!usereg[ireg])
               continue;
  
             for (int ibin = start; ibin <= last; ibin++) {
               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) {
                 tedata.regions_.emplace_back(tuple<int, int, int>(ibin - start, ireg, nstubs));
                 countteall += nstubs;
               }
             }
           }
  
           if (!tedata.regions_.empty()) {
             ntedata++;
             //cout << getName() << " adding TE data" << endl;
             tedatabuffer.store(tedata);
           }
         }
         istub++;
         if (istub >= innerallstubs_[imem]->nStubs()) {
           istub = 0;
           imem++;
         }
       }
     }
  
     bool tedatabuffersdone = true;
     for (auto& tebuffer : tedatabuffers_) {
       CircularBuffer<TEData>& tedatabuffer = std::get<0>(tebuffer);
       tedatabuffersdone &= tedatabuffer.empty();                              //buffer empty
       tedatabuffersdone &= (std::get<2>(tebuffer) == std::get<4>(tebuffer));  //buffer processed all stubs
       if (!tedatabuffer.empty()) {
         for (auto& teunit : teunits_) {
           if (teunit.empty() && teunit.idle()) {
             teunit.init(tedatabuffer.read());
             break;
           }
         }
       }
     }
  
     bool teunitsdone = true;
     TrackletEngineUnit* teunitptr = nullptr;
     for (auto& teunit : teunits_) {
       if (!teunit.idle()) {
         teunit.step();
         teunitsdone = false;
       }
       if (!teunit.empty()) {
         teunitptr = &teunit;
         teunitsdone = false;
       }
     }
  
     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_ < 4) {
         accept = barrelSeeding(innerFPGAStub, innerStub, outerFPGAStub, outerStub);
       } else if (iSeed_ < 6) {
         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();
         break;
       }
  
       if (settings_.debugTracklet()) {
         edm::LogVerbatim("Tracklet") << "TrackletProcessor execute done";
       }
     }
  
     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;
     }
  
     if (teunitsdone && tedatabuffersdone) {
       break;
     }
   }
 }

References accept(), cms::cuda::assert(), trklet::TrackletCalculatorBase::barrelSeeding(), trklet::Stub::bend(), trklet::FPGAWord::bits(), trklet::Settings::debugTracklet(), trklet::Stub::disk(), trklet::TrackletCalculatorBase::diskSeeding(), trklet::CircularBuffer< T >::empty(), trklet::CircularBuffer< T >::full(), trklet::ProcessBase::getName(), trklet::ProcessBase::globals_, iAllStub_, innerallstubs_, trklet::TEData::innerbend_, trklet::TEData::innerfinephi_, trklet::ProcessBase::iSector_, trklet::TrackletCalculatorBase::iSeed_, trklet::Stub::isPSmodule(), trklet::Stub::l1tstub(), dqmdumpme::last, trklet::TrackletCalculatorBase::layerdisk1_, trklet::TrackletCalculatorBase::layerdisk2_, trklet::VMRouterTable::lookupinner(), trklet::VMRouterTable::lookupinneroverlap(), trklet::Settings::lutwidthtab(), trklet::Settings::maxStep(), trklet::N_LAYER, trklet::Settings::nallstubs(), PFElectronDQMAnalyzer_cfi::nBin, LaserClient_cfi::nbins, trklet::FPGAWord::nbits(), nbitsfinephi_, nbitsrfinebintable_, nbitsrzbin_, nbitszfinebintable_, GetRecoTauVFromDQM_MC_cff::next, 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(), trklet::Stub::r(), trklet::CircularBuffer< T >::read(), trklet::TrackletEngineUnit::read(), trklet::TEData::regions_, trklet::TEData::rzbinfirst_, trklet::TEData::rzdiffmax_, trklet::ProcessBase::settings_, command_line::start, trklet::TEData::start_, trklet::TrackletEngineUnit::step(), trklet::CircularBuffer< T >::store(), trklet::TEData::stub_, tedatabuffers_, teunits_, trklet::TrackletCalculatorBase::trackletpars_, useregion_, trklet::Settings::useSeed(), trklet::FPGAWord::value(), vmrtable_, trklet::Settings::writeMonitorData(), and trklet::Stub::z().

◆ writeTETable()

void TrackletProcessor::writeTETable ( )

Definition at line 400 of file TrackletProcessor.cc.

                                      {
   ofstream outstubptinnercut;
   outstubptinnercut.open(getName() + "_stubptinnercut.tab");
   outstubptinnercut << "{" << endl;
   // the below is outcommented as the writing of these tables are currently not implemented, to be adressed
   //for(unsigned int i=0;i<pttableinner_.size();i++){
   //  if (i!=0) outstubptinnercut<<","<<endl;
   //  outstubptinnercut << pttableinner_[i];
   //}
   outstubptinnercut << endl << "};" << endl;
   outstubptinnercut.close();
  
   ofstream outstubptoutercut;
   outstubptoutercut.open(getName() + "_stubptoutercut.tab");
   outstubptoutercut << "{" << endl;
   // the below is outcommented as the writing of these tables are currently not implemented, to be adressed
   //for(unsigned int i=0;i<pttableouter_.size();i++){
   //  if (i!=0) outstubptoutercut<<","<<endl;
   //  outstubptoutercut << pttableouter_[i];
   //}
   outstubptoutercut << endl << "};" << endl;
   outstubptoutercut.close();
 }

References trklet::ProcessBase::getName().

Member Data Documentation

◆ iAllStub_

int trklet::TrackletProcessor::iAllStub_

private

Definition at line 43 of file TrackletProcessor.h.

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

◆ innerallstubs_

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

private

Definition at line 56 of file TrackletProcessor.h.

Referenced by addInput(), and execute().

◆ innerphibits_

int trklet::TrackletProcessor::innerphibits_

private

Definition at line 70 of file TrackletProcessor.h.

Referenced by TrackletProcessor().

◆ iTC_

int trklet::TrackletProcessor::iTC_

private

Definition at line 42 of file TrackletProcessor.h.

Referenced by TrackletProcessor().

◆ nbitsfinephi_

int trklet::TrackletProcessor::nbitsfinephi_

private

Definition at line 67 of file TrackletProcessor.h.

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

◆ nbitsfinephidiff_

int trklet::TrackletProcessor::nbitsfinephidiff_

private

Definition at line 68 of file TrackletProcessor.h.

Referenced by addInput(), and buildLUT().

◆ nbitsrfinebintable_

unsigned int trklet::TrackletProcessor::nbitsrfinebintable_

private

Definition at line 74 of file TrackletProcessor.h.

Referenced by execute(), and TrackletProcessor().

◆ nbitsrzbin_

unsigned int trklet::TrackletProcessor::nbitsrzbin_

private

Definition at line 76 of file TrackletProcessor.h.

Referenced by execute(), and TrackletProcessor().

◆ nbitszfinebintable_

unsigned int trklet::TrackletProcessor::nbitszfinebintable_

private

Definition at line 73 of file TrackletProcessor.h.

Referenced by execute(), and TrackletProcessor().

◆ outerallstubs_

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

private

Definition at line 57 of file TrackletProcessor.h.

Referenced by addInput().

◆ outerphibits_

int trklet::TrackletProcessor::outerphibits_

private

Definition at line 71 of file TrackletProcessor.h.

Referenced by TrackletProcessor().

◆ outervmstubs_

VMStubsTEMemory* trklet::TrackletProcessor::outervmstubs_

private

Definition at line 45 of file TrackletProcessor.h.

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

◆ pttableinner_

std::map<unsigned int, std::vector<bool> > trklet::TrackletProcessor::pttableinner_

private

Definition at line 59 of file TrackletProcessor.h.

◆ pttableinnernew_

std::vector<bool> trklet::TrackletProcessor::pttableinnernew_

private

Definition at line 62 of file TrackletProcessor.h.

Referenced by addInput(), and buildLUT().

◆ pttableouter_

std::map<unsigned int, std::vector<bool> > trklet::TrackletProcessor::pttableouter_

private

Definition at line 60 of file TrackletProcessor.h.

◆ pttableouternew_

std::vector<bool> trklet::TrackletProcessor::pttableouternew_

private

Definition at line 63 of file TrackletProcessor.h.

Referenced by addInput(), and buildLUT().

◆ tedatabuffers_

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

private

Definition at line 52 of file TrackletProcessor.h.

Referenced by addInput(), and execute().

◆ teunits_

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

private

Definition at line 54 of file TrackletProcessor.h.

Referenced by addInput(), and execute().

◆ useregion_

std::vector<std::vector<bool> > trklet::TrackletProcessor::useregion_

private

Definition at line 65 of file TrackletProcessor.h.

Referenced by buildLUT(), and execute().

◆ vmrtable_

VMRouterTable trklet::TrackletProcessor::vmrtable_

private

Definition at line 78 of file TrackletProcessor.h.

Referenced by execute(), and TrackletProcessor().

Public Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ TrackletProcessor()

◆ ~TrackletProcessor()

Member Function Documentation

◆ addInput()

◆ addOutput()

◆ addOutputProjection()

◆ buildLUT()

◆ execute()

◆ writeTETable()

Member Data Documentation

◆ iAllStub_

◆ innerallstubs_

◆ innerphibits_

◆ iTC_

◆ nbitsfinephi_

◆ nbitsfinephidiff_

◆ nbitsrfinebintable_

◆ nbitsrzbin_

◆ nbitszfinebintable_

◆ outerallstubs_

◆ outerphibits_

◆ outervmstubs_

◆ pttableinner_

◆ pttableinnernew_

◆ pttableouter_

◆ pttableouternew_

◆ tedatabuffers_

◆ teunits_

◆ useregion_

◆ vmrtable_