File indexing completed on 2021-03-14 23:24:27
0001 #include "FWCore/Framework/interface/Frameworkfwd.h"
0002 #include "FWCore/Framework/interface/stream/EDProducer.h"
0003 #include "FWCore/Framework/interface/Event.h"
0004 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0005 #include "FWCore/Utilities/interface/InputTag.h"
0006
0007 #include "DataFormats/SiStripCluster/interface/SiStripCluster.h"
0008 #include "DataFormats/SiPixelCluster/interface/SiPixelCluster.h"
0009 #include "DataFormats/TrackerRecHit2D/interface/SiStripRecHit2D.h"
0010 #include "DataFormats/TrackerRecHit2D/interface/SiStripRecHit1D.h"
0011 #include "DataFormats/TrackerRecHit2D/interface/SiStripMatchedRecHit2D.h"
0012 #include "DataFormats/TrackerRecHit2D/interface/ProjectedSiStripRecHit2D.h"
0013 #include "DataFormats/TrackerRecHit2D/interface/SiPixelRecHit.h"
0014 #include "DataFormats/TrackerRecHit2D/interface/SiPixelRecHitCollection.h"
0015 #include "DataFormats/TrackerRecHit2D/interface/SiStripRecHit2DCollection.h"
0016 #include "DataFormats/Common/interface/Handle.h"
0017 #include "DataFormats/Common/interface/DetSetVector.h"
0018 #include "DataFormats/Common/interface/DetSetVectorNew.h"
0019 #include "DataFormats/Common/interface/ContainerMask.h"
0020 #include "DataFormats/Provenance/interface/ProductID.h"
0021
0022 #include "DataFormats/TrackReco/interface/Track.h"
0023 #include "DataFormats/TrackerRecHit2D/interface/ClusterRemovalInfo.h"
0024
0025 #include "TrackingTools/PatternTools/interface/Trajectory.h"
0026 #include "TrackingTools/PatternTools/interface/TrajTrackAssociation.h"
0027 #include "TrackingTools/TrajectoryState/interface/TrajectoryStateOnSurface.h"
0028
0029 #include "Geometry/Records/interface/TrackerDigiGeometryRecord.h"
0030 #include "Geometry/TrackerGeometryBuilder/interface/TrackerGeometry.h"
0031 #include "Geometry/CommonDetUnit/interface/GeomDet.h"
0032 #include "Geometry/CommonDetUnit/interface/GeomDetType.h"
0033
0034
0035
0036
0037
0038 class HLTTrackClusterRemoverNew final : public edm::stream::EDProducer<> {
0039 public:
0040 HLTTrackClusterRemoverNew(const edm::ParameterSet &iConfig);
0041 ~HLTTrackClusterRemoverNew() override;
0042 void produce(edm::Event &iEvent, const edm::EventSetup &iSetup) override;
0043
0044 private:
0045 edm::ESGetToken<TrackerGeometry, TrackerDigiGeometryRecord> const tTrackerGeom_;
0046 struct ParamBlock {
0047 ParamBlock() : isSet_(false), usesCharge_(false) {}
0048 ParamBlock(const edm::ParameterSet &iConfig)
0049 : isSet_(true),
0050 usesCharge_(iConfig.exists("maxCharge")),
0051 usesSize_(iConfig.exists("maxSize")),
0052 cutOnPixelCharge_(iConfig.exists("minGoodPixelCharge")),
0053 cutOnStripCharge_(iConfig.exists("minGoodStripCharge")),
0054 maxChi2_(iConfig.getParameter<double>("maxChi2")),
0055 maxCharge_(usesCharge_ ? iConfig.getParameter<double>("maxCharge") : 0),
0056 minGoodPixelCharge_(cutOnPixelCharge_ ? iConfig.getParameter<double>("minGoodPixelCharge") : 0),
0057 minGoodStripCharge_(cutOnStripCharge_ ? iConfig.getParameter<double>("minGoodStripCharge") : 0),
0058 maxSize_(usesSize_ ? iConfig.getParameter<uint32_t>("maxSize") : 0) {}
0059 bool isSet_, usesCharge_, usesSize_, cutOnPixelCharge_, cutOnStripCharge_;
0060 float maxChi2_, maxCharge_, minGoodPixelCharge_, minGoodStripCharge_;
0061 size_t maxSize_;
0062 };
0063 static const unsigned int NumberOfParamBlocks = 6;
0064
0065 bool doTracks_;
0066 bool doStrip_, doPixel_;
0067 bool mergeOld_;
0068
0069 typedef edm::ContainerMask<edmNew::DetSetVector<SiPixelCluster> > PixelMaskContainer;
0070 typedef edm::ContainerMask<edmNew::DetSetVector<SiStripCluster> > StripMaskContainer;
0071 edm::EDGetTokenT<edmNew::DetSetVector<SiPixelCluster> > pixelClusters_;
0072 edm::EDGetTokenT<edmNew::DetSetVector<SiStripCluster> > stripClusters_;
0073 edm::EDGetTokenT<PixelMaskContainer> oldPxlMaskToken_;
0074 edm::EDGetTokenT<StripMaskContainer> oldStrMaskToken_;
0075 edm::EDGetTokenT<std::vector<Trajectory> > trajectories_;
0076
0077 ParamBlock pblocks_[NumberOfParamBlocks];
0078 void readPSet(const edm::ParameterSet &iConfig,
0079 const std::string &name,
0080 int id1 = -1,
0081 int id2 = -1,
0082 int id3 = -1,
0083 int id4 = -1,
0084 int id5 = -1,
0085 int id6 = -1);
0086
0087 std::vector<uint8_t> pixels, strips;
0088 edm::ProductID pixelSourceProdID, stripSourceProdID;
0089
0090 inline void process(const TrackingRecHit *hit, float chi2, const TrackerGeometry *tg);
0091 inline void process(const OmniClusterRef &cluRef, uint32_t subdet);
0092
0093 template <typename T>
0094 std::unique_ptr<edmNew::DetSetVector<T> > cleanup(const edmNew::DetSetVector<T> &oldClusters,
0095 const std::vector<uint8_t> &isGood,
0096 reco::ClusterRemovalInfo::Indices &refs,
0097 const reco::ClusterRemovalInfo::Indices *oldRefs);
0098
0099
0100 void mergeOld(reco::ClusterRemovalInfo::Indices &refs, const reco::ClusterRemovalInfo::Indices &oldRefs);
0101
0102 bool makeProducts_;
0103 bool doStripChargeCheck_, doPixelChargeCheck_;
0104 std::vector<bool> collectedRegStrips_;
0105 std::vector<bool> collectedPixels_;
0106 };
0107
0108 using namespace std;
0109 using namespace edm;
0110 using namespace reco;
0111
0112 void HLTTrackClusterRemoverNew::readPSet(
0113 const edm::ParameterSet &iConfig, const std::string &name, int id1, int id2, int id3, int id4, int id5, int id6) {
0114 if (iConfig.exists(name)) {
0115 ParamBlock pblock(iConfig.getParameter<ParameterSet>(name));
0116 if (id1 == -1) {
0117 fill(pblocks_, pblocks_ + NumberOfParamBlocks, pblock);
0118 } else {
0119 pblocks_[id1] = pblock;
0120 if (id2 != -1)
0121 pblocks_[id2] = pblock;
0122 if (id3 != -1)
0123 pblocks_[id3] = pblock;
0124 if (id4 != -1)
0125 pblocks_[id4] = pblock;
0126 if (id5 != -1)
0127 pblocks_[id5] = pblock;
0128 if (id6 != -1)
0129 pblocks_[id6] = pblock;
0130 }
0131 }
0132 }
0133
0134 HLTTrackClusterRemoverNew::HLTTrackClusterRemoverNew(const ParameterSet &iConfig)
0135 : tTrackerGeom_(esConsumes<TrackerGeometry, TrackerDigiGeometryRecord>()),
0136 doTracks_(iConfig.exists("trajectories")),
0137 doStrip_(iConfig.existsAs<bool>("doStrip") ? iConfig.getParameter<bool>("doStrip") : true),
0138 doPixel_(iConfig.existsAs<bool>("doPixel") ? iConfig.getParameter<bool>("doPixel") : true),
0139 mergeOld_(false),
0140 makeProducts_(true),
0141 doStripChargeCheck_(
0142 iConfig.existsAs<bool>("doStripChargeCheck") ? iConfig.getParameter<bool>("doStripChargeCheck") : false),
0143 doPixelChargeCheck_(
0144 iConfig.existsAs<bool>("doPixelChargeCheck") ? iConfig.getParameter<bool>("doPixelChargeCheck") : false)
0145
0146 {
0147 if (iConfig.exists("oldClusterRemovalInfo")) {
0148 oldPxlMaskToken_ = consumes<PixelMaskContainer>(iConfig.getParameter<InputTag>("oldClusterRemovalInfo"));
0149 oldStrMaskToken_ = consumes<StripMaskContainer>(iConfig.getParameter<InputTag>("oldClusterRemovalInfo"));
0150 if (not(iConfig.getParameter<InputTag>("oldClusterRemovalInfo") == edm::InputTag()))
0151 mergeOld_ = true;
0152 }
0153
0154 if ((doPixelChargeCheck_ && !doPixel_) || (doStripChargeCheck_ && !doStrip_))
0155 throw cms::Exception("Configuration Error")
0156 << "HLTTrackClusterRemoverNew: Charge check asked without cluster collection ";
0157 if (doPixelChargeCheck_)
0158 throw cms::Exception("Configuration Error")
0159 << "HLTTrackClusterRemoverNew: Pixel cluster charge check not yet implemented";
0160
0161 fill(pblocks_, pblocks_ + NumberOfParamBlocks, ParamBlock());
0162 readPSet(iConfig, "Common", -1);
0163 if (doPixel_) {
0164 readPSet(iConfig, "Pixel", 0, 1);
0165 readPSet(iConfig, "PXB", 0);
0166 readPSet(iConfig, "PXE", 1);
0167 }
0168 if (doStrip_) {
0169 readPSet(iConfig, "Strip", 2, 3, 4, 5);
0170 readPSet(iConfig, "StripInner", 2, 3);
0171 readPSet(iConfig, "StripOuter", 4, 5);
0172 readPSet(iConfig, "TIB", 2);
0173 readPSet(iConfig, "TID", 3);
0174 readPSet(iConfig, "TOB", 4);
0175 readPSet(iConfig, "TEC", 5);
0176 }
0177
0178 bool usingCharge = false;
0179 for (size_t i = 0; i < NumberOfParamBlocks; ++i) {
0180 if (!pblocks_[i].isSet_)
0181 throw cms::Exception("Configuration Error")
0182 << "HLTTrackClusterRemoverNew: Missing configuration for detector with subDetID = " << (i + 1);
0183 if (pblocks_[i].usesCharge_ && !usingCharge) {
0184 throw cms::Exception("Configuration Error")
0185 << "HLTTrackClusterRemoverNew: Configuration for subDetID = " << (i + 1)
0186 << " uses cluster charge, which is not enabled.";
0187 }
0188 }
0189
0190
0191 if (doTracks_)
0192 trajectories_ = consumes<vector<Trajectory> >(iConfig.getParameter<InputTag>("trajectories"));
0193 if (doPixel_)
0194 pixelClusters_ = consumes<edmNew::DetSetVector<SiPixelCluster> >(iConfig.getParameter<InputTag>("pixelClusters"));
0195 if (doStrip_)
0196 stripClusters_ = consumes<edmNew::DetSetVector<SiStripCluster> >(iConfig.getParameter<InputTag>("stripClusters"));
0197 if (mergeOld_) {
0198 oldPxlMaskToken_ = consumes<PixelMaskContainer>(iConfig.getParameter<InputTag>("oldClusterRemovalInfo"));
0199 oldStrMaskToken_ = consumes<StripMaskContainer>(iConfig.getParameter<InputTag>("oldClusterRemovalInfo"));
0200 }
0201
0202
0203
0204
0205 produces<edm::ContainerMask<edmNew::DetSetVector<SiPixelCluster> > >();
0206 produces<edm::ContainerMask<edmNew::DetSetVector<SiStripCluster> > >();
0207 }
0208
0209 HLTTrackClusterRemoverNew::~HLTTrackClusterRemoverNew() {}
0210
0211 void HLTTrackClusterRemoverNew::mergeOld(ClusterRemovalInfo::Indices &refs,
0212 const ClusterRemovalInfo::Indices &oldRefs) {
0213 for (size_t i = 0, n = refs.size(); i < n; ++i) {
0214 refs[i] = oldRefs[refs[i]];
0215 }
0216 }
0217
0218 template <typename T>
0219 std::unique_ptr<edmNew::DetSetVector<T> > HLTTrackClusterRemoverNew::cleanup(
0220 const edmNew::DetSetVector<T> &oldClusters,
0221 const std::vector<uint8_t> &isGood,
0222 reco::ClusterRemovalInfo::Indices &refs,
0223 const reco::ClusterRemovalInfo::Indices *oldRefs) {
0224 typedef typename edmNew::DetSetVector<T> DSV;
0225 typedef typename edmNew::DetSetVector<T>::FastFiller DSF;
0226 typedef typename edmNew::DetSet<T> DS;
0227 auto output = std::make_unique<DSV>();
0228 output->reserve(oldClusters.size(), oldClusters.dataSize());
0229
0230 unsigned int countOld = 0;
0231 unsigned int countNew = 0;
0232
0233
0234 const T *firstOffset = &oldClusters.data().front();
0235 for (typename DSV::const_iterator itdet = oldClusters.begin(), enddet = oldClusters.end(); itdet != enddet; ++itdet) {
0236 DS oldDS = *itdet;
0237
0238 if (oldDS.empty())
0239 continue;
0240
0241 uint32_t id = oldDS.detId();
0242 DSF outds(*output, id);
0243
0244 for (typename DS::const_iterator it = oldDS.begin(), ed = oldDS.end(); it != ed; ++it) {
0245 uint32_t index = ((&*it) - firstOffset);
0246 countOld++;
0247 if (isGood[index]) {
0248 outds.push_back(*it);
0249 countNew++;
0250 refs.push_back(index);
0251
0252 }
0253 }
0254 if (outds.empty())
0255 outds.abort();
0256 }
0257
0258
0259 if (oldRefs != nullptr)
0260 mergeOld(refs, *oldRefs);
0261 return output;
0262 }
0263
0264 void HLTTrackClusterRemoverNew::process(OmniClusterRef const &clusterReg, uint32_t subdet) {
0265 if (clusterReg.id() != stripSourceProdID)
0266 throw cms::Exception("Inconsistent Data")
0267 << "HLTTrackClusterRemoverNew: strip cluster ref from Product ID = " << clusterReg.id()
0268 << " does not match with source cluster collection (ID = " << stripSourceProdID << ")\n.";
0269
0270 if (collectedRegStrips_.size() <= clusterReg.key()) {
0271 edm::LogError("BadCollectionSize") << collectedRegStrips_.size() << " is smaller than " << clusterReg.key();
0272
0273 assert(collectedRegStrips_.size() > clusterReg.key());
0274 }
0275 collectedRegStrips_[clusterReg.key()] = true;
0276 }
0277
0278 void HLTTrackClusterRemoverNew::process(const TrackingRecHit *hit, float chi2, const TrackerGeometry *tg) {
0279 DetId detid = hit->geographicalId();
0280 uint32_t subdet = detid.subdetId();
0281
0282 assert((subdet > 0) && (subdet <= NumberOfParamBlocks));
0283
0284
0285 if (chi2 > pblocks_[subdet - 1].maxChi2_)
0286 return;
0287
0288 if (GeomDetEnumerators::isTrackerPixel(tg->geomDetSubDetector(subdet))) {
0289
0290 if (!doPixel_)
0291 return;
0292
0293 const SiPixelRecHit *pixelHit = static_cast<const SiPixelRecHit *>(hit);
0294
0295 SiPixelRecHit::ClusterRef cluster = pixelHit->cluster();
0296 if (cluster.id() != pixelSourceProdID)
0297 throw cms::Exception("Inconsistent Data")
0298 << "HLTTrackClusterRemoverNew: pixel cluster ref from Product ID = " << cluster.id()
0299 << " does not match with source cluster collection (ID = " << pixelSourceProdID << ")\n.";
0300
0301 assert(cluster.id() == pixelSourceProdID);
0302
0303
0304
0305 if (pblocks_[subdet - 1].usesSize_ && (cluster->pixels().size() > pblocks_[subdet - 1].maxSize_))
0306 return;
0307
0308
0309
0310 assert(collectedPixels_.size() > cluster.key());
0311 collectedPixels_[cluster.key()] = true;
0312 } else {
0313 if (!doStrip_)
0314 return;
0315 const type_info &hitType = typeid(*hit);
0316 if (hitType == typeid(SiStripRecHit2D)) {
0317 const SiStripRecHit2D *stripHit = static_cast<const SiStripRecHit2D *>(hit);
0318
0319 process(stripHit->omniClusterRef(), subdet);
0320
0321
0322
0323 } else if (hitType == typeid(SiStripRecHit1D)) {
0324 const SiStripRecHit1D *hit1D = static_cast<const SiStripRecHit1D *>(hit);
0325 process(hit1D->omniClusterRef(), subdet);
0326
0327
0328
0329 } else if (hitType == typeid(SiStripMatchedRecHit2D)) {
0330 const SiStripMatchedRecHit2D *matchHit = static_cast<const SiStripMatchedRecHit2D *>(hit);
0331
0332 process(matchHit->monoClusterRef(), subdet);
0333
0334
0335
0336
0337 process(matchHit->stereoClusterRef(), subdet);
0338
0339
0340
0341
0342 } else if (hitType == typeid(ProjectedSiStripRecHit2D)) {
0343 const ProjectedSiStripRecHit2D *projHit = static_cast<const ProjectedSiStripRecHit2D *>(hit);
0344
0345 process(projHit->originalHit().omniClusterRef(), subdet);
0346
0347
0348
0349 } else
0350 throw cms::Exception("NOT IMPLEMENTED")
0351 << "Don't know how to handle " << hitType.name() << " on detid " << detid.rawId() << "\n";
0352 }
0353 }
0354
0355
0356
0357
0358
0359
0360
0361
0362
0363
0364
0365 void HLTTrackClusterRemoverNew::produce(Event &iEvent, const EventSetup &iSetup) {
0366 ProductID pixelOldProdID, stripOldProdID;
0367
0368 const auto &tgh = &iSetup.getData(tTrackerGeom_);
0369
0370 edm::Handle<edmNew::DetSetVector<SiPixelCluster> > pixelClusters;
0371 if (doPixel_) {
0372 iEvent.getByToken(pixelClusters_, pixelClusters);
0373 pixelSourceProdID = pixelClusters.id();
0374 }
0375
0376 edm::Handle<edmNew::DetSetVector<SiStripCluster> > stripClusters;
0377 if (doStrip_) {
0378 iEvent.getByToken(stripClusters_, stripClusters);
0379 stripSourceProdID = stripClusters.id();
0380 }
0381
0382
0383 edm::Handle<vector<Trajectory> > trajectories;
0384 iEvent.getByToken(trajectories_, trajectories);
0385
0386 if (mergeOld_) {
0387 edm::Handle<PixelMaskContainer> oldPxlMask;
0388 edm::Handle<StripMaskContainer> oldStrMask;
0389 iEvent.getByToken(oldPxlMaskToken_, oldPxlMask);
0390 iEvent.getByToken(oldStrMaskToken_, oldStrMask);
0391 LogDebug("TrackClusterRemover") << "to merge in, " << oldStrMask->size() << " strp and " << oldPxlMask->size()
0392 << " pxl";
0393 oldStrMask->copyMaskTo(collectedRegStrips_);
0394 oldPxlMask->copyMaskTo(collectedPixels_);
0395 collectedRegStrips_.resize(stripClusters->dataSize(), false);
0396 } else {
0397 collectedRegStrips_.resize(stripClusters->dataSize(), false);
0398 collectedPixels_.resize(pixelClusters->dataSize(), false);
0399 }
0400
0401
0402
0403
0404 for (std::vector<Trajectory>::const_iterator it = trajectories->begin(), ed = trajectories->end(); it != ed; ++it) {
0405 const Trajectory &tj = *it;
0406 const std::vector<TrajectoryMeasurement> &tms = tj.measurements();
0407
0408 std::vector<TrajectoryMeasurement>::const_iterator itm, endtm;
0409 for (itm = tms.begin(), endtm = tms.end(); itm != endtm; ++itm) {
0410 const TrackingRecHit *hit = itm->recHit()->hit();
0411 if (!hit->isValid())
0412 continue;
0413
0414 process(hit, itm->estimate(), tgh);
0415 }
0416 }
0417
0418
0419
0420
0421
0422 if (doStripChargeCheck_) {
0423
0424
0425 auto const &clusters = stripClusters->data();
0426 for (auto const &item : stripClusters->ids()) {
0427 if (!item.isValid())
0428 continue;
0429
0430 DetId detid = item.id;
0431 uint32_t subdet = detid.subdetId();
0432 if (!pblocks_[subdet - 1].cutOnStripCharge_)
0433 continue;
0434
0435
0436
0437 for (int i = item.offset; i < item.offset + int(item.size); ++i) {
0438 int clusCharge = 0;
0439 for (auto cAmp : clusters[i].amplitudes())
0440 clusCharge += cAmp;
0441
0442
0443 if (clusCharge < pblocks_[subdet - 1].minGoodStripCharge_)
0444 collectedRegStrips_[i] = true;
0445 }
0446 }
0447 }
0448
0449
0450
0451 LogDebug("TrackClusterRemover") << "total strip to skip: "
0452 << std::count(collectedRegStrips_.begin(), collectedRegStrips_.end(), true);
0453
0454 iEvent.put(std::make_unique<StripMaskContainer>(edm::RefProd<edmNew::DetSetVector<SiStripCluster> >(stripClusters),
0455 collectedRegStrips_));
0456
0457 LogDebug("TrackClusterRemover") << "total pxl to skip: "
0458 << std::count(collectedPixels_.begin(), collectedPixels_.end(), true);
0459 iEvent.put(std::make_unique<PixelMaskContainer>(edm::RefProd<edmNew::DetSetVector<SiPixelCluster> >(pixelClusters),
0460 collectedPixels_));
0461
0462 collectedRegStrips_.clear();
0463 collectedPixels_.clear();
0464 }
0465
0466 #include "FWCore/PluginManager/interface/ModuleDef.h"
0467 #include "FWCore/Framework/interface/MakerMacros.h"
0468 DEFINE_FWK_MODULE(HLTTrackClusterRemoverNew);