Back to home page

Project CMSSW displayed by LXR
 
 

    

File indexing completed on 2022-10-14 01:44:00 

0001 #ifndef L1Trigger_TrackFindingTracklet_interface_Settings_h
0002 #define L1Trigger_TrackFindingTracklet_interface_Settings_h
0003 
0004 #include <iostream>
0005 #include <string>
0006 #include <array>
0007 #include <set>
0008 #include <cassert>
0009 #include <cmath>
0010 #include <unordered_map>
0011 #include <map>
0012 #include <vector>
0013 
0014 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0015 #include "FWCore/Utilities/interface/Exception.h"
0016 
0017 namespace trklet {
0018 
0019   constexpr unsigned int N_SECTOR = 9;  // # of phi sectors for L1TK processing
0020 
0021   constexpr int N_LAYER = 6;                 // # of barrel layers assumed
0022   constexpr int N_DISK = 5;                  // # of endcap disks assumed
0023   constexpr unsigned int N_PSLAYER = 3;      // # of barrel PS layers assumed
0024   constexpr unsigned int N_SEED = 12;        // # of tracklet+triplet seeds
0025   constexpr unsigned int N_SEED_PROMPT = 8;  // # of tracklet (prompt) seeds
0026 
0027   constexpr unsigned int N_DSS_MOD = 5;  // # of rings with 2S modules per disk
0028 
0029   constexpr unsigned int N_BENDBITS_PS = 3;  // Number of bend bits for PS modules
0030   constexpr unsigned int N_BENDBITS_2S = 4;  // Number of bend bits for 2S modules
0031 
0032   constexpr unsigned int NRINVBITS = 5;     //number of bit for rinv in bend match table
0033   constexpr unsigned int NFINERZBITS = 3;   //number of bit for r or z within a r/z bin
0034   constexpr unsigned int NFINEPHIBITS = 3;  //number of bits for phi within a vm bin
0035   constexpr unsigned int N_RZBITS = 3;      //number of bit for the r/z bins
0036   constexpr unsigned int N_PHIBITS = 3;     //number of bit for the phi bins
0037 
0038   constexpr unsigned int N_VMSTUBSMAX = 15;     // maximum number of stubs in VM bin
0039   constexpr unsigned int N_BITSMEMADDRESS = 7;  // Number of bits for address in memories
0040 
0041   constexpr double sixth = 1.0 / 6.0;  //Commonly used factor
0042   constexpr double third = 1.0 / 3.0;  //Commonly used factor
0043 
0044   constexpr double VMROUTERCUTZL2 = 50.0;      //Min L2 z for inner allstub
0045   constexpr double VMROUTERCUTZL1L3L5 = 95.0;  //Max z for inner barrel layers
0046   constexpr double VMROUTERCUTZL1 = 70.0;      //Max z for L1 barrel seeding
0047   constexpr double VMROUTERCUTRD1D3 = 55.0;    //Max r for disk seeds
0048 
0049   enum Seed { L1L2 = 0, L2L3, L3L4, L5L6, D1D2, D3D4, L1D1, L2D1, L2L3L4, L4L5L6, L2L3D1, D1D2L2 };
0050   enum LayerDisk { L1 = 0, L2, L3, L4, L5, L6, D1, D2, D3, D4, D5 };
0051 
0052   class Settings {
0053   public:
0054     Settings() {
0055       //Comment out to run tracklet-only algorithm
0056 #ifdef CMSSW_GIT_HASH
0057 #ifndef USEHYBRID
0058 #pragma message "USEHYBRID is undefined, so Hybrid L1 tracking disabled."
0059 #endif
0060 #endif
0061     }
0062 
0063     ~Settings() = default;
0064 
0065     // processing & memory modules, wiring, etc.
0066     std::string const& fitPatternFile() const { return fitPatternFile_; }
0067     std::string const& processingModulesFile() const { return processingModulesFile_; }
0068     std::string const& memoryModulesFile() const { return memoryModulesFile_; }
0069     std::string const& wiresFile() const { return wiresFile_; }
0070     std::string const& tableTEDFile() const { return tableTEDFile_; }
0071     std::string const& tableTREFile() const { return tableTREFile_; }
0072 
0073     void setFitPatternFile(std::string fitPatternFileName) { fitPatternFile_ = fitPatternFileName; }
0074     void setProcessingModulesFile(std::string processingModulesFileName) {
0075       processingModulesFile_ = processingModulesFileName;
0076     }
0077     void setMemoryModulesFile(std::string memoryModulesFileName) { memoryModulesFile_ = memoryModulesFileName; }
0078     void setWiresFile(std::string wiresFileName) { wiresFile_ = wiresFileName; }
0079     void setTableTEDFile(std::string tableTEDFileName) { tableTEDFile_ = tableTEDFileName; }
0080     void setTableTREFile(std::string tableTREFileName) { tableTREFile_ = tableTREFileName; }
0081 
0082     unsigned int nzbitsstub(unsigned int layerdisk) const { return nzbitsstub_[layerdisk]; }
0083     unsigned int nphibitsstub(unsigned int layerdisk) const { return nphibitsstub_[layerdisk]; }
0084     unsigned int nrbitsstub(unsigned int layerdisk) const { return nrbitsstub_[layerdisk]; }
0085 
0086     unsigned int nrbitsprojderdisk() const { return nrbitsprojderdisk_; }
0087     unsigned int nbitsphiprojderL123() const { return nbitsphiprojderL123_; }
0088     unsigned int nbitsphiprojderL456() const { return nbitsphiprojderL456_; }
0089     unsigned int nbitszprojderL123() const { return nbitszprojderL123_; }
0090     unsigned int nbitszprojderL456() const { return nbitszprojderL456_; }
0091 
0092     unsigned int nbendbitsmedisk() const { return nbendbitsmedisk_; }
0093 
0094     bool useSeed(unsigned int iSeed) const { return useseeding_.find(iSeed) != useseeding_.end(); }
0095     unsigned int nbitsvmte(unsigned int inner, unsigned int iSeed) const {
0096       if (combined_) {
0097         return nbitsvmtecm_[inner][iSeed];
0098       }
0099       return nbitsvmte_[inner][iSeed];
0100     }
0101     unsigned int nvmte(unsigned int inner, unsigned int iSeed) const { return (1 << nbitsvmte(inner, iSeed)); }
0102 
0103     unsigned int nbitsvmme(unsigned int layerdisk) const { return nbitsvmme_[layerdisk]; }
0104     unsigned int nvmme(unsigned int layerdisk) const { return (1 << nbitsvmme_[layerdisk]); }
0105 
0106     unsigned int nbitsallstubs(unsigned int layerdisk) const { return nbitsallstubs_[layerdisk]; }
0107     unsigned int nallstubs(unsigned int layerdisk) const { return (1 << nbitsallstubs_[layerdisk]); }
0108 
0109     bool writeMonitorData(std::string module) const {
0110       if (writeMonitorData_.find(module) == writeMonitorData_.end()) {
0111         throw cms::Exception("BadConfig") << "Settings::writeMonitorData module = " << module << " not known";
0112       }
0113       return writeMonitorData_.at(module);
0114     }
0115 
0116     unsigned int maxStep(std::string module) const {
0117       if (maxstep_.find(module) == maxstep_.end()) {
0118         throw cms::Exception("BadConfig")
0119             << __FILE__ << " " << __LINE__ << " maxStep module = " << module << " not known";
0120       }
0121       return extended_ ? (maxstep_.at(module) + maxstepoffset_extended_) : (maxstep_.at(module) + maxstepoffset_);
0122     }
0123 
0124     double zlength() const { return zlength_; }
0125     double rmaxdisk() const { return rmaxdisk_; }
0126     double rmindisk() const { return rmindisk_; }
0127 
0128     double drmax() const { return rmaxdisk_ / deltarzfract_; }
0129     double dzmax() const { return zlength_ / deltarzfract_; }
0130 
0131     double half2SmoduleWidth() const { return half2SmoduleWidth_; }
0132 
0133     int nfinephi(unsigned int inner, unsigned int iSeed) const { return nfinephi_[inner][iSeed]; }
0134     double nphireg(unsigned int inner, unsigned int iSeed) const {
0135       if (combined_) {
0136         return nphiregcm_[inner][iSeed];
0137       }
0138       return nphireg_[inner][iSeed];
0139     }
0140     double lutwidthtab(unsigned int inner, unsigned int iSeed) const { return lutwidthtab_[inner][iSeed]; }
0141     double lutwidthtabextended(unsigned int inner, unsigned int iSeed) const {
0142       return lutwidthtabextended_[inner][iSeed];
0143     }
0144 
0145     unsigned int seedlayers(int inner, int seed) const {
0146       int layerdisk = seedlayers_[seed][inner];
0147       assert(layerdisk >= 0);
0148       return layerdisk;
0149     }
0150 
0151     unsigned int teunits(unsigned int iSeed) const { return teunits_[iSeed]; }
0152 
0153     unsigned int NTC(int seed) const { return ntc_[seed]; }
0154 
0155     unsigned int projlayers(unsigned int iSeed, unsigned int i) const { return projlayers_[iSeed][i]; }
0156     unsigned int projdisks(unsigned int iSeed, unsigned int i) const { return projdisks_[iSeed][i]; }
0157     double rphimatchcut(unsigned int iSeed, unsigned int ilayer) const { return rphimatchcut_[ilayer][iSeed]; }
0158     double zmatchcut(unsigned int iSeed, unsigned int ilayer) const { return zmatchcut_[ilayer][iSeed]; }
0159     double rphicutPS(unsigned int iSeed, unsigned int idisk) const { return rphicutPS_[idisk][iSeed]; }
0160     double rcutPS(unsigned int iSeed, unsigned int idisk) const { return rcutPS_[idisk][iSeed]; }
0161     double rphicut2S(unsigned int iSeed, unsigned int idisk) const { return rphicut2S_[idisk][iSeed]; }
0162     double rcut2S(unsigned int iSeed, unsigned int idisk) const { return rcut2S_[idisk][iSeed]; }
0163 
0164     double rmean(unsigned int iLayer) const { return irmean_[iLayer] * rmaxdisk_ / 4096; }
0165     double rmax(unsigned int iLayer) const { return rmean(iLayer) + drmax(); }
0166     double rmin(unsigned int iLayer) const { return rmean(iLayer) - drmax(); }
0167     double zmean(unsigned int iDisk) const { return izmean_[iDisk] * zlength_ / 2048; }
0168     double zmax(unsigned int iDisk) const { return zmean(iDisk) + dzmax(); }
0169     double zmin(unsigned int iDisk) const { return zmean(iDisk) - dzmax(); }
0170 
0171     double rDSSinner(unsigned int iBin) const {
0172       return rDSSinner_mod_[iBin / 2] + halfstrip_ * ((iBin % 2 == 0) ? -1 : 1);
0173     }
0174     double rDSSouter(unsigned int iBin) const {
0175       return rDSSouter_mod_[iBin / 2] + halfstrip_ * ((iBin % 2 == 0) ? -1 : 1);
0176     }
0177 
0178     unsigned int vmrlutzbits(unsigned int layerdisk) const { return vmrlutzbits_[layerdisk]; }
0179     unsigned int vmrlutrbits(unsigned int layerdisk) const { return vmrlutrbits_[layerdisk]; }
0180 
0181     bool printDebugKF() const { return printDebugKF_; }
0182     bool debugTracklet() const { return debugTracklet_; }
0183     bool writetrace() const { return writetrace_; }
0184 
0185     bool warnNoMem() const { return warnNoMem_; }
0186     bool warnNoDer() const { return warnNoDer_; }
0187 
0188     bool writeMem() const { return writeMem_; }
0189     bool writeTable() const { return writeTable_; }
0190     bool writeConfig() const { return writeConfig_; }
0191 
0192     std::string memPath() const { return memPath_; }
0193     std::string tablePath() const { return tablePath_; }
0194 
0195     bool writeVerilog() const { return writeVerilog_; }
0196     bool writeHLS() const { return writeHLS_; }
0197     bool writeInvTable() const { return writeInvTable_; }
0198     bool writeHLSInvTable() const { return writeHLSInvTable_; }
0199 
0200     unsigned int writememsect() const { return writememsect_; }
0201 
0202     bool enableTripletTables() const { return enableTripletTables_; }
0203     bool writeTripletTables() const { return writeTripletTables_; }
0204 
0205     bool writeoutReal() const { return writeoutReal_; }
0206 
0207     bool bookHistos() const { return bookHistos_; }
0208 
0209     double ptcut() const { return ptcut_; }
0210     double rinvcut() const { return 0.01 * c_ * bfield_ / ptcut_; }  //0.01 to convert to cm-1
0211 
0212     double c() const { return c_; }
0213 
0214     double rinvmax() const { return 0.01 * c_ * bfield_ / ptmin_; }
0215 
0216     int alphashift() const { return alphashift_; }
0217     int nbitsalpha() const { return nbitsalpha_; }
0218     int alphaBitsTable() const { return alphaBitsTable_; }
0219     int nrinvBitsTable() const { return nrinvBitsTable_; }
0220 
0221     unsigned int MEBinsBits() const { return MEBinsBits_; }
0222     unsigned int MEBins() const { return 1u << MEBinsBits_; }
0223     unsigned int MEBinsDisks() const { return MEBinsDisks_; }
0224     unsigned int maxStubsPerBin() const { return maxStubsPerBin_; }
0225 
0226     std::string geomext() const {
0227       std::string geo = extended_ ? "hourglassExtended" : "hourglass";
0228       if (combined_)
0229         geo += "Combined";
0230       return geo;
0231     }
0232 
0233     bool exactderivatives() const { return exactderivatives_; }
0234     bool exactderivativesforfloating() const { return exactderivativesforfloating_; }
0235     bool useapprox() const { return useapprox_; }
0236     bool usephicritapprox() const { return usephicritapprox_; }
0237 
0238     unsigned int minIndStubs() const { return minIndStubs_; }
0239     std::string removalType() const { return removalType_; }
0240     std::string mergeComparison() const { return mergeComparison_; }
0241     bool doKF() const { return doKF_; }
0242     bool doMultipleMatches() const { return doMultipleMatches_; }
0243     bool fakefit() const { return fakefit_; }
0244     void setFakefit(bool fakefit) { fakefit_ = fakefit; }
0245     bool storeTrackBuilderOutput() const { return storeTrackBuilderOutput_; }
0246     void setStoreTrackBuilderOutput(bool storeTrackBuilderOutput) {
0247       storeTrackBuilderOutput_ = storeTrackBuilderOutput;
0248     }
0249     void setRemovalType(std::string removalType) { removalType_ = removalType; }
0250     void setDoMultipleMatches(bool doMultipleMatches) { doMultipleMatches_ = doMultipleMatches; }
0251 
0252     // configurable
0253     unsigned int nHelixPar() const { return nHelixPar_; }
0254     void setNHelixPar(unsigned int nHelixPar) { nHelixPar_ = nHelixPar; }
0255 
0256     bool extended() const { return extended_; }
0257     void setExtended(bool extended) { extended_ = extended; }
0258     bool combined() const { return combined_; }
0259     void setCombined(bool combined) { combined_ = combined; }
0260     bool reduced() const { return reduced_; }
0261     void setReduced(bool reduced) { reduced_ = reduced; }
0262 
0263     double bfield() const { return bfield_; }
0264     void setBfield(double bfield) { bfield_ = bfield; }
0265 
0266     unsigned int nStrips(bool isPSmodule) const { return isPSmodule ? nStrips_PS_ : nStrips_2S_; }
0267     void setNStrips_PS(unsigned int nStrips_PS) { nStrips_PS_ = nStrips_PS; }
0268     void setNStrips_2S(unsigned int nStrips_2S) { nStrips_2S_ = nStrips_2S; }
0269 
0270     double stripPitch(bool isPSmodule) const { return isPSmodule ? stripPitch_PS_ : stripPitch_2S_; }
0271     void setStripPitch_PS(double stripPitch_PS) { stripPitch_PS_ = stripPitch_PS; }
0272     void setStripPitch_2S(double stripPitch_2S) { stripPitch_2S_ = stripPitch_2S; }
0273 
0274     double stripLength(bool isPSmodule) const { return isPSmodule ? stripLength_PS_ : stripLength_2S_; }
0275     void setStripLength_PS(double stripLength_PS) { stripLength_PS_ = stripLength_PS; }
0276     void setStripLength_2S(double stripLength_2S) { stripLength_2S_ = stripLength_2S; }
0277 
0278     std::string skimfile() const { return skimfile_; }
0279     void setSkimfile(std::string skimfile) { skimfile_ = skimfile; }
0280 
0281     unsigned int nbitstrackletindex() const { return nbitstrackletindex_; }
0282     void setNbitstrackletindex(unsigned int nbitstrackletindex) { nbitstrackletindex_ = nbitstrackletindex; }
0283 
0284     unsigned int nbitsitc() const { return nbitsitc_; }
0285     unsigned int nbitsseed() const { return (extended_ ? nbitsseedextended_ : nbitsseed_); }
0286     unsigned int nbitstcindex() const { return nbitsseed() + nbitsitc(); }
0287     void setNbitsitc(unsigned int nbitsitc) { nbitsitc_ = nbitsitc; }
0288     void setNbitsseed(unsigned int nbitsseed) { nbitsseed_ = nbitsseed; }
0289     void setNbitsseedextended(unsigned int nbitsseed) { nbitsseedextended_ = nbitsseed; }
0290 
0291     // Phi width of nonant including overlaps (at widest point).
0292     double dphisectorHG() const {
0293       //These values are used in the DTC emulation code.
0294       double rsectmin = 21.8;
0295       double rsectmax = 112.7;
0296       return 2 * M_PI / N_SECTOR + rinvmax() * std::max(rcrit_ - rsectmin, rsectmax - rcrit_);
0297     }
0298 
0299     double rcrit() const { return rcrit_; }
0300 
0301     double dphisector() const { return 2 * M_PI / N_SECTOR; }
0302 
0303     double phicritmin() const { return 0.5 * dphisectorHG() - M_PI / N_SECTOR; }
0304     double phicritmax() const { return dphisectorHG() - 0.5 * dphisectorHG() + M_PI / N_SECTOR; }
0305 
0306     double phicritminmc() const { return phicritmin() - dphicritmc_; }
0307     double phicritmaxmc() const { return phicritmax() + dphicritmc_; }
0308 
0309     // Stub digitization granularities
0310     double kphi() const { return dphisectorHG() / (1 << nphibitsstub(0)); }
0311     double kphi1() const { return dphisectorHG() / (1 << nphibitsstub(N_LAYER - 1)); }
0312     double kphi(unsigned int layerdisk) const { return dphisectorHG() / (1 << nphibitsstub(layerdisk)); }
0313 
0314     double kz() const { return 2.0 * zlength_ / (1 << nzbitsstub_[0]); }
0315     double kz(unsigned int layerdisk) const { return 2.0 * zlength_ / (1 << nzbitsstub_[layerdisk]); }
0316     double kr() const { return rmaxdisk_ / (1 << nrbitsstub_[N_LAYER]); }
0317     double krbarrel() const { return 2.0 * drmax() / (1 << nrbitsstub_[0]); }
0318 
0319     double maxrinv() const { return maxrinv_; }
0320     double maxd0() const { return maxd0_; }
0321     unsigned int nbitsd0() const { return nbitsd0_; }
0322 
0323     double kd0() const { return 2 * maxd0_ / (1 << nbitsd0_); }
0324 
0325     double rinvcutte() const { return 0.01 * c_ * bfield_ / ptcutte_; }  //0.01 to convert to cm-1
0326 
0327     double rmindiskvm() const { return rmindiskvm_; }
0328     double rmaxdiskvm() const { return rmaxdiskvm_; }
0329 
0330     double rmaxdiskl1overlapvm() const { return rmaxdiskl1overlapvm_; }
0331     double rmindiskl2overlapvm() const { return rmindiskl2overlapvm_; }
0332     double rmindiskl3overlapvm() const { return rmindiskl3overlapvm_; }
0333 
0334     double rPS2S() const { return rPS2S_; }
0335 
0336     double z0cut() const { return z0cut_; }
0337 
0338     double disp_z0cut() const { return disp_z0cut_; }
0339 
0340     unsigned int NLONGVMBITS() const { return NLONGVMBITS_; }
0341     unsigned int NLONGVMBINS() const { return (1 << NLONGVMBITS_); }
0342 
0343     unsigned int ntrackletmax() const { return ((1 << nbitstrackletindex_) - 1); }
0344 
0345     //Bits used to store track parameter in tracklet
0346     int nbitsrinv() const { return nbitsrinv_; }
0347     int nbitsphi0() const { return nbitsphi0_; }
0348     int nbitst() const { return nbitst_; }
0349     int nbitsz0() const { return nbitsz0_; }
0350 
0351     //track and tracklet parameters
0352     int rinv_shift() const { return rinv_shift_; }
0353     int phi0_shift() const { return phi0_shift_; }
0354     int t_shift() const { return t_shift_; }
0355     int z0_shift() const { return z0_shift_; }
0356 
0357     //projections are coarsened from global to stub precision
0358 
0359     //projection to R parameters
0360     int SS_phiL_shift() const { return SS_phiL_shift_; }
0361     int PS_zL_shift() const { return PS_zL_shift_; }
0362 
0363     int SS_phiderL_shift() const { return SS_phiderL_shift_; }
0364     int PS_zderL_shift() const { return PS_zderL_shift_; }
0365     int SS_zderL_shift() const { return SS_zderL_shift_; }
0366 
0367     //projection to Z parameters
0368     int SS_phiD_shift() const { return SS_phiD_shift_; }
0369     int PS_rD_shift() const { return PS_rD_shift_; }
0370 
0371     int SS_phiderD_shift() const { return SS_phiderD_shift_; }
0372     int PS_rderD_shift() const { return PS_rderD_shift_; }
0373 
0374     //numbers needed for matches & fit, unclear what they are.
0375     int phi0bitshift() const { return phi0bitshift_; }
0376     int phiderbitshift() const { return phiderbitshift_; }
0377     int zderbitshift() const { return zderbitshift_; }
0378 
0379     int phiresidbits() const { return phiresidbits_; }
0380     int zresidbits() const { return zresidbits_; }
0381     int rresidbits() const { return rresidbits_; }
0382 
0383     //Trackfit
0384     int fitrinvbitshift() const { return fitrinvbitshift_; }
0385     int fitphi0bitshift() const { return fitphi0bitshift_; }
0386     int fittbitshift() const { return fittbitshift_; }
0387     int fitz0bitshift() const { return fitz0bitshift_; }
0388 
0389     //r correction bits
0390     int rcorrbits() const { return rcorrbits_; }
0391 
0392     int chisqphifactbits() const { return chisqphifactbits_; }
0393     int chisqzfactbits() const { return chisqzfactbits_; }
0394 
0395     // Helix param digisation granularities
0396     //0.02 here is the maximum range in rinv values that can be represented
0397     double krinvpars() const {
0398       int shift = ceil(-log2(0.02 * rmaxdisk_ / ((1 << nbitsrinv_) * dphisectorHG())));
0399       return dphisectorHG() / rmaxdisk_ / (1 << shift);
0400     }
0401     double kphi0pars() const { return 2 * kphi1(); }
0402     double ktpars() const { return maxt_ / (1 << nbitst_); }
0403     double kz0pars() const { return kz(); }
0404     double kd0pars() const { return kd0(); }
0405 
0406     double kphider() const { return kphi() / kr() / 256; }
0407     double kphiderdisk() const { return kphi() / kr() / 128; }
0408     double kzder() const { return 1.0 / 64; }
0409     double krder() const { return 1.0 / 128; }
0410 
0411     //This is a 'historical accident' and should be fixed so that we don't
0412     //have the factor if 2
0413     double krprojshiftdisk() const { return 2 * kr(); }
0414 
0415     double benddecode(int ibend, int layerdisk, bool isPSmodule) const {
0416       if (layerdisk >= N_LAYER && (!isPSmodule))
0417         layerdisk += (N_LAYER - 1);
0418       double bend = benddecode_[layerdisk][ibend];
0419       assert(bend < 99.0);
0420       return bend;
0421     }
0422 
0423     double bendcut(int ibend, int layerdisk, bool isPSmodule) const {
0424       if (layerdisk >= N_LAYER && (!isPSmodule))
0425         layerdisk += N_DISK;
0426       double bendcut = bendcut_[layerdisk][ibend];
0427       if (bendcut <= 0.0)
0428         std::cout << "bendcut : " << layerdisk << " " << ibend << " " << isPSmodule << std::endl;
0429       assert(bendcut > 0.0);
0430       return bendcut;
0431     }
0432 
0433     // DTC in given ATCA crate slot.
0434     std::string slotToDTCname(unsigned int slot) const { return slotToDTCname_.at(slot); }
0435 
0436     // Tracker layers read by given DTC.
0437     const std::vector<int>& dtcLayers(const std::string& dtcName) const {
0438       auto iter = dtclayers_.find(dtcName);
0439       assert(iter != dtclayers_.end());
0440       return iter->second;
0441     }
0442 
0443     double bendcutte(int ibend, int layerdisk, bool isPSmodule) const { return bendcut(ibend, layerdisk, isPSmodule); }
0444 
0445     double bendcutme(int ibend, int layerdisk, bool isPSmodule) const {
0446       //Should understand why larger cut needed in disks
0447       double fact = (layerdisk < N_LAYER) ? 1.0 : 1.8;
0448       return fact * bendcut(ibend, layerdisk, isPSmodule);
0449     }
0450 
0451     //layers/disks used by each seed
0452     std::array<std::array<int, 3>, N_SEED> seedlayers() const { return seedlayers_; }
0453 
0454     //projection layers by seed index. For each seeding index (row) the list of layers that we consider projections to
0455     std::array<std::array<unsigned int, N_LAYER - 2>, N_SEED> projlayers() const { return projlayers_; }
0456 
0457     //projection disks by seed index. For each seeding index (row) the list of diks that we consider projections to
0458     std::array<std::array<unsigned int, N_DISK>, N_SEED> projdisks() const { return projdisks_; }
0459 
0460   private:
0461     std::string fitPatternFile_;
0462     std::string processingModulesFile_;
0463     std::string memoryModulesFile_;
0464     std::string wiresFile_;
0465     std::string tableTEDFile_;
0466     std::string tableTREFile_;
0467 
0468     double rcrit_{55.0};  // critical radius for the hourglass configuration
0469 
0470     double dphicritmc_{0.005};
0471 
0472     //fraction of full r and z range that stubs can be located within layer/disk
0473     double deltarzfract_{32.0};
0474 
0475     double maxt_{32.0};  //range in t that we must cover
0476 
0477     std::array<unsigned int, N_LAYER> irmean_{{851, 1269, 1784, 2347, 2936, 3697}};
0478     std::array<unsigned int, N_DISK> izmean_{{2239, 2645, 3163, 3782, 4523}};
0479 
0480     std::array<unsigned int, N_LAYER + N_DISK> nzbitsstub_{{12, 12, 12, 8, 8, 8, 7, 7, 7, 7, 7}};
0481     std::array<unsigned int, N_LAYER + N_DISK> nphibitsstub_{{14, 14, 14, 17, 17, 17, 14, 14, 14, 14, 14}};
0482     std::array<unsigned int, N_LAYER + N_DISK> nrbitsstub_{{7, 7, 7, 7, 7, 7, 12, 12, 12, 12, 12}};
0483 
0484     unsigned int nrbitsprojderdisk_{9};
0485     unsigned int nbitsphiprojderL123_{10};
0486     unsigned int nbitsphiprojderL456_{10};
0487     unsigned int nbitszprojderL123_{10};
0488     unsigned int nbitszprojderL456_{9};
0489 
0490     unsigned int nbendbitsmedisk_{4};  // Always 4 bits even for PS disk hits, for HLS compatibility
0491 
0492     std::set<unsigned int> useseeding_{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
0493 
0494     std::array<unsigned int, N_LAYER + N_DISK> nbitsallstubs_{{3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2}};
0495     std::array<unsigned int, N_LAYER + N_DISK> nbitsvmme_{{2, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2}};
0496     std::array<std::array<unsigned int, N_SEED>, 3> nbitsvmte_{
0497         {{{2, 2, 2, 2, 2, 2, 1, 1, 2, 2, 3, 2}},  // (3 = #stubs/triplet, only row 1+2 used for tracklet)
0498          {{3, 2, 3, 3, 2, 2, 2, 2, 3, 3, 2, 2}},
0499          {{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 1}}}};
0500 
0501     std::array<std::array<unsigned int, N_SEED>, 3> nbitsvmtecm_{
0502         {{{2, 2, 2, 2, 2, 2, 1, 1, 2, 2, 3, 2}},  // (3 = #stubs/triplet, only row 1+2 used for tracklet)
0503          {{3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 2}},
0504          {{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 1}}}};
0505 
0506     // FIX: There should be 3 PS10G slots & 3 PS (5G) ones.
0507     // (Will change output files used by HLS).
0508     std::vector<std::string> slotToDTCname_{
0509         "PS10G_1", "PS10G_2", "PS10G_3", "PS10G_4", "PS_1", "PS_2", "2S_1", "2S_2", "2S_3", "2S_4", "2S_5", "2S_6"};
0510 
0511     std::map<std::string, std::vector<int> > dtclayers_{{"PS10G_1", {0, 6, 8, 10}},
0512                                                         {"PS10G_2", {0, 7, 9}},
0513                                                         {"PS10G_3", {1, 7}},
0514                                                         {"PS10G_4", {6, 8, 10}},
0515                                                         {"PS_1", {2, 7}},
0516                                                         {"PS_2", {2, 9}},
0517                                                         {"2S_1", {3, 4}},
0518                                                         {"2S_2", {4}},
0519                                                         {"2S_3", {5}},
0520                                                         {"2S_4", {5, 8}},
0521                                                         {"2S_5", {6, 9}},
0522                                                         {"2S_6", {7, 10}}};
0523 
0524     double rmindiskvm_{22.5};
0525     double rmaxdiskvm_{67.0};
0526 
0527     double rmaxdiskl1overlapvm_{45.0};
0528     double rmindiskl2overlapvm_{40.0};
0529     double rmindiskl3overlapvm_{50.0};
0530 
0531     double rPS2S_{60.0};
0532 
0533     double z0cut_{15.0};
0534 
0535     double disp_z0cut_{27.0};
0536 
0537     unsigned int NLONGVMBITS_{3};
0538 
0539     double zlength_{120.0};
0540     double rmaxdisk_{120.0};
0541     double rmindisk_{20.0};
0542 
0543     double half2SmoduleWidth_{4.57};
0544 
0545     double maxrinv_{0.006};
0546     double maxd0_{10.0};
0547 
0548     unsigned int nbitsd0_{13};
0549 
0550     double ptmin_{2.0};  //minumim pt for tracks
0551 
0552     double ptcutte_{1.8};  //Minimum pt in TE
0553 
0554     // VALUE AUTOMATICALLY INCREASED FOR EXTENDED TRACKING BY PYTHON CFG
0555     unsigned int nbitstrackletindex_{7};  //Bits used to store the tracklet index
0556 
0557     unsigned int nbitsitc_{4};           //Bits used to store the iTC, a unique
0558                                          //identifier assigned to each TC within a sector
0559     unsigned int nbitsseed_{3};          //Bits used to store the seed number
0560     unsigned int nbitsseedextended_{4};  //Bits used to store the seed number
0561                                          //in the extended project
0562 
0563     //Bits used to store track parameter in tracklet
0564     int nbitsrinv_{14};
0565     int nbitsphi0_{18};
0566     int nbitst_{14};
0567     int nbitsz0_{10};
0568 
0569     //track and tracklet parameters
0570     int rinv_shift_{-8};  // Krinv = 2^shift * Kphi/Kr
0571     int phi0_shift_{1};   // Kphi0 = 2^shift * Kphi
0572     int t_shift_{-10};    // Kt    = 2^shift * Kz/Kr
0573     int z0_shift_{0};     // Kz0   = 2^shift * kz
0574 
0575     //projections are coarsened from global to stub precision
0576 
0577     //projection to R parameters
0578     int SS_phiL_shift_{0};
0579     int PS_zL_shift_{0};  // z projections have global precision in ITC
0580 
0581     int SS_phiderL_shift_{-5};
0582     int PS_zderL_shift_{-7};  // Kderz = 2^shift * Kz/Kr
0583     int SS_zderL_shift_{-7};
0584 
0585     //projection to Z parameters
0586     int SS_phiD_shift_{3};
0587     int PS_rD_shift_{1};  // a bug?! coarser by a factor of two then stubs??
0588 
0589     int SS_phiderD_shift_{-4};
0590     int PS_rderD_shift_{-6};  //Kderrdisk = 2^shift * Kr/Kz
0591 
0592     //numbers needed for matches & fit, unclear what they are.
0593     int phi0bitshift_{1};
0594     int phiderbitshift_{7};
0595     int zderbitshift_{6};
0596 
0597     int phiresidbits_{12};
0598     int zresidbits_{9};
0599     int rresidbits_{7};
0600 
0601     //Trackfit
0602     int fitrinvbitshift_{9};  //6 OK?
0603     int fitphi0bitshift_{6};  //4 OK?
0604     int fittbitshift_{10};    //4 OK? //lower number gives rounding problems
0605     int fitz0bitshift_{8};    //6 OK?
0606 
0607     //r correction bits
0608     int rcorrbits_{6};
0609 
0610     int chisqphifactbits_{14};
0611     int chisqzfactbits_{14};
0612 
0613     std::array<unsigned int, N_SEED> teunits_{{5, 2, 5, 3, 3, 2, 3, 2, 0, 0, 0, 0}};  //teunits used by seed
0614 
0615     std::array<unsigned int, N_LAYER + N_DISK> vmrlutzbits_{
0616         {7, 7, 7, 7, 7, 7, 3, 3, 3, 3, 3}};  // zbits used by LUT in VMR
0617     std::array<unsigned int, N_LAYER + N_DISK> vmrlutrbits_{
0618         {4, 4, 4, 4, 4, 4, 8, 8, 8, 8, 8}};  // rbits used by LUT in VMR
0619 
0620     std::array<std::array<unsigned int, N_SEED>, 3> nfinephi_{
0621         {{{2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2}},    //inner  (3 = #stubs/triplet, only row 1+2 used for tracklet)
0622          {{3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3}},    //outer
0623          {{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3}}}};  //outermost (triplets only)
0624 
0625     //These are the number of bits used for the VM regions in the TE by seedindex
0626     //FIXME not independed nbitsvmte
0627     std::array<std::array<unsigned int, N_SEED>, 3> nphireg_{
0628         {{{5, 4, 4, 4, 4, 4, 4, 3, 4, 4, 5, 4}},    //inner
0629          {{5, 4, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4}},    //outer
0630          {{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4}}}};  //outermost (triplets only)
0631 
0632     //For combined modules
0633     std::array<std::array<unsigned int, N_SEED>, 3> nphiregcm_{
0634         {{{5, 4, 4, 4, 4, 4, 4, 3, 4, 4, 5, 4}},    //inner
0635          {{5, 5, 5, 5, 5, 5, 5, 5, 4, 4, 4, 4}},    //outer
0636          {{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4}}}};  //outermost (triplets only)
0637 
0638     // These are the number of bits to represent lutval for VM memories in TE
0639     std::array<std::array<unsigned int, N_SEED>, 3> lutwidthtab_{{{{10, 10, 10, 10, 10, 10, 10, 10, 0, 0, 11, 0}},
0640                                                                   {{6, 6, 6, 6, 10, 10, 10, 10, 0, 0, 6, 0}},
0641                                                                   {{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 6}}}};
0642 
0643     // These are the number of bits to represent lutval for VM memories in TED
0644     // TO DO: tune lutwidthtabextended_ values
0645 
0646     /* std::array<std::array<unsigned int, N_SEED>, 3> lutwidthtabextended_{ */
0647     /*     {{{11, 11, 21, 21, 21, 21, 11, 11, 0, 0, 21, 0}}, */
0648     /*      {{6, 6, 6, 6, 10, 10, 10, 10, 0, 0, 6, 0}}, */
0649     /*      {{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6}}}}; */
0650 
0651     std::array<std::array<unsigned int, N_SEED>, 3> lutwidthtabextended_{
0652         {{{21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21}},
0653          {{21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21}},
0654          {{21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21}}}};
0655 
0656     //layers/disks used by each seed
0657     std::array<std::array<int, 3>, N_SEED> seedlayers_{{{{0, 1, -1}},   //L1L2
0658                                                         {{1, 2, -1}},   //1 L2L3
0659                                                         {{2, 3, -1}},   //2 L3L4
0660                                                         {{4, 5, -1}},   //3 L5L6
0661                                                         {{6, 7, -1}},   //4 D1D2
0662                                                         {{8, 9, -1}},   //5 D3D4
0663                                                         {{0, 6, -1}},   //6 L1D1
0664                                                         {{1, 6, -1}},   //7 L2D1
0665                                                         {{2, 3, 1}},    //8 L2L3L4
0666                                                         {{4, 5, 3}},    //9 L4L5L6
0667                                                         {{1, 2, 6}},    //10 L2L3D1
0668                                                         {{6, 7, 1}}}};  //11 D1D2L2
0669 
0670     //Number of tracklet calculators for the prompt seeding combinations
0671     std::array<unsigned int, N_SEED> ntc_{{12, 4, 4, 4, 4, 4, 8, 4, 0, 0, 0, 0}};
0672 
0673     //projection layers by seed index. For each seeding index (row) the list of layers that we consider projections to
0674     std::array<std::array<unsigned int, N_LAYER - 2>, N_SEED> projlayers_{{{{3, 4, 5, 6}},  //0 L1L2
0675                                                                            {{1, 4, 5, 6}},  //1 L2L3
0676                                                                            {{1, 2, 5, 6}},  //2 L3L4
0677                                                                            {{1, 2, 3, 4}},  //3 L5L6
0678                                                                            {{1, 2}},        //4 D1D2
0679                                                                            {{1}},           //5 D3D4
0680                                                                            {{}},            //6 L1D1
0681                                                                            {{1}},           //7 L2D1
0682                                                                            {{1, 5, 6}},     //8 L2L3L4
0683                                                                            {{1, 2, 3}},     //9 L4L5L6
0684                                                                            {{1}},           //10 L2L3D1
0685                                                                            {{1}}}};         //11 D1D2L2
0686 
0687     //projection disks by seed index. For each seeding index (row) the list of diks that we consider projections to
0688     std::array<std::array<unsigned int, N_DISK>, N_SEED> projdisks_{{{{1, 2, 3, 4}},  //0 L1L2
0689                                                                      {{1, 2, 3, 4}},  //1 L2L3
0690                                                                      {{1, 2}},        //2 L3L4
0691                                                                      {{}},            //3 L5L6
0692                                                                      {{3, 4, 5}},     //4 D1D2
0693                                                                      {{1, 2, 5}},     //5 D3D4
0694                                                                      {{2, 3, 4, 5}},  //6 L1D1
0695                                                                      {{2, 3, 4}},     //7 L2D1
0696                                                                      {{1, 2, 3}},     //8 L2L3L4
0697                                                                      {{}},            //9 L4L5L6
0698                                                                      {{2, 3, 4}},     //10 L2L3D1
0699                                                                      {{3, 4}}}};      //11 D1D2L2
0700 
0701     //rphi cuts for layers - the column is the seedindex
0702     std::array<std::array<double, N_SEED>, N_LAYER> rphimatchcut_{
0703         {{{0.0, 0.1, 0.07, 0.08, 0.07, 0.05, 0.0, 0.05, 0.08, 0.15, 0.125, 0.15}},  //Layer 1
0704          {{0.0, 0.0, 0.06, 0.08, 0.05, 0.0, 0.0, 0.0, 0.0, 0.1, 0.0, 0.0}},         //Layer 2
0705          {{0.1, 0.0, 0.0, 0.08, 0.0, 0.0, 0.0, 0.0, 0.0, 0.08, 0.0, 0.0}},          //Layer 3
0706          {{0.19, 0.19, 0.0, 0.05, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0}},         //Layer 4
0707          {{0.4, 0.4, 0.08, 0.0, 0.0, 0.0, 0.0, 0.0, 0.08, 0.0, 0.0, 0.0}},          //Layer 5
0708          {{0.5, 0.0, 0.19, 0.0, 0.0, 0.0, 0.0, 0.0, 0.2, 0.0, 0.0, 0.0}}}};         //Layer 6
0709 
0710     //z cuts for layers - the column is the seedindex
0711     std::array<std::array<double, N_SEED>, N_LAYER> zmatchcut_{
0712         {{{0.0, 0.7, 5.5, 15.0, 1.5, 2.0, 0.0, 1.5, 1.0, 8.0, 1.0, 1.5}},   //Layer 1
0713          {{0.0, 0.0, 3.5, 15.0, 1.25, 0.0, 0.0, 0.0, 0.0, 7.0, 0.0, 0.0}},  //Layer 2
0714          {{0.7, 0.0, 0.0, 9.0, 0.0, 0.0, 0.0, 0.0, 0.0, 5.0, 0.0, 0.0}},    //Layer 3
0715          {{3.0, 3.0, 0.0, 7.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0}},    //Layer 4
0716          {{3.0, 3.0, 8.0, 0.0, 0.0, 0.0, 0.0, 0.0, 4.5, 0.0, 0.0, 0.0}},    //Layer 5
0717          {{4.0, 0.0, 9.5, 0.0, 0.0, 0.0, 0.0, 0.0, 4.5, 0.0, 0.0, 0.0}}}};  //Layer 6
0718 
0719     //rphi cuts for PS modules in disks - the column is the seedindex
0720     std::array<std::array<double, N_SEED>, N_DISK> rphicutPS_{
0721         {{{0.2, 0.2, 0.0, 0.0, 0.0, 0.1, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0}},     //disk 1
0722          {{0.2, 0.2, 0.0, 0.0, 0.0, 0.1, 0.1, 0.1, 0.0, 0.0, 0.15, 0.0}},    //disk 2
0723          {{0.25, 0.2, 0.0, 0.0, 0.15, 0.0, 0.2, 0.15, 0.0, 0.0, 0.0, 0.2}},  //disk 3
0724          {{0.5, 0.2, 0.0, 0.0, 0.2, 0.0, 0.3, 0.5, 0.0, 0.0, 0.0, 0.0}},     //disk 4
0725          {{0.0, 0.0, 0.0, 0.0, 0.25, 0.1, 0.5, 0.0, 0.0, 0.0, 0.0, 0.0}}}};  //disk 5
0726 
0727     //r cuts for PS modules in disks - the column is the seedindex
0728     std::array<std::array<double, N_SEED>, N_DISK> rcutPS_{
0729         {{{0.5, 0.5, 0.0, 0.0, 0.0, 0.5, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0}},    //disk 1
0730          {{0.5, 0.5, 0.0, 0.0, 0.0, 0.5, 0.5, 0.5, 0.0, 0.0, 0.5, 0.0}},    //disk 2
0731          {{0.5, 0.5, 0.0, 0.0, 0.5, 0.0, 0.6, 0.8, 0.0, 0.0, 0.0, 0.4}},    //disk 3
0732          {{0.5, 0.5, 0.0, 0.0, 0.8, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0}},    //disk 4
0733          {{0.0, 0.0, 0.0, 0.0, 1.0, 0.5, 2.0, 0.0, 0.0, 0.0, 0.0, 0.0}}}};  //disk 5
0734 
0735     //rphi cuts for 2S modules in disks = the column is the seedindex
0736     std::array<std::array<double, N_SEED>, N_DISK> rphicut2S_{
0737         {{{0.5, 0.5, 0.8, 0.0, 0.0, 0.0, 0.0, 0.0, 0.2, 0.0, 0.0, 0.0}},    //disk 1
0738          {{0.5, 0.5, 0.8, 0.0, 0.0, 0.0, 0.5, 0.15, 0.3, 0.0, 0.68, 0.0}},  //disk 2
0739          {{0.5, 0.5, 0.0, 0.0, 0.15, 0.0, 0.2, 0.25, 0.0, 0.0, 0.8, 0.1}},  //disk 3
0740          {{0.5, 0.5, 0.0, 0.0, 0.2, 0.0, 0.25, 0.5, 0.0, 0.0, 0.6, 0.4}},   //disk 4
0741          {{0.0, 0.0, 0.0, 0.0, 0.4, 0.2, 0.4, 0.0, 0.0, 0.0, 0.0, 0.8}}}};  //disk 5
0742 
0743     //r cuts for 2S modules in disks -the column is the seedindex
0744     std::array<std::array<double, N_SEED>, N_DISK> rcut2S_{
0745         {{{3.8, 3.8, 3.8, 0.0, 0.0, 0.0, 0.0, 0.0, 3.0, 0.0, 0.0, 0.0}},    //disk 1
0746          {{3.8, 3.8, 3.8, 0.0, 0.0, 0.0, 3.8, 3.4, 3.0, 0.0, 3.0, 0.0}},    //disk 2
0747          {{3.6, 3.8, 0.0, 0.0, 3.6, 0.0, 3.6, 3.8, 0.0, 0.0, 3.8, 3.0}},    //disk 3
0748          {{3.6, 3.8, 0.0, 0.0, 3.6, 0.0, 3.5, 3.8, 0.0, 0.0, 3.0, 3.0}},    //disk 4
0749          {{0.0, 0.0, 0.0, 0.0, 3.6, 3.4, 3.7, 0.0, 0.0, 0.0, 0.0, 3.0}}}};  //disk 5
0750 
0751     //returns the mean bend (in strips at a 1.8 mm separation) for bendcode
0752     std::array<std::array<double, 16>, 16> benddecode_{
0753         {{{0.0, 0.5, 0.7, 0.8, 89.9, -1.0, -0.9, -0.8, 99.9, 99.9, 99.9, 99.9, 99.9, 99.9, 99.9, 99.9}},  //L1 PS
0754          {{0.0, 0.7, 1.0, 1.5, 89.9, -1.5, -1.0, -0.7, 99.9, 99.9, 99.9, 99.9, 99.9, 99.9, 99.9, 99.9}},  //L2 PS
0755          {{0.0, 1.0, 1.8, 2.2, 89.9, -2.2, -1.8, -1.0, 99.9, 99.9, 99.9, 99.9, 99.9, 99.9, 99.9, 99.9}},  //L3 PS
0756          {{0.0, 0.7, 1.2, 1.8, 2.1, 2.6, 3.2, 3.5, 89.9, -3.5, -3.2, -2.6, -2.1, -1.8, -1.2, -0.7}},      //L4 2S
0757          {{0.0, 0.8, 1.2, 1.8, 2.2, 3.2, 4.1, 4.4, 89.9, -4.4, -4.1, -3.2, -2.2, -1.8, -1.2, -0.8}},      //L5 2S
0758          {{0.0, 0.9, 1.8, 2.8, 3.8, 4.5, 5.3, 5.9, 89.9, -5.9, -5.3, -4.5, -3.8, -2.8, -1.8, -0.9}},      //L6 2S
0759          {{0.0, 0.8, 1.2, 2.0, 89.9, -2.0, -1.2, -0.8, 99.9, 99.9, 99.9, 99.9, 99.9, 99.9, 99.9, 99.9}},  //D1 PS
0760          {{0.0, 1.5, 1.8, 2.4, 89.9, -2.4, -1.8, -1.4, 99.9, 99.9, 99.9, 99.9, 99.9, 99.9, 99.9, 99.9}},  //D2 PS
0761          {{0.0, 1.7, 2.0, 2.2, 89.9, -2.2, -2.0, -1.7, 99.9, 99.9, 99.9, 99.9, 99.9, 99.9, 99.9, 99.9}},  //D3 PS
0762          {{0.0, 1.8, 2.0, 2.4, 89.9, -2.4, -2.0, -1.8, 99.9, 99.9, 99.9, 99.9, 99.9, 99.9, 99.9, 99.9}},  //D4 PS
0763          {{0.0, 2.0, 2.2, 2.4, 89.9, -2.4, -2.0, -1.8, 99.9, 99.9, 99.9, 99.9, 99.9, 99.9, 99.9, 99.9}},  //D5 PS
0764          {{0.0, 1.8, 2.3, 2.5, 3.0, 3.9, 4.5, 5.2, 89.9, -5.2, -4.5, -3.9, -3.0, -2.5, -2.3, -1.8}},      //D1 2S
0765          {{0.0, 2.0, 2.4, 2.9, 3.2, 4.0, 4.8, 5.2, 89.9, -5.2, -4.8, -4.0, -3.2, -2.9, -2.4, -2.0}},      //D2 2S
0766          {{0.0, 2.0, 2.4, 2.7, 3.6, 3.7, 4.4, 4.6, 89.9, -4.6, -4.4, -3.7, -3.6, -2.7, -2.4, -2.0}},      //D3 2S
0767          {{0.0, 2.0, 2.6, 3.2, 3.8, 4.0, 4.4, 4.4, 89.9, -4.4, -4.4, -4.0, -3.8, -3.2, -2.6, -2.0}},      //D4 2S
0768          {{0.0, 2.0, 3.2, 3.4, 3.9, 3.9, 4.4, 4.4, 89.9, -4.4, -4.4, -3.9, -3.9, -3.4, -3.2, -2.0}}}};    //D5 2S
0769 
0770     //returns the bend 'cut' (in strips at a 1.8 mm separation) for bendcode
0771     std::array<std::array<double, 16>, 16> bendcut_{
0772         {{{1.5, 1.2, 0.8, 0.8, 99.9, 0.8, 0.8, 1.2, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0}},  //L1 PS
0773          {{1.5, 1.3, 1.0, 1.0, 99.9, 1.0, 1.0, 1.3, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0}},  //L2 PS
0774          {{1.6, 1.5, 1.0, 1.0, 99.9, 1.0, 1.0, 1.5, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0}},  //L3 PS
0775          {{1.6, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 99.9, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0}},          //L4 2S
0776          {{1.6, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 99.9, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0}},          //L5 2S
0777          {{1.6, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 99.9, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0}},          //L6 2S
0778          {{1.8, 1.6, 1.6, 1.6, 99.9, 1.6, 1.6, 1.6, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0}},  //D1 PS
0779          {{1.8, 1.6, 1.6, 1.6, 99.9, 1.6, 1.6, 1.6, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0}},  //D2 PS
0780          {{1.8, 1.6, 1.6, 1.6, 99.9, 1.6, 1.6, 1.6, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0}},  //D3 PS
0781          {{2.2, 1.6, 1.6, 1.6, 99.9, 1.6, 1.6, 1.6, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0}},  //D4 PS
0782          {{2.2, 1.6, 1.6, 1.6, 99.9, 1.6, 1.6, 1.6, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0}},  //D5 PS
0783          {{2.0, 1.2, 1.2, 1.2, 1.5, 1.5, 1.5, 1.5, 99.9, 1.5, 1.5, 1.5, 1.5, 1.2, 1.2, 1.2}},          //D1 2S
0784          {{2.0, 1.2, 1.2, 1.2, 1.5, 1.5, 1.5, 1.5, 99.9, 1.5, 1.5, 1.5, 1.5, 1.2, 1.2, 1.2}},          //D2 2S
0785          {{2.2, 1.5, 1.5, 1.5, 2.0, 2.0, 2.0, 2.0, 99.9, 2.0, 2.0, 2.0, 2.0, 1.5, 1.5, 1.5}},          //D3 2S
0786          {{2.5, 1.5, 1.5, 2.0, 2.0, 2.0, 2.0, 2.0, 99.9, 2.0, 2.0, 2.0, 2.0, 2.0, 1.5, 1.5}},          //D4 2S
0787          {{2.5, 1.5, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 99.9, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 1.5}}}};        //D5 2S
0788 
0789     // Offset to the maximum number of steps in each processing step:
0790     // Set to 0 (default) means standard truncation
0791     // Set to large value, e.g. 10000, to disable truncation
0792     unsigned int maxstepoffset_{0};
0793     // turn off truncation for displaced tracking (not implemented properly for displaced seeding)
0794     unsigned int maxstepoffset_extended_{10000};
0795 
0796     //Number of processing steps for one event (108=18TM*240MHz/40MHz)
0797 
0798     //IR should be set to 108 to match the FW for the summer chain, but ultimately should be at 156
0799     std::unordered_map<std::string, unsigned int> maxstep_{{"IR", 156},  //IR will run at a higher clock speed to handle
0800                                                                          //input links running at 25 Gbits/s
0801                                                            //Set to 108 to match firmware project 240 MHz clock
0802 
0803                                                            {"VMR", 107},
0804                                                            {"TE", 107},
0805                                                            {"TC", 108},
0806                                                            {"PR", 108},
0807                                                            {"ME", 108},
0808                                                            //NOTE: The MC is set to 108, but `mergedepth`
0809                                                            //removes 3 iterations to emulate the delay
0810                                                            //due to the HLS priority encoder
0811                                                            {"MC", 108},
0812                                                            {"TB", 108},
0813                                                            {"MP", 108},
0814                                                            {"TP", 108},
0815                                                            {"TRE", 108}};
0816 
0817     // If set to true this will generate debub printout in text files
0818     std::unordered_map<std::string, bool> writeMonitorData_{{"IL", false},
0819                                                             {"TE", false},
0820                                                             {"CT", false},
0821                                                             {"HitPattern", false},
0822                                                             {"ChiSq", false},
0823                                                             {"Seeds", false},
0824                                                             {"FT", false},
0825                                                             {"Residuals", false},
0826                                                             {"StubBend", false},
0827                                                             {"MC", false},
0828                                                             {"MP", false},
0829                                                             {"ME", false},
0830                                                             {"AP", false},
0831                                                             {"VMP", false},
0832                                                             {"TrackProjOcc", false},
0833                                                             {"TC", false},
0834                                                             {"Pars", false},
0835                                                             {"TPars", false},
0836                                                             {"TPD", false},
0837                                                             {"TrackletPars", false},
0838                                                             {"TED", false},
0839                                                             {"TP", false},
0840                                                             {"TRE", false},
0841                                                             {"VMR", false},
0842                                                             {"StubsLayer", false},
0843                                                             {"StubsLayerSector", false},
0844                                                             {"HitEff", false},
0845                                                             {"MatchEff", false},
0846                                                             {"IFit", false},
0847                                                             {"AS", false},
0848                                                             {"WriteEmptyProj", false}};
0849 
0850     std::array<double, N_DSS_MOD> rDSSinner_mod_{{68.9391, 78.7750, 85.4550, 96.3150, 102.3160}};
0851     std::array<double, N_DSS_MOD> rDSSouter_mod_{{66.4903, 76.7750, 84.4562, 94.9920, 102.3160}};
0852 
0853     //we want the center of the two strip positions in a module, not just the center of a module
0854     double halfstrip_{2.5};
0855 
0856     // various printouts for debugging and warnings
0857     bool printDebugKF_{false};   // if true print lots of debugging statements related to the KF fit
0858     bool debugTracklet_{false};  //Print detailed debug information about tracklet tracking
0859     bool writetrace_{false};     //Print out details about parsing configuration files
0860 
0861     bool warnNoMem_{false};  //If true will print out warnings about missing projection memories
0862     bool warnNoDer_{false};  //If true will print out warnings about missing track fit derivatives
0863 
0864     //--- These used to create files needed by HLS code.
0865     bool writeMem_{false};     //If true will print out content of memories (between algo steps) to files
0866     bool writeTable_{false};   //If true will print out content of LUTs to files
0867     bool writeConfig_{false};  //If true will print out the autogenerated configuration as files
0868     std::string memPath_{"../data/MemPrints/"};  //path for writing memories
0869     std::string tablePath_{"../data/LUTs/"};     //path for writing LUTs
0870 
0871     // Write various lookup tables and autogenerated code (from iMath)
0872     bool writeVerilog_{false};      //Write out auto-generated Verilog mudules used by TCs
0873     bool writeHLS_{false};          //Write out auto-generated HLS mudules used by TCs
0874     bool writeInvTable_{false};     //Write out tables of drinv and invt in tracklet calculator for Verilog module
0875     bool writeHLSInvTable_{false};  //Write out tables of drinv and invt in tracklet calculator for HLS module
0876 
0877     unsigned int writememsect_{3};  //writemem only for this sector (note that the files will have _4 extension)
0878 
0879     bool enableTripletTables_{false};  //Enable the application of the TED and
0880                                        //TRE tables; when this flag is false,
0881                                        //the tables will not be read from disk
0882     bool writeTripletTables_{false};   //Train and write the TED and TRE tables. N.B.: the tables
0883                                        //cannot be applied while they are being trained, i.e.,
0884                                        //this flag effectively turns off the cuts in
0885                                        //TrackletEngineDisplaced and TripletEngine
0886 
0887     bool writeoutReal_{false};
0888 
0889     //set to true/false to turn on/off histogram booking internal to the tracking (class "HistBase/HistImp", does nothing in central CMSSW)
0890     bool bookHistos_{false};
0891 
0892     // pt constants
0893     double ptcut_{1.91};  //Minimum pt cut
0894 
0895     // Parameters for bit sizes
0896     int alphashift_{12};
0897     int nbitsalpha_{4};      //bits used to store alpha
0898     int alphaBitsTable_{2};  //For number of bits in track derivative table
0899     int nrinvBitsTable_{3};  //number of bits for tabulating rinv dependence
0900 
0901     unsigned int MEBinsBits_{3};
0902     unsigned int MEBinsDisks_{8};      //on each side
0903     unsigned int maxStubsPerBin_{15};  //16 causes overflow!
0904 
0905     // Options for chisq fit
0906     bool exactderivatives_{false};
0907     bool exactderivativesforfloating_{true};  //only for the floating point
0908     bool useapprox_{true};          //use approximate postion based on integer representation for floating point
0909     bool usephicritapprox_{false};  //use floating point approximate version of phicrit cut if true
0910 
0911     // Duplicate Removal
0912     // "merge" (hybrid dup removal)
0913     // "ichi" (pairwise, keep track with best ichisq), "nstub" (pairwise, keep track with more stubs)
0914     // "grid" (TMTT-like removal), "" (no removal)
0915     unsigned int minIndStubs_{3};  // not used with merge removal
0916 
0917 #ifdef USEHYBRID
0918     // Duplicate track removal algo. VALUE HERE OVERRIDDEN BY PYTHON CFG
0919     std::string removalType_{"merge"};
0920     // "CompareBest" (recommended) Compares only the best stub in each track for each region (best = smallest phi residual)
0921     // and will merge the two tracks if stubs are shared in three or more regions
0922     // "CompareAll" Compares all stubs in a region, looking for matches, and will merge the two tracks if stubs are shared in three or more regions
0923     std::string mergeComparison_{"CompareBest"};
0924     bool doKF_{true};
0925 #else
0926     std::string removalType_{"ichi"};
0927     std::string mergeComparison_{""};
0928     bool doKF_{false};
0929 #endif
0930 
0931     // VALUE OVERRIDDEN BY PYTHON CFG
0932     // When false, match calculator does not save multiple matches, even when doKF=true.
0933     // This is a temporary fix for compatibilty with HLS. We will need to implement multiple match
0934     // printing in emulator eventually, possibly after CMSSW-integration inspired rewrites
0935     // Use false when generating HLS files, use true when doing full hybrid tracking
0936     bool doMultipleMatches_{true};
0937 
0938     // NEXT 2 VALUES OVERRIDDEN BY PYTHON CFG
0939     // if true, run a dummy fit, producing TTracks directly from output of tracklet pattern reco stage
0940     bool fakefit_{false};
0941     // if true, EDProducer fills additional bit & clock accurate TrackBuilder EDProduct
0942     bool storeTrackBuilderOutput_{false};
0943 
0944     // NEXT 3 VALUES OVERRIDDEN BY PYTHON CFG
0945     unsigned int nHelixPar_{4};  // 4 or 5 param helix fit
0946     bool extended_{false};       // turn on displaced tracking
0947     bool reduced_{false};        // use reduced (Summer Chain) config
0948 
0949     // Use combined TP (TE+TC) and MP (PR+ME+MC) configuration (with prompt tracking)
0950     bool combined_{false};
0951     // N.B. To use combined modules with extended tracking, edit
0952     // Tracklet_cfi.py to refer to *_hourglassExtendedCombined.dat,
0953     // but leave combined_=false.
0954 
0955     std::string skimfile_{""};  //if not empty events will be written out in ascii format to this file
0956 
0957     double bfield_{3.8112};  //B-field in T
0958     double c_{0.299792458};  //speed of light m/ns
0959 
0960     unsigned int nStrips_PS_{960};
0961     unsigned int nStrips_2S_{1016};
0962 
0963     double stripPitch_PS_{0.01};
0964     double stripPitch_2S_{0.009};
0965 
0966     double stripLength_PS_{0.1467};
0967     double stripLength_2S_{5.0250};
0968   };
0969 
0970   constexpr unsigned int N_TILTED_RINGS = 12;  // # of tilted rings per half-layer in TBPS layers
0971   constexpr std::array<unsigned int, N_PSLAYER> N_MOD_PLANK = {{7, 11, 15}};  // # of flat barrel modules/plank in TBPS
0972 
0973   constexpr unsigned int N_TRKLSEED = 7;  // # of tracklet seeds
0974   constexpr unsigned int N_PROJ = 4;      // # of projections (beyond stubs from tracklet seed)
0975 
0976   // chi2 fitting
0977   constexpr unsigned int N_FITPARAM = 4;  // # of fit parameters for chi2 fit
0978   constexpr unsigned int N_FITSTUB = 6;   // max # of number of stubs used
0979 
0980   constexpr unsigned int N_TRACKDER_PTBIN = 4;
0981   constexpr unsigned int N_TRACKDER_INDEX = 1000;
0982 
0983 }  // namespace trklet
0984 
0985 #endif
[ 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!