diff --git a/HLTrigger/Configuration/python/customizeHLTforCMSSW.py b/HLTrigger/Configuration/python/customizeHLTforCMSSW.py
index a024a925826bf..780544c5e1bed 100644
--- a/HLTrigger/Configuration/python/customizeHLTforCMSSW.py
+++ b/HLTrigger/Configuration/python/customizeHLTforCMSSW.py
@@ -17,6 +17,79 @@
 #                     pset.minGoodStripCharge = cms.PSet(refToPSet_ = cms.string('HLTSiStripClusterChargeCutNone'))
 #     return process
 
+#
+# PF config cleanup
+def customiseFor28110(process):
+
+    for producer in producers_by_type(process, "PFProducer"):
+        #
+        # kill cleaned-up parameters
+        if hasattr(producer, "iCfgCandConnector"):
+            pset = getattr(producer, "iCfgCandConnector")
+            delattr(pset,'bCalibSecondary')
+        toDelete=['algoType',
+                  'isolatedElectronID_mvaWeightFile',
+                  'pf_electronID_mvaWeightFile',
+                  'pf_electron_output_col',
+                  'minTrackerHits',
+                  'minPixelHits',
+                  'dzPV']
+        #
+        # kill parameters that are moved to sub-psets
+        # PFEGammaFiltersParameters
+        toDelete.extend(['electron_iso_pt',
+                         'electron_iso_mva_barrel',
+                         'electron_iso_mva_endcap',
+                         'electron_iso_combIso_barrel',
+                         'electron_iso_combIso_endcap',
+                         'electron_noniso_mvaCut',
+                         'electron_missinghits',
+                         'electron_ecalDrivenHademPreselCut',
+                         'electron_maxElePtForOnlyMVAPresel',
+                         'electron_protectionsForJetMET',
+                         'electron_protectionsForBadHcal',
+                         'photon_MinEt',
+                         'photon_combIso',
+                         'photon_HoE',
+                         'photon_SigmaiEtaiEta_barrel',
+                         'photon_SigmaiEtaiEta_endcap',
+                         'photon_protectionsForJetMET',
+                         'photon_protectionsForBadHcal'
+                         ])
+        # PFMuonAlgoParameters
+        toDelete.extend(['maxDPtOPt',
+                         'trackQuality',
+                         'ptErrorScale',
+                         'eventFractionForCleaning',
+                         'minPtForPostCleaning',
+                         'eventFactorForCosmics',
+                         'metSignificanceForCleaning',
+                         'metSignificanceForRejection',
+                         'metFactorForCleaning',
+                         'eventFractionForRejection',
+                         'metFactorForRejection',
+                         'metFactorForHighEta',
+                         'ptFactorForHighEta',
+                         'metFactorForFakes',
+                         'minMomentumForPunchThrough',
+                         'minEnergyForPunchThrough',
+                         'punchThroughFactor',
+                         'punchThroughMETFactor',
+                         'cosmicRejectionDistance'])
+        # Post HF cleaning
+        toDelete.extend(['minHFCleaningPt',
+                         'maxSignificance',
+                         'minSignificance',
+                         'minSignificanceReduction',
+                         'maxDeltaPhiPt',
+                         'minDeltaMet'])
+        #
+        # Actually kill them
+        for att in toDelete:
+            if (hasattr(producer, att)): delattr(producer, att)
+        #
+    return process
+
 def customiseFor2017DtUnpacking(process):
     """Adapt the HLT to run the legacy DT unpacking
     for pre2018 data/MC workflows as the default"""
@@ -52,4 +125,6 @@ def customizeHLTforCMSSW(process, menuType="GRun"):
     # add call to action function in proper order: newest last!
     # process = customiseFor12718(process)
 
+    process = customiseFor28110(process)
+
     return process
diff --git a/RecoJets/JetProducers/python/hltParticleFlowForJets_cfi.py b/RecoJets/JetProducers/python/hltParticleFlowForJets_cfi.py
index 92e1012efc83d..3d7860cca20ce 100644
--- a/RecoJets/JetProducers/python/hltParticleFlowForJets_cfi.py
+++ b/RecoJets/JetProducers/python/hltParticleFlowForJets_cfi.py
@@ -53,7 +53,7 @@
 )
 
 
