Back to home page

Project CMSSW displayed by LXR

 
 

    


File indexing completed on 2024-12-25 02:13:48

0001 #include "FWCore/Framework/interface/stream/EDProducer.h"
0002 #include "FWCore/Framework/interface/Event.h"
0003 #include "FWCore/Utilities/interface/EDPutToken.h"
0004 #include "FWCore/Framework/interface/MakerMacros.h"
0005 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0006 #include "FWCore/ParameterSet/interface/EmptyGroupDescription.h"
0007 #include "DataFormats/EgammaCandidates/interface/GsfElectron.h"
0008 #include "DataFormats/ParticleFlowReco/interface/PFRecHit.h"
0009 #include "DataFormats/ParticleFlowReco/interface/PFBlockElementSuperCluster.h"
0010 #include "DataFormats/Common/interface/ValueMap.h"
0011 #include "RecoParticleFlow/PFProducer/interface/PFEGammaFilters.h"
0012 #include "RecoParticleFlow/PFProducer/interface/PFAlgo.h"
0013 #include "FWCore/Framework/interface/MakerMacros.h"
0014 #include "FWCore/Framework/interface/ESHandle.h"
0015 #include "FWCore/Framework/interface/EventSetup.h"
0016 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0017 #include "RecoParticleFlow/PFClusterTools/interface/PFEnergyCalibration.h"
0018 #include "RecoParticleFlow/PFClusterTools/interface/PFEnergyCalibrationHF.h"
0019 #include "CondFormats/PhysicsToolsObjects/interface/PerformancePayloadFromTFormula.h"
0020 #include "CondFormats/DataRecord/interface/PFCalibrationRcd.h"
0021 #include "CondFormats/DataRecord/interface/GBRWrapperRcd.h"
0022 
0023 #include <sstream>
0024 #include <string>
0025 
0026 #include "TFile.h"
0027 
0028 /**\class PFProducer
0029 \brief Producer for particle flow reconstructed particles (PFCandidates)
0030 
0031 This producer makes use of PFAlgo, the particle flow algorithm.
0032 
0033 \author Colin Bernet
0034 \date   July 2006
0035 */
0036 
0037 class PFProducer : public edm::stream::EDProducer<> {
0038 public:
0039   explicit PFProducer(const edm::ParameterSet&);
0040 
0041   void produce(edm::Event&, const edm::EventSetup&) override;
0042   void beginRun(const edm::Run&, const edm::EventSetup&) override;
0043 
0044   static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
0045 
0046 private:
0047   const edm::EDPutTokenT<reco::PFCandidateCollection> pfCandidatesToken_;
0048   const edm::EDPutTokenT<reco::PFCandidateCollection> pfCleanedCandidatesToken_;
0049   edm::ESGetToken<PerformancePayload, PFCalibrationRcd> perfToken_;
0050 
0051   const edm::EDGetTokenT<reco::PFBlockCollection> inputTagBlocks_;
0052   edm::EDGetTokenT<reco::MuonCollection> inputTagMuons_;
0053   edm::EDGetTokenT<reco::VertexCollection> vertices_;
0054   edm::EDGetTokenT<reco::GsfElectronCollection> inputTagEgammaElectrons_;
0055 
0056   std::vector<edm::EDGetTokenT<reco::PFRecHitCollection>> inputTagCleanedHF_;
0057   std::string electronExtraOutputCol_;
0058   std::string photonExtraOutputCol_;
0059 
0060   bool vetoEndcap_;
0061   edm::EDGetTokenT<reco::PFCandidateCollection> inputTagVetoes_;
0062 
0063   // NEW EGamma Filters
0064   edm::EDGetTokenT<edm::ValueMap<reco::GsfElectronRef>> inputTagValueMapGedElectrons_;
0065   edm::EDGetTokenT<edm::ValueMap<reco::PhotonRef>> inputTagValueMapGedPhotons_;
0066   edm::EDGetTokenT<edm::View<reco::PFCandidate>> inputTagPFEGammaCandidates_;
0067 
0068   bool use_EGammaFilters_;
0069   std::unique_ptr<PFEGammaFilters> pfegamma_ = nullptr;
0070 
0071   //Use of HO clusters and links in PF Reconstruction
0072   bool useHO_;
0073 
0074   /// verbose ?
0075   bool verbose_;
0076 
0077   // Post muon cleaning ?
0078   bool postMuonCleaning_;
0079 
0080   // what about e/g electrons ?
0081   bool useEGammaElectrons_;
0082 
0083   // Use vertices for Neutral particles ?
0084   bool useVerticesForNeutral_;
0085 
0086   // Take PF cluster calibrations from Global Tag ?
0087   bool useCalibrationsFromDB_;
0088   std::string calibrationsLabel_;
0089 
0090   bool postHFCleaning_;
0091   // Name of the calibration functions to read from the database
0092   // std::vector<std::string> fToRead;
0093 
0094   // calibrations
0095   PFEnergyCalibration pfEnergyCalibration_;
0096   PFEnergyCalibrationHF pfEnergyCalibrationHF_;
0097 
0098   /// particle flow algorithm
0099   PFAlgo pfAlgo_;
0100 };
0101 
0102 DEFINE_FWK_MODULE(PFProducer);
0103 
0104 using namespace std;
0105 using namespace edm;
0106 
0107 PFProducer::PFProducer(const edm::ParameterSet& iConfig)
0108     : pfCandidatesToken_{produces<reco::PFCandidateCollection>()},
0109       pfCleanedCandidatesToken_{produces<reco::PFCandidateCollection>("CleanedHF")},
0110       inputTagBlocks_(consumes<reco::PFBlockCollection>(iConfig.getParameter<InputTag>("blocks"))),
0111       pfEnergyCalibrationHF_(iConfig.getParameter<bool>("calibHF_use"),
0112                              iConfig.getParameter<std::vector<double>>("calibHF_eta_step"),
0113                              iConfig.getParameter<std::vector<double>>("calibHF_a_EMonly"),
0114                              iConfig.getParameter<std::vector<double>>("calibHF_b_HADonly"),
0115                              iConfig.getParameter<std::vector<double>>("calibHF_a_EMHAD"),
0116                              iConfig.getParameter<std::vector<double>>("calibHF_b_EMHAD")),
0117       pfAlgo_(iConfig.getParameter<double>("pf_nsigma_ECAL"),
0118               iConfig.getParameter<double>("pf_nsigma_HCAL"),
0119               iConfig.getParameter<double>("pf_nsigma_HFEM"),
0120               iConfig.getParameter<double>("pf_nsigma_HFHAD"),
0121               iConfig.getParameter<std::vector<double>>("resolHF_square"),
0122               pfEnergyCalibration_,
0123               pfEnergyCalibrationHF_,
0124               iConfig) {
0125   //Post cleaning of the muons
0126   inputTagMuons_ = consumes<reco::MuonCollection>(iConfig.getParameter<InputTag>("muons"));
0127   postMuonCleaning_ = iConfig.getParameter<bool>("postMuonCleaning");
0128   vetoEndcap_ = iConfig.getParameter<bool>("vetoEndcap");
0129   if (vetoEndcap_)
0130     inputTagVetoes_ = consumes<reco::PFCandidateCollection>(iConfig.getParameter<edm::InputTag>("vetoes"));
0131 
0132   use_EGammaFilters_ = iConfig.getParameter<bool>("useEGammaFilters");
0133   useEGammaElectrons_ = iConfig.getParameter<bool>("useEGammaElectrons");
0134 
0135   if (useEGammaElectrons_) {
0136     inputTagEgammaElectrons_ =
0137         consumes<reco::GsfElectronCollection>(iConfig.getParameter<edm::InputTag>("egammaElectrons"));
0138   }
0139 
0140   // register products
0141   produces<reco::PFCandidateCollection>("CleanedCosmicsMuons");
0142   produces<reco::PFCandidateCollection>("CleanedTrackerAndGlobalMuons");
0143   produces<reco::PFCandidateCollection>("CleanedFakeMuons");
0144   produces<reco::PFCandidateCollection>("CleanedPunchThroughMuons");
0145   produces<reco::PFCandidateCollection>("CleanedPunchThroughNeutralHadrons");
0146   produces<reco::PFCandidateCollection>("AddedMuonsAndHadrons");
0147 
0148   // Reading new EGamma selection cuts
0149   bool useProtectionsForJetMET(false);
0150 
0151   // Reading new EGamma ubiased collections and value maps
0152   if (use_EGammaFilters_) {
0153     inputTagPFEGammaCandidates_ =
0154         consumes<edm::View<reco::PFCandidate>>((iConfig.getParameter<edm::InputTag>("PFEGammaCandidates")));
0155     inputTagValueMapGedElectrons_ =
0156         consumes<edm::ValueMap<reco::GsfElectronRef>>(iConfig.getParameter<edm::InputTag>("GedElectronValueMap"));
0157     inputTagValueMapGedPhotons_ =
0158         consumes<edm::ValueMap<reco::PhotonRef>>(iConfig.getParameter<edm::InputTag>("GedPhotonValueMap"));
0159     useProtectionsForJetMET = iConfig.getParameter<bool>("useProtectionsForJetMET");
0160 
0161     const edm::ParameterSet pfEGammaFiltersParams =
0162         iConfig.getParameter<edm::ParameterSet>("PFEGammaFiltersParameters");
0163     pfegamma_ = std::make_unique<PFEGammaFilters>(pfEGammaFiltersParams);
0164   }
0165 
0166   // EGamma filters
0167   pfAlgo_.setEGammaParameters(use_EGammaFilters_, useProtectionsForJetMET);
0168 
0169   //Secondary tracks and displaced vertices parameters
0170 
0171   bool rejectTracks_Bad = iConfig.getParameter<bool>("rejectTracks_Bad");
0172 
0173   bool rejectTracks_Step45 = iConfig.getParameter<bool>("rejectTracks_Step45");
0174 
0175   bool usePFNuclearInteractions = iConfig.getParameter<bool>("usePFNuclearInteractions");
0176 
0177   bool usePFConversions = iConfig.getParameter<bool>("usePFConversions");
0178 
0179   bool usePFDecays = iConfig.getParameter<bool>("usePFDecays");
0180 
0181   double dptRel_DispVtx = iConfig.getParameter<double>("dptRel_DispVtx");
0182 
0183   useCalibrationsFromDB_ = iConfig.getParameter<bool>("useCalibrationsFromDB");
0184 
0185   if (useCalibrationsFromDB_) {
0186     calibrationsLabel_ = iConfig.getParameter<std::string>("calibrationsLabel");
0187     perfToken_ = esConsumes<edm::Transition::BeginRun>(edm::ESInputTag("", calibrationsLabel_));
0188   }
0189   // Secondary tracks and displaced vertices parameters
0190   pfAlgo_.setDisplacedVerticesParameters(
0191       rejectTracks_Bad, rejectTracks_Step45, usePFNuclearInteractions, usePFConversions, usePFDecays, dptRel_DispVtx);
0192 
0193   if (usePFNuclearInteractions)
0194     pfAlgo_.setCandConnectorParameters(iConfig.getParameter<edm::ParameterSet>("iCfgCandConnector"));
0195 
0196   // Post cleaning of the HF
0197   postHFCleaning_ = iConfig.getParameter<bool>("postHFCleaning");
0198   const edm::ParameterSet pfHFCleaningParams = iConfig.getParameter<edm::ParameterSet>("PFHFCleaningParameters");
0199 
0200   // Set post HF cleaning muon parameters
0201   pfAlgo_.setPostHFCleaningParameters(postHFCleaning_, pfHFCleaningParams);
0202 
0203   // Input tags for HF cleaned rechits
0204   std::vector<edm::InputTag> tags = iConfig.getParameter<std::vector<edm::InputTag>>("cleanedHF");
0205   for (unsigned int i = 0; i < tags.size(); ++i)
0206     inputTagCleanedHF_.push_back(consumes<reco::PFRecHitCollection>(tags[i]));
0207   //MIKE: Vertex Parameters
0208   vertices_ = consumes<reco::VertexCollection>(iConfig.getParameter<edm::InputTag>("vertexCollection"));
0209   useVerticesForNeutral_ = iConfig.getParameter<bool>("useVerticesForNeutral");
0210 
0211   // Use HO clusters and links in the PF reconstruction
0212   useHO_ = iConfig.getParameter<bool>("useHO");
0213   pfAlgo_.setHOTag(useHO_);
0214 
0215   verbose_ = iConfig.getUntrackedParameter<bool>("verbose", false);
0216 }
0217 
0218 void PFProducer::beginRun(const edm::Run& run, const edm::EventSetup& es) {
0219   if (useCalibrationsFromDB_) {
0220     // read the PFCalibration functions from the global tags
0221     auto perfH = es.getHandle(perfToken_);
0222 
0223     PerformancePayloadFromTFormula const* pfCalibrations =
0224         static_cast<const PerformancePayloadFromTFormula*>(perfH.product());
0225 
0226     pfEnergyCalibration_.setCalibrationFunctions(pfCalibrations);
0227   }
0228 }
0229 
0230 void PFProducer::produce(Event& iEvent, const EventSetup& iSetup) {
0231   LogDebug("PFProducer") << "START event: " << iEvent.id().event() << " in run " << iEvent.id().run() << endl;
0232 
0233   //Assign the PFAlgo Parameters
0234   pfAlgo_.setPFVertexParameters(useVerticesForNeutral_, iEvent.get(vertices_));
0235 
0236   // get the collection of blocks
0237   auto blocks = iEvent.getHandle(inputTagBlocks_);
0238   assert(blocks.isValid());
0239 
0240   // get and set the collection of muons (and collection of vetoes if specified)
0241   if (postMuonCleaning_) {
0242     pfAlgo_.setMuonHandle(iEvent.getHandle(inputTagMuons_));
0243     if (vetoEndcap_) {
0244       auto& muAlgo = *pfAlgo_.getPFMuonAlgo();
0245       muAlgo.setVetoes(iEvent.get(inputTagVetoes_));
0246     }
0247   }
0248 
0249   if (use_EGammaFilters_)
0250     pfAlgo_.setEGammaCollections(iEvent.get(inputTagPFEGammaCandidates_),
0251                                  iEvent.get(inputTagValueMapGedElectrons_),
0252                                  iEvent.get(inputTagValueMapGedPhotons_));
0253 
0254   LogDebug("PFProducer") << "particle flow is starting" << endl;
0255 
0256   pfAlgo_.reconstructParticles(blocks, pfegamma_.get());
0257 
0258   if (verbose_) {
0259     ostringstream str;
0260     str << pfAlgo_ << endl;
0261     LogInfo("PFProducer") << str.str() << endl;
0262   }
0263 
0264   // Check HF overcleaning
0265   if (postHFCleaning_) {
0266     reco::PFRecHitCollection hfCopy;
0267     for (unsigned ihf = 0; ihf < inputTagCleanedHF_.size(); ++ihf) {
0268       Handle<reco::PFRecHitCollection> hfCleaned;
0269       bool foundHF = iEvent.getByToken(inputTagCleanedHF_[ihf], hfCleaned);
0270       if (!foundHF)
0271         continue;
0272       for (unsigned jhf = 0; jhf < (*hfCleaned).size(); ++jhf) {
0273         hfCopy.push_back((*hfCleaned)[jhf]);
0274       }
0275     }
0276     pfAlgo_.checkCleaning(hfCopy);
0277   }
0278 
0279   // Save the final PFCandidate collection
0280   auto pOutputCandidateCollection = pfAlgo_.makeConnectedCandidates();
0281 
0282   LogDebug("PFProducer") << "particle flow: putting products in the event";
0283   if (verbose_) {
0284     int nC = 0;
0285     ostringstream ss;
0286     for (auto const& cand : pOutputCandidateCollection) {
0287       nC++;
0288       ss << "  " << nC << ") pid=" << cand.particleId() << " pt=" << cand.pt() << endl;
0289     }
0290     LogDebug("PFProducer") << "Here the full list:" << endl << ss.str();
0291   }
0292 
0293   // Write in the event
0294   iEvent.emplace(pfCandidatesToken_, std::move(pOutputCandidateCollection));
0295   iEvent.emplace(pfCleanedCandidatesToken_, std::move(pfAlgo_.getCleanedCandidates()));
0296 
0297   if (postMuonCleaning_) {
0298     auto& muAlgo = *pfAlgo_.getPFMuonAlgo();
0299     // Save cosmic cleaned muon candidates
0300     iEvent.put(muAlgo.transferCleanedCosmicCandidates(), "CleanedCosmicsMuons");
0301     // Save tracker/global cleaned muon candidates
0302     iEvent.put(muAlgo.transferCleanedTrackerAndGlobalCandidates(), "CleanedTrackerAndGlobalMuons");
0303     // Save fake cleaned muon candidates
0304     iEvent.put(muAlgo.transferCleanedFakeCandidates(), "CleanedFakeMuons");
0305     // Save punch-through cleaned muon candidates
0306     iEvent.put(muAlgo.transferPunchThroughCleanedMuonCandidates(), "CleanedPunchThroughMuons");
0307     // Save punch-through cleaned neutral hadron candidates
0308     iEvent.put(muAlgo.transferPunchThroughCleanedHadronCandidates(), "CleanedPunchThroughNeutralHadrons");
0309     // Save added muon candidates
0310     iEvent.put(muAlgo.transferAddedMuonCandidates(), "AddedMuonsAndHadrons");
0311   }
0312   pfAlgo_.clear();
0313 }
0314 
0315 void PFProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
0316   edm::ParameterSetDescription desc;
0317 
0318   // Verbosity and debug flags
0319   desc.addUntracked<bool>("verbose", false);
0320   desc.addUntracked<bool>("debug", false);
0321 
0322   // PF Blocks label
0323   desc.add<edm::InputTag>("blocks", edm::InputTag("particleFlowBlock"));
0324 
0325   // reco::muons label and Post Muon cleaning
0326   desc.add<edm::InputTag>("muons", edm::InputTag("muons1stStep"));
0327   desc.add<bool>("postMuonCleaning", true);
0328 
0329   // vetoEndcap flag and pf candidates for vetoes
0330   edm::ParameterSetDescription emptyDescription;
0331   desc.ifValue(edm::ParameterDescription<bool>("vetoEndcap", false, true),
0332                true >> edm::ParameterDescription<edm::InputTag>("vetoes", {"pfTICL"}, true) or
0333                    false >> edm::EmptyGroupDescription());
0334 
0335   // Vertices label
0336   desc.add<edm::InputTag>("vertexCollection", edm::InputTag("offlinePrimaryVertices"));
0337   desc.add<bool>("useVerticesForNeutral", true);
0338 
0339   // Use HO clusters in PF hadron reconstruction
0340   desc.add<bool>("useHO", true);
0341 
0342   // EGamma-related
0343   desc.add<edm::InputTag>("PFEGammaCandidates", edm::InputTag("particleFlowEGamma"));
0344   desc.add<edm::InputTag>("GedElectronValueMap", {"gedGsfElectronValueMapsTmp"});
0345   desc.add<edm::InputTag>("GedPhotonValueMap", edm::InputTag("gedPhotonsTmp", "valMapPFEgammaCandToPhoton"));
0346 
0347   desc.add<bool>("useEGammaElectrons", true);
0348   desc.add<edm::InputTag>("egammaElectrons", edm::InputTag("mvaElectrons"));
0349 
0350   desc.add<bool>("useEGammaFilters", true);
0351   desc.add<bool>("useProtectionsForJetMET", true);  // Propagated to PFEGammaFilters
0352 
0353   // For PFEGammaFilters
0354   edm::ParameterSetDescription psd_PFEGammaFilters;
0355   PFEGammaFilters::fillPSetDescription(psd_PFEGammaFilters);
0356   desc.add<edm::ParameterSetDescription>("PFEGammaFiltersParameters", psd_PFEGammaFilters);
0357 
0358   // Treatment of muons :
0359   // Expected energy in ECAL and HCAL, and RMS
0360   desc.add<std::vector<double>>("muon_HCAL", {3.0, 3.0});
0361   desc.add<std::vector<double>>("muon_ECAL", {0.5, 0.5});
0362   desc.add<std::vector<double>>("muon_HO", {0.9, 0.9});
0363 
0364   // For PFMuonAlgo
0365   edm::ParameterSetDescription psd_PFMuonAlgo;
0366   PFMuonAlgo::fillPSetDescription(psd_PFMuonAlgo);
0367   desc.add<edm::ParameterSetDescription>("PFMuonAlgoParameters", psd_PFMuonAlgo);
0368 
0369   // Input displaced vertices
0370   // It is strongly adviced to keep usePFNuclearInteractions = bCorrect
0371   desc.add<bool>("rejectTracks_Bad", true);
0372   desc.add<bool>("rejectTracks_Step45", true);
0373 
0374   desc.add<bool>("usePFNuclearInteractions", true);
0375   desc.add<bool>("usePFConversions", true);
0376   desc.add<bool>("usePFDecays", false);
0377 
0378   desc.add<double>("dptRel_DispVtx", 10.0);
0379 
0380   // PFCandConnector
0381   edm::ParameterSetDescription psd_CandConnector;
0382   PFCandConnector::fillPSetDescription(psd_CandConnector);
0383   desc.add<edm::ParameterSetDescription>("iCfgCandConnector", psd_CandConnector);
0384 
0385   // Treatment of potential fake tracks
0386   desc.add<double>("nsigma_TRACK", 1.0)->setComment("Number of sigmas for fake track detection");
0387   // pt_Error: dont forget to modify also ptErrorSecondary if you modify this parameter
0388   desc.add<double>("pt_Error", 1.0)
0389       ->setComment("Absolute pt error to detect fake tracks in the first three iterations");
0390   desc.add<std::vector<double>>("factors_45", {10.0, 100.0})
0391       ->setComment("Factors to be applied in the four and fifth steps to the pt error");
0392 
0393   // Treatment of tracks in region of bad HCal
0394   desc.add<double>("goodTrackDeadHcal_ptErrRel", 0.2)->setComment("trackRef->ptError()/trackRef->pt() < X");
0395   desc.add<double>("goodTrackDeadHcal_chi2n", 5)->setComment("trackRef->normalizedChi2() < X");
0396   desc.add<unsigned int>("goodTrackDeadHcal_layers", 4)
0397       ->setComment("trackRef->hitPattern().trackerLayersWithMeasurement() >= X");
0398   desc.add<double>("goodTrackDeadHcal_validFr", 0.5)->setComment("trackRef->validFraction() > X");
0399   desc.add<double>("goodTrackDeadHcal_dxy", 0.5)->setComment("abs(trackRef->dxy(primaryVertex_.position())) < X [cm]");
0400 
0401   desc.add<double>("goodPixelTrackDeadHcal_minEta", 2.3)->setComment("abs(trackRef->eta()) > X");
0402   desc.add<double>("goodPixelTrackDeadHcal_maxPt", 50.0)->setComment("trackRef->ptError()/trackRef->pt() < X");
0403   desc.add<double>("goodPixelTrackDeadHcal_ptErrRel", 1.0)->setComment("trackRef->ptError()/trackRef->pt() < X");
0404   desc.add<double>("goodPixelTrackDeadHcal_chi2n", 2)->setComment("trackRef->normalizedChi2() < X");
0405   desc.add<int>("goodPixelTrackDeadHcal_maxLost3Hit", 0)
0406       ->setComment(
0407           "max missing outer hits for a track with 3 valid pixel layers (can set to -1 to reject all these tracks)");
0408   desc.add<int>("goodPixelTrackDeadHcal_maxLost4Hit", 1)
0409       ->setComment("max missing outer hits for a track with >= 4 valid pixel layers");
0410   desc.add<double>("goodPixelTrackDeadHcal_dxy", 0.02)
0411       ->setComment("abs(trackRef->dxy(primaryVertex_.position())) < X [cm] ");
0412   desc.add<double>("goodPixelTrackDeadHcal_dz", 0.05)
0413       ->setComment("abs(trackRef->dz(primaryVertex_.position())) < X [cm]");
0414 
0415   // number of sigmas for neutral energy detection
0416   desc.add<double>("pf_nsigma_ECAL", 0.0);
0417   desc.add<double>("pf_nsigma_HCAL", 1.0);
0418   desc.add<double>("pf_nsigma_HFEM", 1.0);
0419   desc.add<double>("pf_nsigma_HFHAD", 1.0);
0420 
0421   // ECAL/HCAL PF cluster calibration : take it from global tag ?
0422   desc.add<bool>("useCalibrationsFromDB", true);
0423   desc.add<std::string>("calibrationsLabel", "");
0424 
0425   // Post HF cleaning
0426   desc.add<bool>("postHFCleaning", false);
0427   {
0428     edm::ParameterSetDescription psd_PFHFCleaning;
0429     psd_PFHFCleaning.add<double>("minHFCleaningPt", 5.0)
0430         ->setComment("Clean only objects with pt larger than this value");
0431     psd_PFHFCleaning.add<double>("maxSignificance", 2.5)
0432         ->setComment("Clean only if the initial MET/sqrt(sumet) is larger than this value");
0433     psd_PFHFCleaning.add<double>("minSignificance", 2.5)
0434         ->setComment("Clean only if the final MET/sqrt(sumet) is smaller than this value");
0435     psd_PFHFCleaning.add<double>("minSignificanceReduction", 1.4)
0436         ->setComment("Clean only if the significance reduction is larger than this value");
0437     psd_PFHFCleaning.add<double>("maxDeltaPhiPt", 7.0)
0438         ->setComment("Clean only if the MET and the to-be-cleaned object satisfy this DeltaPhi * Pt cut");
0439     // (the MET angular resoution is in 1/MET)
0440     psd_PFHFCleaning.add<double>("minDeltaMet", 0.4)
0441         ->setComment(
0442             "Clean only if the MET relative reduction from the to-be-cleaned object is larger than this value");
0443     desc.add<edm::ParameterSetDescription>("PFHFCleaningParameters", psd_PFHFCleaning);
0444   }
0445 
0446   // Check HF cleaning
0447   desc.add<std::vector<edm::InputTag>>("cleanedHF",
0448                                        {
0449                                            edm::InputTag("particleFlowRecHitHF", "Cleaned"),
0450                                            edm::InputTag("particleFlowClusterHF", "Cleaned"),
0451                                        });
0452 
0453   // calibration parameters for HF:
0454   desc.add<bool>("calibHF_use", false);
0455   desc.add<std::vector<double>>("calibHF_eta_step", {0.0, 2.9, 3.0, 3.2, 4.2, 4.4, 4.6, 4.8, 5.2, 5.4});
0456   desc.add<std::vector<double>>("calibHF_a_EMonly", {1., 1., 1., 1., 1., 1., 1., 1., 1., 1.});
0457   desc.add<std::vector<double>>("calibHF_a_EMHAD", {1., 1., 1., 1., 1., 1., 1., 1., 1., 1.});
0458   desc.add<std::vector<double>>("calibHF_b_HADonly", {1., 1., 1., 1., 1., 1., 1., 1., 1., 1.});
0459   desc.add<std::vector<double>>("calibHF_b_EMHAD", {1., 1., 1., 1., 1., 1., 1., 1., 1., 1.});
0460 
0461   // resolution parameters for HF: EPJC 53(2008)139, doi:10.1140/epjc/s10052-007-0459-4
0462   desc.add<std::vector<double>>("resolHF_square", {2.799 * 2.799, 0.114 * 0.114, 0.0 * 0.0})
0463       ->setComment("HF resolution - stochastic, constant, noise term squares");
0464 
0465   descriptions.add("particleFlow", desc);
0466 }