File indexing completed on 2025-04-15 22:41:36
0001 #include "FWCore/Framework/interface/MakerMacros.h"
0002 #include "FWCore/Framework/interface/stream/EDProducer.h"
0003 #include "FWCore/Framework/interface/ESHandle.h"
0004 #include "FWCore/Utilities/interface/ESGetToken.h"
0005 #include "FWCore/Framework/interface/ModuleFactory.h"
0006 #include "FWCore/Framework/interface/ESProducer.h"
0007 #include "FWCore/Framework/interface/ESHandle.h"
0008 #include "FWCore/Framework/interface/ESProducts.h"
0009 #include "FWCore/Framework/interface/ConsumesCollector.h"
0010
0011 #include "FWCore/Framework/interface/Event.h"
0012 #include "FWCore/Framework/interface/Frameworkfwd.h"
0013 #include "FWCore/Framework/interface/EventSetup.h"
0014 #include "FWCore/Framework/interface/Run.h"
0015 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0016 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0017
0018 #include "Geometry/Records/interface/MuonGeometryRecord.h"
0019 #include "Geometry/DTGeometry/interface/DTGeometry.h"
0020 #include "Geometry/DTGeometry/interface/DTLayer.h"
0021
0022 #include "L1Trigger/DTTriggerPhase2/interface/MuonPath.h"
0023 #include "L1Trigger/DTTriggerPhase2/interface/constants.h"
0024
0025 #include "L1Trigger/DTTriggerPhase2/interface/MotherGrouping.h"
0026 #include "L1Trigger/DTTriggerPhase2/interface/TrapezoidalGrouping.h"
0027 #include "L1Trigger/DTTriggerPhase2/interface/HoughGrouping.h"
0028 #include "L1Trigger/DTTriggerPhase2/interface/PseudoBayesGrouping.h"
0029 #include "L1Trigger/DTTriggerPhase2/interface/LateralityProvider.h"
0030 #include "L1Trigger/DTTriggerPhase2/interface/LateralityBasicProvider.h"
0031 #include "L1Trigger/DTTriggerPhase2/interface/LateralityCoarsedProvider.h"
0032 #include "L1Trigger/DTTriggerPhase2/interface/MuonPathAnalyzer.h"
0033 #include "L1Trigger/DTTriggerPhase2/interface/MuonPathSLFitter.h"
0034 #include "L1Trigger/DTTriggerPhase2/interface/MuonPathCorFitter.h"
0035 #include "L1Trigger/DTTriggerPhase2/interface/MuonPathAnalyticAnalyzer.h"
0036 #include "L1Trigger/DTTriggerPhase2/interface/MuonPathAnalyzerInChamber.h"
0037 #include "L1Trigger/DTTriggerPhase2/interface/MuonPathAssociator.h"
0038 #include "L1Trigger/DTTriggerPhase2/interface/MuonPathConfirmator.h"
0039 #include "L1Trigger/DTTriggerPhase2/interface/MPFilter.h"
0040 #include "L1Trigger/DTTriggerPhase2/interface/MPSLFilter.h"
0041 #include "L1Trigger/DTTriggerPhase2/interface/MPCorFilter.h"
0042 #include "L1Trigger/DTTriggerPhase2/interface/MPCoincidenceFilter.h"
0043 #include "L1Trigger/DTTriggerPhase2/interface/MPThetaMatching.h"
0044 #include "L1Trigger/DTTriggerPhase2/interface/MPQualityEnhancerFilter.h"
0045 #include "L1Trigger/DTTriggerPhase2/interface/MPRedundantFilter.h"
0046 #include "L1Trigger/DTTriggerPhase2/interface/MPCleanHitsFilter.h"
0047 #include "L1Trigger/DTTriggerPhase2/interface/MPQualityEnhancerFilterBayes.h"
0048 #include "L1Trigger/DTTriggerPhase2/interface/GlobalCoordsObtainer.h"
0049
0050 #include "DataFormats/MuonDetId/interface/DTChamberId.h"
0051 #include "DataFormats/MuonDetId/interface/DTSuperLayerId.h"
0052 #include "DataFormats/MuonDetId/interface/DTLayerId.h"
0053 #include "DataFormats/MuonDetId/interface/DTWireId.h"
0054 #include "DataFormats/DTDigi/interface/DTDigiCollection.h"
0055 #include "DataFormats/L1DTTrackFinder/interface/L1Phase2MuDTPhContainer.h"
0056 #include "DataFormats/L1DTTrackFinder/interface/L1Phase2MuDTPhDigi.h"
0057 #include "DataFormats/L1DTTrackFinder/interface/L1Phase2MuDTExtPhContainer.h"
0058 #include "DataFormats/L1DTTrackFinder/interface/L1Phase2MuDTExtPhDigi.h"
0059 #include "DataFormats/L1DTTrackFinder/interface/L1Phase2MuDTThContainer.h"
0060 #include "DataFormats/L1DTTrackFinder/interface/L1Phase2MuDTThDigi.h"
0061 #include "DataFormats/L1DTTrackFinder/interface/L1Phase2MuDTExtThContainer.h"
0062 #include "DataFormats/L1DTTrackFinder/interface/L1Phase2MuDTExtThDigi.h"
0063
0064
0065 #include "DQM/DTMonitorModule/interface/DTTrigGeomUtils.h"
0066
0067
0068 #include "DataFormats/RPCRecHit/interface/RPCRecHitCollection.h"
0069 #include <DataFormats/MuonDetId/interface/RPCDetId.h>
0070 #include "Geometry/RPCGeometry/interface/RPCGeometry.h"
0071 #include "L1Trigger/DTTriggerPhase2/interface/RPCIntegrator.h"
0072
0073 #include <fstream>
0074 #include <iostream>
0075 #include <queue>
0076 #include <cmath>
0077
0078 using namespace edm;
0079 using namespace std;
0080 using namespace cmsdt;
0081
0082 class DTTrigPhase2Prod : public edm::stream::EDProducer<> {
0083 typedef std::map<DTChamberId, DTDigiCollection, std::less<DTChamberId>> DTDigiMap;
0084 typedef DTDigiMap::iterator DTDigiMap_iterator;
0085 typedef DTDigiMap::const_iterator DTDigiMap_const_iterator;
0086
0087 public:
0088
0089 DTTrigPhase2Prod(const edm::ParameterSet& pset);
0090
0091
0092 ~DTTrigPhase2Prod() override;
0093
0094
0095 void beginRun(edm::Run const& iRun, const edm::EventSetup& iEventSetup) override;
0096
0097
0098 void produce(edm::Event& iEvent, const edm::EventSetup& iEventSetup) override;
0099
0100
0101 void endRun(edm::Run const& iRun, const edm::EventSetup& iEventSetup) override;
0102
0103
0104 int rango(const metaPrimitive& mp) const;
0105 bool outer(const metaPrimitive& mp) const;
0106 bool inner(const metaPrimitive& mp) const;
0107 void printmP(const std::string& ss, const metaPrimitive& mP) const;
0108 void printmP(const metaPrimitive& mP) const;
0109 void printmPC(const std::string& ss, const metaPrimitive& mP) const;
0110 void printmPC(const metaPrimitive& mP) const;
0111 bool hasPosRF(int wh, int sec) const;
0112
0113
0114 MP_QUALITY getMinimumQuality(void);
0115
0116
0117 void setChiSquareThreshold(float ch2Thr);
0118 void setMinimumQuality(MP_QUALITY q);
0119
0120 static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
0121
0122
0123 const DTGeometry* dtGeo_;
0124 edm::ESGetToken<DTGeometry, MuonGeometryRecord> dtGeomH;
0125 std::vector<std::pair<int, MuonPath>> primitives_;
0126
0127 private:
0128
0129 bool my_CCBValid_;
0130
0131
0132 int my_BXoffset_;
0133
0134
0135 bool debug_;
0136 bool dump_;
0137 double dT0_correlate_TP_;
0138 int scenario_;
0139 int df_extended_;
0140 int co_option_;
0141 int co_quality_;
0142 int co_wh2option_;
0143 int th_option_;
0144 int th_quality_;
0145 int max_index_;
0146
0147 bool output_mixer_;
0148 bool output_latpredictor_;
0149 bool output_slfitter_;
0150 bool output_slfilter_;
0151 bool output_confirmed_;
0152 bool output_matcher_;
0153 bool skip_processing_;
0154 bool allow_confirmation_;
0155
0156
0157 edm::EDGetTokenT<DTDigiCollection> dtDigisToken_;
0158 edm::EDGetTokenT<RPCRecHitCollection> rpcRecHitsLabel_;
0159
0160
0161 int algo_;
0162 std::unique_ptr<MotherGrouping> grouping_obj_;
0163 std::unique_ptr<MuonPathAnalyzer> mpathanalyzer_;
0164 std::unique_ptr<LateralityProvider> latprovider_;
0165 std::unique_ptr<MPFilter> mpathqualityenhancer_;
0166 std::unique_ptr<MPFilter> mpathqualityenhancerbayes_;
0167 std::unique_ptr<MPFilter> mpathredundantfilter_;
0168 std::unique_ptr<MPFilter> mpathhitsfilter_;
0169 std::unique_ptr<MuonPathAnalyzer> mpathassociator_;
0170 std::unique_ptr<MuonPathConfirmator> mpathconfirmator_;
0171 std::unique_ptr<MPFilter> mpathcorfilter_;
0172 std::unique_ptr<MPFilter> mpathcoifilter_;
0173 std::unique_ptr<MPFilter> mpaththetamatching_;
0174 std::shared_ptr<GlobalCoordsObtainer> globalcoordsobtainer_;
0175
0176
0177 bool activateBuffer_;
0178 int superCellhalfspacewidth_;
0179 float superCelltimewidth_;
0180 std::vector<DTDigiCollection*> distribDigis(std::queue<std::pair<DTLayerId, DTDigi>>& inQ);
0181 void processDigi(std::queue<std::pair<DTLayerId, DTDigi>>& inQ,
0182 std::vector<std::queue<std::pair<DTLayerId, DTDigi>>*>& vec);
0183
0184
0185 std::unique_ptr<RPCIntegrator> rpc_integrator_;
0186 bool useRPC_;
0187
0188 void assignIndex(std::vector<metaPrimitive>& inMPaths);
0189 void assignIndexPerBX(std::vector<metaPrimitive>& inMPaths);
0190 int assignQualityOrder(const metaPrimitive& mP) const;
0191
0192 const std::unordered_map<int, int> qmap_;
0193 };
0194
0195 namespace {
0196 struct {
0197 bool operator()(std::pair<DTLayerId, DTDigi> a, std::pair<DTLayerId, DTDigi> b) const {
0198 return (a.second.time() < b.second.time());
0199 }
0200 } const DigiTimeOrdering;
0201 }
0202
0203 DTTrigPhase2Prod::DTTrigPhase2Prod(const ParameterSet& pset)
0204 : qmap_({{8, 8}, {7, 7}, {6, 6}, {4, 4}, {3, 3}, {2, 2}, {1, 1}}) {
0205 produces<L1Phase2MuDTPhContainer>();
0206 produces<L1Phase2MuDTThContainer>();
0207 produces<L1Phase2MuDTExtPhContainer>();
0208 produces<L1Phase2MuDTExtThContainer>();
0209
0210 debug_ = pset.getUntrackedParameter<bool>("debug");
0211 dump_ = pset.getUntrackedParameter<bool>("dump");
0212
0213 scenario_ = pset.getParameter<int>("scenario");
0214
0215 df_extended_ = pset.getParameter<int>("df_extended");
0216 co_option_ = pset.getParameter<int>("co_option");
0217 co_quality_ = pset.getParameter<int>("co_quality");
0218 co_wh2option_ = pset.getParameter<int>("co_wh2option");
0219 th_option_ = pset.getParameter<int>("th_option");
0220 th_quality_ = pset.getParameter<int>("th_quality");
0221 max_index_ = pset.getParameter<int>("max_primitives") - 1;
0222
0223 dtDigisToken_ = consumes<DTDigiCollection>(pset.getParameter<edm::InputTag>("digiTag"));
0224
0225 rpcRecHitsLabel_ = consumes<RPCRecHitCollection>(pset.getParameter<edm::InputTag>("rpcRecHits"));
0226 useRPC_ = pset.getParameter<bool>("useRPC");
0227
0228
0229 algo_ = pset.getParameter<int>("algo");
0230
0231
0232
0233 output_mixer_ = pset.getParameter<bool>("output_mixer");
0234 output_latpredictor_ = pset.getParameter<bool>("output_latpredictor");
0235 output_slfitter_ = pset.getParameter<bool>("output_slfitter");
0236 output_slfilter_ = pset.getParameter<bool>("output_slfilter");
0237 output_confirmed_ = pset.getParameter<bool>("output_confirmed");
0238 output_matcher_ = pset.getParameter<bool>("output_matcher");
0239 allow_confirmation_ = pset.getParameter<bool>("allow_confirmation");
0240
0241 edm::ConsumesCollector consumesColl(consumesCollector());
0242 globalcoordsobtainer_ = std::make_shared<GlobalCoordsObtainer>(pset);
0243 globalcoordsobtainer_->generate_luts();
0244
0245 if (algo_ == PseudoBayes) {
0246 grouping_obj_ =
0247 std::make_unique<PseudoBayesGrouping>(pset.getParameter<edm::ParameterSet>("PseudoBayesPattern"), consumesColl);
0248 } else if (algo_ == HoughTrans) {
0249 grouping_obj_ =
0250 std::make_unique<HoughGrouping>(pset.getParameter<edm::ParameterSet>("HoughGrouping"), consumesColl);
0251 } else {
0252 grouping_obj_ = std::make_unique<TrapezoidalGrouping>(pset, consumesColl);
0253 }
0254
0255 if (algo_ == Standard) {
0256 if (debug_)
0257 LogDebug("DTTrigPhase2Prod") << "DTp2:constructor: JM analyzer";
0258 mpathanalyzer_ = std::make_unique<MuonPathSLFitter>(pset, consumesColl, globalcoordsobtainer_);
0259 latprovider_ = std::make_unique<LateralityCoarsedProvider>(pset, consumesColl);
0260 } else {
0261 if (debug_)
0262 LogDebug("DTTrigPhase2Prod") << "DTp2:constructor: Full chamber analyzer";
0263 mpathanalyzer_ = std::make_unique<MuonPathAnalyzerInChamber>(pset, consumesColl, globalcoordsobtainer_);
0264 }
0265
0266
0267 activateBuffer_ = pset.getParameter<bool>("activateBuffer");
0268 superCellhalfspacewidth_ = pset.getParameter<int>("superCellspacewidth") / 2;
0269 superCelltimewidth_ = pset.getParameter<double>("superCelltimewidth");
0270
0271 mpathqualityenhancer_ = std::make_unique<MPSLFilter>(pset);
0272 mpathqualityenhancerbayes_ = std::make_unique<MPQualityEnhancerFilterBayes>(pset);
0273 mpathredundantfilter_ = std::make_unique<MPRedundantFilter>(pset);
0274 mpathhitsfilter_ = std::make_unique<MPCleanHitsFilter>(pset);
0275 mpathconfirmator_ = std::make_unique<MuonPathConfirmator>(pset, consumesColl);
0276 mpathassociator_ = std::make_unique<MuonPathCorFitter>(pset, consumesColl, globalcoordsobtainer_);
0277 mpathcorfilter_ = std::make_unique<MPCorFilter>(pset);
0278 mpathcoifilter_ = std::make_unique<MPCoincidenceFilter>(pset);
0279 mpaththetamatching_ = std::make_unique<MPThetaMatching>(pset);
0280 rpc_integrator_ = std::make_unique<RPCIntegrator>(pset, consumesColl);
0281
0282 dtGeomH = esConsumes<DTGeometry, MuonGeometryRecord, edm::Transition::BeginRun>();
0283 }
0284
0285 DTTrigPhase2Prod::~DTTrigPhase2Prod() {
0286 if (debug_)
0287 LogDebug("DTTrigPhase2Prod") << "DTp2: calling destructor" << std::endl;
0288 }
0289
0290 void DTTrigPhase2Prod::beginRun(edm::Run const& iRun, const edm::EventSetup& iEventSetup) {
0291 if (debug_)
0292 LogDebug("DTTrigPhase2Prod") << "beginRun " << iRun.id().run();
0293 if (debug_)
0294 LogDebug("DTTrigPhase2Prod") << "beginRun: getting DT geometry";
0295
0296 grouping_obj_->initialise(iEventSetup);
0297 mpathanalyzer_->initialise(iEventSetup);
0298 mpathqualityenhancer_->initialise(iEventSetup);
0299 mpathredundantfilter_->initialise(iEventSetup);
0300 mpathqualityenhancerbayes_->initialise(iEventSetup);
0301 mpathhitsfilter_->initialise(iEventSetup);
0302 mpathassociator_->initialise(iEventSetup);
0303 mpathcorfilter_->initialise(iEventSetup);
0304 mpathcoifilter_->initialise(iEventSetup);
0305 mpaththetamatching_->initialise(iEventSetup);
0306
0307 if (auto geom = iEventSetup.getHandle(dtGeomH)) {
0308 dtGeo_ = &(*geom);
0309 }
0310 }
0311
0312 void DTTrigPhase2Prod::produce(Event& iEvent, const EventSetup& iEventSetup) {
0313 if (debug_)
0314 LogDebug("DTTrigPhase2Prod") << "produce";
0315 edm::Handle<DTDigiCollection> dtdigis;
0316 iEvent.getByToken(dtDigisToken_, dtdigis);
0317
0318 if (debug_)
0319 LogDebug("DTTrigPhase2Prod") << "\t Getting the RPC RecHits" << std::endl;
0320 edm::Handle<RPCRecHitCollection> rpcRecHits;
0321 iEvent.getByToken(rpcRecHitsLabel_, rpcRecHits);
0322
0323
0324
0325
0326
0327 DTDigiMap digiMap;
0328 DTDigiCollection::DigiRangeIterator detUnitIt;
0329 for (const auto& detUnitIt : *dtdigis) {
0330 const DTLayerId& layId = detUnitIt.first;
0331 const DTChamberId chambId = layId.superlayerId().chamberId();
0332 const DTDigiCollection::Range& range = detUnitIt.second;
0333 digiMap[chambId].put(range, layId);
0334 }
0335
0336
0337 if (debug_ && activateBuffer_)
0338 LogDebug("DTTrigPhase2Prod") << "produce - Getting and grouping digis per chamber using a buffer and super cells.";
0339 else if (debug_)
0340 LogDebug("DTTrigPhase2Prod") << "produce - Getting and grouping digis per chamber.";
0341
0342 std::map<int, MuonPathPtrs> muonpaths;
0343 for (const auto& ich : dtGeo_->chambers()) {
0344
0345 const DTChamber* chamb = ich;
0346 DTChamberId chid = chamb->id();
0347 DTDigiMap_iterator dmit = digiMap.find(chid);
0348
0349 if (dmit == digiMap.end())
0350 continue;
0351
0352 if (activateBuffer_) {
0353
0354 std::vector<std::pair<DTLayerId, DTDigi>> tmpvec;
0355 tmpvec.clear();
0356
0357 for (const auto& dtLayerIdIt : (*dmit).second) {
0358 for (DTDigiCollection::const_iterator digiIt = (dtLayerIdIt.second).first;
0359 digiIt != (dtLayerIdIt.second).second;
0360 digiIt++) {
0361 tmpvec.emplace_back(dtLayerIdIt.first, *digiIt);
0362 }
0363 }
0364
0365
0366 if (tmpvec.empty())
0367 continue;
0368
0369
0370 std::sort(tmpvec.begin(), tmpvec.end(), DigiTimeOrdering);
0371 std::queue<std::pair<DTLayerId, DTDigi>> timequeue;
0372
0373 for (const auto& elem : tmpvec)
0374 timequeue.emplace(elem);
0375 tmpvec.clear();
0376
0377
0378 std::vector<DTDigiCollection*> superCells;
0379 superCells = distribDigis(timequeue);
0380
0381
0382
0383
0384 while (!superCells.empty()) {
0385 grouping_obj_->run(iEvent, iEventSetup, *(superCells.back()), muonpaths[chid.rawId()]);
0386 superCells.pop_back();
0387 }
0388 } else {
0389 grouping_obj_->run(iEvent, iEventSetup, (*dmit).second, muonpaths[chid.rawId()]);
0390 }
0391 }
0392 digiMap.clear();
0393
0394 if (dump_) {
0395 for (auto& ch_muonpaths : muonpaths) {
0396 for (unsigned int i = 0; i < ch_muonpaths.second.size(); i++) {
0397 stringstream ss;
0398 ss << iEvent.id().event() << " mpath " << i << ": ";
0399 for (int lay = 0; lay < ch_muonpaths.second.at(i)->nprimitives(); lay++)
0400 ss << ch_muonpaths.second.at(i)->primitive(lay)->channelId() << " ";
0401 for (int lay = 0; lay < ch_muonpaths.second.at(i)->nprimitives(); lay++)
0402 ss << ch_muonpaths.second.at(i)->primitive(lay)->tdcTimeStamp() << " ";
0403 for (int lay = 0; lay < ch_muonpaths.second.at(i)->nprimitives(); lay++)
0404 ss << ch_muonpaths.second.at(i)->primitive(lay)->laterality() << " ";
0405 LogInfo("DTTrigPhase2Prod") << ss.str();
0406 }
0407 }
0408 }
0409
0410 std::map<int, std::vector<lat_vector>> lateralities;
0411 if (!output_mixer_) {
0412 for (auto& ch_muonpaths : muonpaths) {
0413 if (algo_ == Standard) {
0414 latprovider_->run(iEvent, iEventSetup, ch_muonpaths.second, lateralities[ch_muonpaths.first]);
0415 }
0416 }
0417 }
0418
0419
0420 std::map<int, MuonPathPtrs> filteredmuonpaths;
0421 for (auto& ch_muonpaths : muonpaths) {
0422 if (algo_ == Standard) {
0423 mpathredundantfilter_->run(iEvent, iEventSetup, ch_muonpaths.second, filteredmuonpaths[ch_muonpaths.first]);
0424 } else {
0425 mpathhitsfilter_->run(iEvent, iEventSetup, ch_muonpaths.second, filteredmuonpaths[ch_muonpaths.first]);
0426 }
0427 }
0428
0429 if (dump_) {
0430 for (auto& ch_filteredmuonpaths : filteredmuonpaths) {
0431 for (unsigned int i = 0; i < ch_filteredmuonpaths.second.size(); i++) {
0432 stringstream ss;
0433 ss << iEvent.id().event() << " filt. mpath " << i << ": ";
0434 for (int lay = 0; lay < ch_filteredmuonpaths.second.at(i)->nprimitives(); lay++)
0435 ss << ch_filteredmuonpaths.second.at(i)->primitive(lay)->channelId() << " ";
0436 for (int lay = 0; lay < ch_filteredmuonpaths.second.at(i)->nprimitives(); lay++)
0437 ss << ch_filteredmuonpaths.second.at(i)->primitive(lay)->tdcTimeStamp() << " ";
0438 LogInfo("DTTrigPhase2Prod") << ss.str();
0439 }
0440 }
0441 }
0442
0443 skip_processing_ = output_mixer_ || output_latpredictor_;
0444
0445
0446
0447
0448
0449 if (debug_) {
0450 for (auto& ch_muonpaths : muonpaths) {
0451 LogDebug("DTTrigPhase2Prod") << "MUON PATHS found: " << ch_muonpaths.second.size() << " ("
0452 << filteredmuonpaths[ch_muonpaths.first].size() << ") in event "
0453 << iEvent.id().event();
0454 }
0455 }
0456 if (debug_)
0457 LogDebug("DTTrigPhase2Prod") << "filling NmetaPrimtives" << std::endl;
0458 std::map<int, std::vector<metaPrimitive>> metaPrimitives;
0459 std::map<int, MuonPathPtrs> outmpaths;
0460 if (algo_ == Standard) {
0461 if (debug_)
0462 LogDebug("DTTrigPhase2Prod") << "Fitting 1SL ";
0463 for (auto& ch_muonpaths : muonpaths) {
0464 if (!output_mixer_ && !output_latpredictor_)
0465 mpathanalyzer_->run(iEvent,
0466 iEventSetup,
0467 ch_muonpaths.second,
0468 lateralities[ch_muonpaths.first],
0469 metaPrimitives[ch_muonpaths.first]);
0470 else if (output_mixer_) {
0471 for (auto& inMPath : ch_muonpaths.second) {
0472 auto sl = inMPath->primitive(0)->superLayerId();
0473 int selected_lay = 1;
0474 if (inMPath->primitive(0)->tdcTimeStamp() != -1)
0475 selected_lay = 0;
0476 int dumLayId = inMPath->primitive(selected_lay)->cameraId();
0477 auto dtDumlayerId = DTLayerId(dumLayId);
0478 DTSuperLayerId MuonPathSLId(dtDumlayerId.wheel(), dtDumlayerId.station(), dtDumlayerId.sector(), sl + 1);
0479 if (sl == 0)
0480 metaPrimitives[ch_muonpaths.first].emplace_back(metaPrimitive({MuonPathSLId.rawId(),
0481 -1,
0482 -1,
0483 -1,
0484 -1,
0485 -1,
0486 -1,
0487 -1,
0488 -1,
0489 -1,
0490 inMPath->primitive(0)->channelId(),
0491 inMPath->primitive(0)->tdcTimeStamp(),
0492 -1,
0493 inMPath->primitive(1)->channelId(),
0494 inMPath->primitive(1)->tdcTimeStamp(),
0495 -1,
0496 inMPath->primitive(2)->channelId(),
0497 inMPath->primitive(2)->tdcTimeStamp(),
0498 -1,
0499 inMPath->primitive(3)->channelId(),
0500 inMPath->primitive(3)->tdcTimeStamp(),
0501 -1,
0502 -1,
0503 -1,
0504 -1,
0505 -1,
0506 -1,
0507 -1,
0508 -1,
0509 -1,
0510 -1,
0511 -1,
0512 -1,
0513 -1,
0514 -1}));
0515 else
0516 metaPrimitives[ch_muonpaths.first].emplace_back(metaPrimitive({MuonPathSLId.rawId(),
0517 -1,
0518 -1,
0519 -1,
0520 -1,
0521 -1,
0522 -1,
0523 -1,
0524 -1,
0525 -1,
0526 -1,
0527 -1,
0528 -1,
0529 -1,
0530 -1,
0531 -1,
0532 -1,
0533 -1,
0534 -1,
0535 -1,
0536 -1,
0537 -1,
0538 inMPath->primitive(0)->channelId(),
0539 inMPath->primitive(0)->tdcTimeStamp(),
0540 -1,
0541 inMPath->primitive(1)->channelId(),
0542 inMPath->primitive(1)->tdcTimeStamp(),
0543 -1,
0544 inMPath->primitive(2)->channelId(),
0545 inMPath->primitive(2)->tdcTimeStamp(),
0546 -1,
0547 inMPath->primitive(3)->channelId(),
0548 inMPath->primitive(3)->tdcTimeStamp(),
0549 -1,
0550 -1}));
0551 }
0552 } else if (output_latpredictor_) {
0553 int imp = -1;
0554 for (auto& inMPath : ch_muonpaths.second) {
0555 imp++;
0556 auto sl = inMPath->primitive(0)->superLayerId();
0557 int selected_lay = 1;
0558 if (inMPath->primitive(0)->tdcTimeStamp() != -1)
0559 selected_lay = 0;
0560 int dumLayId = inMPath->primitive(selected_lay)->cameraId();
0561 auto dtDumlayerId = DTLayerId(dumLayId);
0562 DTSuperLayerId MuonPathSLId(dtDumlayerId.wheel(), dtDumlayerId.station(), dtDumlayerId.sector(), sl + 1);
0563 for (auto& latcomb : lateralities[ch_muonpaths.first][imp]) {
0564 if (sl == 0)
0565 metaPrimitives[ch_muonpaths.first].emplace_back(metaPrimitive({MuonPathSLId.rawId(),
0566 -1,
0567 -1,
0568 -1,
0569 -1,
0570 -1,
0571 -1,
0572 -1,
0573 -1,
0574 -1,
0575 inMPath->primitive(0)->channelId(),
0576 inMPath->primitive(0)->tdcTimeStamp(),
0577 latcomb[0],
0578 inMPath->primitive(1)->channelId(),
0579 inMPath->primitive(1)->tdcTimeStamp(),
0580 latcomb[1],
0581 inMPath->primitive(2)->channelId(),
0582 inMPath->primitive(2)->tdcTimeStamp(),
0583 latcomb[2],
0584 inMPath->primitive(3)->channelId(),
0585 inMPath->primitive(3)->tdcTimeStamp(),
0586 latcomb[3],
0587 -1,
0588 -1,
0589 -1,
0590 -1,
0591 -1,
0592 -1,
0593 -1,
0594 -1,
0595 -1,
0596 -1,
0597 -1,
0598 -1,
0599 -1}));
0600 else
0601 metaPrimitives[ch_muonpaths.first].emplace_back(metaPrimitive({MuonPathSLId.rawId(),
0602 -1,
0603 -1,
0604 -1,
0605 -1,
0606 -1,
0607 -1,
0608 -1,
0609 -1,
0610 -1,
0611 -1,
0612 -1,
0613 -1,
0614 -1,
0615 -1,
0616 -1,
0617 -1,
0618 -1,
0619 -1,
0620 -1,
0621 -1,
0622 -1,
0623 inMPath->primitive(0)->channelId(),
0624 inMPath->primitive(0)->tdcTimeStamp(),
0625 latcomb[0],
0626 inMPath->primitive(1)->channelId(),
0627 inMPath->primitive(1)->tdcTimeStamp(),
0628 latcomb[1],
0629 inMPath->primitive(2)->channelId(),
0630 inMPath->primitive(2)->tdcTimeStamp(),
0631 latcomb[2],
0632 inMPath->primitive(3)->channelId(),
0633 inMPath->primitive(3)->tdcTimeStamp(),
0634 latcomb[3],
0635 -1}));
0636 }
0637 }
0638 }
0639 }
0640 } else {
0641
0642 if (debug_)
0643 LogDebug("DTTrigPhase2Prod") << "Fitting 2SL at once ";
0644 for (auto& ch_muonpaths : muonpaths) {
0645 mpathanalyzer_->run(iEvent, iEventSetup, ch_muonpaths.second, outmpaths[ch_muonpaths.first]);
0646 }
0647 }
0648
0649 skip_processing_ = skip_processing_ || output_slfitter_;
0650
0651 if (dump_) {
0652 for (auto& ch_outmpaths : outmpaths) {
0653 for (unsigned int i = 0; i < ch_outmpaths.second.size(); i++) {
0654 LogInfo("DTTrigPhase2Prod") << iEvent.id().event() << " mp " << i << ": "
0655 << ch_outmpaths.second.at(i)->bxTimeValue() << " "
0656 << ch_outmpaths.second.at(i)->horizPos() << " "
0657 << ch_outmpaths.second.at(i)->tanPhi() << " " << ch_outmpaths.second.at(i)->phi()
0658 << " " << ch_outmpaths.second.at(i)->phiB() << " "
0659 << ch_outmpaths.second.at(i)->quality() << " "
0660 << ch_outmpaths.second.at(i)->chiSquare();
0661 }
0662 }
0663 for (auto& ch_metaPrimitives : metaPrimitives) {
0664 for (unsigned int i = 0; i < ch_metaPrimitives.second.size(); i++) {
0665 stringstream ss;
0666 ss << iEvent.id().event() << " mp " << i << ": ";
0667 printmP(ss.str(), ch_metaPrimitives.second.at(i));
0668 }
0669 }
0670 }
0671
0672 muonpaths.clear();
0673 filteredmuonpaths.clear();
0674
0675
0676
0677
0678
0679 std::map<int, std::vector<metaPrimitive>> confirmedMetaPrimitives;
0680 for (auto& ch_metaPrimitives : metaPrimitives) {
0681 if (!skip_processing_ && allow_confirmation_)
0682 mpathconfirmator_->run(
0683 iEvent, iEventSetup, ch_metaPrimitives.second, dtdigis, confirmedMetaPrimitives[ch_metaPrimitives.first]);
0684 else
0685 for (auto& mp : ch_metaPrimitives.second) {
0686 confirmedMetaPrimitives[ch_metaPrimitives.first].push_back(mp);
0687 }
0688 }
0689
0690 metaPrimitives.clear();
0691 skip_processing_ = skip_processing_ || output_confirmed_;
0692
0693
0694
0695
0696
0697 if (debug_)
0698 LogDebug("DTTrigPhase2Prod") << "declaring new vector for filtered" << std::endl;
0699
0700 std::map<int, std::vector<metaPrimitive>> filteredMetaPrimitives;
0701 if (algo_ == Standard)
0702 for (auto& ch_confirmedMetaPrimitives : confirmedMetaPrimitives) {
0703 if (!skip_processing_)
0704 mpathqualityenhancer_->run(iEvent,
0705 iEventSetup,
0706 ch_confirmedMetaPrimitives.second,
0707 filteredMetaPrimitives[ch_confirmedMetaPrimitives.first]);
0708 else
0709 for (auto& mp : ch_confirmedMetaPrimitives.second) {
0710 filteredMetaPrimitives[ch_confirmedMetaPrimitives.first].push_back(mp);
0711 }
0712 }
0713 if (dump_) {
0714 for (auto& ch_filteredMetaPrimitives : filteredMetaPrimitives) {
0715 for (unsigned int i = 0; i < ch_filteredMetaPrimitives.second.size(); i++) {
0716 stringstream ss;
0717 ss << iEvent.id().event() << " filtered mp " << i << ": ";
0718 printmP(ss.str(), ch_filteredMetaPrimitives.second.at(i));
0719 }
0720 }
0721 }
0722
0723 skip_processing_ = skip_processing_ || output_slfilter_;
0724 confirmedMetaPrimitives.clear();
0725
0726 if (debug_)
0727 for (auto& ch_filteredMetaPrimitives : filteredMetaPrimitives) {
0728 LogDebug("DTTrigPhase2Prod") << "DTp2 in event:" << iEvent.id().event() << " we found "
0729 << ch_filteredMetaPrimitives.second.size() << " filteredMetaPrimitives (superlayer)"
0730 << std::endl;
0731 }
0732 if (debug_)
0733 LogDebug("DTTrigPhase2Prod") << "filteredMetaPrimitives: starting correlations" << std::endl;
0734
0735
0736
0737
0738
0739 std::map<int, std::vector<metaPrimitive>> correlatedMetaPrimitives;
0740 if (algo_ == Standard) {
0741 for (auto& ch_filteredMetaPrimitives : filteredMetaPrimitives) {
0742 if (!skip_processing_)
0743 mpathassociator_->run(iEvent,
0744 iEventSetup,
0745 ch_filteredMetaPrimitives.second,
0746 correlatedMetaPrimitives[ch_filteredMetaPrimitives.first]);
0747 else
0748 for (auto& mp : ch_filteredMetaPrimitives.second) {
0749 correlatedMetaPrimitives[ch_filteredMetaPrimitives.first].push_back(mp);
0750 }
0751 }
0752 } else {
0753 for (auto& ch_outmpaths : outmpaths) {
0754 for (const auto& muonpath : ch_outmpaths.second) {
0755 correlatedMetaPrimitives[ch_outmpaths.first].emplace_back(muonpath->rawId(),
0756 (double)muonpath->bxTimeValue(),
0757 muonpath->horizPos(),
0758 muonpath->tanPhi(),
0759 muonpath->phi(),
0760 muonpath->phiB(),
0761 muonpath->phi_cmssw(),
0762 muonpath->phiB_cmssw(),
0763 muonpath->chiSquare(),
0764 (int)muonpath->quality(),
0765 muonpath->primitive(0)->channelId(),
0766 muonpath->primitive(0)->tdcTimeStamp(),
0767 muonpath->primitive(0)->laterality(),
0768 muonpath->primitive(1)->channelId(),
0769 muonpath->primitive(1)->tdcTimeStamp(),
0770 muonpath->primitive(1)->laterality(),
0771 muonpath->primitive(2)->channelId(),
0772 muonpath->primitive(2)->tdcTimeStamp(),
0773 muonpath->primitive(2)->laterality(),
0774 muonpath->primitive(3)->channelId(),
0775 muonpath->primitive(3)->tdcTimeStamp(),
0776 muonpath->primitive(3)->laterality(),
0777 muonpath->primitive(4)->channelId(),
0778 muonpath->primitive(4)->tdcTimeStamp(),
0779 muonpath->primitive(4)->laterality(),
0780 muonpath->primitive(5)->channelId(),
0781 muonpath->primitive(5)->tdcTimeStamp(),
0782 muonpath->primitive(5)->laterality(),
0783 muonpath->primitive(6)->channelId(),
0784 muonpath->primitive(6)->tdcTimeStamp(),
0785 muonpath->primitive(6)->laterality(),
0786 muonpath->primitive(7)->channelId(),
0787 muonpath->primitive(7)->tdcTimeStamp(),
0788 muonpath->primitive(7)->laterality());
0789 }
0790 }
0791 }
0792
0793 skip_processing_ = skip_processing_ || output_matcher_;
0794
0795 if (debug_)
0796 for (auto& ch_correlatedMetaPrimitives : correlatedMetaPrimitives) {
0797 LogDebug("DTTrigPhase2Prod") << "DTp2 in event:" << iEvent.id().event() << " we found "
0798 << ch_correlatedMetaPrimitives.second.size() << " correlatedMetPrimitives (chamber)";
0799 }
0800 if (dump_) {
0801 for (auto& ch_correlatedMetaPrimitives : correlatedMetaPrimitives) {
0802 LogDebug("DTTrigPhase2Prod") << "DTp2 in event:" << iEvent.id().event() << " we found "
0803 << ch_correlatedMetaPrimitives.second.size() << " correlatedMetPrimitives (chamber)";
0804 }
0805 for (auto& ch_correlatedMetaPrimitives : correlatedMetaPrimitives) {
0806 for (unsigned int i = 0; i < ch_correlatedMetaPrimitives.second.size(); i++) {
0807 stringstream ss;
0808 ss << iEvent.id().event() << " correlated mp " << i << ": ";
0809 printmPC(ss.str(), ch_correlatedMetaPrimitives.second.at(i));
0810 }
0811 }
0812 }
0813
0814
0815 std::map<int, std::vector<metaPrimitive>> filtCorrelatedMetaPrimitives;
0816 if (algo_ == Standard) {
0817 for (auto& ch_filteredMetaPrimitives : filteredMetaPrimitives) {
0818 if (!skip_processing_)
0819 mpathcorfilter_->run(iEvent,
0820 iEventSetup,
0821 ch_filteredMetaPrimitives.second,
0822 correlatedMetaPrimitives[ch_filteredMetaPrimitives.first],
0823 filtCorrelatedMetaPrimitives[ch_filteredMetaPrimitives.first]);
0824 else {
0825 for (auto& mp : ch_filteredMetaPrimitives.second) {
0826 filtCorrelatedMetaPrimitives[ch_filteredMetaPrimitives.first].push_back(mp);
0827 }
0828 if (output_matcher_)
0829 for (auto& mp : correlatedMetaPrimitives[ch_filteredMetaPrimitives.first]) {
0830 filtCorrelatedMetaPrimitives[ch_filteredMetaPrimitives.first].push_back(mp);
0831 }
0832 }
0833 }
0834 }
0835
0836 correlatedMetaPrimitives.clear();
0837 filteredMetaPrimitives.clear();
0838
0839
0840
0841 std::vector<metaPrimitive> allMetaPrimitives;
0842 for (auto& ch_filtcorrelatedMetaPrimitives : filtCorrelatedMetaPrimitives) {
0843 for (const auto& metaPrimitiveIt : ch_filtcorrelatedMetaPrimitives.second) {
0844 allMetaPrimitives.push_back(metaPrimitiveIt);
0845 }
0846 }
0847
0848 std::map<int, std::vector<metaPrimitive>> coMetaPrimitives;
0849 if (algo_ == Standard) {
0850 for (auto& ch_filtcorrelatedMetaPrimitives : filtCorrelatedMetaPrimitives) {
0851 if (!skip_processing_)
0852 mpathcoifilter_->run(iEvent,
0853 iEventSetup,
0854 allMetaPrimitives,
0855 filtCorrelatedMetaPrimitives[ch_filtcorrelatedMetaPrimitives.first],
0856 coMetaPrimitives[ch_filtcorrelatedMetaPrimitives.first]);
0857 else {
0858 for (auto& mp : ch_filtcorrelatedMetaPrimitives.second) {
0859 coMetaPrimitives[ch_filtcorrelatedMetaPrimitives.first].push_back(mp);
0860 }
0861 }
0862 }
0863 }
0864
0865 allMetaPrimitives.clear();
0866
0867
0868 std::map<int, std::vector<metaPrimitive>> thMatchedMetaPrimitives;
0869 if (algo_ == Standard) {
0870 for (auto& ch_filtcoMetaPrimitives : coMetaPrimitives) {
0871 if (!skip_processing_)
0872 mpaththetamatching_->run(iEvent,
0873 iEventSetup,
0874 coMetaPrimitives[ch_filtcoMetaPrimitives.first],
0875 thMatchedMetaPrimitives[ch_filtcoMetaPrimitives.first]);
0876 else {
0877 for (auto& mp : ch_filtcoMetaPrimitives.second) {
0878 thMatchedMetaPrimitives[ch_filtcoMetaPrimitives.first].push_back(mp);
0879 }
0880 }
0881 }
0882 }
0883
0884
0885
0886 double shift_back = 0;
0887 if (scenario_ == MC)
0888 shift_back = 400;
0889 else if (scenario_ == DATA)
0890 shift_back = 0;
0891 else if (scenario_ == SLICE_TEST)
0892 shift_back = 400;
0893
0894
0895 if (useRPC_) {
0896 rpc_integrator_->initialise(iEventSetup, shift_back);
0897 rpc_integrator_->prepareMetaPrimitives(rpcRecHits);
0898 for (auto& ch_thMatchedMetaPrimitives : thMatchedMetaPrimitives) {
0899 rpc_integrator_->matchWithDTAndUseRPCTime(ch_thMatchedMetaPrimitives.second);
0900 }
0901 rpc_integrator_->makeRPCOnlySegments();
0902 rpc_integrator_->storeRPCSingleHits();
0903 rpc_integrator_->removeRPCHitsUsed();
0904 }
0905
0906
0907 vector<L1Phase2MuDTPhDigi> outP2Ph;
0908 vector<L1Phase2MuDTExtPhDigi> outExtP2Ph;
0909 vector<L1Phase2MuDTThDigi> outP2Th;
0910 vector<L1Phase2MuDTExtThDigi> outExtP2Th;
0911
0912
0913 if (!skip_processing_)
0914 for (auto& ch_thMatchedMetaPrimitives : thMatchedMetaPrimitives) {
0915 assignIndex(ch_thMatchedMetaPrimitives.second);
0916 }
0917
0918 for (auto& ch_thMatchedMetaPrimitives : thMatchedMetaPrimitives) {
0919 for (const auto& metaPrimitiveIt : ch_thMatchedMetaPrimitives.second) {
0920 DTChamberId chId(metaPrimitiveIt.rawId);
0921 DTSuperLayerId slId(metaPrimitiveIt.rawId);
0922 if (debug_)
0923 LogDebug("DTTrigPhase2Prod") << "looping in final vector: SuperLayerId" << chId << " x=" << metaPrimitiveIt.x
0924 << " quality=" << metaPrimitiveIt.quality
0925 << " BX=" << round(metaPrimitiveIt.t0 / 25.) << " index=" << metaPrimitiveIt.index;
0926
0927 int sectorTP = chId.sector();
0928
0929
0930 if (sectorTP == 13)
0931 sectorTP = 4;
0932 if (sectorTP == 14)
0933 sectorTP = 10;
0934 sectorTP = sectorTP - 1;
0935 int sl = 0;
0936 if (metaPrimitiveIt.quality < LOWLOWQ || metaPrimitiveIt.quality == CHIGHQ) {
0937 if (inner(metaPrimitiveIt))
0938 sl = 1;
0939 else
0940 sl = 3;
0941 }
0942
0943 float tp_t0 =
0944 (metaPrimitiveIt.t0 - shift_back * LHC_CLK_FREQ) * ((float)TIME_TO_TDC_COUNTS / (float)LHC_CLK_FREQ);
0945
0946 if (debug_)
0947 LogDebug("DTTrigPhase2Prod") << "pushing back phase-2 dataformat carlo-federica dataformat";
0948
0949 if (slId.superLayer() != 2) {
0950 if (df_extended_ == 1 || df_extended_ == 2) {
0951 int pathWireId[8] = {metaPrimitiveIt.wi1,
0952 metaPrimitiveIt.wi2,
0953 metaPrimitiveIt.wi3,
0954 metaPrimitiveIt.wi4,
0955 metaPrimitiveIt.wi5,
0956 metaPrimitiveIt.wi6,
0957 metaPrimitiveIt.wi7,
0958 metaPrimitiveIt.wi8};
0959
0960 int pathTDC[8] = {max((int)round(metaPrimitiveIt.tdc1 - shift_back * LHC_CLK_FREQ), -1),
0961 max((int)round(metaPrimitiveIt.tdc2 - shift_back * LHC_CLK_FREQ), -1),
0962 max((int)round(metaPrimitiveIt.tdc3 - shift_back * LHC_CLK_FREQ), -1),
0963 max((int)round(metaPrimitiveIt.tdc4 - shift_back * LHC_CLK_FREQ), -1),
0964 max((int)round(metaPrimitiveIt.tdc5 - shift_back * LHC_CLK_FREQ), -1),
0965 max((int)round(metaPrimitiveIt.tdc6 - shift_back * LHC_CLK_FREQ), -1),
0966 max((int)round(metaPrimitiveIt.tdc7 - shift_back * LHC_CLK_FREQ), -1),
0967 max((int)round(metaPrimitiveIt.tdc8 - shift_back * LHC_CLK_FREQ), -1)};
0968
0969 int pathLat[8] = {metaPrimitiveIt.lat1,
0970 metaPrimitiveIt.lat2,
0971 metaPrimitiveIt.lat3,
0972 metaPrimitiveIt.lat4,
0973 metaPrimitiveIt.lat5,
0974 metaPrimitiveIt.lat6,
0975 metaPrimitiveIt.lat7,
0976 metaPrimitiveIt.lat8};
0977
0978
0979 outExtP2Ph.emplace_back(
0980 L1Phase2MuDTExtPhDigi((int)round(metaPrimitiveIt.t0 / (float)LHC_CLK_FREQ) - shift_back,
0981 chId.wheel(),
0982 sectorTP,
0983 chId.station(),
0984 sl,
0985 (int)round(metaPrimitiveIt.phi * PHIRES_CONV),
0986 (int)round(metaPrimitiveIt.phiB * PHIBRES_CONV),
0987 metaPrimitiveIt.quality,
0988 metaPrimitiveIt.index,
0989 tp_t0,
0990 (int)round(metaPrimitiveIt.chi2 * CHI2RES_CONV),
0991 (int)round(metaPrimitiveIt.x * 1000),
0992 (int)round(metaPrimitiveIt.tanPhi * 1000),
0993 (int)round(metaPrimitiveIt.phi_cmssw * PHIRES_CONV),
0994 (int)round(metaPrimitiveIt.phiB_cmssw * PHIBRES_CONV),
0995 metaPrimitiveIt.rpcFlag,
0996 pathWireId,
0997 pathTDC,
0998 pathLat));
0999 }
1000 if (df_extended_ == 0 || df_extended_ == 2) {
1001
1002 outP2Ph.push_back(L1Phase2MuDTPhDigi(
1003 (int)round(metaPrimitiveIt.t0 / (float)LHC_CLK_FREQ) - shift_back,
1004 chId.wheel(),
1005 sectorTP,
1006 chId.station(),
1007 sl,
1008 (int)round(metaPrimitiveIt.phi * PHIRES_CONV),
1009 (int)round(metaPrimitiveIt.phiB * PHIBRES_CONV),
1010 metaPrimitiveIt.quality,
1011 metaPrimitiveIt.index,
1012 tp_t0,
1013 (int)round(metaPrimitiveIt.chi2 * CHI2RES_CONV),
1014 metaPrimitiveIt.rpcFlag
1015 ));
1016 }
1017 } else {
1018 if (df_extended_ == 1 || df_extended_ == 2) {
1019 int pathWireId[4] = {metaPrimitiveIt.wi1, metaPrimitiveIt.wi2, metaPrimitiveIt.wi3, metaPrimitiveIt.wi4};
1020
1021 int pathTDC[4] = {max((int)round(metaPrimitiveIt.tdc1 - shift_back * LHC_CLK_FREQ), -1),
1022 max((int)round(metaPrimitiveIt.tdc2 - shift_back * LHC_CLK_FREQ), -1),
1023 max((int)round(metaPrimitiveIt.tdc3 - shift_back * LHC_CLK_FREQ), -1),
1024 max((int)round(metaPrimitiveIt.tdc4 - shift_back * LHC_CLK_FREQ), -1)};
1025
1026 int pathLat[4] = {metaPrimitiveIt.lat1, metaPrimitiveIt.lat2, metaPrimitiveIt.lat3, metaPrimitiveIt.lat4};
1027
1028
1029 outExtP2Th.emplace_back(
1030 L1Phase2MuDTExtThDigi((int)round(metaPrimitiveIt.t0 / (float)LHC_CLK_FREQ) - shift_back,
1031 chId.wheel(),
1032 sectorTP,
1033 chId.station(),
1034 (int)round(metaPrimitiveIt.phi * ZRES_CONV),
1035 (int)round(metaPrimitiveIt.phiB * KRES_CONV),
1036 metaPrimitiveIt.quality,
1037 metaPrimitiveIt.index,
1038 tp_t0,
1039 (int)round(metaPrimitiveIt.chi2 * CHI2RES_CONV),
1040 (int)round(metaPrimitiveIt.x * 1000),
1041 (int)round(metaPrimitiveIt.phi_cmssw * ZRES_CONV),
1042 (int)round(metaPrimitiveIt.phiB_cmssw * KRES_CONV),
1043 metaPrimitiveIt.rpcFlag,
1044 pathWireId,
1045 pathTDC,
1046 pathLat));
1047 }
1048 if (df_extended_ == 0 || df_extended_ == 2) {
1049
1050 outP2Th.push_back(L1Phase2MuDTThDigi(
1051 (int)round(metaPrimitiveIt.t0 / (float)LHC_CLK_FREQ) - shift_back,
1052 chId.wheel(),
1053 sectorTP,
1054 chId.station(),
1055 (int)round(metaPrimitiveIt.phi * ZRES_CONV),
1056 (int)round(metaPrimitiveIt.phiB * KRES_CONV),
1057 metaPrimitiveIt.quality,
1058 metaPrimitiveIt.index,
1059 tp_t0,
1060 (int)round(metaPrimitiveIt.chi2 * CHI2RES_CONV),
1061 metaPrimitiveIt.rpcFlag
1062 ));
1063 }
1064 }
1065 }
1066 }
1067
1068
1069 if (useRPC_) {
1070 for (auto rpc_dt_digi = rpc_integrator_->rpcRecHits_translated_.begin();
1071 rpc_dt_digi != rpc_integrator_->rpcRecHits_translated_.end();
1072 rpc_dt_digi++) {
1073 outP2Ph.push_back(*rpc_dt_digi);
1074 }
1075 }
1076
1077
1078 if (df_extended_ == 1 || df_extended_ == 2) {
1079 std::unique_ptr<L1Phase2MuDTExtPhContainer> resultExtP2Ph(new L1Phase2MuDTExtPhContainer);
1080 resultExtP2Ph->setContainer(outExtP2Ph);
1081 iEvent.put(std::move(resultExtP2Ph));
1082 }
1083 if (df_extended_ == 0 || df_extended_ == 2) {
1084 std::unique_ptr<L1Phase2MuDTPhContainer> resultP2Ph(new L1Phase2MuDTPhContainer);
1085 resultP2Ph->setContainer(outP2Ph);
1086 iEvent.put(std::move(resultP2Ph));
1087 }
1088 outExtP2Ph.clear();
1089 outExtP2Ph.erase(outExtP2Ph.begin(), outExtP2Ph.end());
1090 outP2Ph.clear();
1091 outP2Ph.erase(outP2Ph.begin(), outP2Ph.end());
1092
1093
1094 if (df_extended_ == 1 || df_extended_ == 2) {
1095 std::unique_ptr<L1Phase2MuDTExtThContainer> resultExtP2Th(new L1Phase2MuDTExtThContainer);
1096 resultExtP2Th->setContainer(outExtP2Th);
1097 iEvent.put(std::move(resultExtP2Th));
1098 }
1099 if (df_extended_ == 0 || df_extended_ == 2) {
1100 std::unique_ptr<L1Phase2MuDTThContainer> resultP2Th(new L1Phase2MuDTThContainer);
1101 resultP2Th->setContainer(outP2Th);
1102 iEvent.put(std::move(resultP2Th));
1103 }
1104 outExtP2Th.clear();
1105 outExtP2Th.erase(outExtP2Th.begin(), outExtP2Th.end());
1106 outP2Th.clear();
1107 outP2Th.erase(outP2Th.begin(), outP2Th.end());
1108 }
1109
1110 void DTTrigPhase2Prod::endRun(edm::Run const& iRun, const edm::EventSetup& iEventSetup) {
1111 grouping_obj_->finish();
1112 mpathanalyzer_->finish();
1113 mpathqualityenhancer_->finish();
1114 mpathqualityenhancerbayes_->finish();
1115 mpathredundantfilter_->finish();
1116 mpathhitsfilter_->finish();
1117 mpathassociator_->finish();
1118 rpc_integrator_->finish();
1119 };
1120
1121 bool DTTrigPhase2Prod::outer(const metaPrimitive& mp) const {
1122 int counter = (mp.wi5 != -1) + (mp.wi6 != -1) + (mp.wi7 != -1) + (mp.wi8 != -1);
1123 return (counter > 2);
1124 }
1125
1126 bool DTTrigPhase2Prod::inner(const metaPrimitive& mp) const {
1127 int counter = (mp.wi1 != -1) + (mp.wi2 != -1) + (mp.wi3 != -1) + (mp.wi4 != -1);
1128 return (counter > 2);
1129 }
1130
1131 bool DTTrigPhase2Prod::hasPosRF(int wh, int sec) const { return wh > 0 || (wh == 0 && sec % 4 > 1); }
1132
1133 void DTTrigPhase2Prod::printmP(const string& ss, const metaPrimitive& mP) const {
1134 DTSuperLayerId slId(mP.rawId);
1135 LogInfo("DTTrigPhase2Prod") << ss << (int)slId << "\t " << setw(2) << left << mP.wi1 << " " << setw(2) << left
1136 << mP.wi2 << " " << setw(2) << left << mP.wi3 << " " << setw(2) << left << mP.wi4 << " "
1137 << setw(5) << left << mP.tdc1 << " " << setw(5) << left << mP.tdc2 << " " << setw(5)
1138 << left << mP.tdc3 << " " << setw(5) << left << mP.tdc4 << " " << setw(10) << right
1139 << mP.x << " " << setw(9) << left << mP.tanPhi << " " << setw(5) << left << mP.t0 << " "
1140 << setw(13) << left << mP.chi2 << " r:" << rango(mP);
1141 }
1142
1143 void DTTrigPhase2Prod::printmP(const metaPrimitive& mP) const {
1144 DTSuperLayerId slId(mP.rawId);
1145 LogInfo("DTTrigPhase2Prod") << (int)slId << "\t " << setw(2) << left << mP.wi1 << " " << setw(2) << left << mP.wi2
1146 << " " << setw(2) << left << mP.wi3 << " " << setw(2) << left << mP.wi4 << " " << setw(5)
1147 << left << mP.tdc1 << " " << setw(5) << left << mP.tdc2 << " " << setw(5) << left
1148 << mP.tdc3 << " " << setw(5) << left << mP.tdc4 << " " << setw(10) << right << mP.x << " "
1149 << setw(9) << left << mP.tanPhi << " " << setw(5) << left << mP.t0 << " " << setw(13)
1150 << left << mP.chi2 << " r:" << rango(mP) << std::endl;
1151 }
1152
1153 void DTTrigPhase2Prod::printmPC(const string& ss, const metaPrimitive& mP) const {
1154 DTChamberId ChId(mP.rawId);
1155 LogInfo("DTTrigPhase2Prod") << ss << (int)ChId << "\t " << setw(2) << left << mP.wi1 << " " << setw(2) << left
1156 << mP.wi2 << " " << setw(2) << left << mP.wi3 << " " << setw(2) << left << mP.wi4 << " "
1157 << setw(2) << left << mP.wi5 << " " << setw(2) << left << mP.wi6 << " " << setw(2) << left
1158 << mP.wi7 << " " << setw(2) << left << mP.wi8 << " " << setw(5) << left << mP.tdc1 << " "
1159 << setw(5) << left << mP.tdc2 << " " << setw(5) << left << mP.tdc3 << " " << setw(5)
1160 << left << mP.tdc4 << " " << setw(5) << left << mP.tdc5 << " " << setw(5) << left
1161 << mP.tdc6 << " " << setw(5) << left << mP.tdc7 << " " << setw(5) << left << mP.tdc8
1162 << " " << setw(2) << left << mP.lat1 << " " << setw(2) << left << mP.lat2 << " "
1163 << setw(2) << left << mP.lat3 << " " << setw(2) << left << mP.lat4 << " " << setw(2)
1164 << left << mP.lat5 << " " << setw(2) << left << mP.lat6 << " " << setw(2) << left
1165 << mP.lat7 << " " << setw(2) << left << mP.lat8 << " " << setw(10) << right << mP.x << " "
1166 << setw(9) << left << mP.tanPhi << " " << setw(5) << left << mP.t0 << " " << setw(13)
1167 << left << mP.chi2 << " r:" << rango(mP);
1168 }
1169
1170 void DTTrigPhase2Prod::printmPC(const metaPrimitive& mP) const {
1171 DTChamberId ChId(mP.rawId);
1172 LogInfo("DTTrigPhase2Prod") << (int)ChId << "\t " << setw(2) << left << mP.wi1 << " " << setw(2) << left << mP.wi2
1173 << " " << setw(2) << left << mP.wi3 << " " << setw(2) << left << mP.wi4 << " " << setw(2)
1174 << left << mP.wi5 << " " << setw(2) << left << mP.wi6 << " " << setw(2) << left << mP.wi7
1175 << " " << setw(2) << left << mP.wi8 << " " << setw(5) << left << mP.tdc1 << " " << setw(5)
1176 << left << mP.tdc2 << " " << setw(5) << left << mP.tdc3 << " " << setw(5) << left
1177 << mP.tdc4 << " " << setw(5) << left << mP.tdc5 << " " << setw(5) << left << mP.tdc6
1178 << " " << setw(5) << left << mP.tdc7 << " " << setw(5) << left << mP.tdc8 << " "
1179 << setw(2) << left << mP.lat1 << " " << setw(2) << left << mP.lat2 << " " << setw(2)
1180 << left << mP.lat3 << " " << setw(2) << left << mP.lat4 << " " << setw(2) << left
1181 << mP.lat5 << " " << setw(2) << left << mP.lat6 << " " << setw(2) << left << mP.lat7
1182 << " " << setw(2) << left << mP.lat8 << " " << setw(10) << right << mP.x << " " << setw(9)
1183 << left << mP.tanPhi << " " << setw(5) << left << mP.t0 << " " << setw(13) << left
1184 << mP.chi2 << " r:" << rango(mP) << std::endl;
1185 }
1186
1187 int DTTrigPhase2Prod::rango(const metaPrimitive& mp) const {
1188 if (mp.quality == 1 or mp.quality == 2)
1189 return 3;
1190 if (mp.quality == 3 or mp.quality == 4)
1191 return 4;
1192 return mp.quality;
1193 }
1194
1195 void DTTrigPhase2Prod::assignIndex(std::vector<metaPrimitive>& inMPaths) {
1196 std::map<int, std::vector<metaPrimitive>> primsPerBX;
1197 for (const auto& metaPrimitive : inMPaths) {
1198 int BX = round(metaPrimitive.t0 / 25.);
1199 primsPerBX[BX].push_back(metaPrimitive);
1200 }
1201 inMPaths.clear();
1202 for (auto& prims : primsPerBX) {
1203 assignIndexPerBX(prims.second);
1204 for (const auto& primitive : prims.second)
1205 if (primitive.index <= max_index_)
1206 inMPaths.push_back(primitive);
1207 }
1208 }
1209
1210 void DTTrigPhase2Prod::assignIndexPerBX(std::vector<metaPrimitive>& inMPaths) {
1211
1212 uint32_t rawId = -1;
1213 int numP = -1;
1214 for (auto& metaPrimitiveIt : inMPaths) {
1215 numP++;
1216 rawId = metaPrimitiveIt.rawId;
1217 int iOrder = assignQualityOrder(metaPrimitiveIt);
1218 int inf = 0;
1219 int numP2 = -1;
1220 for (auto& metaPrimitiveItN : inMPaths) {
1221 int nOrder = assignQualityOrder(metaPrimitiveItN);
1222 numP2++;
1223 if (rawId != metaPrimitiveItN.rawId)
1224 continue;
1225 if (numP2 == numP) {
1226 metaPrimitiveIt.index = inf;
1227 break;
1228 } else if (iOrder < nOrder) {
1229 inf++;
1230 } else if (iOrder > nOrder) {
1231 metaPrimitiveItN.index++;
1232 } else if (iOrder == nOrder) {
1233 if (std::abs(metaPrimitiveIt.phiB) >= std::abs(metaPrimitiveItN.phiB)) {
1234 inf++;
1235 } else if (std::abs(metaPrimitiveIt.phiB) < std::abs(metaPrimitiveItN.phiB)) {
1236 metaPrimitiveItN.index++;
1237 }
1238 }
1239 }
1240 }
1241 }
1242
1243 int DTTrigPhase2Prod::assignQualityOrder(const metaPrimitive& mP) const {
1244 if (mP.quality > 8 || mP.quality < 1)
1245 return -1;
1246
1247 return qmap_.find(mP.quality)->second;
1248 }
1249
1250 std::vector<DTDigiCollection*> DTTrigPhase2Prod::distribDigis(std::queue<std::pair<DTLayerId, DTDigi>>& inQ) {
1251 std::vector<std::queue<std::pair<DTLayerId, DTDigi>>*> tmpVector;
1252 tmpVector.clear();
1253 std::vector<DTDigiCollection*> collVector;
1254 collVector.clear();
1255 while (!inQ.empty()) {
1256 processDigi(inQ, tmpVector);
1257 }
1258 for (auto& sQ : tmpVector) {
1259 DTDigiCollection tmpColl;
1260 while (!sQ->empty()) {
1261 tmpColl.insertDigi((sQ->front().first), (sQ->front().second));
1262 sQ->pop();
1263 }
1264 collVector.push_back(&tmpColl);
1265 }
1266 return collVector;
1267 }
1268
1269 void DTTrigPhase2Prod::processDigi(std::queue<std::pair<DTLayerId, DTDigi>>& inQ,
1270 std::vector<std::queue<std::pair<DTLayerId, DTDigi>>*>& vec) {
1271 bool classified = false;
1272 if (!vec.empty()) {
1273 for (auto& sC : vec) {
1274 if ((sC->front().second.time() + superCelltimewidth_) > inQ.front().second.time()) {
1275
1276 if (TMath::Abs(sC->front().second.wire() - inQ.front().second.wire()) <= superCellhalfspacewidth_) {
1277
1278 sC->push(std::move(inQ.front()));
1279 classified = true;
1280 }
1281 }
1282 }
1283 }
1284 if (classified) {
1285 inQ.pop();
1286 return;
1287 }
1288
1289 std::queue<std::pair<DTLayerId, DTDigi>> newQueue;
1290
1291 std::pair<DTLayerId, DTDigi> tmpPair;
1292 tmpPair = std::move(inQ.front());
1293 newQueue.push(tmpPair);
1294 inQ.pop();
1295
1296 vec.push_back(&newQueue);
1297 }
1298
1299 void DTTrigPhase2Prod::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
1300
1301 edm::ParameterSetDescription desc;
1302 desc.add<edm::InputTag>("digiTag", edm::InputTag("CalibratedDigis"));
1303 desc.add<int>("timeTolerance", 999999);
1304 desc.add<double>("tanPhiTh", 1.0);
1305 desc.add<double>("tanPhiThw2max", 1.3);
1306 desc.add<double>("tanPhiThw2min", 0.5);
1307 desc.add<double>("tanPhiThw1max", 0.9);
1308 desc.add<double>("tanPhiThw1min", 0.2);
1309 desc.add<double>("tanPhiThw0", 0.5);
1310 desc.add<double>("chi2Th", 0.01);
1311 desc.add<double>("chi2corTh", 0.1);
1312 desc.add<bool>("useBX_correlation", false);
1313 desc.add<double>("dT0_correlate_TP", 25.0);
1314 desc.add<int>("dBX_correlate_TP", 0);
1315 desc.add<double>("dTanPsi_correlate_TP", 99999.0);
1316 desc.add<bool>("clean_chi2_correlation", true);
1317 desc.add<bool>("allow_confirmation", true);
1318 desc.add<double>("minx_match_2digis", 1.0);
1319 desc.add<int>("scenario", 0);
1320 desc.add<int>("df_extended", 0);
1321 desc.add<int>("co_option", 0);
1322 desc.add<int>("co_quality", 0);
1323 desc.add<int>("co_wh2option", 0);
1324 desc.add<int>("th_option", 0);
1325 desc.add<int>("th_quality", 0);
1326 desc.add<int>("max_primitives", 999);
1327 desc.add<bool>("output_mixer", false);
1328 desc.add<bool>("output_latpredictor", false);
1329 desc.add<bool>("output_slfitter", false);
1330 desc.add<bool>("output_slfilter", false);
1331 desc.add<bool>("output_confirmed", false);
1332 desc.add<bool>("output_matcher", false);
1333 desc.add<edm::FileInPath>("ttrig_filename", edm::FileInPath("L1Trigger/DTTriggerPhase2/data/wire_rawId_ttrig.txt"));
1334 desc.add<edm::FileInPath>("z_filename", edm::FileInPath("L1Trigger/DTTriggerPhase2/data/wire_rawId_z.txt"));
1335 desc.add<edm::FileInPath>("lut_sl1", edm::FileInPath("L1Trigger/DTTriggerPhase2/data/fitterlut_sl1.dat"));
1336 desc.add<edm::FileInPath>("lut_sl2", edm::FileInPath("L1Trigger/DTTriggerPhase2/data/fitterlut_slx.dat"));
1337 desc.add<edm::FileInPath>("lut_sl3", edm::FileInPath("L1Trigger/DTTriggerPhase2/data/fitterlut_sl3.dat"));
1338 desc.add<edm::FileInPath>("lut_2sl", edm::FileInPath("L1Trigger/DTTriggerPhase2/data/fitterlut_2sl.dat"));
1339 desc.add<edm::FileInPath>("shift_filename", edm::FileInPath("L1Trigger/DTTriggerPhase2/data/wire_rawId_x.txt"));
1340 desc.add<edm::FileInPath>("maxdrift_filename",
1341 edm::FileInPath("L1Trigger/DTTriggerPhase2/data/drift_time_per_chamber.txt"));
1342 desc.add<edm::FileInPath>("shift_theta_filename", edm::FileInPath("L1Trigger/DTTriggerPhase2/data/theta_shift.txt"));
1343 desc.add<edm::FileInPath>("global_coords_filename",
1344 edm::FileInPath("L1Trigger/DTTriggerPhase2/data/global_coord_perp_x_phi0.txt"));
1345 desc.add<edm::FileInPath>("laterality_filename",
1346 edm::FileInPath("L1Trigger/DTTriggerPhase2/data/lat_predictions.dat"));
1347 desc.add<int>("algo", 0);
1348 desc.add<int>("minHits4Fit", 3);
1349 desc.add<bool>("splitPathPerSL", true);
1350 desc.addUntracked<bool>("debug", false);
1351 desc.addUntracked<bool>("dump", false);
1352 desc.add<edm::InputTag>("rpcRecHits", edm::InputTag("rpcRecHits"));
1353 desc.add<bool>("useRPC", false);
1354 desc.add<int>("bx_window", 1);
1355 desc.add<double>("phi_window", 50.0);
1356 desc.add<int>("max_quality_to_overwrite_t0", 9);
1357 desc.add<bool>("storeAllRPCHits", false);
1358 desc.add<bool>("activateBuffer", false);
1359 desc.add<double>("superCelltimewidth", 400);
1360 desc.add<int>("superCellspacewidth", 20);
1361 {
1362 edm::ParameterSetDescription psd0;
1363 psd0.addUntracked<bool>("debug", false);
1364 psd0.add<double>("angletan", 0.3);
1365 psd0.add<double>("anglebinwidth", 1.0);
1366 psd0.add<double>("posbinwidth", 2.1);
1367 psd0.add<double>("maxdeltaAngDeg", 10);
1368 psd0.add<double>("maxdeltaPos", 10);
1369 psd0.add<int>("UpperNumber", 6);
1370 psd0.add<int>("LowerNumber", 4);
1371 psd0.add<double>("MaxDistanceToWire", 0.03);
1372 psd0.add<int>("minNLayerHits", 6);
1373 psd0.add<int>("minSingleSLHitsMax", 3);
1374 psd0.add<int>("minSingleSLHitsMin", 3);
1375 psd0.add<bool>("allowUncorrelatedPatterns", true);
1376 psd0.add<int>("minUncorrelatedHits", 3);
1377 desc.add<edm::ParameterSetDescription>("HoughGrouping", psd0);
1378 }
1379 {
1380 edm::ParameterSetDescription psd0;
1381 psd0.add<edm::FileInPath>(
1382 "pattern_filename", edm::FileInPath("L1Trigger/DTTriggerPhase2/data/PseudoBayesPatterns_uncorrelated_v0.root"));
1383 psd0.addUntracked<bool>("debug", false);
1384 psd0.add<int>("minNLayerHits", 3);
1385 psd0.add<int>("minSingleSLHitsMax", 3);
1386 psd0.add<int>("minSingleSLHitsMin", 0);
1387 psd0.add<int>("allowedVariance", 1);
1388 psd0.add<bool>("allowDuplicates", false);
1389 psd0.add<bool>("setLateralities", true);
1390 psd0.add<bool>("allowUncorrelatedPatterns", true);
1391 psd0.add<int>("minUncorrelatedHits", 3);
1392 psd0.add<bool>("saveOnPlace", true);
1393 psd0.add<int>("maxPathsPerMatch", 256);
1394 desc.add<edm::ParameterSetDescription>("PseudoBayesPattern", psd0);
1395 }
1396 descriptions.add("dtTriggerPhase2PrimitiveDigis", desc);
1397 }
1398
1399 DEFINE_FWK_MODULE(DTTrigPhase2Prod);