EgammaClusterProducers/src/PFECALSuperClusterProducer.cc

0001
0002 #include "CondFormats/DataRecord/interface/GBRWrapperRcd.h"
0003 #include "CondFormats/GBRForest/interface/GBRForest.h"
0004 #include "DataFormats/CaloRecHit/interface/CaloCluster.h"
0005 #include "DataFormats/CaloRecHit/interface/CaloClusterFwd.h"
0006 #include "DataFormats/Common/interface/ValueMap.h"
0007 #include "DataFormats/EcalRecHit/interface/EcalRecHit.h"
0008 #include "DataFormats/EcalRecHit/interface/EcalRecHitCollections.h"
0009 #include "DataFormats/EgammaReco/interface/SuperCluster.h"
0010 #include "DataFormats/EgammaReco/interface/SuperClusterFwd.h"
0011 #include "DataFormats/Math/interface/deltaR.h"
0012 #include "DataFormats/ParticleFlowReco/interface/PFCluster.h"
0013 #include "DataFormats/ParticleFlowReco/interface/PFClusterFwd.h"
0014 #include "DataFormats/ParticleFlowReco/interface/PFRecHit.h"
0015 #include "DataFormats/ParticleFlowReco/interface/PFRecHitFwd.h"
0016 #include "DataFormats/VertexReco/interface/Vertex.h"
0017 #include "DataFormats/VertexReco/interface/VertexFwd.h"
0018 #include "FWCore/Framework/interface/ESHandle.h"
0019 #include "FWCore/Framework/interface/Event.h"
0020 #include "FWCore/Framework/interface/EventSetup.h"
0021 #include "FWCore/Framework/interface/MakerMacros.h"
0022 #include "FWCore/Framework/interface/stream/EDProducer.h"
0023 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0024 #include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
0025 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0026 #include "FWCore/ParameterSet/interface/ParameterSetDescription.h"
0027 #include "FWCore/ParameterSet/interface/EmptyGroupDescription.h"
0028 #include "Geometry/CaloTopology/interface/CaloTopology.h"
0029 #include "Geometry/Records/interface/CaloTopologyRecord.h"
0030 #include "RecoEcal/EgammaClusterAlgos/interface/PFECALSuperClusterAlgo.h"
0031 #include "RecoEcal/EgammaClusterAlgos/interface/SCEnergyCorrectorSemiParm.h"
0032 #include "RecoEcal/EgammaCoreTools/interface/EcalClusterTools.h"
0033 #include "RecoEcal/EgammaCoreTools/interface/SCProducerCache.h"
0034 #include "TVector2.h"
0035
0036 #include <memory>
0037 #include <vector>
0038
0039 /*
0040  * class PFECALSuperClusterProducer
0041  * author Nicolas Chanon
0042  * Additional authors for Mustache: Y. Gershtein, R. Patel, L. Gray
0043  * Additional authors for DeepSC: D.Valsecchi, B.Marzocchi
0044  * date   July 2012
0045  * updates Feb 2022
0046  */
0047
0048 class PFECALSuperClusterProducer : public edm::stream::EDProducer<edm::GlobalCache<reco::SCProducerCache>> {
0049 public:
0050   explicit PFECALSuperClusterProducer(const edm::ParameterSet&, const reco::SCProducerCache* gcache);
0051   ~PFECALSuperClusterProducer() override;
0052
0053   void beginLuminosityBlock(const edm::LuminosityBlock&, const edm::EventSetup&) override;
0054   void produce(edm::Event&, const edm::EventSetup&) override;
0055
0056   static std::unique_ptr<reco::SCProducerCache> initializeGlobalCache(const edm::ParameterSet& config) {
0057     return std::make_unique<reco::SCProducerCache>(config);
0058   }
0059
0060   static void globalEndJob(const reco::SCProducerCache*){};
0061
0062   static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
0063
0064 private:
0065   // ----------member data ---------------------------
0066
0067   /// clustering algorithm
0068   PFECALSuperClusterAlgo superClusterAlgo_;
0069   PFECALSuperClusterAlgo::clustering_type _theclusteringtype;
0070   PFECALSuperClusterAlgo::energy_weight _theenergyweight;
0071
0072   std::shared_ptr<PFEnergyCalibration> thePFEnergyCalibration_;
0073
0074   /// verbose ?
0075   bool verbose_;
0076
0077   std::string PFBasicClusterCollectionBarrel_;
0078   std::string PFSuperClusterCollectionBarrel_;
0079   std::string PFBasicClusterCollectionEndcap_;
0080   std::string PFSuperClusterCollectionEndcap_;
0081   std::string PFBasicClusterCollectionPreshower_;
0082   std::string PFSuperClusterCollectionEndcapWithPreshower_;
0083   std::string PFClusterAssociationEBEE_;
0084   std::string PFClusterAssociationES_;
0085
0086   // OOT photons
0087   bool isOOTCollection_;
0088 };
0089
0090 #include "FWCore/Framework/interface/MakerMacros.h"
0091 DEFINE_FWK_MODULE(PFECALSuperClusterProducer);
0092
0093 using namespace std;
0094
0095 using namespace edm;
0096
0097 namespace {
0098   const std::string ClusterType__BOX("Box");
0099   const std::string ClusterType__Mustache("Mustache");
0100   const std::string ClusterType__DeepSC("DeepSC");
0101
0102   const std::string EnergyWeight__Raw("Raw");
0103   const std::string EnergyWeight__CalibratedNoPS("CalibratedNoPS");
0104   const std::string EnergyWeight__CalibratedTotal("CalibratedTotal");
0105 }  // namespace
0106
0107 PFECALSuperClusterProducer::PFECALSuperClusterProducer(const edm::ParameterSet& iConfig,
0108                                                        const reco::SCProducerCache* gcache)
0109     : superClusterAlgo_(gcache) {
0110   verbose_ = iConfig.getUntrackedParameter<bool>("verbose", false);
0111
0112   superClusterAlgo_.setUseRegression(iConfig.getParameter<bool>("useRegression"));
0113
0114   isOOTCollection_ = iConfig.getParameter<bool>("isOOTCollection");
0115   superClusterAlgo_.setIsOOTCollection(isOOTCollection_);
0116
0117   std::string _typename = iConfig.getParameter<std::string>("ClusteringType");
0118   if (_typename == ClusterType__BOX) {
0119     _theclusteringtype = PFECALSuperClusterAlgo::kBOX;
0120   } else if (_typename == ClusterType__Mustache) {
0121     _theclusteringtype = PFECALSuperClusterAlgo::kMustache;
0122   } else if (_typename == ClusterType__DeepSC) {
0123     _theclusteringtype = PFECALSuperClusterAlgo::kDeepSC;
0124   } else {
0125     throw cms::Exception("InvalidClusteringType") << "You have not chosen a valid clustering type,"
0126                                                   << " please choose from \"Box\" or \"Mustache\" or \"DeepSC\"!";
0127   }
0128
0129   std::string _weightname = iConfig.getParameter<std::string>("EnergyWeight");
0130   if (_weightname == EnergyWeight__Raw) {
0131     _theenergyweight = PFECALSuperClusterAlgo::kRaw;
0132   } else if (_weightname == EnergyWeight__CalibratedNoPS) {
0133     _theenergyweight = PFECALSuperClusterAlgo::kCalibratedNoPS;
0134   } else if (_weightname == EnergyWeight__CalibratedTotal) {
0135     _theenergyweight = PFECALSuperClusterAlgo::kCalibratedTotal;
0136   } else {
0137     throw cms::Exception("InvalidClusteringType") << "You have not chosen a valid energy weighting scheme,"
0138                                                   << " please choose from \"Raw\", \"CalibratedNoPS\", or"
0139                                                   << " \"CalibratedTotal\"!";
0140   }
0141
0142   // parameters for clustering
0143   bool seedThresholdIsET = iConfig.getParameter<bool>("seedThresholdIsET");
0144
0145   bool useDynamicDPhi = iConfig.getParameter<bool>("useDynamicDPhiWindow");
0146
0147   double threshPFClusterSeedBarrel = iConfig.getParameter<double>("thresh_PFClusterSeedBarrel");
0148   double threshPFClusterBarrel = iConfig.getParameter<double>("thresh_PFClusterBarrel");
0149
0150   double threshPFClusterSeedEndcap = iConfig.getParameter<double>("thresh_PFClusterSeedEndcap");
0151   double threshPFClusterEndcap = iConfig.getParameter<double>("thresh_PFClusterEndcap");
0152
0153   double phiwidthSuperClusterBarrel = iConfig.getParameter<double>("phiwidth_SuperClusterBarrel");
0154   double etawidthSuperClusterBarrel = iConfig.getParameter<double>("etawidth_SuperClusterBarrel");
0155
0156   double phiwidthSuperClusterEndcap = iConfig.getParameter<double>("phiwidth_SuperClusterEndcap");
0157   double etawidthSuperClusterEndcap = iConfig.getParameter<double>("etawidth_SuperClusterEndcap");
0158
0159   double doSatelliteClusterMerge = iConfig.getParameter<bool>("doSatelliteClusterMerge");
0160   double satelliteClusterSeedThreshold = iConfig.getParameter<double>("satelliteClusterSeedThreshold");
0161   double satelliteMajorityFraction = iConfig.getParameter<double>("satelliteMajorityFraction");
0162   bool dropUnseedable = iConfig.getParameter<bool>("dropUnseedable");
0163
0164   superClusterAlgo_.setClusteringType(_theclusteringtype);
0165   superClusterAlgo_.setUseDynamicDPhi(useDynamicDPhi);
0166   // clusteringType and useDynamicDPhi need to be defined before setting the tokens in order to esConsume only the necessary records
0167   superClusterAlgo_.setTokens(iConfig, consumesCollector());
0168
0169   superClusterAlgo_.setVerbosityLevel(verbose_);
0170   superClusterAlgo_.setEnergyWeighting(_theenergyweight);
0171   superClusterAlgo_.setUseETForSeeding(seedThresholdIsET);
0172
0173   superClusterAlgo_.setThreshSuperClusterEt(iConfig.getParameter<double>("thresh_SCEt"));
0174
0175   superClusterAlgo_.setThreshPFClusterSeedBarrel(threshPFClusterSeedBarrel);
0176   superClusterAlgo_.setThreshPFClusterBarrel(threshPFClusterBarrel);
0177
0178   superClusterAlgo_.setThreshPFClusterSeedEndcap(threshPFClusterSeedEndcap);
0179   superClusterAlgo_.setThreshPFClusterEndcap(threshPFClusterEndcap);
0180
0181   superClusterAlgo_.setPhiwidthSuperClusterBarrel(phiwidthSuperClusterBarrel);
0182   superClusterAlgo_.setEtawidthSuperClusterBarrel(etawidthSuperClusterBarrel);
0183
0184   superClusterAlgo_.setPhiwidthSuperClusterEndcap(phiwidthSuperClusterEndcap);
0185   superClusterAlgo_.setEtawidthSuperClusterEndcap(etawidthSuperClusterEndcap);
0186
0187   superClusterAlgo_.setSatelliteMerging(doSatelliteClusterMerge);
0188   superClusterAlgo_.setSatelliteThreshold(satelliteClusterSeedThreshold);
0189   superClusterAlgo_.setMajorityFraction(satelliteMajorityFraction);
0190   superClusterAlgo_.setDropUnseedable(dropUnseedable);
0191
0192   //Load the ECAL energy calibration
0193   thePFEnergyCalibration_ = std::make_shared<PFEnergyCalibration>();
0194   superClusterAlgo_.setPFClusterCalibration(thePFEnergyCalibration_);
0195
0196   bool applyCrackCorrections_ = iConfig.getParameter<bool>("applyCrackCorrections");
0197   superClusterAlgo_.setCrackCorrections(applyCrackCorrections_);
0198
0199   PFBasicClusterCollectionBarrel_ = iConfig.getParameter<string>("PFBasicClusterCollectionBarrel");
0200   PFSuperClusterCollectionBarrel_ = iConfig.getParameter<string>("PFSuperClusterCollectionBarrel");
0201
0202   PFBasicClusterCollectionEndcap_ = iConfig.getParameter<string>("PFBasicClusterCollectionEndcap");
0203   PFSuperClusterCollectionEndcap_ = iConfig.getParameter<string>("PFSuperClusterCollectionEndcap");
0204
0205   PFBasicClusterCollectionPreshower_ = iConfig.getParameter<string>("PFBasicClusterCollectionPreshower");
0206   PFSuperClusterCollectionEndcapWithPreshower_ =
0207       iConfig.getParameter<string>("PFSuperClusterCollectionEndcapWithPreshower");
0208
0209   PFClusterAssociationEBEE_ = "PFClusterAssociationEBEE";
0210   PFClusterAssociationES_ = "PFClusterAssociationES";
0211
0212   produces<reco::SuperClusterCollection>(PFSuperClusterCollectionBarrel_);
0213   produces<reco::SuperClusterCollection>(PFSuperClusterCollectionEndcapWithPreshower_);
0214   produces<reco::CaloClusterCollection>(PFBasicClusterCollectionBarrel_);
0215   produces<reco::CaloClusterCollection>(PFBasicClusterCollectionEndcap_);
0216   produces<reco::CaloClusterCollection>(PFBasicClusterCollectionPreshower_);
0217   produces<edm::ValueMap<reco::CaloClusterPtr>>(PFClusterAssociationEBEE_);
0218   produces<edm::ValueMap<reco::CaloClusterPtr>>(PFClusterAssociationES_);
0219 }
0220
0221 PFECALSuperClusterProducer::~PFECALSuperClusterProducer() {}
0222
0223 void PFECALSuperClusterProducer::beginLuminosityBlock(LuminosityBlock const& iL, EventSetup const& iE) {
0224   superClusterAlgo_.update(iE);
0225 }
0226
0227 void PFECALSuperClusterProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) {
0228   // update SC parameters
0229   superClusterAlgo_.updateSCParams(iSetup);
0230   // do clustering
0231   superClusterAlgo_.loadAndSortPFClusters(iEvent);
0232   superClusterAlgo_.run();
0233
0234   //build collections of output CaloClusters from the used PFClusters
0235   auto caloClustersEB = std::make_unique<reco::CaloClusterCollection>();
0236   auto caloClustersEE = std::make_unique<reco::CaloClusterCollection>();
0237   auto caloClustersES = std::make_unique<reco::CaloClusterCollection>();
0238
0239   std::map<reco::CaloClusterPtr, unsigned int> pfClusterMapEB;  //maps of pfclusters to caloclusters
0240   std::map<reco::CaloClusterPtr, unsigned int> pfClusterMapEE;
0241   std::map<reco::CaloClusterPtr, unsigned int> pfClusterMapES;
0242
0243   //fill calocluster collections and maps
0244   for (const auto& ebsc : *(superClusterAlgo_.getEBOutputSCCollection())) {
0245     for (reco::CaloCluster_iterator pfclus = ebsc.clustersBegin(); pfclus != ebsc.clustersEnd(); ++pfclus) {
0246       if (!pfClusterMapEB.count(*pfclus)) {
0247         reco::CaloCluster caloclus(**pfclus);
0248         caloClustersEB->push_back(caloclus);
0249         pfClusterMapEB[*pfclus] = caloClustersEB->size() - 1;
0250       } else {
0251         throw cms::Exception("PFECALSuperClusterProducer::produce")
0252             << "Found an EB pfcluster matched to more than one EB supercluster!" << std::dec << std::endl;
0253       }
0254     }
0255   }
0256   for (const auto& eesc : *(superClusterAlgo_.getEEOutputSCCollection())) {
0257     for (reco::CaloCluster_iterator pfclus = eesc.clustersBegin(); pfclus != eesc.clustersEnd(); ++pfclus) {
0258       if (!pfClusterMapEE.count(*pfclus)) {
0259         reco::CaloCluster caloclus(**pfclus);
0260         caloClustersEE->push_back(caloclus);
0261         pfClusterMapEE[*pfclus] = caloClustersEE->size() - 1;
0262       } else {
0263         throw cms::Exception("PFECALSuperClusterProducer::produce")
0264             << "Found an EE pfcluster matched to more than one EE supercluster!" << std::dec << std::endl;
0265       }
0266     }
0267     for (reco::CaloCluster_iterator pfclus = eesc.preshowerClustersBegin(); pfclus != eesc.preshowerClustersEnd();
0268          ++pfclus) {
0269       if (!pfClusterMapES.count(*pfclus)) {
0270         reco::CaloCluster caloclus(**pfclus);
0271         caloClustersES->push_back(caloclus);
0272         pfClusterMapES[*pfclus] = caloClustersES->size() - 1;
0273       } else {
0274         throw cms::Exception("PFECALSuperClusterProducer::produce")
0275             << "Found an ES pfcluster matched to more than one EE supercluster!" << std::dec << std::endl;
0276       }
0277     }
0278   }
0279
0280   //create ValueMaps from output CaloClusters back to original PFClusters
0281   auto pfClusterAssociationEBEE = std::make_unique<edm::ValueMap<reco::CaloClusterPtr>>();
0282   auto pfClusterAssociationES = std::make_unique<edm::ValueMap<reco::CaloClusterPtr>>();
0283
0284   //vectors to fill ValueMaps
0285   std::vector<reco::CaloClusterPtr> clusptrsEB(caloClustersEB->size());
0286   std::vector<reco::CaloClusterPtr> clusptrsEE(caloClustersEE->size());
0287   std::vector<reco::CaloClusterPtr> clusptrsES(caloClustersES->size());
0288
0289   //put calocluster output collections in event and get orphan handles to create ptrs
0290   const edm::OrphanHandle<reco::CaloClusterCollection>& caloClusHandleEB =
0291       iEvent.put(std::move(caloClustersEB), PFBasicClusterCollectionBarrel_);
0292   const edm::OrphanHandle<reco::CaloClusterCollection>& caloClusHandleEE =
0293       iEvent.put(std::move(caloClustersEE), PFBasicClusterCollectionEndcap_);
0294   const edm::OrphanHandle<reco::CaloClusterCollection>& caloClusHandleES =
0295       iEvent.put(std::move(caloClustersES), PFBasicClusterCollectionPreshower_);
0296
0297   //relink superclusters to output caloclusters and fill vectors for ValueMaps
0298   for (auto& ebsc : *(superClusterAlgo_.getEBOutputSCCollection())) {
0299     reco::CaloClusterPtr seedptr(caloClusHandleEB, pfClusterMapEB[ebsc.seed()]);
0300     ebsc.setSeed(seedptr);
0301
0302     reco::CaloClusterPtrVector clusters;
0303     for (reco::CaloCluster_iterator pfclus = ebsc.clustersBegin(); pfclus != ebsc.clustersEnd(); ++pfclus) {
0304       int caloclusidx = pfClusterMapEB[*pfclus];
0305       reco::CaloClusterPtr clusptr(caloClusHandleEB, caloclusidx);
0306       clusters.push_back(clusptr);
0307       clusptrsEB[caloclusidx] = *pfclus;
0308     }
0309     ebsc.setClusters(clusters);
0310   }
0311   for (auto& eesc : *(superClusterAlgo_.getEEOutputSCCollection())) {
0312     reco::CaloClusterPtr seedptr(caloClusHandleEE, pfClusterMapEE[eesc.seed()]);
0313     eesc.setSeed(seedptr);
0314
0315     reco::CaloClusterPtrVector clusters;
0316     for (reco::CaloCluster_iterator pfclus = eesc.clustersBegin(); pfclus != eesc.clustersEnd(); ++pfclus) {
0317       int caloclusidx = pfClusterMapEE[*pfclus];
0318       reco::CaloClusterPtr clusptr(caloClusHandleEE, caloclusidx);
0319       clusters.push_back(clusptr);
0320       clusptrsEE[caloclusidx] = *pfclus;
0321     }
0322     eesc.setClusters(clusters);
0323
0324     reco::CaloClusterPtrVector psclusters;
0325     for (reco::CaloCluster_iterator pfclus = eesc.preshowerClustersBegin(); pfclus != eesc.preshowerClustersEnd();
0326          ++pfclus) {
0327       int caloclusidx = pfClusterMapES[*pfclus];
0328       reco::CaloClusterPtr clusptr(caloClusHandleES, caloclusidx);
0329       psclusters.push_back(clusptr);
0330       clusptrsES[caloclusidx] = *pfclus;
0331     }
0332     eesc.setPreshowerClusters(psclusters);
0333   }
0334
0335   //fill association maps from output CaloClusters back to original PFClusters
0336   edm::ValueMap<reco::CaloClusterPtr>::Filler fillerEBEE(*pfClusterAssociationEBEE);
0337   fillerEBEE.insert(caloClusHandleEB, clusptrsEB.begin(), clusptrsEB.end());
0338   fillerEBEE.insert(caloClusHandleEE, clusptrsEE.begin(), clusptrsEE.end());
0339   fillerEBEE.fill();
0340
0341   edm::ValueMap<reco::CaloClusterPtr>::Filler fillerES(*pfClusterAssociationES);
0342   fillerES.insert(caloClusHandleES, clusptrsES.begin(), clusptrsES.end());
0343   fillerES.fill();
0344
0345   //store in the event
0346   iEvent.put(std::move(pfClusterAssociationEBEE), PFClusterAssociationEBEE_);
0347   iEvent.put(std::move(pfClusterAssociationES), PFClusterAssociationES_);
0348   iEvent.put(std::move(superClusterAlgo_.getEBOutputSCCollection()), PFSuperClusterCollectionBarrel_);
0349   iEvent.put(std::move(superClusterAlgo_.getEEOutputSCCollection()), PFSuperClusterCollectionEndcapWithPreshower_);
0350 }
0351
0352 void PFECALSuperClusterProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
0353   edm::ParameterSetDescription desc;
0354   desc.add<std::string>("PFSuperClusterCollectionEndcap", "particleFlowSuperClusterECALEndcap");
0355   desc.add<bool>("doSatelliteClusterMerge", false);
0356   desc.add<double>("thresh_PFClusterBarrel", 0.0);
0357   desc.add<std::string>("PFBasicClusterCollectionBarrel", "particleFlowBasicClusterECALBarrel");
0358   desc.add<bool>("useRegression", true);
0359   desc.add<double>("satelliteMajorityFraction", 0.5);
0360   desc.add<double>("thresh_PFClusterEndcap", 0.0);
0361   desc.add<edm::InputTag>("ESAssociation", edm::InputTag("particleFlowClusterECAL"));
0362   desc.add<std::string>("PFBasicClusterCollectionPreshower", "particleFlowBasicClusterECALPreshower");
0363   desc.addUntracked<bool>("verbose", false);
0364   desc.add<double>("thresh_SCEt", 4.0);
0365   desc.add<double>("etawidth_SuperClusterEndcap", 0.04);
0366   desc.add<double>("phiwidth_SuperClusterEndcap", 0.6);
0367   desc.add<bool>("useDynamicDPhiWindow", true);
0368   desc.add<std::string>("PFSuperClusterCollectionBarrel", "particleFlowSuperClusterECALBarrel");
0369   desc.add<edm::ParameterSetDescription>("regressionConfig", SCEnergyCorrectorSemiParm::makePSetDescription());
0370   desc.add<bool>("applyCrackCorrections", false);
0371   desc.add<double>("satelliteClusterSeedThreshold", 50.0);
0372   desc.add<double>("etawidth_SuperClusterBarrel", 0.04);
0373   desc.add<std::string>("PFBasicClusterCollectionEndcap", "particleFlowBasicClusterECALEndcap");
0374   desc.add<edm::InputTag>("PFClusters", edm::InputTag("particleFlowClusterECAL"));
0375   desc.add<double>("thresh_PFClusterSeedBarrel", 1.0);
0376   desc.add<std::string>("EnergyWeight", "Raw");
0377   desc.add<edm::InputTag>("BeamSpot", edm::InputTag("offlineBeamSpot"));
0378   desc.add<double>("thresh_PFClusterSeedEndcap", 1.0);
0379   desc.add<double>("phiwidth_SuperClusterBarrel", 0.6);
0380   desc.add<double>("thresh_PFClusterES", 0.0);
0381   desc.add<bool>("seedThresholdIsET", true);
0382   desc.add<bool>("isOOTCollection", false);
0383   desc.add<edm::InputTag>("barrelRecHits", edm::InputTag("ecalRecHit", "EcalRecHitsEB"));
0384   desc.add<edm::InputTag>("endcapRecHits", edm::InputTag("ecalRecHit", "EcalRecHitsEE"));
0385   desc.add<std::string>("PFSuperClusterCollectionEndcapWithPreshower",
0386                         "particleFlowSuperClusterECALEndcapWithPreshower");
0387   desc.add<bool>("dropUnseedable", false);
0388
0389   edm::ParameterSetDescription deepSCParams;
0390   deepSCParams.add<std::string>("modelFile", "");
0391   deepSCParams.add<std::string>("configFileClusterFeatures", "");
0392   deepSCParams.add<std::string>("configFileWindowFeatures", "");
0393   deepSCParams.add<std::string>("configFileHitsFeatures", "");
0394   deepSCParams.add<uint>("nClusterFeatures", 12);
0395   deepSCParams.add<uint>("nWindowFeatures", 18);
0396   deepSCParams.add<uint>("nHitsFeatures", 4);
0397   deepSCParams.add<uint>("maxNClusters", 40);
0398   deepSCParams.add<uint>("maxNRechits", 40);
0399   deepSCParams.add<uint>("batchSize", 64);
0400   deepSCParams.add<std::string>("collectionStrategy", "Cascade");
0401
0402   EmptyGroupDescription emptyGroup;
0403
0404   // Add DeepSC parameters only to the specific ClusteringType
0405   edm::ParameterSwitch<std::string> switchNode(
0406       edm::ParameterDescription<std::string>("ClusteringType", ClusterType__Mustache, true),
0407       ClusterType__Mustache >> emptyGroup or ClusterType__BOX >> emptyGroup or
0408           ClusterType__DeepSC >>
0409               edm::ParameterDescription<edm::ParameterSetDescription>("deepSuperClusterConfig", deepSCParams, true));
0410   desc.addNode(switchNode);
0411
0412   descriptions.add("particleFlowSuperClusterECALMustache", desc);
0413 }