-from RecoParticleFlow.PFProducer.particleFlow_cfi import particleFlowTmp
+from RecoParticleFlow.PFProducer.particleFlow_cff import particleFlowTmp
 
 hltParticleFlow = particleFlowTmp.clone(
     GedPhotonValueMap = cms.InputTag(""),
diff --git a/RecoParticleFlow/PFProducer/interface/PFAlgo.h b/RecoParticleFlow/PFProducer/interface/PFAlgo.h
index 086c03380769f..4440b98d5b884 100644
--- a/RecoParticleFlow/PFProducer/interface/PFAlgo.h
+++ b/RecoParticleFlow/PFProducer/interface/PFAlgo.h
@@ -84,13 +84,7 @@ class PFAlgo {
                             const edm::ValueMap<reco::GsfElectronRef>& valueMapGedElectrons,
                             const edm::ValueMap<reco::PhotonRef>& valueMapGedPhotons);
 
-  void setPostHFCleaningParameters(bool postHFCleaning,
-                                   double minHFCleaningPt,
-                                   double minSignificance,
-                                   double maxSignificance,
-                                   double minSignificanceReduction,
-                                   double maxDeltaPhiPt,
-                                   double minDeltaMet);
+  void setPostHFCleaningParameters(bool postHFCleaning, const edm::ParameterSet& pfHFCleaningParams);
 
   void setDisplacedVerticesParameters(bool rejectTracks_Bad,
                                       bool rejectTracks_Step45,
diff --git a/RecoParticleFlow/PFProducer/interface/PFCandConnector.h b/RecoParticleFlow/PFProducer/interface/PFCandConnector.h
index 846c5bb5768fa..580a7c034358b 100644
--- a/RecoParticleFlow/PFProducer/interface/PFCandConnector.h
+++ b/RecoParticleFlow/PFProducer/interface/PFCandConnector.h
@@ -2,12 +2,11 @@
 #define PFProducer_PFCandConnector_H_
 
 #include "DataFormats/ParticleFlowCandidate/interface/PFCandidate.h"
-
 #include "DataFormats/ParticleFlowCandidate/interface/PFCandidateFwd.h"
-
 #include "FWCore/MessageLogger/interface/MessageLogger.h"
-
 #include "FWCore/ParameterSet/interface/ParameterSet.h"
+#include "FWCore/ParameterSet/interface/ParameterSetDescription.h"
+
 // \author : M. Gouzevitch
 // \date : May 2010
 
@@ -79,6 +78,8 @@ class PFCandConnector {
                      double ptErrorSecondary,
                      const std::vector<double>& nuclCalibFactors);
 
+  static void fillPSetDescription(edm::ParameterSetDescription& iDesc);
+
   reco::PFCandidateCollection connect(reco::PFCandidateCollection& pfCand) const;
 
 private:
diff --git a/RecoParticleFlow/PFProducer/interface/PFEGammaFilters.h b/RecoParticleFlow/PFProducer/interface/PFEGammaFilters.h
index e229228e70f04..bd2eaacafa886 100644
--- a/RecoParticleFlow/PFProducer/interface/PFEGammaFilters.h
+++ b/RecoParticleFlow/PFProducer/interface/PFEGammaFilters.h
@@ -10,6 +10,7 @@
 #include "DataFormats/ParticleFlowCandidate/interface/PFCandidate.h"
 #include "DataFormats/ParticleFlowCandidate/interface/PFCandidateEGammaExtra.h"
 #include "FWCore/ParameterSet/interface/ParameterSet.h"
+#include "FWCore/ParameterSet/interface/ParameterSetDescription.h"
 
 #include <iostream>
 
@@ -28,6 +29,8 @@ class PFEGammaFilters {
 
   bool isPhotonSafeForJetMET(const reco::Photon &, const reco::PFCandidate &) const;
 
+  static void fillPSetDescription(edm::ParameterSetDescription &iDesc);
+
 private:
   bool passGsfElePreSelWithOnlyConeHadem(const reco::GsfElectron &) const;
 
diff --git a/RecoParticleFlow/PFProducer/interface/PFMuonAlgo.h b/RecoParticleFlow/PFProducer/interface/PFMuonAlgo.h
index 51c98731c6dd0..51b9f6199787b 100644
--- a/RecoParticleFlow/PFProducer/interface/PFMuonAlgo.h
+++ b/RecoParticleFlow/PFProducer/interface/PFMuonAlgo.h
@@ -5,6 +5,7 @@
 #include "DataFormats/VertexReco/interface/Vertex.h"
 #include "DataFormats/VertexReco/interface/VertexFwd.h"
 #include "FWCore/ParameterSet/interface/ParameterSet.h"
+#include "FWCore/ParameterSet/interface/ParameterSetDescription.h"
 #include "DataFormats/Common/interface/Handle.h"
 #include "DataFormats/MuonReco/interface/Muon.h"
 #include "DataFormats/MuonReco/interface/MuonFwd.h"
@@ -15,7 +16,9 @@ class PFMuonAlgo {
 
 public:
   /// constructor
-  PFMuonAlgo(edm::ParameterSet const&);
+  PFMuonAlgo(edm::ParameterSet const&, bool postMuonCleaning);
+
+  static void fillPSetDescription(edm::ParameterSetDescription& iDesc);
 
   ////STATIC MUON ID METHODS
   static bool isMuon(const reco::PFBlockElement& elt);
@@ -118,14 +121,14 @@ class PFMuonAlgo {
   const reco::VertexCollection* vertices_;
 
   //Configurables
+  // for PFMuonAlgo::goodMuonTracks/muonTracks
   const double maxDPtOPt_;
-  const int minTrackerHits_;
-  const int minPixelHits_;
+  // for PFMuonAlgo::reconstructMuon
   const reco::TrackBase::TrackQuality trackQuality_;
   const double errorCompScale_;
-  const double eventFractionCleaning_;
-  const double dzPV_;
+  // for postCleaning (postClean/addMissingMuons)
   const bool postCleaning_;
+  const double eventFractionCleaning_;
   const double minPostCleaningPt_;
   const double eventFactorCosmics_;
   const double metSigForCleaning_;
diff --git a/RecoParticleFlow/PFProducer/plugins/PFEGammaProducer.cc b/RecoParticleFlow/PFProducer/plugins/PFEGammaProducer.cc
index c130f990c5ca1..2578c8f27ecd5 100644
--- a/RecoParticleFlow/PFProducer/plugins/PFEGammaProducer.cc
+++ b/RecoParticleFlow/PFProducer/plugins/PFEGammaProducer.cc
@@ -184,8 +184,6 @@ void PFEGammaProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup
   std::list<reco::PFBlockRef> otherBlockRefs;
 
   for (unsigned i = 0; i < blocks->size(); ++i) {
-    // reco::PFBlockRef blockref( blockh,i );
-    //reco::PFBlockRef blockref = createBlockRef( *blocks, i);
     reco::PFBlockRef blockref(blocks, i);
 
     const edm::OwnVector<reco::PFBlockElement>& elements = blockref->elements();
diff --git a/RecoParticleFlow/PFProducer/plugins/PFProducer.cc b/RecoParticleFlow/PFProducer/plugins/PFProducer.cc
index 31db2b5af7833..4c79eb8b4c27b 100644
--- a/RecoParticleFlow/PFProducer/plugins/PFProducer.cc
+++ b/RecoParticleFlow/PFProducer/plugins/PFProducer.cc
@@ -49,6 +49,8 @@ class PFProducer : public edm::stream::EDProducer<> {
   void produce(edm::Event&, const edm::EventSetup&) override;
   void beginRun(const edm::Run&, const edm::EventSetup&) override;
 
+  static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
+
 private:
   const edm::EDPutTokenT<reco::PFCandidateCollection> pfCandidatesToken_;
   const edm::EDPutTokenT<reco::PFCandidateCollection> pfCleanedCandidatesToken_;
@@ -59,7 +61,6 @@ class PFProducer : public edm::stream::EDProducer<> {
   edm::EDGetTokenT<reco::GsfElectronCollection> inputTagEgammaElectrons_;
 
   std::vector<edm::EDGetTokenT<reco::PFRecHitCollection>> inputTagCleanedHF_;
-  std::string electronOutputCol_;
   std::string electronExtraOutputCol_;
   std::string photonExtraOutputCol_;
 
@@ -139,8 +140,6 @@ PFProducer::PFProducer(const edm::ParameterSet& iConfig)
         consumes<reco::GsfElectronCollection>(iConfig.getParameter<edm::InputTag>("egammaElectrons"));
   }
 
-  electronOutputCol_ = iConfig.getParameter<std::string>("pf_electron_output_col");
-
   // register products
   produces<reco::PFCandidateCollection>("CleanedCosmicsMuons");
   produces<reco::PFCandidateCollection>("CleanedTrackerAndGlobalMuons");
@@ -149,19 +148,6 @@ PFProducer::PFProducer(const edm::ParameterSet& iConfig)
   produces<reco::PFCandidateCollection>("CleanedPunchThroughNeutralHadrons");
   produces<reco::PFCandidateCollection>("AddedMuonsAndHadrons");
 
-  string mvaWeightFileEleID = iConfig.getParameter<string>("pf_electronID_mvaWeightFile");
-
-  string path_mvaWeightFileEleID;
-
-  //PFPhoton Configuration
-
-  string path_mvaWeightFileConvID;
-  string mvaWeightFileConvID;
-  string path_mvaWeightFileGCorr;
-  string path_mvaWeightFileLCorr;
-  string path_X0_Map;
-  string path_mvaWeightFileRes;
-
   // Reading new EGamma selection cuts
   bool useProtectionsForJetMET(false);
   // Reading new EGamma ubiased collections and value maps
@@ -194,37 +180,28 @@ PFProducer::PFProducer(const edm::ParameterSet& iConfig)
   if (useCalibrationsFromDB_)
     calibrationsLabel_ = iConfig.getParameter<std::string>("calibrationsLabel");
 
-  // NEW EGamma Filters
+  // EGamma filters
   pfAlgo_.setEGammaParameters(use_EGammaFilters_, useProtectionsForJetMET);
 
-  if (use_EGammaFilters_)
-    pfegamma_ = std::make_unique<PFEGammaFilters>(iConfig);
-
-  //Secondary tracks and displaced vertices parameters
+  if (use_EGammaFilters_) {
+    const edm::ParameterSet pfEGammaFiltersParams =
+        iConfig.getParameter<edm::ParameterSet>("PFEGammaFiltersParameters");
+    pfegamma_ = std::make_unique<PFEGammaFilters>(pfEGammaFiltersParams);
+  }
 
+  // Secondary tracks and displaced vertices parameters
   pfAlgo_.setDisplacedVerticesParameters(
       rejectTracks_Bad, rejectTracks_Step45, usePFNuclearInteractions, usePFConversions, usePFDecays, dptRel_DispVtx);
 
   if (usePFNuclearInteractions)
     pfAlgo_.setCandConnectorParameters(iConfig.getParameter<edm::ParameterSet>("iCfgCandConnector"));
 
-  //Post cleaning of the HF
+  // Post cleaning of the HF
   postHFCleaning_ = iConfig.getParameter<bool>("postHFCleaning");
-  double minHFCleaningPt = iConfig.getParameter<double>("minHFCleaningPt");
-  double minSignificance = iConfig.getParameter<double>("minSignificance");
-  double maxSignificance = iConfig.getParameter<double>("maxSignificance");
-  double minSignificanceReduction = iConfig.getParameter<double>("minSignificanceReduction");
-  double maxDeltaPhiPt = iConfig.getParameter<double>("maxDeltaPhiPt");
-  double minDeltaMet = iConfig.getParameter<double>("minDeltaMet");
+  const edm::ParameterSet pfHFCleaningParams = iConfig.getParameter<edm::ParameterSet>("PFHFCleaningParameters");
 
   // Set post HF cleaning muon parameters
-  pfAlgo_.setPostHFCleaningParameters(postHFCleaning_,
-                                      minHFCleaningPt,
-                                      minSignificance,
-                                      maxSignificance,
-                                      minSignificanceReduction,
-                                      maxDeltaPhiPt,
-                                      minDeltaMet);
+  pfAlgo_.setPostHFCleaningParameters(postHFCleaning_, pfHFCleaningParams);
 
   // Input tags for HF cleaned rechits
   std::vector<edm::InputTag> tags = iConfig.getParameter<std::vector<edm::InputTag>>("cleanedHF");
@@ -318,7 +295,6 @@ void PFProducer::produce(Event& iEvent, const EventSetup& iSetup) {
 
   if (postMuonCleaning_) {
     auto& muAlgo = *pfAlgo_.getPFMuonAlgo();
-
     // Save cosmic cleaned muon candidates
     iEvent.put(muAlgo.transferCleanedCosmicCandidates(), "CleanedCosmicsMuons");
     // Save tracker/global cleaned muon candidates
@@ -333,3 +309,144 @@ void PFProducer::produce(Event& iEvent, const EventSetup& iSetup) {
     iEvent.put(muAlgo.transferAddedMuonCandidates(), "AddedMuonsAndHadrons");
   }
 }
+
+void PFProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
+  edm::ParameterSetDescription desc;
+
+  // Verbosity and debug flags
+  desc.addUntracked<bool>("verbose", false);
+  desc.addUntracked<bool>("debug", false);
+
+  // PF Blocks label
+  desc.add<edm::InputTag>("blocks", edm::InputTag("particleFlowBlock"));
+
+  // reco::muons label and Post Muon cleaning
+  desc.add<edm::InputTag>("muons", edm::InputTag("muons1stStep"));
+  desc.add<bool>("postMuonCleaning", true);
+
+  // Vertices label
+  desc.add<edm::InputTag>("vertexCollection", edm::InputTag("offlinePrimaryVertices"));
+  desc.add<bool>("useVerticesForNeutral", true);
+
+  // Use HO clusters in PF hadron reconstruction
+  desc.add<bool>("useHO", true);
+
+  // EGamma-related
+  desc.add<edm::InputTag>("PFEGammaCandidates", edm::InputTag("particleFlowEGamma"));
+  desc.add<edm::InputTag>("GedElectronValueMap", edm::InputTag("gedGsfElectronsTmp"));
+  desc.add<edm::InputTag>("GedPhotonValueMap", edm::InputTag("gedPhotonsTmp", "valMapPFEgammaCandToPhoton"));
+
+  desc.add<bool>("useEGammaElectrons", true);
+  desc.add<edm::InputTag>("egammaElectrons", edm::InputTag("mvaElectrons"));
+
+  desc.add<bool>("useEGammaFilters", true);
+  desc.add<bool>("useProtectionsForJetMET", true);  // Propagated to PFEGammaFilters
+
+  // For PFEGammaFilters
+  edm::ParameterSetDescription psd_PFEGammaFilters;
+  PFEGammaFilters::fillPSetDescription(psd_PFEGammaFilters);
+  desc.add<edm::ParameterSetDescription>("PFEGammaFiltersParameters", psd_PFEGammaFilters);
+
+  // Treatment of muons :
+  // Expected energy in ECAL and HCAL, and RMS
+  desc.add<std::vector<double>>("muon_HCAL", {3.0, 3.0});
+  desc.add<std::vector<double>>("muon_ECAL", {0.5, 0.5});
+  desc.add<std::vector<double>>("muon_HO", {0.9, 0.9});
+
+  // For PFMuonAlgo
+  edm::ParameterSetDescription psd_PFMuonAlgo;
+  PFEGammaFilters::fillPSetDescription(psd_PFMuonAlgo);
+  desc.add<edm::ParameterSetDescription>("PFMuonAlgoParameters", psd_PFMuonAlgo);
+
+  // Input displaced vertices
+  // It is strongly adviced to keep usePFNuclearInteractions = bCorrect
+  desc.add<bool>("rejectTracks_Bad", true);
+  desc.add<bool>("rejectTracks_Step45", true);
+
+  desc.add<bool>("usePFNuclearInteractions", true);
+  desc.add<bool>("usePFConversions", true);
+  desc.add<bool>("usePFDecays", false);
+
+  desc.add<double>("dptRel_DispVtx", 10.0);
+
+  // PFCandConnector
+  edm::ParameterSetDescription psd_CandConnector;
+  PFCandConnector::fillPSetDescription(psd_CandConnector);
+  desc.add<edm::ParameterSetDescription>("iCfgCandConnector", psd_CandConnector);
+
+  // Treatment of potential fake tracks
+  desc.add<double>("nsigma_TRACK", 1.0)->setComment("Number of sigmas for fake track detection");
+  // pt_Error: dont forget to modify also ptErrorSecondary if you modify this parameter
+  desc.add<double>("pt_Error", 1.0)
+      ->setComment("Absolute pt error to detect fake tracks in the first three iterations");
+  desc.add<std::vector<double>>("factors_45", {10.0, 100.0})
+      ->setComment("Factors to be applied in the four and fifth steps to the pt error");
+
+  // Treatment of tracks in region of bad HCal
+  desc.add<double>("goodTrackDeadHcal_ptErrRel", 0.2)->setComment("trackRef->ptError()/trackRef->pt() < X");
+  desc.add<double>("goodTrackDeadHcal_chi2n", 5)->setComment("trackRef->normalizedChi2() < X");
+  desc.add<unsigned int>("goodTrackDeadHcal_layers", 4)
+      ->setComment("trackRef->hitPattern().trackerLayersWithMeasurement() >= X");
+  desc.add<double>("goodTrackDeadHcal_validFr", 0.5)->setComment("trackRef->validFraction() > X");
+  desc.add<double>("goodTrackDeadHcal_dxy", 0.5)->setComment("abs(trackRef->dxy(primaryVertex_.position())) < X [cm]");
+
+  desc.add<double>("goodPixelTrackDeadHcal_minEta", 2.3)->setComment("abs(trackRef->eta()) > X");
+  desc.add<double>("goodPixelTrackDeadHcal_maxPt", 50.0)->setComment("trackRef->ptError()/trackRef->pt() < X");
+  desc.add<double>("goodPixelTrackDeadHcal_ptErrRel", 1.0)->setComment("trackRef->ptError()/trackRef->pt() < X");
+  desc.add<double>("goodPixelTrackDeadHcal_chi2n", 2)->setComment("trackRef->normalizedChi2() < X");
+  desc.add<int>("goodPixelTrackDeadHcal_maxLost3Hit", 0)
+      ->setComment(
+          "max missing outer hits for a track with 3 valid pixel layers (can set to -1 to reject all these tracks)");
+  desc.add<int>("goodPixelTrackDeadHcal_maxLost4Hit", 1)
+      ->setComment("max missing outer hits for a track with >= 4 valid pixel layers");
+  desc.add<double>("goodPixelTrackDeadHcal_dxy", 0.02)
+      ->setComment("abs(trackRef->dxy(primaryVertex_.position())) < X [cm] ");
+  desc.add<double>("goodPixelTrackDeadHcal_dz", 0.05)
+      ->setComment("abs(trackRef->dz(primaryVertex_.position())) < X [cm]");
+
+  // number of sigmas for neutral energy detection
+  desc.add<double>("pf_nsigma_ECAL", 0.0);
+  desc.add<double>("pf_nsigma_HCAL", 1.0);
+
+  // ECAL/HCAL PF cluster calibration : take it from global tag ?
+  desc.add<bool>("useCalibrationsFromDB", true);
+  desc.add<std::string>("calibrationsLabel", "");
+
+  // Post HF cleaning
+  desc.add<bool>("postHFCleaning", false);
+  {
+    edm::ParameterSetDescription psd_PFHFCleaning;
+    psd_PFHFCleaning.add<double>("minHFCleaningPt", 5.0)
+        ->setComment("Clean only objects with pt larger than this value");
+    psd_PFHFCleaning.add<double>("maxSignificance", 2.5)
+        ->setComment("Clean only if the initial MET/sqrt(sumet) is larger than this value");
+    psd_PFHFCleaning.add<double>("minSignificance", 2.5)
+        ->setComment("Clean only if the final MET/sqrt(sumet) is smaller than this value");
+    psd_PFHFCleaning.add<double>("minSignificanceReduction", 1.4)
+        ->setComment("Clean only if the significance reduction is larger than this value");
+    psd_PFHFCleaning.add<double>("maxDeltaPhiPt", 7.0)
+        ->setComment("Clean only if the MET and the to-be-cleaned object satisfy this DeltaPhi * Pt cut");
+    // (the MET angular resoution is in 1/MET)
+    psd_PFHFCleaning.add<double>("minDeltaMet", 0.4)
+        ->setComment(
+            "Clean only if the MET relative reduction from the to-be-cleaned object is larger than this value");
+    desc.add<edm::ParameterSetDescription>("PFHFCleaningParameters", psd_PFHFCleaning);
+  }
+
+  // Check HF cleaning
+  desc.add<std::vector<edm::InputTag>>("cleanedHF",
+                                       {
+                                           edm::InputTag("particleFlowRecHitHF", "Cleaned"),
+                                           edm::InputTag("particleFlowClusterHF", "Cleaned"),
+                                       });
+
+  // calibration parameters for HF:
+  desc.add<bool>("calibHF_use", false);
+  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});
+  desc.add<std::vector<double>>("calibHF_a_EMonly", {1., 1., 1., 1., 1., 1., 1., 1., 1., 1.});
+  desc.add<std::vector<double>>("calibHF_a_EMHAD", {1., 1., 1., 1., 1., 1., 1., 1., 1., 1.});
+  desc.add<std::vector<double>>("calibHF_b_HADonly", {1., 1., 1., 1., 1., 1., 1., 1., 1., 1.});
+  desc.add<std::vector<double>>("calibHF_b_EMHAD", {1., 1., 1., 1., 1., 1., 1., 1., 1., 1.});
+
+  descriptions.add("particleFlow", desc);
+}
diff --git a/RecoParticleFlow/PFProducer/plugins/importers/GeneralTracksImporter.cc b/RecoParticleFlow/PFProducer/plugins/importers/GeneralTracksImporter.cc
index 7f7e38ca10cc9..7a53bac7ee2ad 100644
--- a/RecoParticleFlow/PFProducer/plugins/importers/GeneralTracksImporter.cc
+++ b/RecoParticleFlow/PFProducer/plugins/importers/GeneralTracksImporter.cc
@@ -24,7 +24,9 @@ class GeneralTracksImporter : public BlockElementImporterBase {
         useIterTracking_(conf.getParameter<bool>("useIterativeTracking")),
         cleanBadConvBrems_(
             conf.existsAs<bool>("cleanBadConvertedBrems") ? conf.getParameter<bool>("cleanBadConvertedBrems") : false) {
-    pfmu_ = std::unique_ptr<PFMuonAlgo>(new PFMuonAlgo(conf));
+    bool postMuonCleaning =
+        conf.existsAs<bool>("postMuonCleaning") ? conf.getParameter<bool>("postMuonCleaning") : false;
+    pfmu_ = std::unique_ptr<PFMuonAlgo>(new PFMuonAlgo(conf, postMuonCleaning));
   }
 
   void importToBlock(const edm::Event&, ElementList&) const override;
diff --git a/RecoParticleFlow/PFProducer/plugins/importers/GeneralTracksImporterWithVeto.cc b/RecoParticleFlow/PFProducer/plugins/importers/GeneralTracksImporterWithVeto.cc
index c415c2cc045f7..e8891f0f9284f 100644
--- a/RecoParticleFlow/PFProducer/plugins/importers/GeneralTracksImporterWithVeto.cc
+++ b/RecoParticleFlow/PFProducer/plugins/importers/GeneralTracksImporterWithVeto.cc
@@ -25,7 +25,9 @@ class GeneralTracksImporterWithVeto : public BlockElementImporterBase {
         useIterTracking_(conf.getParameter<bool>("useIterativeTracking")),
         cleanBadConvBrems_(
             conf.existsAs<bool>("cleanBadConvertedBrems") ? conf.getParameter<bool>("cleanBadConvertedBrems") : false) {
-    pfmu_ = std::unique_ptr<PFMuonAlgo>(new PFMuonAlgo(conf));
+    bool postMuonCleaning =
+        conf.existsAs<bool>("postMuonCleaning") ? conf.getParameter<bool>("postMuonCleaning") : false;
+    pfmu_ = std::unique_ptr<PFMuonAlgo>(new PFMuonAlgo(conf, postMuonCleaning));
   }
 
   void importToBlock(const edm::Event&, ElementList&) const override;
diff --git a/RecoParticleFlow/PFProducer/python/particleFlow_cff.py b/RecoParticleFlow/PFProducer/python/particleFlow_cff.py
index 218654dd96b22..db8d3cfff0dc8 100644
--- a/RecoParticleFlow/PFProducer/python/particleFlow_cff.py
+++ b/RecoParticleFlow/PFProducer/python/particleFlow_cff.py
@@ -8,3 +8,12 @@
 from RecoParticleFlow.PFProducer.particleFlow_cfi import *
 from RecoParticleFlow.PFProducer.particleFlowTmpPtrs_cfi import *
 
+particleFlowTmp = particleFlow.clone()
+
+from Configuration.Eras.Modifier_pf_badHcalMitigation_cff import pf_badHcalMitigation
+pf_badHcalMitigation.toModify(particleFlowTmp.PFEGammaFiltersParameters,
+        electron_protectionsForBadHcal = dict(enableProtections = True),
+        photon_protectionsForBadHcal   = dict(enableProtections = True))
+
+from Configuration.ProcessModifiers.egamma_lowPt_exclusive_cff import egamma_lowPt_exclusive
+egamma_lowPt_exclusive.toModify(particleFlowTmp.PFEGammaFiltersParameters,photon_MinEt = 1.)
diff --git a/RecoParticleFlow/PFProducer/python/particleFlow_cfi.py b/RecoParticleFlow/PFProducer/python/particleFlow_cfi.py
deleted file mode 100644
index f4dbe87ee77e4..0000000000000
--- a/RecoParticleFlow/PFProducer/python/particleFlow_cfi.py
+++ /dev/null
@@ -1,235 +0,0 @@
-import FWCore.ParameterSet.Config as cms
-
-particleFlowTmp = cms.EDProducer("PFProducer",
-
-    # PF Blocks label
-    blocks = cms.InputTag("particleFlowBlock"),
-
-    # reco::muons label and Post Muon cleaning
-    muons = cms.InputTag("muons1stStep"),
-    postMuonCleaning = cms.bool(True),
-
-    # Vertices label
-    vertexCollection = cms.InputTag("offlinePrimaryVertices"),
-    useVerticesForNeutral = cms.bool(True),
-
-    # Algorithm type ?
-    algoType = cms.uint32(0),
-
-    # Verbose and debug flags
-    verbose = cms.untracked.bool(False),
-    debug = cms.untracked.bool(False),
-
-    # Use HO clusters in PF hadron reconstruction
-    useHO = cms.bool(True),                                 
-
-    # Use electron identification in PFAlgo
-    pf_electron_output_col=cms.string('electrons'),
-    pf_electronID_mvaWeightFile = cms.string('RecoParticleFlow/PFProducer/data/MVAnalysis_BDT.weights_PfElectrons23Jan_IntToFloat.txt'),
-
-    useEGammaFilters = cms.bool(True),
-    useProtectionsForJetMET = cms.bool(True),    
-    # New electron selection cuts for CMSSW_700
-    electron_iso_pt = cms.double(10.0),
-    electron_iso_mva_barrel  = cms.double( -0.1875),
-    electron_iso_mva_endcap = cms.double( -0.1075),
-    electron_iso_combIso_barrel = cms.double(10.0),
-    electron_iso_combIso_endcap = cms.double(10.0),
-    electron_noniso_mvaCut = cms.double(-0.1),                            
-    electron_missinghits = cms.uint32(1),
-    electron_ecalDrivenHademPreselCut = cms.double(0.15),
-    electron_maxElePtForOnlyMVAPresel = cms.double(50.),
-    isolatedElectronID_mvaWeightFile = cms.string('RecoEgamma/ElectronIdentification/data/TMVA_BDTSimpleCat_17Feb2011.weights.xml'),
-    # maxNtracks,maxHcalE,maxTrackPOverEele,maxE,maxEleHcalEOverEcalE,maxEcalEOverPRes
-    # maxEeleOverPoutRes,maxHcalEOverP,maxHcalEOverEcalE,maxEcalEOverP_cut1,axEcalEOverP_cut2,maxEeleOverPout,maxDPhiIN;                             
-    electron_protectionsForJetMET = cms.PSet(
-    maxNtracks = cms.double(3.0), #max tracks pointing at Ele cluster
-    maxHcalE = cms.double(10.0),
-    maxTrackPOverEele = cms.double(1.0),
-    maxE = cms.double(50.0), #for dphi cut
-    maxEleHcalEOverEcalE = cms.double(0.1),
-    maxEcalEOverPRes = cms.double(0.2),
-    maxEeleOverPoutRes = cms.double(0.5),
-    maxHcalEOverP = cms.double(1.0),
-    maxHcalEOverEcalE = cms.double(0.1),
-    maxEcalEOverP_1 = cms.double(0.5), #pion rejection
-    maxEcalEOverP_2 = cms.double(0.2), #weird events
-    maxEeleOverPout = cms.double(0.2),
-    maxDPhiIN = cms.double(0.1)    
-    ),
-    electron_protectionsForBadHcal = cms.PSet(
-        enableProtections = cms.bool(False),   
-        full5x5_sigmaIetaIeta = cms.vdouble(0.0106, 0.0387), # EB, EE; 94Xv2 cut-based medium id
-        eInvPInv = cms.vdouble(0.184, 0.0721),
-        dEta = cms.vdouble(0.0032*2, 0.00632*2), # relax factor 2 to be safer against misalignment
-        dPhi = cms.vdouble(0.0547, 0.0394),
-    ),
-    # New photon selection cuts for CMSSW_700
-    photon_MinEt = cms.double(10.),
-    photon_combIso = cms.double(10.),
-    photon_HoE =  cms.double(0.05),
-    photon_SigmaiEtaiEta_barrel = cms.double(0.0125),
-    photon_SigmaiEtaiEta_endcap = cms.double(0.034),                             
-    photon_protectionsForBadHcal = cms.PSet(
-        enableProtections = cms.bool(False),   
-        solidConeTrkIsoOffset = cms.double(10.),
-        solidConeTrkIsoSlope  = cms.double(0.3),
-    ),
-
-    # sumPtTrackIso, sumPtTrackIsoSlope                          
-    photon_protectionsForJetMET = cms.PSet(
-    sumPtTrackIso = cms.double(4.0),
-    sumPtTrackIsoSlope = cms.double(0.001)
-    ),
-    PFEGammaCandidates = cms.InputTag("particleFlowEGamma"),
-    GedElectronValueMap = cms.InputTag("gedGsfElectronsTmp"),
-    GedPhotonValueMap = cms.InputTag("gedPhotonsTmp","valMapPFEgammaCandToPhoton"),
-
-    useEGammaElectrons = cms.bool(True),                                 
-    egammaElectrons = cms.InputTag('mvaElectrons'),                              
-
-    # Input displaced vertices
-    # It is strongly adviced to keep usePFNuclearInteractions = bCorrect                       
-                              
-    rejectTracks_Bad =  cms.bool(True),
-    rejectTracks_Step45 = cms.bool(True),
-
-    usePFNuclearInteractions = cms.bool(True),
-    usePFConversions = cms.bool(True),
-    usePFDecays = cms.bool(False),
-
-    dptRel_DispVtx = cms.double(10.),
-
-    iCfgCandConnector = cms.PSet(
-    
-	 bCorrect         =  cms.bool(True), 
-	 bCalibPrimary    =  cms.bool(True),
-         dptRel_PrimaryTrack = cms.double(10.),
-         dptRel_MergedTrack = cms.double(5.0),
-         ptErrorSecondary = cms.double(1.0),
-	 nuclCalibFactors =  cms.vdouble(0.8, 0.15, 0.5, 0.5, 0.05)
-    ),
-
-    
-
-    # Treatment of muons : 
-    # Expected energy in ECAL and HCAL, and RMS
-    muon_HCAL = cms.vdouble(3.0,3.0),
-    muon_ECAL = cms.vdouble(0.5,0.5),
-    muon_HO = cms.vdouble(0.9,0.9),		
-
-    # Muon ID and post cleaning parameters
-    maxDPtOPt      = cms.double(1.),                                 
-    minTrackerHits = cms.int32(8),
-    minPixelHits   = cms.int32(1),
-    trackQuality   = cms.string('highPurity'),
-    dzPV = cms.double(0.2),
-    ptErrorScale   = cms.double(8.),
-    minPtForPostCleaning = cms.double(20.),
-    eventFactorForCosmics =cms.double(10.),
-    metSignificanceForCleaning = cms.double(3.),
-    metSignificanceForRejection = cms.double(4.),
-    metFactorForCleaning = cms.double(4.),
-    eventFractionForCleaning =cms.double(0.5),
-    eventFractionForRejection = cms.double(0.8),
-    metFactorForRejection =cms.double(4.),
-    metFactorForHighEta   = cms.double(25.),
-    ptFactorForHighEta   = cms.double(2.),
-    metFactorForFakes    = cms.double(4.),
-    minMomentumForPunchThrough = cms.double(100.),
-    minEnergyForPunchThrough = cms.double(100.),
-    punchThroughFactor = cms.double(3.),                             
-    punchThroughMETFactor = cms.double(4.),                             
-    cosmicRejectionDistance = cms.double(1.),
-                                 
-    # Treatment of potential fake tracks
-    # Number of sigmas for fake track detection
-    nsigma_TRACK = cms.double(1.0),
-    # Absolute pt error to detect fake tracks in the first three iterations
-    # dont forget to modify also ptErrorSecondary if you modify this parameter
-    pt_Error = cms.double(1.0),
-    # Factors to be applied in the four and fifth steps to the pt error
-    factors_45 = cms.vdouble(10.,100.),
-
-    # Treatment of tracks in region of bad HCal
-    goodTrackDeadHcal_ptErrRel = cms.double(0.2), # trackRef->ptError()/trackRef->pt() < X
-    goodTrackDeadHcal_chi2n = cms.double(5),      # trackRef->normalizedChi2() < X
-    goodTrackDeadHcal_layers = cms.uint32(4),     # trackRef->hitPattern().trackerLayersWithMeasurement() >= X
-    goodTrackDeadHcal_validFr = cms.double(0.5),  # trackRef->validFraction() > X
-    goodTrackDeadHcal_dxy = cms.double(0.5),      # [cm] abs(trackRef->dxy(primaryVertex_.position())) < X
-
-    goodPixelTrackDeadHcal_minEta = cms.double(2.3),   # abs(trackRef->eta()) > X
-    goodPixelTrackDeadHcal_maxPt  = cms.double(50.),   # trackRef->ptError()/trackRef->pt() < X
-    goodPixelTrackDeadHcal_ptErrRel = cms.double(1.0), # trackRef->ptError()/trackRef->pt() < X
-    goodPixelTrackDeadHcal_chi2n = cms.double(2),      # trackRef->normalizedChi2() < X
-    goodPixelTrackDeadHcal_maxLost3Hit = cms.int32(0), # max missing outer hits for a track with 3 valid pixel layers (can set to -1 to reject all these tracks)
-    goodPixelTrackDeadHcal_maxLost4Hit = cms.int32(1), # max missing outer hits for a track with >= 4 valid pixel layers
-    goodPixelTrackDeadHcal_dxy = cms.double(0.02),     # [cm] abs(trackRef->dxy(primaryVertex_.position())) < X
-    goodPixelTrackDeadHcal_dz  = cms.double(0.05),     # [cm] abs(trackRef->dz(primaryVertex_.position())) < X
-
- 
-    # Post HF cleaning
-    postHFCleaning = cms.bool(False),
-    # Clean only objects with pt larger than this value
-    minHFCleaningPt = cms.double(5.),
-    # Clean only if the initial MET/sqrt(sumet) is larger than this value
-    maxSignificance = cms.double(2.5),                          
-    # Clean only if the final MET/sqrt(sumet) is smaller than this value
-    minSignificance = cms.double(2.5),
-    # Clean only if the significance reduction is larger than this value
-    minSignificanceReduction = cms.double(1.4),
-    # Clean only if the MET and the to-be-cleaned object satisfy this DeltaPhi * Pt cut
-    # (the MET angular resoution is in 1/MET) 
-    maxDeltaPhiPt = cms.double(7.0),
-    # Clean only if the MET relative reduction from the to-be-cleaned object
-    # is larger than this value
-    minDeltaMet = cms.double(0.4),
-
-    # Check HF cleaning
-    cleanedHF = cms.VInputTag(
-                cms.InputTag("particleFlowRecHitHF","Cleaned"),
-                cms.InputTag("particleFlowClusterHF","Cleaned")
-                ),
-    
-    # number of sigmas for neutral energy detection
-    pf_nsigma_ECAL = cms.double(0.0),
-    pf_nsigma_HCAL = cms.double(1.0),
-
-    # ECAL/HCAL PF cluster calibration : take it from global tag ?
-    useCalibrationsFromDB = cms.bool(True),
-    calibrationsLabel = cms.string(''),
-
-    # calibration parameters for HF:
-    calibHF_use = cms.bool(False),
-    calibHF_eta_step  = cms.vdouble(0.0,2.90,3.00,3.20,4.20,4.40,4.60,4.80,5.20,5.40),
-#    calibHF_a_EMonly  = cms.vdouble(10.00,10.00,10.00,10.00,10.00,10.00,10.00,10.00,10.00,10.00,10.00),
-#    calibHF_b_HADonly = cms.vdouble(10.00,10.00,10.00,10.00,10.00,10.00,10.00,10.00,10.00,10.00,10.00),
-#    calibHF_a_EMHAD   = cms.vdouble(10.00,10.00,10.00,10.00,10.00,10.00,10.00,10.00,10.00,10.00,10.00),
-#    calibHF_b_EMHAD   = cms.vdouble(10.00,10.00,10.00,10.00,10.00,10.00,10.00,10.00,10.00,10.00,10.00)
-    calibHF_a_EMonly  = cms.vdouble(0.96945,0.96701,0.76309,0.82268,0.87583,0.89718,0.98674,1.4681,1.4580,1.4580),
-    calibHF_b_HADonly = cms.vdouble(1.27541,0.85361,0.86333,0.89091,0.94348,0.94348,0.94370,1.0034,1.0444,1.0444),
-    calibHF_a_EMHAD   = cms.vdouble(1.42215,1.00496,0.68961,0.81656,0.98504,0.98504,1.00802,1.0593,1.4576,1.4576),
-    calibHF_b_EMHAD   = cms.vdouble(1.27541,0.85361,0.86333,0.89091,0.94348,0.94348,0.94370,1.0034,1.0444,1.0444)
- 
-#    toRead = cms.untracked.vstring("PFfa_BARREL",
-#                                   "PFfa_ENDCAP",
-#                                   "PFfb_BARREL",
-#                                   "PFfb_ENDCAP",
-#                                   "PFfc_BARREL",
-#                                   "PFfc_ENDCAP",
-#                                   "PFfaEta_BARREL",
-#                                   "PFfaEta_ENDCAP",
-#                                   "PFfbEta_BARREL",
-#                                   "PFfbEta_ENDCAP") # same strings as fType
-
-)
-
-
-
-from Configuration.Eras.Modifier_pf_badHcalMitigation_cff import pf_badHcalMitigation
-pf_badHcalMitigation.toModify(particleFlowTmp,
-        electron_protectionsForBadHcal = dict(enableProtections = True),
-        photon_protectionsForBadHcal   = dict(enableProtections = True))
-
-from Configuration.ProcessModifiers.egamma_lowPt_exclusive_cff import egamma_lowPt_exclusive
-egamma_lowPt_exclusive.toModify(particleFlowTmp,photon_MinEt = 1.)
diff --git a/RecoParticleFlow/PFProducer/src/PFAlgo.cc b/RecoParticleFlow/PFProducer/src/PFAlgo.cc
index 4163ff72e0503..2f086d35534d6 100644
--- a/RecoParticleFlow/PFProducer/src/PFAlgo.cc
+++ b/RecoParticleFlow/PFProducer/src/PFAlgo.cc
@@ -23,7 +23,9 @@ PFAlgo::PFAlgo(double nSigmaECAL,
       calibration_(calibration),
       thepfEnergyCalibrationHF_(thepfEnergyCalibrationHF),
       connector_() {
-  pfmu_ = std::make_unique<PFMuonAlgo>(pset);
+  const edm::ParameterSet pfMuonAlgoParams = pset.getParameter<edm::ParameterSet>("PFMuonAlgoParameters");
+  bool postMuonCleaning = pset.getParameter<bool>("postMuonCleaning");
+  pfmu_ = std::make_unique<PFMuonAlgo>(pfMuonAlgoParams, postMuonCleaning);
 
   // Muon parameters
   muonHCAL_ = pset.getParameter<std::vector<double>>("muon_HCAL");
@@ -74,20 +76,14 @@ void PFAlgo::setEGammaCollections(const edm::View<reco::PFCandidate>& pfEgammaCa
 
 void PFAlgo::setMuonHandle(const edm::Handle<reco::MuonCollection>& muons) { muonHandle_ = muons; }
 
-void PFAlgo::setPostHFCleaningParameters(bool postHFCleaning,
-                                         double minHFCleaningPt,
-                                         double minSignificance,
-                                         double maxSignificance,
-                                         double minSignificanceReduction,
-                                         double maxDeltaPhiPt,
-                                         double minDeltaMet) {
+void PFAlgo::setPostHFCleaningParameters(bool postHFCleaning, const edm::ParameterSet& pfHFCleaningParams) {
   postHFCleaning_ = postHFCleaning;
-  minHFCleaningPt_ = minHFCleaningPt;
-  minSignificance_ = minSignificance;
-  maxSignificance_ = maxSignificance;
-  minSignificanceReduction_ = minSignificanceReduction;
-  maxDeltaPhiPt_ = maxDeltaPhiPt;
-  minDeltaMet_ = minDeltaMet;
+  minHFCleaningPt_ = pfHFCleaningParams.getParameter<double>("minHFCleaningPt");
+  minSignificance_ = pfHFCleaningParams.getParameter<double>("minSignificance");
+  maxSignificance_ = pfHFCleaningParams.getParameter<double>("maxSignificance");
+  minSignificanceReduction_ = pfHFCleaningParams.getParameter<double>("minSignificanceReduction");
+  maxDeltaPhiPt_ = pfHFCleaningParams.getParameter<double>("maxDeltaPhiPt");
+  minDeltaMet_ = pfHFCleaningParams.getParameter<double>("minDeltaMet");
 }
 
 void PFAlgo::setDisplacedVerticesParameters(bool rejectTracks_Bad,
@@ -1311,6 +1307,8 @@ void PFAlgo::createCandidatesHCAL(const reco::PFBlock& block,
   LogTrace("PFAlgo|createCandidatesHCAL")
       << "start of function PFAlgo::createCandidatesHCAL, inds.hcalIs.size()=" << inds.hcalIs.size();
 
+  // --------------- loop hcal ------------------
+
   for (unsigned iHcal : inds.hcalIs) {
     PFBlockElement::Type type = elements[iHcal].type();
 
@@ -2419,7 +2417,9 @@ void PFAlgo::createCandidatesHCALUnlinked(const reco::PFBlock& block,
                                           std::vector<bool>& deadArea) {
   // Processing the remaining HCAL clusters
   LogTrace("PFAlgo|createCandidatesHCALUnlinked")
-      << "start of function, PFAlgo::createCandidatesHCALUnlinked, hcalIs.size()=" << inds.hcalIs.size();
+      << "start of function PFAlgo::createCandidatesHCALUnlinked, hcalIs.size()=" << inds.hcalIs.size();
+
+  // --------------- loop remaining hcal ------------------
 
   for (unsigned iHcal : inds.hcalIs) {
     // Keep ECAL and HO elements for reference in the PFCandidate
@@ -2615,7 +2615,9 @@ void PFAlgo::createCandidatesECAL(const reco::PFBlock& block,
                                   ElementIndices& inds,
                                   std::vector<bool>& deadArea) {
   LogTrace("PFAlgo|createCandidatesECAL")
-      << "start of function PFALgo::createCandidatesECAL(), ecalIs.size()=" << inds.ecalIs.size();
+      << "start of function PFAlgo::createCandidatesECAL(), ecalIs.size()=" << inds.ecalIs.size();
+
+  // --------------- loop ecal ------------------
 
   // for each ecal element iEcal = ecalIs[i] in turn:
 
diff --git a/RecoParticleFlow/PFProducer/src/PFCandConnector.cc b/RecoParticleFlow/PFProducer/src/PFCandConnector.cc
index 872906d6740da..2ec78adb785cc 100644
--- a/RecoParticleFlow/PFProducer/src/PFCandConnector.cc
+++ b/RecoParticleFlow/PFProducer/src/PFCandConnector.cc
@@ -551,3 +551,12 @@ double PFCandConnector::rescaleFactor(const double pt, const double cFrac) const
 
   return factor;
 }
+
+void PFCandConnector::fillPSetDescription(edm::ParameterSetDescription& iDesc) {
+  iDesc.add<bool>("bCorrect", true);
+  iDesc.add<bool>("bCalibPrimary", true);
+  iDesc.add<double>("dptRel_PrimaryTrack", 10.0);
+  iDesc.add<double>("dptRel_MergedTrack", 5.0);
+  iDesc.add<double>("ptErrorSecondary", 1.0);
+  iDesc.add<std::vector<double>>("nuclCalibFactors", {0.8, 0.15, 0.5, 0.5, 0.05});
+}
diff --git a/RecoParticleFlow/PFProducer/src/PFEGammaFilters.cc b/RecoParticleFlow/PFProducer/src/PFEGammaFilters.cc
index 1a33b9f27d686..172bdcc5a8cb3 100644
--- a/RecoParticleFlow/PFProducer/src/PFEGammaFilters.cc
+++ b/RecoParticleFlow/PFProducer/src/PFEGammaFilters.cc
@@ -63,8 +63,8 @@ PFEGammaFilters::PFEGammaFilters(const edm::ParameterSet& cfg)
   readEBEEParams_(eleProtectionsForBadHcal, "eInvPInv", badHcal_eInvPInv_);
   readEBEEParams_(eleProtectionsForBadHcal, "dEta", badHcal_dEta_);
   readEBEEParams_(eleProtectionsForBadHcal, "dPhi", badHcal_dPhi_);
-
   badHcal_eleEnable_ = eleProtectionsForBadHcal.getParameter<bool>("enableProtections");
+
   badHcal_phoTrkSolidConeIso_offs_ = phoProtectionsForBadHcal.getParameter<double>("solidConeTrkIsoOffset");
   badHcal_phoTrkSolidConeIso_slope_ = phoProtectionsForBadHcal.getParameter<double>("solidConeTrkIsoSlope");
   badHcal_phoEnable_ = phoProtectionsForBadHcal.getParameter<bool>("enableProtections");
@@ -404,3 +404,64 @@ bool PFEGammaFilters::passGsfElePreSelWithOnlyConeHadem(const reco::GsfElectron&
   } else
     return passCutBased || passMVA;
 }
+
+void PFEGammaFilters::fillPSetDescription(edm::ParameterSetDescription& iDesc) {
+  // Electron selection cuts
+  iDesc.add<double>("electron_iso_pt", 10.0);
+  iDesc.add<double>("electron_iso_mva_barrel", -0.1875);
+  iDesc.add<double>("electron_iso_mva_endcap", -0.1075);
+  iDesc.add<double>("electron_iso_combIso_barrel", 10.0);
+  iDesc.add<double>("electron_iso_combIso_endcap", 10.0);
+  iDesc.add<double>("electron_noniso_mvaCut", -0.1);
+  iDesc.add<unsigned int>("electron_missinghits", 1);
+  iDesc.add<double>("electron_ecalDrivenHademPreselCut", 0.15);
+  iDesc.add<double>("electron_maxElePtForOnlyMVAPresel", 50.0);
+  {
+    edm::ParameterSetDescription psd;
+    psd.add<double>("maxNtracks", 3.0)->setComment("Max tracks pointing at Ele cluster");
+    psd.add<double>("maxHcalE", 10.0);
+    psd.add<double>("maxTrackPOverEele", 1.0);
+    psd.add<double>("maxE", 50.0)->setComment("Above this maxE, consider dphi(SC,track) cut");
+    psd.add<double>("maxEleHcalEOverEcalE", 0.1);
+    psd.add<double>("maxEcalEOverPRes", 0.2);
+    psd.add<double>("maxEeleOverPoutRes", 0.5);
+    psd.add<double>("maxHcalEOverP", 1.0);
+    psd.add<double>("maxHcalEOverEcalE", 0.1);
+    psd.add<double>("maxEcalEOverP_1", 0.5)->setComment("E(SC)/P cut - pion rejection");
+    psd.add<double>("maxEcalEOverP_2", 0.2)->setComment("E(SC)/P cut - weird ele rejection");
+    psd.add<double>("maxEeleOverPout", 0.2);
+    psd.add<double>("maxDPhiIN", 0.1)->setComment("Above this dphi(SC,track) and maxE, considered not safe");
+    iDesc.add<edm::ParameterSetDescription>("electron_protectionsForJetMET", psd);
+  }
+  {
+    edm::ParameterSetDescription psd;
+    psd.add<bool>("enableProtections", false);
+    psd.add<std::vector<double>>("full5x5_sigmaIetaIeta",  // EB, EE; 94Xv2 cut-based medium id
+                                 {0.0106, 0.0387});
+    psd.add<std::vector<double>>("eInvPInv", {0.184, 0.0721});
+    psd.add<std::vector<double>>("dEta",  // relax factor 2 to be safer against misalignment
+                                 {0.0032 * 2, 0.00632 * 2});
+    psd.add<std::vector<double>>("dPhi", {0.0547, 0.0394});
+    iDesc.add<edm::ParameterSetDescription>("electron_protectionsForBadHcal", psd);
+  }
+
+  // Photon selection cuts
+  iDesc.add<double>("photon_MinEt", 10.0);
+  iDesc.add<double>("photon_combIso", 10.0);
+  iDesc.add<double>("photon_HoE", 0.05);
+  iDesc.add<double>("photon_SigmaiEtaiEta_barrel", 0.0125);
+  iDesc.add<double>("photon_SigmaiEtaiEta_endcap", 0.034);
+  {
+    edm::ParameterSetDescription psd;
+    psd.add<double>("sumPtTrackIso", 4.0);
+    psd.add<double>("sumPtTrackIsoSlope", 0.001);
+    iDesc.add<edm::ParameterSetDescription>("photon_protectionsForJetMET", psd);
+  }
+  {
+    edm::ParameterSetDescription psd;
+    psd.add<double>("solidConeTrkIsoSlope", 0.3);
+    psd.add<bool>("enableProtections", false);
+    psd.add<double>("solidConeTrkIsoOffset", 10.0);
+    iDesc.add<edm::ParameterSetDescription>("photon_protectionsForBadHcal", psd);
+  }
+}
diff --git a/RecoParticleFlow/PFProducer/src/PFMuonAlgo.cc b/RecoParticleFlow/PFProducer/src/PFMuonAlgo.cc
index 53bf6006e53e0..bb8c3a91627bf 100644
--- a/RecoParticleFlow/PFProducer/src/PFMuonAlgo.cc
+++ b/RecoParticleFlow/PFProducer/src/PFMuonAlgo.cc
@@ -22,33 +22,29 @@ namespace {
 
 }  // namespace
 
-PFMuonAlgo::PFMuonAlgo(const edm::ParameterSet& iConfig)
+PFMuonAlgo::PFMuonAlgo(const edm::ParameterSet& iConfig, bool postMuonCleaning)
 
     : pfCosmicsMuonCleanedCandidates_(std::make_unique<reco::PFCandidateCollection>()),
       pfCleanedTrackerAndGlobalMuonCandidates_(std::make_unique<reco::PFCandidateCollection>()),
       pfFakeMuonCleanedCandidates_(std::make_unique<reco::PFCandidateCollection>()),
       pfPunchThroughMuonCleanedCandidates_(std::make_unique<reco::PFCandidateCollection>()),
       pfPunchThroughHadronCleanedCandidates_(std::make_unique<reco::PFCandidateCollection>()),
-      pfAddedMuonCandidates_(std::make_unique<reco::PFCandidateCollection>())
+      pfAddedMuonCandidates_(std::make_unique<reco::PFCandidateCollection>()),
 
-      ,
       maxDPtOPt_(getParameter<double>(iConfig, "maxDPtOPt", 1.0)),
-      minTrackerHits_(getParameter<int>(iConfig, "minTrackerHits", 8)),
-      minPixelHits_(getParameter<int>(iConfig, "minPixelHits", 1)),
       trackQuality_(reco::TrackBase::qualityByName(getParameter<std::string>(iConfig, "trackQuality", "highPurity"))),
-      errorCompScale_(getParameter<double>(iConfig, "ptErrorScale", 4.0)),
-      eventFractionCleaning_(getParameter<double>(iConfig, "eventFractionForCleaning", 0.75)),
-      dzPV_(getParameter<double>(iConfig, "dzPV", 0.2)),
-      postCleaning_(getParameter<bool>(iConfig, "postMuonCleaning", false))  // disable by default (for HLT)
-      ,
+      errorCompScale_(getParameter<double>(iConfig, "ptErrorScale", 8.0)),
+
+      postCleaning_(postMuonCleaning),  // disable by default (for HLT)
+      eventFractionCleaning_(getParameter<double>(iConfig, "eventFractionForCleaning", 0.5)),
       minPostCleaningPt_(getParameter<double>(iConfig, "minPtForPostCleaning", 20.)),
       eventFactorCosmics_(getParameter<double>(iConfig, "eventFactorForCosmics", 10.)),
       metSigForCleaning_(getParameter<double>(iConfig, "metSignificanceForCleaning", 3.)),
       metSigForRejection_(getParameter<double>(iConfig, "metSignificanceForRejection", 4.)),
       metFactorCleaning_(getParameter<double>(iConfig, "metFactorForCleaning", 4.)),
-      eventFractionRejection_(getParameter<double>(iConfig, "eventFractionForRejection", 0.75)),
+      eventFractionRejection_(getParameter<double>(iConfig, "eventFractionForRejection", 0.8)),
       metFactorRejection_(getParameter<double>(iConfig, "metFactorForRejection", 4.)),
-      metFactorHighEta_(getParameter<double>(iConfig, "metFactorForHighEta", 4.)),
+      metFactorHighEta_(getParameter<double>(iConfig, "metFactorForHighEta", 25.)),
       ptFactorHighEta_(getParameter<double>(iConfig, "ptFactorForHighEta", 2.)),
       metFactorFake_(getParameter<double>(iConfig, "metFactorForFakes", 4.)),
       minPunchThroughMomentum_(getParameter<double>(iConfig, "minMomentumForPunchThrough", 100.)),
@@ -1037,3 +1033,27 @@ void PFMuonAlgo::removeDeadCandidates(reco::PFCandidateCollection* obj, const st
 
   obj->resize(collSize - indices.size());
 }
+
+void PFMuonAlgo::fillPSetDescription(edm::ParameterSetDescription& iDesc) {
+  // Muon ID and post cleaning parameters
+  iDesc.add<double>("maxDPtOPt", 1.0);
+  iDesc.add<std::string>("trackQuality", "highPurity");
+  iDesc.add<double>("ptErrorScale", 8.0);
+
+  iDesc.add<double>("eventFractionForCleaning", 0.5);
+  iDesc.add<double>("minPtForPostCleaning", 20.0);
+  iDesc.add<double>("eventFactorForCosmics", 10.0);
+  iDesc.add<double>("metSignificanceForCleaning", 3.0);
+  iDesc.add<double>("metSignificanceForRejection", 4.0);
+  iDesc.add<double>("metFactorForCleaning", 4.0);
+  iDesc.add<double>("eventFractionForRejection", 0.8);
+  iDesc.add<double>("metFactorForRejection", 4.0);
+  iDesc.add<double>("metFactorForHighEta", 25.0);
+  iDesc.add<double>("ptFactorForHighEta", 2.0);
+  iDesc.add<double>("metFactorForFakes", 4.0);
+  iDesc.add<double>("minMomentumForPunchThrough", 100.0);
+  iDesc.add<double>("minEnergyForPunchThrough", 100.0);
+  iDesc.add<double>("punchThroughFactor", 3.0);
+  iDesc.add<double>("punchThroughMETFactor", 4.0);
+  iDesc.add<double>("cosmicRejectionDistance", 1.0);
+}