Back to home page

Project CMSSW displayed by LXR
 
 

    

File indexing completed on 2024-04-06 12:22:05 

0001 #include "L1Trigger/TrackFindingTracklet/interface/TrackletProcessorDisplaced.h"
0002 #include "L1Trigger/TrackFindingTracklet/interface/Settings.h"
0003 #include "L1Trigger/TrackFindingTracklet/interface/Globals.h"
0004 #include "L1Trigger/TrackFindingTracklet/interface/AllStubsMemory.h"
0005 #include "L1Trigger/TrackFindingTracklet/interface/AllInnerStubsMemory.h"
0006 #include "L1Trigger/TrackFindingTracklet/interface/StubPairsMemory.h"
0007 #include "L1Trigger/TrackFindingTracklet/interface/Tracklet.h"
0008 #include "L1Trigger/TrackFindingTracklet/interface/Util.h"
0009 #include "L1Trigger/TrackFindingTracklet/interface/IMATH_TrackletCalculator.h"
0010 
0011 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0012 #include "FWCore/Utilities/interface/Exception.h"
0013 #include "DataFormats/Math/interface/deltaPhi.h"
0014 
0015 #include <utility>
0016 #include <tuple>
0017 
0018 using namespace std;
0019 using namespace trklet;
0020 
0021 TrackletProcessorDisplaced::TrackletProcessorDisplaced(string name, Settings const& settings, Globals* globals)
0022     : TrackletCalculatorDisplaced(name, settings, globals),
0023       innerTable_(settings),
0024       innerOverlapTable_(settings),
0025       innerThirdTable_(settings) {
0026   innerallstubs_.clear();
0027   middleallstubs_.clear();
0028   outerallstubs_.clear();
0029   stubpairs_.clear();
0030   innervmstubs_.clear();
0031   outervmstubs_.clear();
0032 
0033   const unsigned layerdiskPosInName = 4;
0034   const unsigned regionPosInName1 = 9;
0035 
0036   // iAllStub_ = -1;
0037   layerdisk_ = initLayerDisk(layerdiskPosInName);
0038 
0039   unsigned int region = name.substr(1)[regionPosInName1] - 'A';
0040   // assert(region < settings_.nallstubs(layerdisk_));
0041 
0042   if (layerdisk_ == LayerDisk::L1 || layerdisk_ == LayerDisk::L2 || layerdisk_ == LayerDisk::L3 ||
0043       layerdisk_ == LayerDisk::L5 || layerdisk_ == LayerDisk::D1 || layerdisk_ == LayerDisk::D3) {
0044     innerTable_.initVMRTable(layerdisk_, TrackletLUT::VMRTableType::inner, region);  //projection to next layer/disk
0045   }
0046 
0047   if (layerdisk_ == LayerDisk::L1 || layerdisk_ == LayerDisk::L2) {
0048     innerOverlapTable_.initVMRTable(
0049         layerdisk_, TrackletLUT::VMRTableType::inneroverlap, region);  //projection to disk from layer
0050   }
0051 
0052   if (layerdisk_ == LayerDisk::L2 || layerdisk_ == LayerDisk::L3 || layerdisk_ == LayerDisk::L5 ||
0053       layerdisk_ == LayerDisk::D1) {
0054     innerThirdTable_.initVMRTable(
0055         layerdisk_, TrackletLUT::VMRTableType::innerthird, region);  //projection to third layer/disk
0056   }
0057 
0058   nbitszfinebintable_ = settings_.vmrlutzbits(layerdisk_);
0059   nbitsrfinebintable_ = settings_.vmrlutrbits(layerdisk_);
0060 
0061   for (unsigned int ilayer = 0; ilayer < N_LAYER; ilayer++) {
0062     vector<TrackletProjectionsMemory*> tmp(settings_.nallstubs(ilayer), nullptr);
0063     trackletprojlayers_.push_back(tmp);
0064   }
0065 
0066   for (unsigned int idisk = 0; idisk < N_DISK; idisk++) {
0067     vector<TrackletProjectionsMemory*> tmp(settings_.nallstubs(idisk + N_LAYER), nullptr);
0068     trackletprojdisks_.push_back(tmp);
0069   }
0070 
0071   // initLayerDisksandISeed(layerdisk1_, layerdisk2_, iSeed_);
0072 
0073   layer_ = 0;
0074   disk_ = 0;
0075   layer1_ = 0;
0076   layer2_ = 0;
0077   layer3_ = 0;
0078   disk1_ = 0;
0079   disk2_ = 0;
0080   disk3_ = 0;
0081 
0082   constexpr unsigned layerPosInName1 = 4;
0083   constexpr unsigned diskPosInName1 = 4;
0084   constexpr unsigned layer1PosInName1 = 4;
0085   constexpr unsigned disk1PosInName1 = 4;
0086   constexpr unsigned layer2PosInName1 = 6;
0087   constexpr unsigned disk2PosInName1 = 6;
0088 
0089   string name1 = name.substr(1);  //this is to correct for "TPD" having one more letter then "TP"
0090   if (name1[3] == 'L')
0091     layer_ = name1[layerPosInName1] - '0';
0092   if (name1[3] == 'D')
0093     disk_ = name1[diskPosInName1] - '0';
0094 
0095   if (name1[3] == 'L')
0096     layer1_ = name1[layer1PosInName1] - '0';
0097   if (name1[3] == 'D')
0098     disk1_ = name1[disk1PosInName1] - '0';
0099   if (name1[5] == 'L')
0100     layer2_ = name1[layer2PosInName1] - '0';
0101   if (name1[5] == 'D')
0102     disk2_ = name1[disk2PosInName1] - '0';
0103 
0104   // set TC index
0105   iSeed_ = 0;
0106 
0107   int iTC = name1[regionPosInName1] - 'A';
0108 
0109   if (name1.substr(3, 6) == "L3L4L2") {
0110     iSeed_ = 8;
0111     layer3_ = 2;
0112   } else if (name1.substr(3, 6) == "L5L6L4") {
0113     iSeed_ = 9;
0114     layer3_ = 4;
0115   } else if (name1.substr(3, 6) == "L2L3D1") {
0116     iSeed_ = 10;
0117     disk3_ = 1;
0118   } else if (name1.substr(3, 6) == "D1D2L2") {
0119     iSeed_ = 11;
0120     layer3_ = 2;
0121   }
0122   assert(iSeed_ != 0);
0123 
0124   constexpr int TCIndexMin = 128;
0125   constexpr int TCIndexMax = 191;
0126 
0127   TCIndex_ = (iSeed_ << 4) + iTC;
0128   assert(TCIndex_ >= TCIndexMin && TCIndex_ < TCIndexMax);
0129 
0130   assert((layer_ != 0) || (disk_ != 0));
0131 }
0132 
0133 void TrackletProcessorDisplaced::addOutputProjection(TrackletProjectionsMemory*& outputProj, MemoryBase* memory) {
0134   outputProj = dynamic_cast<TrackletProjectionsMemory*>(memory);
0135   assert(outputProj != nullptr);
0136 }
0137 
0138 void TrackletProcessorDisplaced::addOutput(MemoryBase* memory, string output) {
0139   if (settings_.writetrace()) {
0140     edm::LogVerbatim("Tracklet") << "In " << name_ << " adding output to " << memory->getName() << " to output "
0141                                  << output;
0142   }
0143 
0144   if (output == "trackpar") {
0145     auto* tmp = dynamic_cast<TrackletParametersMemory*>(memory);
0146     assert(tmp != nullptr);
0147     trackletpars_ = tmp;
0148     return;
0149   }
0150 
0151   if (output.substr(0, 7) == "projout") {
0152     //output is on the form 'projoutL2PHIC' or 'projoutD3PHIB'
0153     auto* tmp = dynamic_cast<TrackletProjectionsMemory*>(memory);
0154     assert(tmp != nullptr);
0155 
0156     constexpr unsigned layerdiskPosInprojout = 8;
0157     constexpr unsigned phiPosInprojout = 12;
0158 
0159     unsigned int layerdisk = output[layerdiskPosInprojout] - '1';  //layer or disk counting from 0
0160     unsigned int phiregion = output[phiPosInprojout] - 'A';        //phiregion counting from 0
0161 
0162     if (output[7] == 'L') {
0163       assert(layerdisk < N_LAYER);
0164       assert(phiregion < trackletprojlayers_[layerdisk].size());
0165       //check that phiregion not already initialized
0166       assert(trackletprojlayers_[layerdisk][phiregion] == nullptr);
0167       trackletprojlayers_[layerdisk][phiregion] = tmp;
0168       return;
0169     }
0170 
0171     if (output[7] == 'D') {
0172       assert(layerdisk < N_DISK);
0173       assert(phiregion < trackletprojdisks_[layerdisk].size());
0174       //check that phiregion not already initialized
0175       assert(trackletprojdisks_[layerdisk][phiregion] == nullptr);
0176       trackletprojdisks_[layerdisk][phiregion] = tmp;
0177       return;
0178     }
0179   }
0180 
0181   throw cms::Exception("BadConfig") << __FILE__ << " " << __LINE__ << " Could not find output : " << output;
0182 }
0183 
0184 void TrackletProcessorDisplaced::addInput(MemoryBase* memory, string input) {
0185   if (settings_.writetrace()) {
0186     edm::LogVerbatim("Tracklet") << "In " << name_ << " adding input from " << memory->getName() << " to input "
0187                                  << input;
0188   }
0189 
0190   if (input == "thirdallstubin") {
0191     auto* tmp = dynamic_cast<AllStubsMemory*>(memory);
0192     assert(tmp != nullptr);
0193     innerallstubs_.push_back(tmp);
0194     return;
0195   }
0196   if (input == "firstallstubin") {
0197     auto* tmp = dynamic_cast<AllStubsMemory*>(memory);
0198     assert(tmp != nullptr);
0199     middleallstubs_.push_back(tmp);
0200     return;
0201   }
0202   if (input == "secondallstubin") {
0203     auto* tmp = dynamic_cast<AllStubsMemory*>(memory);
0204     assert(tmp != nullptr);
0205     outerallstubs_.push_back(tmp);
0206     return;
0207   }
0208   if (input.substr(0, 8) == "stubpair") {
0209     auto* tmp = dynamic_cast<StubPairsMemory*>(memory);
0210     assert(tmp != nullptr);
0211     stubpairs_.push_back(tmp);
0212     return;
0213   }
0214 
0215   if (input == "thirdvmstubin") {
0216     auto* tmp = dynamic_cast<VMStubsTEMemory*>(memory);
0217     assert(tmp != nullptr);
0218     innervmstubs_.push_back(tmp);
0219     return;
0220   }
0221   if (input == "secondvmstubin") {
0222     auto* tmp = dynamic_cast<VMStubsTEMemory*>(memory);
0223     assert(tmp != nullptr);
0224     // outervmstubs_ = tmp;
0225     outervmstubs_.push_back(tmp);
0226     return;
0227   }
0228 
0229   throw cms::Exception("BadConfig") << __FILE__ << " " << __LINE__ << " Could not find input : " << input;
0230 }
0231 
0232 void TrackletProcessorDisplaced::execute(unsigned int iSector, double phimin, double phimax) {
0233   unsigned int countall = 0;
0234   unsigned int countsel = 0;
0235   // unsigned int nThirdStubs = 0;
0236   // unsigned int nOuterStubs = 0;
0237   count_ = 0;
0238 
0239   phimin_ = phimin;
0240   phimax_ = phimax;
0241   iSector_ = iSector;
0242 
0243   assert(!innerallstubs_.empty());
0244   assert(!middleallstubs_.empty());
0245   assert(!outerallstubs_.empty());
0246   assert(!innervmstubs_.empty());
0247   assert(!outervmstubs_.empty());
0248   assert(stubpairs_.empty());
0249 
0250   for (auto& iInnerMem : middleallstubs_) {
0251     assert(iInnerMem->nStubs() == iInnerMem->nStubs());
0252     for (unsigned int j = 0; j < iInnerMem->nStubs(); j++) {
0253       const Stub* firstallstub = iInnerMem->getStub(j);
0254 
0255       if (settings_.debugTracklet()) {
0256         edm::LogVerbatim("Tracklet") << "In " << getName() << " have first stub\n";
0257       }
0258 
0259       int inner = 0;
0260       bool negdisk = (firstallstub->disk().value() < 0);
0261       int indexz = (((1 << (firstallstub->z().nbits() - 1)) + firstallstub->z().value()) >>
0262                     (firstallstub->z().nbits() - nbitszfinebintable_));
0263       int indexr = -1;
0264       if (layerdisk_ > (N_LAYER - 1)) {
0265         if (negdisk) {
0266           indexz = (1 << nbitszfinebintable_) - indexz;
0267         }
0268         indexr = firstallstub->r().value();
0269         if (firstallstub->isPSmodule()) {
0270           indexr = firstallstub->r().value() >> (firstallstub->r().nbits() - nbitsrfinebintable_);
0271         }
0272       } else {
0273         //Take the top nbitsfinebintable_ bits of the z coordinate. The & is to handle the negative z values.
0274         indexr = (((1 << (firstallstub->r().nbits() - 1)) + firstallstub->r().value()) >>
0275                   (firstallstub->r().nbits() - nbitsrfinebintable_));
0276       }
0277 
0278       assert(indexz >= 0);
0279       assert(indexr >= 0);
0280       assert(indexz < (1 << nbitszfinebintable_));
0281       assert(indexr < (1 << nbitsrfinebintable_));
0282 
0283       // int melut = meTable_.lookup((indexz << nbitsrfinebintable_) + indexr);
0284       // assert(melut >= 0);
0285 
0286       unsigned int lutwidth = settings_.lutwidthtab(inner, iSeed_);
0287       if (settings_.extended()) {
0288         lutwidth = settings_.lutwidthtabextended(inner, iSeed_);
0289       }
0290 
0291       int lutval = -999;
0292 
0293       if (iSeed_ < Seed::L1D1 || iSeed_ > Seed::L2D1) {
0294         lutval = innerTable_.lookup((indexz << nbitsrfinebintable_) + indexr);
0295       } else {
0296         lutval = innerOverlapTable_.lookup((indexz << nbitsrfinebintable_) + indexr);
0297       }
0298 
0299       if (lutval == -1)
0300         continue;
0301       if (settings_.extended() &&
0302           (iSeed_ == Seed::L2L3L4 || iSeed_ == Seed::L4L5L6 || iSeed_ == Seed::D1D2L2 || iSeed_ == Seed::L2L3D1)) {
0303         int lutval2 = innerThirdTable_.lookup((indexz << nbitsrfinebintable_) + indexr);
0304         if (lutval2 != -1)
0305           lutval += (lutval2 << 10);
0306       }
0307 
0308       assert(lutval >= 0);
0309       // assert(lutwidth > 0);
0310 
0311       FPGAWord binlookup(lutval, lutwidth, true, __LINE__, __FILE__);
0312 
0313       if ((layer1_ == 3 && layer2_ == 4) || (layer1_ == 5 && layer2_ == 6)) {
0314         if (settings_.debugTracklet()) {
0315           edm::LogVerbatim("Tracklet") << getName() << " Layer-layer pair\n";
0316         }
0317 
0318         constexpr int andlookupbits = 1023;
0319         constexpr int shiftzdiffmax = 7;
0320         constexpr int andnewbin = 127;
0321         constexpr int divbin = 8;
0322         constexpr int andzbinfirst = 7;
0323         constexpr int shiftstart = 1;
0324         constexpr int andlast = 1;
0325         constexpr int maxlast = 8;
0326 
0327         int lookupbits = binlookup.value() & andlookupbits;
0328         int zdiffmax = (lookupbits >> shiftzdiffmax);
0329         int newbin = (lookupbits & andnewbin);
0330         int bin = newbin / divbin;
0331 
0332         int zbinfirst = newbin & andzbinfirst;
0333 
0334         int start = (bin >> shiftstart);
0335         int last = start + (bin & andlast);
0336 
0337         assert(last < maxlast);
0338 
0339         if (settings_.debugTracklet()) {
0340           edm::LogVerbatim("Tracklet") << "Will look in zbins " << start << " to " << last << endl;
0341         }
0342 
0343         for (int ibin = start; ibin <= last; ibin++) {
0344           for (unsigned int m = 0; m < outervmstubs_.size(); m++) {
0345             for (unsigned int j = 0; j < outervmstubs_.at(m)->nVMStubsBinned(ibin); j++) {
0346               if (settings_.debugTracklet()) {
0347                 edm::LogVerbatim("Tracklet")
0348                     << "In " << getName() << " have second stub(1) " << ibin << " " << j << endl;
0349               }
0350 
0351               const VMStubTE& secondvmstub = outervmstubs_.at(m)->getVMStubTEBinned(ibin, j);
0352 
0353               int zbin = (secondvmstub.vmbits().value() & 7);
0354               if (start != ibin)
0355                 zbin += 8;
0356               if (zbin < zbinfirst || zbin - zbinfirst > zdiffmax) {
0357                 if (settings_.debugTracklet()) {
0358                   edm::LogVerbatim("Tracklet") << "Stubpair rejected because of wrong zbin";
0359                 }
0360                 continue;
0361               }
0362 
0363               if ((layer2_ == 4 && layer3_ == 2) || (layer2_ == 6 && layer3_ == 4)) {
0364                 constexpr int vmbitshift = 10;
0365                 constexpr int andlookupbits_ = 1023;
0366                 constexpr int andnewbin_ = 127;
0367                 constexpr int divbin_ = 8;
0368                 constexpr int shiftstart_ = 1;
0369                 constexpr int andlast_ = 1;
0370 
0371                 int lookupbits_ = (int)((binlookup.value() >> vmbitshift) & andlookupbits_);
0372                 int newbin_ = (lookupbits_ & andnewbin_);
0373                 int bin_ = newbin_ / divbin_;
0374 
0375                 int start_ = (bin_ >> shiftstart_);
0376                 int last_ = start_ + (bin_ & andlast_);
0377 
0378                 if (settings_.debugTracklet()) {
0379                   edm::LogVerbatim("Tracklet")
0380                       << "Will look in zbins for third stub" << start_ << " to " << last_ << endl;
0381                 }
0382 
0383                 for (int ibin_ = start_; ibin_ <= last_; ibin_++) {
0384                   for (unsigned int k = 0; k < innervmstubs_.size(); k++) {
0385                     for (unsigned int l = 0; l < innervmstubs_.at(k)->nVMStubsBinned(ibin_); l++) {
0386                       if (settings_.debugTracklet()) {
0387                         edm::LogVerbatim("Tracklet") << "In " << getName() << " have third stub\n";
0388                       }
0389 
0390                       countall++;
0391 
0392                       const VMStubTE& thirdvmstub = innervmstubs_.at(k)->getVMStubTEBinned(ibin_, l);
0393 
0394                       const Stub* innerFPGAStub = firstallstub;
0395                       const Stub* middleFPGAStub = secondvmstub.stub();
0396                       const Stub* outerFPGAStub = thirdvmstub.stub();
0397 
0398                       const L1TStub* innerStub = innerFPGAStub->l1tstub();
0399                       const L1TStub* middleStub = middleFPGAStub->l1tstub();
0400                       const L1TStub* outerStub = outerFPGAStub->l1tstub();
0401 
0402                       if (settings_.debugTracklet()) {
0403                         edm::LogVerbatim("Tracklet")
0404                             << "LLL seeding\n"
0405                             << innerFPGAStub->strbare() << middleFPGAStub->strbare() << outerFPGAStub->strbare()
0406                             << innerStub->stubword() << middleStub->stubword() << outerStub->stubword()
0407                             << innerFPGAStub->layerdisk() << middleFPGAStub->layerdisk() << outerFPGAStub->layerdisk();
0408                       }
0409 
0410                       if (settings_.debugTracklet()) {
0411                         edm::LogVerbatim("Tracklet")
0412                             << "TrackletCalculatorDisplaced execute " << getName() << "[" << iSector_ << "]";
0413                       }
0414 
0415                       if (innerFPGAStub->layerdisk() < N_LAYER && middleFPGAStub->layerdisk() < N_LAYER &&
0416                           outerFPGAStub->layerdisk() < N_LAYER) {
0417                         bool accept =
0418                             LLLSeeding(outerFPGAStub, outerStub, innerFPGAStub, innerStub, middleFPGAStub, middleStub);
0419 
0420                         if (accept)
0421                           countsel++;
0422                       } else if (innerFPGAStub->layerdisk() >= N_LAYER && middleFPGAStub->layerdisk() >= N_LAYER &&
0423                                  outerFPGAStub->layerdisk() >= N_LAYER) {
0424                         throw cms::Exception("LogicError") << __FILE__ << " " << __LINE__ << " Invalid seeding!";
0425                       }
0426 
0427                       if (settings_.debugTracklet()) {
0428                         edm::LogVerbatim("Tracklet") << "TrackletCalculatorDisplaced execute done";
0429                       }
0430                     }
0431                   }
0432                 }
0433               }
0434             }
0435           }
0436         }
0437 
0438       } else if (layer1_ == 2 && layer2_ == 3) {
0439         if (settings_.debugTracklet()) {
0440           edm::LogVerbatim("Tracklet") << getName() << " Layer-layer pair";
0441         }
0442 
0443         constexpr int andlookupbits = 1023;
0444         constexpr int shiftzdiffmax = 7;
0445         constexpr int andnewbin = 127;
0446         constexpr int divbin = 8;
0447         constexpr int andzbinfirst = 7;
0448         constexpr int shiftstart = 1;
0449         constexpr int andlast = 1;
0450         constexpr int maxlast = 8;
0451 
0452         int lookupbits = binlookup.value() & andlookupbits;
0453         int zdiffmax = (lookupbits >> shiftzdiffmax);
0454         int newbin = (lookupbits & andnewbin);
0455         int bin = newbin / divbin;
0456 
0457         int zbinfirst = newbin & andzbinfirst;
0458 
0459         int start = (bin >> shiftstart);
0460         int last = start + (bin & andlast);
0461 
0462         assert(last < maxlast);
0463 
0464         if (settings_.debugTracklet()) {
0465           edm::LogVerbatim("Tracklet") << "Will look in zbins " << start << " to " << last;
0466         }
0467 
0468         for (int ibin = start; ibin <= last; ibin++) {
0469           for (unsigned int m = 0; m < outervmstubs_.size(); m++) {
0470             for (unsigned int j = 0; j < outervmstubs_.at(m)->nVMStubsBinned(ibin); j++) {
0471               if (settings_.debugTracklet()) {
0472                 edm::LogVerbatim("Tracklet") << "In " << getName() << " have second stub(1) " << ibin << " " << j;
0473               }
0474 
0475               const VMStubTE& secondvmstub = outervmstubs_.at(m)->getVMStubTEBinned(ibin, j);
0476 
0477               int zbin = (secondvmstub.vmbits().value() & 7);
0478               if (start != ibin)
0479                 zbin += 8;
0480               if (zbin < zbinfirst || zbin - zbinfirst > zdiffmax) {
0481                 if (settings_.debugTracklet()) {
0482                   edm::LogVerbatim("Tracklet") << "Stubpair rejected because of wrong zbin";
0483                 }
0484                 continue;
0485               }
0486 
0487               if (layer2_ == 3 && disk3_ == 1) {
0488                 constexpr int vmbitshift = 10;
0489                 constexpr int andlookupbits_ = 1023;
0490                 constexpr int andnewbin_ = 127;
0491                 constexpr int divbin_ = 8;
0492                 constexpr int shiftstart_ = 1;
0493                 constexpr int andlast_ = 1;
0494 
0495                 int lookupbits_ = (int)((binlookup.value() >> vmbitshift) & andlookupbits_);
0496                 int newbin_ = (lookupbits_ & andnewbin_);
0497                 int bin_ = newbin_ / divbin_;
0498 
0499                 int start_ = (bin_ >> shiftstart_);
0500                 int last_ = start_ + (bin_ & andlast_);
0501 
0502                 for (int ibin_ = start_; ibin_ <= last_; ibin_++) {
0503                   for (unsigned int k = 0; k < innervmstubs_.size(); k++) {
0504                     for (unsigned int l = 0; l < innervmstubs_.at(k)->nVMStubsBinned(ibin_); l++) {
0505                       if (settings_.debugTracklet()) {
0506                         edm::LogVerbatim("Tracklet") << "In " << getName() << " have third stub";
0507                       }
0508 
0509                       countall++;
0510 
0511                       const VMStubTE& thirdvmstub = innervmstubs_.at(k)->getVMStubTEBinned(ibin_, l);
0512 
0513                       const Stub* innerFPGAStub = firstallstub;
0514                       const Stub* middleFPGAStub = secondvmstub.stub();
0515                       const Stub* outerFPGAStub = thirdvmstub.stub();
0516 
0517                       const L1TStub* innerStub = innerFPGAStub->l1tstub();
0518                       const L1TStub* middleStub = middleFPGAStub->l1tstub();
0519                       const L1TStub* outerStub = outerFPGAStub->l1tstub();
0520 
0521                       if (settings_.debugTracklet()) {
0522                         edm::LogVerbatim("Tracklet")
0523                             << "LLD seeding\n"
0524                             << innerFPGAStub->strbare() << middleFPGAStub->strbare() << outerFPGAStub->strbare()
0525                             << innerStub->stubword() << middleStub->stubword() << outerStub->stubword()
0526                             << innerFPGAStub->layerdisk() << middleFPGAStub->layerdisk() << outerFPGAStub->layerdisk();
0527                       }
0528 
0529                       if (settings_.debugTracklet()) {
0530                         edm::LogVerbatim("Tracklet")
0531                             << "TrackletCalculatorDisplaced execute " << getName() << "[" << iSector_ << "]";
0532                       }
0533 
0534                       bool accept =
0535                           LLDSeeding(outerFPGAStub, outerStub, innerFPGAStub, innerStub, middleFPGAStub, middleStub);
0536 
0537                       if (accept)
0538                         countsel++;
0539 
0540                       if (settings_.debugTracklet()) {
0541                         edm::LogVerbatim("Tracklet") << "TrackletCalculatorDisplaced execute done";
0542                       }
0543                     }
0544                   }
0545                 }
0546               }
0547             }
0548           }
0549         }
0550 
0551       } else if (disk1_ == 1 && disk2_ == 2) {
0552         if (settings_.debugTracklet())
0553           edm::LogVerbatim("Tracklet") << getName() << " Disk-disk pair";
0554 
0555         constexpr int andlookupbits = 511;
0556         constexpr int shiftrdiffmax = 6;
0557         constexpr int andnewbin = 63;
0558         constexpr int divbin = 8;
0559         constexpr int andrbinfirst = 7;
0560         constexpr int shiftstart = 1;
0561         constexpr int andlast = 1;
0562         constexpr int maxlast = 8;
0563 
0564         int lookupbits = binlookup.value() & andlookupbits;
0565         bool negdisk = firstallstub->disk().value() < 0;
0566         int rdiffmax = (lookupbits >> shiftrdiffmax);
0567         int newbin = (lookupbits & andnewbin);
0568         int bin = newbin / divbin;
0569 
0570         int rbinfirst = newbin & andrbinfirst;
0571 
0572         int start = (bin >> shiftstart);
0573         if (negdisk)
0574           start += 4;
0575         int last = start + (bin & andlast);
0576         assert(last < maxlast);
0577 
0578         for (int ibin = start; ibin <= last; ibin++) {
0579           for (unsigned int m = 0; m < outervmstubs_.size(); m++) {
0580             if (settings_.debugTracklet()) {
0581               edm::LogVerbatim("Tracklet")
0582                   << getName() << " looking for matching stub in " << outervmstubs_.at(m)->getName()
0583                   << " in bin = " << ibin << " with " << outervmstubs_.at(m)->nVMStubsBinned(ibin) << " stubs";
0584             }
0585 
0586             for (unsigned int j = 0; j < outervmstubs_.at(m)->nVMStubsBinned(ibin); j++) {
0587               const VMStubTE& secondvmstub = outervmstubs_.at(m)->getVMStubTEBinned(ibin, j);
0588               int rbin = (secondvmstub.vmbits().value() & 7);
0589               if (start != ibin)
0590                 rbin += 8;
0591               if (rbin < rbinfirst)
0592                 continue;
0593               if (rbin - rbinfirst > rdiffmax)
0594                 continue;
0595 
0596               if (disk2_ == 2 && layer3_ == 2) {
0597                 constexpr int vmbitshift = 10;
0598                 constexpr int andlookupbits_ = 1023;
0599                 constexpr int andnewbin_ = 127;
0600                 constexpr int divbin_ = 8;
0601                 constexpr int shiftstart_ = 1;
0602                 constexpr int andlast_ = 1;
0603 
0604                 int lookupbits_ = (int)((binlookup.value() >> vmbitshift) & andlookupbits_);
0605                 int newbin_ = (lookupbits_ & andnewbin_);
0606                 int bin_ = newbin_ / divbin_;
0607 
0608                 int start_ = (bin_ >> shiftstart_);
0609                 int last_ = start_ + (bin_ & andlast_);
0610 
0611                 if (firstallstub->disk().value() < 0) {  //TODO - negative disk should come from memory
0612                   start_ = settings_.NLONGVMBINS() - last_ - 1;
0613                   last_ = settings_.NLONGVMBINS() - start_ - 1;
0614                 }
0615 
0616                 for (int ibin_ = start_; ibin_ <= last_; ibin_++) {
0617                   for (unsigned int k = 0; k < innervmstubs_.size(); k++) {
0618                     for (unsigned int l = 0; l < innervmstubs_.at(k)->nVMStubsBinned(ibin_); l++) {
0619                       if (settings_.debugTracklet()) {
0620                         edm::LogVerbatim("Tracklet") << "In " << getName() << " have third stub";
0621                       }
0622 
0623                       countall++;
0624 
0625                       const VMStubTE& thirdvmstub = innervmstubs_.at(k)->getVMStubTEBinned(ibin_, l);
0626 
0627                       const Stub* innerFPGAStub = firstallstub;
0628                       const Stub* middleFPGAStub = secondvmstub.stub();
0629                       const Stub* outerFPGAStub = thirdvmstub.stub();
0630 
0631                       const L1TStub* innerStub = innerFPGAStub->l1tstub();
0632                       const L1TStub* middleStub = middleFPGAStub->l1tstub();
0633                       const L1TStub* outerStub = outerFPGAStub->l1tstub();
0634 
0635                       if (settings_.debugTracklet()) {
0636                         edm::LogVerbatim("Tracklet")
0637                             << "DDL seeding\n"
0638                             << innerFPGAStub->strbare() << middleFPGAStub->strbare() << outerFPGAStub->strbare()
0639                             << innerStub->stubword() << middleStub->stubword() << outerStub->stubword()
0640                             << innerFPGAStub->layerdisk() << middleFPGAStub->layerdisk() << outerFPGAStub->layerdisk();
0641                       }
0642 
0643                       if (settings_.debugTracklet()) {
0644                         edm::LogVerbatim("Tracklet")
0645                             << "TrackletCalculatorDisplaced execute " << getName() << "[" << iSector_ << "]";
0646                       }
0647 
0648                       bool accept =
0649                           DDLSeeding(outerFPGAStub, outerStub, innerFPGAStub, innerStub, middleFPGAStub, middleStub);
0650 
0651                       if (accept)
0652                         countsel++;
0653 
0654                       if (settings_.debugTracklet()) {
0655                         edm::LogVerbatim("Tracklet") << "TrackletCalculatorDisplaced execute done";
0656                       }
0657                     }
0658                   }
0659                 }
0660               }
0661             }
0662           }
0663         }
0664       }
0665     }
0666   }
0667 
0668   if (settings_.writeMonitorData("TPD")) {
0669     globals_->ofstream("trackletprocessordisplaced.txt") << getName() << " " << countall << " " << countsel << endl;
0670   }
0671 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.2.1 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!