PFProducer/plugins/PFBlockProducer.cc

0001 #include "RecoParticleFlow/PFProducer/interface/PFBlockAlgo.h"
0002 #include "FWCore/Framework/interface/Event.h"
0003 #include "FWCore/Framework/interface/MakerMacros.h"
0004 #include "FWCore/Framework/interface/stream/EDProducer.h"
0005 #include "FWCore/Utilities/interface/EDPutToken.h"
0006 #include "FWCore/Utilities/interface/Exception.h"
0007
0008 /**\class PFBlockProducer
0009 \brief Producer for particle flow blocks
0010
0011 This producer makes use of PFBlockAlgo, the particle flow block algorithm.
0012 Particle flow itself consists in reconstructing particles from the particle
0013 flow blocks This is done at a later stage, see PFProducer and PFAlgo.
0014
0015 \author Colin Bernet
0016 \date   April 2007
0017 */
0018
0019 class FSimEvent;
0020
0021 class PFBlockProducer : public edm::stream::EDProducer<> {
0022 public:
0023   explicit PFBlockProducer(const edm::ParameterSet&);
0024
0025   void beginLuminosityBlock(edm::LuminosityBlock const&, edm::EventSetup const&) override;
0026
0027   void produce(edm::Event&, const edm::EventSetup&) override;
0028   static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
0029
0030 private:
0031   /// verbose ?
0032   const bool verbose_;
0033   const edm::EDPutTokenT<reco::PFBlockCollection> putToken_;
0034
0035   /// Particle flow block algorithm
0036   PFBlockAlgo pfBlockAlgo_;
0037 };
0038
0039 DEFINE_FWK_MODULE(PFBlockProducer);
0040
0041 void PFBlockProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
0042   edm::ParameterSetDescription desc;
0043   // verbosity
0044   desc.addUntracked<bool>("verbose", false);
0045   // Debug flag
0046   desc.addUntracked<bool>("debug", false);
0047   //define what we are importing into particle flow
0048   //from the various subdetectors
0049   // importers are executed in the order they are defined here!!!
0050   //order matters for some modules (it is pointed out where this is important)
0051   // you can find a list of all available importers in:
0052   //  plugins/importers
0053   {
0054     std::vector<edm::ParameterSet> vpset;
0055     vpset.reserve(12);
0056     {
0057       edm::ParameterSet pset;
0058       pset.addParameter<std::string>("importerName", "GSFTrackImporter");
0059       pset.addParameter<edm::InputTag>("source", {"pfTrackElec"});
0060       pset.addParameter<bool>("gsfsAreSecondary", false);
0061       pset.addParameter<bool>("superClustersArePF", true);
0062       vpset.emplace_back(pset);
0063     }
0064     {
0065       edm::ParameterSet pset;
0066       pset.addParameter<std::string>("importerName", "ConvBremTrackImporter");
0067       pset.addParameter<edm::InputTag>("source", {"pfTrackElec"});
0068       pset.addParameter<bool>("vetoEndcap", false);
0069       vpset.emplace_back(pset);
0070     }
0071     {
0072       edm::ParameterSet pset;
0073       pset.addParameter<std::string>("importerName", "SuperClusterImporter");
0074       pset.addParameter<edm::InputTag>("source_eb",
0075                                        {"particleFlowSuperClusterECAL:particleFlowSuperClusterECALBarrel"});
0076       pset.addParameter<edm::InputTag>(
0077           "source_ee", {"particleFlowSuperClusterECAL:particleFlowSuperClusterECALEndcapWithPreshower"});
0078       pset.addParameter<double>("maximumHoverE", 0.5);
0079       pset.addParameter<double>("minSuperClusterPt", 10.0);
0080       pset.addParameter<double>("minPTforBypass", 100.0);
0081       pset.addParameter<edm::InputTag>("hbheRecHitsTag", {"hbhereco"});
0082       pset.addParameter<int>("maxSeverityHB", 9);
0083       pset.addParameter<int>("maxSeverityHE", 9);
0084       pset.addParameter<bool>("usePFThresholdsFromDB", false);
0085       pset.addParameter<bool>("superClustersArePF", true);
0086       vpset.emplace_back(pset);
0087     }
0088     {
0089       edm::ParameterSet pset;
0090       pset.addParameter<std::string>("importerName", "ConversionTrackImporter");
0091       pset.addParameter<edm::InputTag>("source", {"pfConversions"});
0092       pset.addParameter<bool>("vetoEndcap", false);
0093       vpset.emplace_back(pset);
0094     }
0095     // V0's not actually used in particle flow block building so far
0096     //NuclearInteraction's also come in Loose and VeryLoose varieties
0097     {
0098       edm::ParameterSet pset;
0099       pset.addParameter<std::string>("importerName", "NuclearInteractionTrackImporter");
0100       pset.addParameter<edm::InputTag>("source", {"pfDisplacedTrackerVertex"});
0101       pset.addParameter<bool>("vetoEndcap", false);
0102       vpset.emplace_back(pset);
0103     }
0104     //for best timing GeneralTracksImporter should come after
0105     // all secondary track importers
0106     {
0107       edm::ParameterSet pset;
0108       pset.addParameter<std::string>("importerName", "GeneralTracksImporter");
0109       pset.addParameter<edm::InputTag>("source", {"pfTrack"});
0110       pset.addParameter<bool>("vetoEndcap", false);
0111       pset.addParameter<edm::InputTag>("muonSrc", {"muons1stStep"});
0112       pset.addParameter<std::string>("trackQuality", "highPurity");
0113       pset.addParameter<bool>("cleanBadConvertedBrems", true);
0114       pset.addParameter<bool>("useIterativeTracking", true);
0115       pset.addParameter<std::vector<double>>("DPtOverPtCuts_byTrackAlgo", {10.0, 10.0, 10.0, 10.0, 10.0, 5.0});
0116       pset.addParameter<std::vector<uint32_t>>("NHitCuts_byTrackAlgo", {3, 3, 3, 3, 3, 3});
0117       pset.addParameter<double>("muonMaxDPtOPt", 1);
0118       vpset.emplace_back(pset);
0119     }
0120     // secondary GSF tracks are also turned off
0121     // to properly set SC based links you need to run ECAL importer
0122     // after you've imported all SCs to the block
0123     {
0124       edm::ParameterSet pset;
0125       pset.addParameter<std::string>("importerName", "ECALClusterImporter");
0126       pset.addParameter<edm::InputTag>("source", {"particleFlowClusterECAL"});
0127       pset.addParameter<edm::InputTag>("BCtoPFCMap", {"particleFlowSuperClusterECAL:PFClusterAssociationEBEE"});
0128       vpset.emplace_back(pset);
0129     }
0130     {
0131       edm::ParameterSet pset;
0132       pset.addParameter<std::string>("importerName", "GenericClusterImporter");
0133       pset.addParameter<edm::InputTag>("source", {"particleFlowClusterHCAL"});
0134       vpset.emplace_back(pset);
0135     }
0136     {
0137       edm::ParameterSet pset;
0138       pset.addParameter<std::string>("importerName", "GenericClusterImporter");
0139       pset.addParameter<edm::InputTag>("source", {"particleFlowBadHcalPseudoCluster"});
0140       vpset.emplace_back(pset);
0141     }
0142     {
0143       edm::ParameterSet pset;
0144       pset.addParameter<std::string>("importerName", "GenericClusterImporter");
0145       pset.addParameter<edm::InputTag>("source", {"particleFlowClusterHO"});
0146       vpset.emplace_back(pset);
0147     }
0148     {
0149       edm::ParameterSet pset;
0150       pset.addParameter<std::string>("importerName", "GenericClusterImporter");
0151       pset.addParameter<edm::InputTag>("source", {"particleFlowClusterHF"});
0152       vpset.emplace_back(pset);
0153     }
0154     {
0155       edm::ParameterSet pset;
0156       pset.addParameter<std::string>("importerName", "GenericClusterImporter");
0157       pset.addParameter<edm::InputTag>("source", {"particleFlowClusterPS"});
0158       vpset.emplace_back(pset);
0159     }
0160     edm::ParameterSetDescription psd;
0161     psd.add<std::string>("importerName", "");
0162     psd.add<edm::InputTag>("source", {});
0163     psd.add<bool>("gsfsAreSecondary", false);
0164     psd.add<bool>("superClustersArePF", false);
0165     psd.add<edm::InputTag>("source_eb", {});
0166     psd.add<edm::InputTag>("source_ee", {});
0167     psd.add<double>("maximumHoverE", 0);
0168     psd.add<double>("minSuperClusterPt", 0);
0169     psd.add<double>("minPTforBypass", 0);
0170     psd.add<edm::InputTag>("hbheRecHitsTag", {});
0171     psd.add<int>("maxSeverityHB", 0);
0172     psd.add<int>("maxSeverityHE", 0);
0173     psd.add<bool>("usePFThresholdsFromDB", false);
0174     psd.add<bool>("vetoEndcap", false);
0175     psd.add<edm::InputTag>("muonSrc", {});
0176     psd.add<std::string>("trackQuality", "");
0177     psd.add<bool>("cleanBadConvertedBrems", false);
0178     psd.add<bool>("useIterativeTracking", false);
0179     psd.add<std::vector<double>>("DPtOverPtCuts_byTrackAlgo", {});
0180     psd.add<std::vector<uint32_t>>("NHitCuts_byTrackAlgo", {});
0181     psd.add<double>("muonMaxDPtOPt", 0);
0182     psd.add<edm::InputTag>("BCtoPFCMap", {});
0183     psd.add<double>("maxDPtOPt", 0);
0184     psd.add<uint32_t>("vetoMode", 0);
0185     psd.add<edm::InputTag>("vetoSrc", {});
0186     psd.add<edm::InputTag>("timeValueMap", {});
0187     psd.add<edm::InputTag>("timeErrorMap", {});
0188     psd.add<edm::InputTag>("timeQualityMap", {});
0189     psd.add<double>("timeQualityThreshold", 0);
0190     psd.add<edm::InputTag>("timeValueMapGsf", {});
0191     psd.add<edm::InputTag>("timeErrorMapGsf", {});
0192     psd.add<edm::InputTag>("timeQualityMapGsf", {});
0193     psd.add<bool>("useTimeQuality", false);
0194     desc.addVPSet("elementImporters", psd, vpset);
0195   }
0196   //linking definitions
0197   // you can find a list of all available linkers in:
0198   //  plugins/linkers
0199   // see : plugins/kdtrees for available KDTree Types
0200   // to enable a KDTree for a linking pair, write a KDTree linker
0201   // and set useKDTree = True in the linker PSet
0202   //order does not matter here since we are defining a lookup table
0203   {
0204     std::vector<edm::ParameterSet> vpset;
0205     vpset.reserve(18);
0206     {
0207       edm::ParameterSet pset;
0208       pset.addParameter<std::string>("linkerName", "PreshowerAndECALLinker");
0209       pset.addParameter<std::string>("linkType", "PS1:ECAL");
0210       pset.addParameter<bool>("useKDTree ", true);
0211       vpset.emplace_back(pset);
0212     }
0213     {
0214       edm::ParameterSet pset;
0215       pset.addParameter<std::string>("linkerName", "PreshowerAndECALLinker");
0216       pset.addParameter<std::string>("linkType", "PS2:ECAL");
0217       pset.addParameter<bool>("useKDTree ", true);
0218       vpset.emplace_back(pset);
0219     }
0220     {
0221       edm::ParameterSet pset;
0222       pset.addParameter<std::string>("linkerName", "TrackAndECALLinker");
0223       pset.addParameter<std::string>("linkType", "TRACK:ECAL");
0224       pset.addParameter<bool>("useKDTree ", true);
0225       vpset.emplace_back(pset);
0226     }
0227     {
0228       edm::ParameterSet pset;
0229       pset.addParameter<std::string>("linkerName", "TrackAndHCALLinker");
0230       pset.addParameter<std::string>("linkType", "TRACK:HCAL");
0231       pset.addParameter<bool>("useKDTree", true);
0232       pset.addParameter<std::string>("trajectoryLayerEntrance", "HCALEntrance");
0233       pset.addParameter<std::string>("trajectoryLayerExit", "HCALExit");
0234       pset.addParameter<int>("nMaxHcalLinksPerTrack",
0235                              1);  // the max hcal links per track (negative values: no restriction)
0236       vpset.emplace_back(pset);
0237     }
0238     {
0239       edm::ParameterSet pset;
0240       pset.addParameter<std::string>("linkerName", "TrackAndHOLinker");
0241       pset.addParameter<std::string>("linkType", "TRACK:HO");
0242       pset.addParameter<bool>("useKDTree", false);
0243       vpset.emplace_back(pset);
0244     }
0245     {
0246       edm::ParameterSet pset;
0247       pset.addParameter<std::string>("linkerName", "ECALAndHCALLinker");
0248       pset.addParameter<std::string>("linkType", "ECAL:HCAL");
0249       pset.addParameter<double>("minAbsEtaEcal", 2.5);
0250       pset.addParameter<bool>("useKDTree", false);
0251       vpset.emplace_back(pset);
0252     }
0253     {
0254       edm::ParameterSet pset;
0255       pset.addParameter<std::string>("linkerName", "HCALAndHOLinker");
0256       pset.addParameter<std::string>("linkType", "HCAL:HO");
0257       pset.addParameter<bool>("useKDTree", false);
0258       vpset.emplace_back(pset);
0259     }
0260     {
0261       edm::ParameterSet pset;
0262       pset.addParameter<std::string>("linkerName", "HFEMAndHFHADLinker");
0263       pset.addParameter<std::string>("linkType", "HFEM:HFHAD");
0264       pset.addParameter<bool>("useKDTree", false);
0265       vpset.emplace_back(pset);
0266     }
0267     {
0268       edm::ParameterSet pset;
0269       pset.addParameter<std::string>("linkerName", "TrackAndTrackLinker");
0270       pset.addParameter<std::string>("linkType", "TRACK:TRACK");
0271       pset.addParameter<bool>("useKDTree", false);
0272       vpset.emplace_back(pset);
0273     }
0274     {
0275       edm::ParameterSet pset;
0276       pset.addParameter<std::string>("linkerName", "ECALAndECALLinker");
0277       pset.addParameter<std::string>("linkType", "ECAL:ECAL");
0278       pset.addParameter<bool>("useKDTree", false);
0279       vpset.emplace_back(pset);
0280     }
0281     {
0282       edm::ParameterSet pset;
0283       pset.addParameter<std::string>("linkerName", "GSFAndECALLinker");
0284       pset.addParameter<std::string>("linkType", "GSF:ECAL");
0285       pset.addParameter<bool>("useKDTree", false);
0286       vpset.emplace_back(pset);
0287     }
0288     {
0289       edm::ParameterSet pset;
0290       pset.addParameter<std::string>("linkerName", "TrackAndGSFLinker");
0291       pset.addParameter<std::string>("linkType", "TRACK:GSF");
0292       pset.addParameter<bool>("useKDTree", false);
0293       pset.addParameter<bool>("useConvertedBrems", true);
0294       vpset.emplace_back(pset);
0295     }
0296     {
0297       edm::ParameterSet pset;
0298       pset.addParameter<std::string>("linkerName", "GSFAndBREMLinker");
0299       pset.addParameter<std::string>("linkType", "GSF:BREM");
0300       pset.addParameter<bool>("useKDTree", false);
0301       vpset.emplace_back(pset);
0302     }
0303     {
0304       edm::ParameterSet pset;
0305       pset.addParameter<std::string>("linkerName", "GSFAndGSFLinker");
0306       pset.addParameter<std::string>("linkType", "GSF:GSF");
0307       pset.addParameter<bool>("useKDTree", false);
0308       vpset.emplace_back(pset);
0309     }
0310     {
0311       edm::ParameterSet pset;
0312       pset.addParameter<std::string>("linkerName", "ECALAndBREMLinker");
0313       pset.addParameter<std::string>("linkType", "ECAL:BREM");
0314       pset.addParameter<bool>("useKDTree", false);
0315       vpset.emplace_back(pset);
0316     }
0317     {
0318       edm::ParameterSet pset;
0319       pset.addParameter<std::string>("linkerName", "GSFAndHCALLinker");
0320       pset.addParameter<std::string>("linkType", "GSF:HCAL");
0321       pset.addParameter<bool>("useKDTree", false);
0322       vpset.emplace_back(pset);
0323     }
0324     {
0325       edm::ParameterSet pset;
0326       pset.addParameter<std::string>("linkerName", "HCALAndBREMLinker");
0327       pset.addParameter<std::string>("linkType", "HCAL:BREM");
0328       pset.addParameter<bool>("useKDTree", false);
0329       vpset.emplace_back(pset);
0330     }
0331     {
0332       edm::ParameterSet pset;
0333       pset.addParameter<std::string>("linkerName", "SCAndECALLinker");
0334       pset.addParameter<std::string>("linkType", "SC:ECAL");
0335       pset.addParameter<bool>("useKDTree", false);
0336       pset.addParameter<bool>("SuperClusterMatchByRef", true);
0337       vpset.emplace_back(pset);
0338     }
0339     edm::ParameterSetDescription psd;
0340     psd.add<std::string>("linkerName", "");
0341     psd.add<std::string>("linkType", "");
0342     psd.add<bool>("useKDTree", false);
0343     psd.add<std::string>("trajectoryLayerEntrance", "");
0344     psd.add<std::string>("trajectoryLayerExit", "");
0345     psd.add<int>("nMaxHcalLinksPerTrack", 0);
0346     psd.add<double>("minAbsEtaEcal", 0);
0347     psd.add<bool>("useConvertedBrems", false);
0348     psd.add<bool>("SuperClusterMatchByRef", false);
0349     desc.addVPSet("linkDefinitions", psd, vpset);
0350   }
0351   descriptions.addWithDefaultLabel(desc);
0352 }
0353
0354 using namespace std;
0355 using namespace edm;
0356
0357 PFBlockProducer::PFBlockProducer(const edm::ParameterSet& iConfig)
0358     : verbose_{iConfig.getUntrackedParameter<bool>("verbose", false)}, putToken_{produces<reco::PFBlockCollection>()} {
0359   bool debug_ = iConfig.getUntrackedParameter<bool>("debug", false);
0360   pfBlockAlgo_.setDebug(debug_);
0361
0362   edm::ConsumesCollector cc = consumesCollector();
0363   const std::vector<edm::ParameterSet>& importers = iConfig.getParameterSetVector("elementImporters");
0364   pfBlockAlgo_.setImporters(importers, cc);
0365
0366   const std::vector<edm::ParameterSet>& linkdefs = iConfig.getParameterSetVector("linkDefinitions");
0367   pfBlockAlgo_.setLinkers(linkdefs);
0368 }
0369
0370 void PFBlockProducer::beginLuminosityBlock(edm::LuminosityBlock const& lb, edm::EventSetup const& es) {
0371   pfBlockAlgo_.updateEventSetup(es);
0372 }
0373
0374 void PFBlockProducer::produce(Event& iEvent, const EventSetup& iSetup) {
0375   pfBlockAlgo_.buildElements(iEvent);
0376
0377   auto blocks = pfBlockAlgo_.findBlocks();
0378
0379   if (verbose_) {
0380     ostringstream str;
0381     str << pfBlockAlgo_ << endl;
0382     str << "number of blocks : " << blocks.size() << endl;
0383     str << endl;
0384
0385     for (auto const& block : blocks) {
0386       str << block << endl;
0387     }
0388
0389     LogInfo("PFBlockProducer") << str.str() << endl;
0390   }
0391
0392   iEvent.emplace(putToken_, blocks);
0393 }