Back to home page

Project CMSSW displayed by LXR
 
 

    

File indexing completed on 2025-06-03 00:12:22 

0001 //
0002 //  Created by J.Li on 1/23/21.
0003 //
0004 
0005 #include "L1Trigger/TrackFindingTracklet/interface/HitPatternHelper.h"
0006 #include "L1Trigger/TrackFindingTMTT/interface/KFbase.h"
0007 #include "L1Trigger/TrackFindingTMTT/interface/TrackerModule.h"
0008 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0009 
0010 #include <vector>
0011 #include <algorithm>
0012 #include <cmath>
0013 
0014 namespace hph {
0015 
0016   Setup::Setup(const Config& iConfig,
0017                const tt::Setup& setupTT,
0018                const trackerTFP::DataFormats& dataFormats,
0019                const trackerTFP::LayerEncoding& layerEncoding)
0020       : setupTT_(&setupTT),
0021         layerEncoding_(&layerEncoding),
0022         hphDebug_(iConfig.hphDebug_),
0023         useNewKF_(iConfig.useNewKF_),
0024         chosenRofZNewKF_(setupTT_->chosenRofZ()),
0025         layermap_(),
0026         nEtaRegions_(tmtt::KFbase::nEta_ / 2),
0027         nKalmanLayers_(tmtt::KFbase::nKFlayer_) {
0028     if (useNewKF_) {
0029       chosenRofZ_ = chosenRofZNewKF_;
0030       etaRegions_ = etaRegionsNewKF_;
0031     } else {
0032       chosenRofZ_ = iConfig.chosenRofZ_;
0033       etaRegions_ = iConfig.etaRegions_;
0034     }
0035     static constexpr auto layerIds = {1, 2, 3, 4, 5, 6, 11, 12, 13, 14, 15};  //layer ID 11~15 correspond to D1~D5
0036     // Converting tmtt::KFbase::layerMap_ to a format that is acceptatble by HitPatternHelper
0037     for (int i = 0; i < nEtaRegions_; i++) {
0038       for (int j : layerIds) {
0039         int layer;
0040         if (j < 7) {
0041           layer = tmtt::KFbase::layerMap_[i][tmtt::TrackerModule::calcLayerIdReduced(j)].first;
0042         } else {
0043           layer = tmtt::KFbase::layerMap_[i][tmtt::TrackerModule::calcLayerIdReduced(j)].second;
0044         }
0045         if (layer < nKalmanLayers_) {
0046           layermap_[i][layer].push_back(j);
0047         }
0048       }
0049     }
0050   }
0051 
0052   HitPatternHelper::HitPatternHelper(const Setup* setup, int hitpattern, double cot, double z0)
0053       : setup_(setup),
0054         hphDebug_(setup_->hphDebug()),
0055         useNewKF_(setup_->useNewKF()),
0056         etaRegions_(setup_->etaRegions()),
0057         layermap_(setup_->layermap()),
0058         nKalmanLayers_(setup_->nKalmanLayers()),
0059         zT_(z0 + cot * setup_->chosenRofZ()),
0060         layerEncoding_(setup->layerEncoding(zT_)),
0061         numExpLayer_(layerEncoding_.size()),
0062         hitpattern_(hitpattern),
0063         etaSector_(setup_->etaRegion(z0, cot, useNewKF_)),
0064         numMissingLayer_(0),
0065         numMissingPS_(0),
0066         numMissing2S_(0),
0067         numPS_(0),
0068         num2S_(0),
0069         numMissingInterior1_(0),
0070         numMissingInterior2_(0),
0071         binary_(11, 0),  //there are 11 unique layer IDs, as defined in variable "layerIds"
0072         bonusFeatures_() {
0073     setup->analyze(hitpattern, cot, z0, numPS_, num2S_, numMissingPS_, numMissing2S_);
0074     int kf_eta_reg = etaSector_;
0075     if (kf_eta_reg < ((int)etaRegions_.size() - 1) / 2) {
0076       kf_eta_reg = ((int)etaRegions_.size() - 1) / 2 - 1 - kf_eta_reg;
0077     } else {
0078       kf_eta_reg = kf_eta_reg - (int)(etaRegions_.size() - 1) / 2;
0079     }
0080 
0081     int nbits = floor(log2(hitpattern_)) + 1;
0082     int lay_i = 0;
0083     bool seq = false;
0084     for (int i = 0; i < nbits; i++) {
0085       lay_i = ((1 << i) & hitpattern_) >> i;  //0 or 1 in ith bit (right to left)
0086 
0087       if (lay_i && !seq)
0088         seq = true;  //sequence starts when first 1 found
0089       if (!lay_i && seq) {
0090         numMissingInterior1_++;  //This is the same as the "tmp_trk_nlaymiss_interior" calculated in Trackquality.cc
0091       }
0092       if (!lay_i) {
0093         bool realhit = false;
0094         if (layermap_[kf_eta_reg][i].empty())
0095           continue;
0096         for (int j : layermap_[kf_eta_reg][i]) {
0097           int k = findLayer(j);
0098           if (k > 0)
0099             realhit = true;
0100         }
0101         if (realhit)
0102           numMissingInterior2_++;  //This variable doesn't make sense for new KF because it uses the layermap from Old KF
0103       }
0104     }
0105 
0106     if (hphDebug_) {
0107       if (useNewKF_) {
0108         edm::LogVerbatim("TrackTriggerHPH") << "Running with New KF";
0109       } else {
0110         edm::LogVerbatim("TrackTriggerHPH") << "Running with Old KF";
0111       }
0112       edm::LogVerbatim("TrackTriggerHPH") << "======================================================";
0113       edm::LogVerbatim("TrackTriggerHPH")
0114           << "Looking at hitpattern " << std::bitset<7>(hitpattern_) << "; Looping over KF layers:";
0115     }
0116 
0117     if (useNewKF_) {
0118       //New KF uses sensor modules to determine the hitmask already
0119       for (int i = 0; i < numExpLayer_; i++) {
0120         if (hphDebug_) {
0121           edm::LogVerbatim("TrackTriggerHPH") << "--------------------------";
0122           edm::LogVerbatim("TrackTriggerHPH") << "Looking at KF layer " << i;
0123           if (layerEncoding_[i] < 10) {
0124             edm::LogVerbatim("TrackTriggerHPH") << "KF expects L" << layerEncoding_[i];
0125           } else {
0126             edm::LogVerbatim("TrackTriggerHPH") << "KF expects D" << layerEncoding_[i] - 10;
0127           }
0128         }
0129 
0130         if (((1 << i) & hitpattern_) >> i) {
0131           if (hphDebug_) {
0132             edm::LogVerbatim("TrackTriggerHPH") << "Layer found in hitpattern";
0133           }
0134           binary_[reducedId(layerEncoding_[i])] = 1;
0135         } else {
0136           if (hphDebug_) {
0137             edm::LogVerbatim("TrackTriggerHPH") << "Layer missing in hitpattern";
0138           }
0139         }
0140       }
0141 
0142     } else {
0143       //Old KF uses the hard coded layermap to determien hitmask
0144       for (int i = 0; i < nKalmanLayers_; i++) {  //Loop over each digit of hitpattern
0145 
0146         if (hphDebug_) {
0147           edm::LogVerbatim("TrackTriggerHPH") << "--------------------------";
0148           edm::LogVerbatim("TrackTriggerHPH") << "Looking at KF layer " << i;
0149         }
0150 
0151         if (layermap_[kf_eta_reg][i].empty()) {
0152           if (hphDebug_) {
0153             edm::LogVerbatim("TrackTriggerHPH") << "KF does not expect this layer";
0154           }
0155 
0156           continue;
0157         }
0158 
0159         for (int j :
0160              layermap_[kf_eta_reg][i]) {  //Find out which layer the Old KF is dealing with when hitpattern is encoded
0161 
0162           if (hphDebug_) {
0163             if (j < 10) {
0164               edm::LogVerbatim("TrackTriggerHPH") << "KF expects L" << j;
0165             } else {
0166               edm::LogVerbatim("TrackTriggerHPH") << "KF expects D" << j - 10;
0167             }
0168           }
0169 
0170           int k = findLayer(j);
0171           if (k < 0) {
0172             //k<0 means even though layer j is predicted by Old KF, this prediction is rejected because it contradicts
0173             if (hphDebug_) {  //a more accurate prediction made with the help of information from sensor modules
0174               edm::LogVerbatim("TrackTriggerHPH") << "Rejected by sensor modules";
0175             }
0176 
0177             continue;
0178           }
0179 
0180           if (hphDebug_) {
0181             edm::LogVerbatim("TrackTriggerHPH") << "Confirmed by sensor modules";
0182           }
0183           //prediction is accepted
0184           if (((1 << i) & hitpattern_) >> i) {
0185             if (hphDebug_) {
0186               edm::LogVerbatim("TrackTriggerHPH") << "Layer found in hitpattern";
0187             }
0188             binary_[reducedId(j)] = 1;
0189           } else {
0190             if (hphDebug_) {
0191               edm::LogVerbatim("TrackTriggerHPH") << "Layer missing in hitpattern";
0192             }
0193           }
0194         }
0195       }
0196     }
0197 
0198     if (hphDebug_) {
0199       edm::LogVerbatim("TrackTriggerHPH") << "------------------------------";
0200       edm::LogVerbatim("TrackTriggerHPH") << "numPS = " << numPS_ << ", num2S = " << num2S_
0201                                           << ", missingPS = " << numMissingPS_ << ", missing2S = " << numMissing2S_;
0202       edm::LogVerbatim("TrackTriggerHPH") << "======================================================";
0203     }
0204   }
0205 
0206   int Setup::etaRegion(double z0, double cot, bool useNewKF) const {
0207     //Calculating eta sector based on cot and z0
0208     double chosenRofZ;
0209     std::vector<double> etaRegions;
0210     if (useNewKF) {
0211       chosenRofZ = chosenRofZNewKF_;
0212       etaRegions = etaRegionsNewKF_;
0213     } else {
0214       chosenRofZ = chosenRofZ_;
0215       etaRegions = etaRegions_;
0216     }
0217     double kfzRef = z0 + chosenRofZ * cot;
0218     int kf_eta_reg = 0;
0219     for (int iEtaSec = 1; iEtaSec < ((int)etaRegions.size() - 1); iEtaSec++) {  // Doesn't apply eta < 2.4 cut.
0220       double etaMax = etaRegions[iEtaSec];
0221       double zRefMax = chosenRofZ / tan(2. * atan(exp(-etaMax)));
0222       if (kfzRef < zRefMax)
0223         break;
0224       kf_eta_reg = iEtaSec;
0225     }
0226     return kf_eta_reg;
0227   }
0228 
0229   int HitPatternHelper::reducedId(int layerId) {
0230     if (hphDebug_ && (layerId > 15 || layerId < 1)) {
0231       edm::LogVerbatim("TrackTriggerHPH") << "Warning: invalid layer id !";
0232     }
0233     if (layerId <= 6) {
0234       layerId = layerId - 1;
0235       return layerId;
0236     } else {
0237       layerId = layerId - 5;
0238       return layerId;
0239     }
0240   }
0241 
0242   int HitPatternHelper::findLayer(int layerId) {
0243     for (int i = 0; i < (int)layerEncoding_.size(); i++) {
0244       if (layerId == (int)layerEncoding_[i]) {
0245         return i;
0246       }
0247     }
0248     return -1;
0249   }
0250 
0251 }  // namespace hph
[ 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!