File indexing completed on 2023-03-17 11:19:23
0001
0002
0003
0004
0005
0006 #include <RecoLocalMuon/GEMCSCSegment/plugins/GEMCSCSegmentBuilder.h>
0007 #include <RecoLocalMuon/GEMCSCSegment/plugins/GEMCSCSegmentAlgorithm.h>
0008 #include <RecoLocalMuon/GEMCSCSegment/plugins/GEMCSCSegmentBuilderPluginFactory.h>
0009
0010 #include "FWCore/Framework/interface/ESHandle.h"
0011 #include <FWCore/Utilities/interface/Exception.h>
0012 #include <FWCore/MessageLogger/interface/MessageLogger.h>
0013
0014 #include <Geometry/Records/interface/MuonGeometryRecord.h>
0015 #include <Geometry/CSCGeometry/interface/CSCChamberSpecs.h>
0016 #include <Geometry/CSCGeometry/interface/CSCLayer.h>
0017 #include <Geometry/CSCGeometry/interface/CSCGeometry.h>
0018 #include <Geometry/GEMGeometry/interface/GEMGeometry.h>
0019 #include <Geometry/GEMGeometry/interface/GEMEtaPartition.h>
0020
0021 #include <DataFormats/MuonDetId/interface/CSCDetId.h>
0022 #include <DataFormats/MuonDetId/interface/GEMDetId.h>
0023 #include <DataFormats/CSCRecHit/interface/CSCRecHit2D.h>
0024 #include <DataFormats/CSCRecHit/interface/CSCRangeMapAccessor.h>
0025 #include <DataFormats/CSCRecHit/interface/CSCRecHit2DCollection.h>
0026 #include <DataFormats/CSCRecHit/interface/CSCSegmentCollection.h>
0027 #include <DataFormats/CSCRecHit/interface/CSCSegment.h>
0028 #include <DataFormats/GEMRecHit/interface/GEMRecHit.h>
0029 #include <DataFormats/GEMRecHit/interface/GEMRecHitCollection.h>
0030
0031 GEMCSCSegmentBuilder::GEMCSCSegmentBuilder(const edm::ParameterSet& ps)
0032 :
0033 algo{GEMCSCSegmentBuilderPluginFactory::get()->create(ps.getParameter<std::string>("algo_name"),
0034 ps.getParameter<edm::ParameterSet>("algo_psets"))},
0035 enable_me21_ge21_(ps.getParameter<bool>("enableME21GE21")),
0036 gemgeom_{nullptr},
0037 cscgeom_{nullptr} {
0038 edm::LogVerbatim("GEMCSCSegmentBuilder")
0039 << "[GEMCSCSegmentBuilder :: ctor] algorithm name: " << ps.getParameter<std::string>("algo_name");
0040 }
0041
0042 GEMCSCSegmentBuilder::~GEMCSCSegmentBuilder() {
0043 edm::LogVerbatim("GEMCSCSegmentBuilder") << "[GEMCSCSegmentBuilder :: dstor] deleted the algorithm";
0044 }
0045
0046 void GEMCSCSegmentBuilder::LinkGEMRollsToCSCChamberIndex(const GEMGeometry* gemGeo, const CSCGeometry* cscGeo) {
0047 for (TrackingGeometry::DetContainer::const_iterator it = gemGeo->dets().begin(); it < gemGeo->dets().end(); it++) {
0048 const GEMChamber* ch = dynamic_cast<const GEMChamber*>(*it);
0049 if (ch != nullptr) {
0050 std::vector<const GEMEtaPartition*> rolls = (ch->etaPartitions());
0051 for (std::vector<const GEMEtaPartition*>::const_iterator r = rolls.begin(); r != rolls.end(); ++r) {
0052 GEMDetId gemId = (*r)->id();
0053 int region = gemId.region();
0054 if (region != 0) {
0055 int station = gemId.station();
0056 int ring = gemId.ring();
0057 int gemchamber = gemId.chamber();
0058 int layer = gemId.layer();
0059 int cscring = ring;
0060 int cscstation = station;
0061 int cscchamber = gemchamber;
0062 int csclayer = layer;
0063 CSCStationIndex ind(region, cscstation, cscring, cscchamber, csclayer);
0064 std::set<GEMDetId> myrolls;
0065 if (rollstoreCSC.find(ind) != rollstoreCSC.end())
0066 myrolls = rollstoreCSC[ind];
0067 myrolls.insert(gemId);
0068 rollstoreCSC[ind] = myrolls;
0069 }
0070 }
0071 }
0072 }
0073
0074
0075 for (std::map<CSCStationIndex, std::set<GEMDetId> >::iterator mapit = rollstoreCSC.begin();
0076 mapit != rollstoreCSC.end();
0077 ++mapit) {
0078 CSCStationIndex map_first = mapit->first;
0079 std::set<GEMDetId> map_secnd = mapit->second;
0080 std::stringstream GEMRollsstream;
0081 for (std::set<GEMDetId>::iterator setit = map_secnd.begin(); setit != map_secnd.end(); ++setit) {
0082 GEMRollsstream << "[ GEM Id: " << setit->rawId() << " (" << *setit << ")"
0083 << "]," << std::endl;
0084 }
0085 std::string GEMRollsstr = GEMRollsstream.str();
0086 edm::LogVerbatim("GEMCSCSegmentBuilder")
0087 << "[GEMCSCSegmentBuilder :: LinkGEMRollsToCSCChamberIndex] CSC Station Index :: [" << map_first.region() << ","
0088 << map_first.station() << "," << map_first.ring() << "," << map_first.chamber() << "," << map_first.layer()
0089 << "] has following GEM rolls: [" << GEMRollsstr << "]" << std::endl;
0090 }
0091 }
0092
0093 void GEMCSCSegmentBuilder::build(const GEMRecHitCollection* recHits,
0094 const CSCSegmentCollection* cscsegments,
0095 GEMCSCSegmentCollection& oc) {
0096 edm::LogVerbatim("GEMCSCSegmentBuilder")
0097 << "[GEMCSCSegmentBuilder :: build] Total number of GEM rechits in this event: " << recHits->size()
0098 << " Total number of CSC segments in this event: " << cscsegments->size();
0099
0100
0101
0102
0103
0104
0105
0106
0107
0108
0109
0110
0111
0112
0113
0114 std::map<uint32_t, std::vector<GEMRecHit*> > gemRecHitCollection;
0115 std::map<uint32_t, std::vector<const CSCSegment*> > cscSegColl_GEM11;
0116 std::map<uint32_t, std::vector<const CSCSegment*> > cscSegColl_noGEM;
0117
0118
0119
0120 for (CSCSegmentCollection::const_iterator segmIt = cscsegments->begin(); segmIt != cscsegments->end(); ++segmIt) {
0121 CSCDetId CSCId = segmIt->cscDetId();
0122
0123
0124
0125
0126
0127 if (CSCId.isME11() or (enable_me21_ge21_ and CSCId.isME21())) {
0128 edm::LogVerbatim("GEMCSCSegmentBuilder")
0129 << "[GEMCSCSegmentBuilder :: build] Found " << (CSCId.isME11() ? "ME1/1" : "ME2/1") << " Segment in "
0130 << CSCId.rawId() << " = " << CSCId;
0131
0132
0133
0134
0135
0136
0137
0138 std::vector<const CSCSegment*> cscsegmentvector = cscSegColl_GEM11[CSCId.rawId()];
0139 cscsegmentvector.push_back(segmIt->clone());
0140 cscSegColl_GEM11[CSCId.rawId()] = cscsegmentvector;
0141
0142
0143
0144 std::vector<GEMDetId> rollsForThisCSCvector;
0145
0146 int cscRegion = CSCId.endcap();
0147 int cscStation = CSCId.station();
0148 int cscChamber = CSCId.chamber();
0149 int gemRegion = 1;
0150 if (cscRegion == 2)
0151 gemRegion = -1;
0152 int gemRing = 1;
0153 int gemStation = cscStation;
0154
0155 int gem1stChamber = cscChamber;
0156
0157
0158
0159
0160
0161
0162 std::vector<CSCStationIndex> indexvector;
0163 CSCStationIndex index11(gemRegion, gemStation, gemRing, gem1stChamber, 1);
0164 CSCStationIndex index12(gemRegion, gemStation, gemRing, gem1stChamber, 2);
0165 indexvector.push_back(index11);
0166 indexvector.push_back(index12);
0167
0168
0169
0170
0171
0172
0173 for (std::vector<CSCStationIndex>::iterator cscIndexIt = indexvector.begin(); cscIndexIt != indexvector.end();
0174 ++cscIndexIt) {
0175 std::set<GEMDetId> rollsForThisCSC = rollstoreCSC[*cscIndexIt];
0176 for (std::set<GEMDetId>::iterator gemRollIt = rollsForThisCSC.begin(); gemRollIt != rollsForThisCSC.end();
0177 ++gemRollIt) {
0178 rollsForThisCSCvector.push_back(*gemRollIt);
0179 }
0180 }
0181
0182
0183
0184 edm::LogVerbatim("GEMCSCSegmentBuilder")
0185 << "[GEMCSCSegmentBuilder :: build] Start Loop over GEM Rechits :: size = " << recHits->size()
0186 << " and number of Rolls for this CSC :: " << rollsForThisCSCvector.size() << std::endl;
0187 for (GEMRecHitCollection::const_iterator hitIt = recHits->begin(); hitIt != recHits->end(); ++hitIt) {
0188 GEMDetId gemIdfromHit = hitIt->gemId();
0189
0190
0191 for (std::vector<GEMDetId>::iterator gemRollIt = rollsForThisCSCvector.begin();
0192 gemRollIt != rollsForThisCSCvector.end();
0193 ++gemRollIt) {
0194 GEMDetId gemIdfromCSC(*gemRollIt);
0195 if (gemIdfromHit == GEMDetId(gemIdfromCSC.rawId())) {
0196
0197
0198
0199
0200 std::vector<GEMRecHit*> gemrechitvector = gemRecHitCollection[CSCId.rawId()];
0201
0202 bool hitfound = false;
0203 for (std::vector<GEMRecHit*>::const_iterator it = gemrechitvector.begin(); it != gemrechitvector.end();
0204 ++it) {
0205 if (hitIt->gemId() == (*it)->gemId() && hitIt->localPosition() == (*it)->localPosition())
0206 hitfound = true;
0207 }
0208 if (!hitfound)
0209 gemrechitvector.push_back(hitIt->clone());
0210 gemRecHitCollection[CSCId.rawId()] = gemrechitvector;
0211 edm::LogVerbatim("GEMCSCSegmentBuilder")
0212 << "[GEMCSCSegmentBuilder :: build] GEM Rechit in " << hitIt->gemId() << "[" << hitIt->gemId().rawId()
0213 << "] added to CSC segment found in " << CSCId << " [" << CSCId.rawId() << "]" << std::endl;
0214 }
0215 }
0216 }
0217 }
0218
0219
0220
0221 else {
0222 edm::LogVerbatim("GEMCSCSegmentBuilder")
0223 << "[GEMCSCSegmentBuilder :: build] Found a Segment in " << CSCId.rawId() << " = " << CSCId;
0224
0225
0226
0227
0228
0229 std::vector<const CSCSegment*> cscsegmentvector_noGEM = cscSegColl_noGEM[CSCId.rawId()];
0230 cscsegmentvector_noGEM.push_back(segmIt->clone());
0231 cscSegColl_noGEM[CSCId.rawId()] = cscsegmentvector_noGEM;
0232 }
0233 }
0234
0235
0236
0237
0238
0239
0240
0241
0242
0243
0244
0245
0246
0247
0248
0249
0250
0251
0252
0253
0254
0255
0256
0257 edm::LogVerbatim("GEMCSCSegmentBuilder")
0258 << "[GEMCSCSegmentBuilder :: build] Run over the gemRecHitCollection (size = " << gemRecHitCollection.size()
0259 << ") and build GEMCSC Segments";
0260 for (auto gemHitIt = gemRecHitCollection.begin(); gemHitIt != gemRecHitCollection.end(); ++gemHitIt) {
0261 CSCDetId cscId(gemHitIt->first);
0262
0263
0264 std::vector<const CSCSegment*> cscSegments = cscSegColl_GEM11[cscId.rawId()];
0265 std::vector<const GEMRecHit*> gemRecHits;
0266
0267 std::map<uint32_t, const CSCLayer*> cscLayers;
0268 std::map<uint32_t, const GEMEtaPartition*> gemEtaPartitions;
0269
0270
0271 std::vector<const CSCLayer*> cscLayerVector = cscgeom_->chamber(cscId.rawId())->layers();
0272 for (std::vector<const CSCLayer*>::const_iterator layIt = cscLayerVector.begin(); layIt != cscLayerVector.end();
0273 ++layIt) {
0274 cscLayers[(*layIt)->id()] = cscgeom_->layer((*layIt)->id());
0275 }
0276
0277
0278 for (auto rechit = gemHitIt->second.begin(); rechit != gemHitIt->second.end(); ++rechit) {
0279 GEMDetId gemid = (*rechit)->gemId();
0280 gemRecHits.push_back(*rechit);
0281 gemEtaPartitions[gemid.rawId()] = gemgeom_->etaPartition(gemid.rawId());
0282 }
0283
0284
0285 edm::LogVerbatim("GEMCSCSegmentBuilder")
0286 << "[GEMCSCSegmentBuilder :: build] ask SegmentAlgo to be run :: CSC DetId " << cscId.rawId() << " = " << cscId
0287 << " with " << cscSegments.size() << " CSC segments and " << gemRecHits.size() << " GEM rechits";
0288
0289
0290 std::vector<GEMCSCSegment> segmentvector = algo->run(cscLayers, gemEtaPartitions, cscSegments, gemRecHits);
0291
0292
0293 edm::LogVerbatim("GEMCSCSegmentBuilder") << "[GEMCSCSegmentBuilder :: build] SegmentAlgo ran, now trying to add "
0294 "the segments from the returned GEMCSCSegment vector (with size = "
0295 << segmentvector.size() << ") to the master collection";
0296 std::stringstream segmentvectorss;
0297 segmentvectorss << "[GEMCSCSegmentBuilder :: build] :: GEMCSC segmentvector :: elements [" << std::endl;
0298 for (std::vector<GEMCSCSegment>::const_iterator segIt = segmentvector.begin(); segIt != segmentvector.end();
0299 ++segIt) {
0300 segmentvectorss << "[GEMCSC Segment details: \n" << *segIt << "]," << std::endl;
0301 }
0302 segmentvectorss << "]";
0303 std::string segmentvectorstr = segmentvectorss.str();
0304 edm::LogVerbatim("GEMCSCSegmentBuilder") << segmentvectorstr;
0305
0306
0307
0308 edm::LogVerbatim("GEMCSCSegmentBuilder")
0309 << "[GEMCSCSegmentBuilder :: build] |--> GEMCSC Segments created, now try to add to the collection :: CSC "
0310 "DetId: "
0311 << cscId.rawId() << " = " << cscId << " added " << segmentvector.size() << " GEMCSC Segments";
0312 oc.put(cscId, segmentvector.begin(), segmentvector.end());
0313 edm::LogVerbatim("GEMCSCSegmentBuilder")
0314 << "[GEMCSCSegmentBuilder :: build] |--> GEMCSC Segments added to the collection";
0315 }
0316
0317
0318
0319
0320
0321
0322
0323 edm::LogVerbatim("GEMCSCSegmentBuilder")
0324 << "[GEMCSCSegmentBuilder :: build] Run over the CSC Segment collection without GEM (size = "
0325 << cscSegColl_noGEM.size() << " CSC chambers with segments) and wrap GEMCSC Segments";
0326 for (auto cscSegIt = cscSegColl_noGEM.begin(); cscSegIt != cscSegColl_noGEM.end(); ++cscSegIt) {
0327 CSCDetId cscId(cscSegIt->first);
0328
0329 std::vector<const GEMRecHit*> gemRecHits_noGEM;
0330 std::vector<const CSCSegment*> cscSegments_noGEM = cscSegColl_noGEM[cscSegIt->first];
0331 std::vector<GEMCSCSegment> segmentvector;
0332
0333 edm::LogVerbatim("GEMCSCSegmentBuilder")
0334 << "[GEMCSCSegmentBuilder :: build] |--> Run over the CSC Segment vector without GEM (size = "
0335 << cscSegments_noGEM.size() << " CSC segments) and wrap GEMCSC Segments";
0336 for (std::vector<const CSCSegment*>::iterator it = cscSegments_noGEM.begin(); it != cscSegments_noGEM.end(); ++it) {
0337
0338 GEMCSCSegment tmp(*it,
0339 gemRecHits_noGEM,
0340 (*it)->localPosition(),
0341 (*it)->localDirection(),
0342 (*it)->parametersError(),
0343 (*it)->chi2());
0344 segmentvector.push_back(tmp);
0345 }
0346
0347
0348 edm::LogVerbatim("GEMCSCSegmentBuilder")
0349 << "[GEMCSCSegmentBuilder :: build] |--> CSC Segments wrapped, now try to add to the collection :: CSC DetId: "
0350 << cscId.rawId() << " = " << cscId << " added " << segmentvector.size() << " GEMCSC Segments";
0351 oc.put(cscId, segmentvector.begin(), segmentvector.end());
0352 edm::LogVerbatim("GEMCSCSegmentBuilder")
0353 << "[GEMCSCSegmentBuilder :: build] |--> CSC Segments added to the collection";
0354 }
0355
0356 edm::LogVerbatim("GEMCSCSegmentBuilder") << "[GEMCSCSegmentBuilder :: build] job done !!!";
0357 }
0358
0359 void GEMCSCSegmentBuilder::setGeometry(const GEMGeometry* gemgeom, const CSCGeometry* cscgeom) {
0360 gemgeom_ = gemgeom;
0361 cscgeom_ = cscgeom;
0362 }