Inheritance diagram for PFECALSuperClusterProducer:

Public Member Functions
void	beginLuminosityBlock (const edm::LuminosityBlock &, const edm::EventSetup &) override

	PFECALSuperClusterProducer (const edm::ParameterSet &)

void	produce (edm::Event &, const edm::EventSetup &) override

	~PFECALSuperClusterProducer () override

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

Private Attributes
PFECALSuperClusterAlgo::clustering_type	_theclusteringtype

PFECALSuperClusterAlgo::energy_weight	_theenergyweight

bool	isOOTCollection_

std::string	PFBasicClusterCollectionBarrel_

std::string	PFBasicClusterCollectionEndcap_

std::string	PFBasicClusterCollectionPreshower_

std::string	PFClusterAssociationEBEE_

std::string	PFClusterAssociationES_

std::string	PFSuperClusterCollectionBarrel_

std::string	PFSuperClusterCollectionEndcap_

std::string	PFSuperClusterCollectionEndcapWithPreshower_

PFECALSuperClusterAlgo	superClusterAlgo_
	clustering algorithm More...

std::shared_ptr < PFEnergyCalibration >	thePFEnergyCalibration_

bool	verbose_
	verbose ? More...

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
using	CacheTypes = CacheContexts< T...>

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T...>

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Detailed Description

Author: Nicolas Chanon Additional authors for Mustache: Y. Gershtein, R. Patel, L. Gray

Date: July 2012

Definition at line 44 of file PFECALSuperClusterProducer.cc.

Constructor & Destructor Documentation

PFECALSuperClusterProducer::PFECALSuperClusterProducer ( const edm::ParameterSet & iConfig )

explicit

Definition at line 95 of file PFECALSuperClusterProducer.cc.

References HLT_FULL_cff::doSatelliteClusterMerge, HLT_FULL_cff::dropUnseedable, Exception, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), PFECALSuperClusterAlgo::kBOX, PFECALSuperClusterAlgo::kCalibratedNoPS, PFECALSuperClusterAlgo::kCalibratedTotal, PFECALSuperClusterAlgo::kMustache, PFECALSuperClusterAlgo::kRaw, HLT_FULL_cff::satelliteClusterSeedThreshold, HLT_FULL_cff::satelliteMajorityFraction, HLT_FULL_cff::seedThresholdIsET, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                      {
   verbose_ = iConfig.getUntrackedParameter<bool>("verbose", false);
 
   superClusterAlgo_.setUseRegression(iConfig.getParameter<bool>("useRegression"));
 
   isOOTCollection_ = iConfig.getParameter<bool>("isOOTCollection");
   superClusterAlgo_.setIsOOTCollection(isOOTCollection_);
 
   std::string _typename = iConfig.getParameter<std::string>("ClusteringType");
   if (_typename == ClusterType__BOX) {
     _theclusteringtype = PFECALSuperClusterAlgo::kBOX;
   } else if (_typename == ClusterType__Mustache) {
     _theclusteringtype = PFECALSuperClusterAlgo::kMustache;
   } else {
     throw cms::Exception("InvalidClusteringType") << "You have not chosen a valid clustering type,"
                                                   << " please choose from \"Box\" or \"Mustache\"!";
   }
   superClusterAlgo_.setClusteringType(_theclusteringtype);
   superClusterAlgo_.setUseDynamicDPhi(iConfig.getParameter<bool>("useDynamicDPhiWindow"));
   // clusteringType and useDynamicDPhi need to be defined before setting the tokens in order to esConsume only the necessary records
   superClusterAlgo_.setTokens(iConfig, consumesCollector());
 
   std::string _weightname = iConfig.getParameter<std::string>("EnergyWeight");
   if (_weightname == EnergyWeight__Raw) {
     _theenergyweight = PFECALSuperClusterAlgo::kRaw;
   } else if (_weightname == EnergyWeight__CalibratedNoPS) {
     _theenergyweight = PFECALSuperClusterAlgo::kCalibratedNoPS;
   } else if (_weightname == EnergyWeight__CalibratedTotal) {
     _theenergyweight = PFECALSuperClusterAlgo::kCalibratedTotal;
   } else {
     throw cms::Exception("InvalidClusteringType") << "You have not chosen a valid energy weighting scheme,"
                                                   << " please choose from \"Raw\", \"CalibratedNoPS\", or"
                                                   << " \"CalibratedTotal\"!";
   }
 
   // parameters for clustering
   bool seedThresholdIsET = iConfig.getParameter<bool>("seedThresholdIsET");
 
   double threshPFClusterSeedBarrel = iConfig.getParameter<double>("thresh_PFClusterSeedBarrel");
   double threshPFClusterBarrel = iConfig.getParameter<double>("thresh_PFClusterBarrel");
 
   double threshPFClusterSeedEndcap = iConfig.getParameter<double>("thresh_PFClusterSeedEndcap");
   double threshPFClusterEndcap = iConfig.getParameter<double>("thresh_PFClusterEndcap");
 
   double phiwidthSuperClusterBarrel = iConfig.getParameter<double>("phiwidth_SuperClusterBarrel");
   double etawidthSuperClusterBarrel = iConfig.getParameter<double>("etawidth_SuperClusterBarrel");
 
   double phiwidthSuperClusterEndcap = iConfig.getParameter<double>("phiwidth_SuperClusterEndcap");
   double etawidthSuperClusterEndcap = iConfig.getParameter<double>("etawidth_SuperClusterEndcap");
 
   double doSatelliteClusterMerge = iConfig.getParameter<bool>("doSatelliteClusterMerge");
   double satelliteClusterSeedThreshold = iConfig.getParameter<double>("satelliteClusterSeedThreshold");
   double satelliteMajorityFraction = iConfig.getParameter<double>("satelliteMajorityFraction");
   bool dropUnseedable = iConfig.getParameter<bool>("dropUnseedable");
 
   superClusterAlgo_.setVerbosityLevel(verbose_);
   superClusterAlgo_.setEnergyWeighting(_theenergyweight);
   superClusterAlgo_.setUseETForSeeding(seedThresholdIsET);
 
   superClusterAlgo_.setThreshSuperClusterEt(iConfig.getParameter<double>("thresh_SCEt"));
 
   superClusterAlgo_.setThreshPFClusterSeedBarrel(threshPFClusterSeedBarrel);
   superClusterAlgo_.setThreshPFClusterBarrel(threshPFClusterBarrel);
 
   superClusterAlgo_.setThreshPFClusterSeedEndcap(threshPFClusterSeedEndcap);
   superClusterAlgo_.setThreshPFClusterEndcap(threshPFClusterEndcap);
 
   superClusterAlgo_.setPhiwidthSuperClusterBarrel(phiwidthSuperClusterBarrel);
   superClusterAlgo_.setEtawidthSuperClusterBarrel(etawidthSuperClusterBarrel);
 
   superClusterAlgo_.setPhiwidthSuperClusterEndcap(phiwidthSuperClusterEndcap);
   superClusterAlgo_.setEtawidthSuperClusterEndcap(etawidthSuperClusterEndcap);
 
   superClusterAlgo_.setSatelliteMerging(doSatelliteClusterMerge);
   superClusterAlgo_.setSatelliteThreshold(satelliteClusterSeedThreshold);
   superClusterAlgo_.setMajorityFraction(satelliteMajorityFraction);
   superClusterAlgo_.setDropUnseedable(dropUnseedable);
 
   //Load the ECAL energy calibration
   thePFEnergyCalibration_ = std::make_shared<PFEnergyCalibration>();
   superClusterAlgo_.setPFClusterCalibration(thePFEnergyCalibration_);
 
   bool applyCrackCorrections_ = iConfig.getParameter<bool>("applyCrackCorrections");
   superClusterAlgo_.setCrackCorrections(applyCrackCorrections_);
 
   PFBasicClusterCollectionBarrel_ = iConfig.getParameter<string>("PFBasicClusterCollectionBarrel");
   PFSuperClusterCollectionBarrel_ = iConfig.getParameter<string>("PFSuperClusterCollectionBarrel");
 
   PFBasicClusterCollectionEndcap_ = iConfig.getParameter<string>("PFBasicClusterCollectionEndcap");
   PFSuperClusterCollectionEndcap_ = iConfig.getParameter<string>("PFSuperClusterCollectionEndcap");
 
   PFBasicClusterCollectionPreshower_ = iConfig.getParameter<string>("PFBasicClusterCollectionPreshower");
   PFSuperClusterCollectionEndcapWithPreshower_ =
       iConfig.getParameter<string>("PFSuperClusterCollectionEndcapWithPreshower");
 
   PFClusterAssociationEBEE_ = "PFClusterAssociationEBEE";
   PFClusterAssociationES_ = "PFClusterAssociationES";
 
   produces<reco::SuperClusterCollection>(PFSuperClusterCollectionBarrel_);
   produces<reco::SuperClusterCollection>(PFSuperClusterCollectionEndcapWithPreshower_);
   produces<reco::CaloClusterCollection>(PFBasicClusterCollectionBarrel_);
   produces<reco::CaloClusterCollection>(PFBasicClusterCollectionEndcap_);
   produces<reco::CaloClusterCollection>(PFBasicClusterCollectionPreshower_);
   produces<edm::ValueMap<reco::CaloClusterPtr>>(PFClusterAssociationEBEE_);
   produces<edm::ValueMap<reco::CaloClusterPtr>>(PFClusterAssociationES_);
 }

PFECALSuperClusterProducer::~PFECALSuperClusterProducer ( )

override

Definition at line 202 of file PFECALSuperClusterProducer.cc.

202 {}

Member Function Documentation

void PFECALSuperClusterProducer::beginLuminosityBlock	(	const edm::LuminosityBlock &	iL,
		const edm::EventSetup &	iE
	)

override

Definition at line 204 of file PFECALSuperClusterProducer.cc.

                                                                                                      {
   superClusterAlgo_.update(iE);
 }

void PFECALSuperClusterProducer::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 333 of file PFECALSuperClusterProducer.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addUntracked(), submitPVResolutionJobs::desc, HLT_FULL_cff::InputTag, SCEnergyCorrectorSemiParm::makePSetDescription(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                             {
   edm::ParameterSetDescription desc;
   desc.add<std::string>("PFSuperClusterCollectionEndcap", "particleFlowSuperClusterECALEndcap");
   desc.add<bool>("doSatelliteClusterMerge", false);
   desc.add<double>("thresh_PFClusterBarrel", 0.0);
   desc.add<std::string>("PFBasicClusterCollectionBarrel", "particleFlowBasicClusterECALBarrel");
   desc.add<bool>("useRegression", true);
   desc.add<double>("satelliteMajorityFraction", 0.5);
   desc.add<double>("thresh_PFClusterEndcap", 0.0);
   desc.add<edm::InputTag>("ESAssociation", edm::InputTag("particleFlowClusterECAL"));
   desc.add<std::string>("PFBasicClusterCollectionPreshower", "particleFlowBasicClusterECALPreshower");
   desc.add<bool>("use_preshower", true);
   desc.addUntracked<bool>("verbose", false);
   desc.add<double>("thresh_SCEt", 4.0);
   desc.add<double>("etawidth_SuperClusterEndcap", 0.04);
   desc.add<double>("phiwidth_SuperClusterEndcap", 0.6);
   desc.add<bool>("useDynamicDPhiWindow", true);
   desc.add<std::string>("PFSuperClusterCollectionBarrel", "particleFlowSuperClusterECALBarrel");
   desc.add<edm::ParameterSetDescription>("regressionConfig", SCEnergyCorrectorSemiParm::makePSetDescription());
   desc.add<bool>("applyCrackCorrections", false);
   desc.add<double>("satelliteClusterSeedThreshold", 50.0);
   desc.add<double>("etawidth_SuperClusterBarrel", 0.04);
   desc.add<std::string>("PFBasicClusterCollectionEndcap", "particleFlowBasicClusterECALEndcap");
   desc.add<edm::InputTag>("PFClusters", edm::InputTag("particleFlowClusterECAL"));
   desc.add<double>("thresh_PFClusterSeedBarrel", 1.0);
   desc.add<std::string>("ClusteringType", "Mustache");
   desc.add<std::string>("EnergyWeight", "Raw");
   desc.add<edm::InputTag>("BeamSpot", edm::InputTag("offlineBeamSpot"));
   desc.add<double>("thresh_PFClusterSeedEndcap", 1.0);
   desc.add<double>("phiwidth_SuperClusterBarrel", 0.6);
   desc.add<double>("thresh_PFClusterES", 0.0);
   desc.add<bool>("seedThresholdIsET", true);
   desc.add<bool>("isOOTCollection", false);
   desc.add<edm::InputTag>("barrelRecHits", edm::InputTag("ecalRecHit", "EcalRecHitsEE"));
   desc.add<edm::InputTag>("endcapRecHits", edm::InputTag("ecalRecHit", "EcalRecHitsEB"));
   desc.add<std::string>("PFSuperClusterCollectionEndcapWithPreshower",
                         "particleFlowSuperClusterECALEndcapWithPreshower");
   desc.add<bool>("dropUnseedable", false);
   descriptions.add("particleFlowSuperClusterECALMustache", desc);
 }

void PFECALSuperClusterProducer::produce	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

override

Definition at line 208 of file PFECALSuperClusterProducer.cc.

References HLT_FULL_cff::clusters, TauDecayModes::dec, Exception, edm::helper::Filler< Map >::fill(), edm::helper::Filler< Map >::insert(), eostools::move(), edm::PtrVector< T >::push_back(), and edm::Event::put().

                                                                                       {
   // update SC parameters
   superClusterAlgo_.updateSCParams(iSetup);
   // do clustering
   superClusterAlgo_.loadAndSortPFClusters(iEvent);
   superClusterAlgo_.run();
 
   //build collections of output CaloClusters from the used PFClusters
   auto caloClustersEB = std::make_unique<reco::CaloClusterCollection>();
   auto caloClustersEE = std::make_unique<reco::CaloClusterCollection>();
   auto caloClustersES = std::make_unique<reco::CaloClusterCollection>();
 
   std::map<reco::CaloClusterPtr, unsigned int> pfClusterMapEB;  //maps of pfclusters to caloclusters
   std::map<reco::CaloClusterPtr, unsigned int> pfClusterMapEE;
   std::map<reco::CaloClusterPtr, unsigned int> pfClusterMapES;
 
   //fill calocluster collections and maps
   for (const auto& ebsc : *(superClusterAlgo_.getEBOutputSCCollection())) {
     for (reco::CaloCluster_iterator pfclus = ebsc.clustersBegin(); pfclus != ebsc.clustersEnd(); ++pfclus) {
       if (!pfClusterMapEB.count(*pfclus)) {
         reco::CaloCluster caloclus(**pfclus);
         caloClustersEB->push_back(caloclus);
         pfClusterMapEB[*pfclus] = caloClustersEB->size() - 1;
       } else {
         throw cms::Exception("PFECALSuperClusterProducer::produce")
             << "Found an EB pfcluster matched to more than one EB supercluster!" << std::dec << std::endl;
       }
     }
   }
   for (const auto& eesc : *(superClusterAlgo_.getEEOutputSCCollection())) {
     for (reco::CaloCluster_iterator pfclus = eesc.clustersBegin(); pfclus != eesc.clustersEnd(); ++pfclus) {
       if (!pfClusterMapEE.count(*pfclus)) {
         reco::CaloCluster caloclus(**pfclus);
         caloClustersEE->push_back(caloclus);
         pfClusterMapEE[*pfclus] = caloClustersEE->size() - 1;
       } else {
         throw cms::Exception("PFECALSuperClusterProducer::produce")
             << "Found an EE pfcluster matched to more than one EE supercluster!" << std::dec << std::endl;
       }
     }
     for (reco::CaloCluster_iterator pfclus = eesc.preshowerClustersBegin(); pfclus != eesc.preshowerClustersEnd();
          ++pfclus) {
       if (!pfClusterMapES.count(*pfclus)) {
         reco::CaloCluster caloclus(**pfclus);
         caloClustersES->push_back(caloclus);
         pfClusterMapES[*pfclus] = caloClustersES->size() - 1;
       } else {
         throw cms::Exception("PFECALSuperClusterProducer::produce")
             << "Found an ES pfcluster matched to more than one EE supercluster!" << std::dec << std::endl;
       }
     }
   }
 
   //create ValueMaps from output CaloClusters back to original PFClusters
   auto pfClusterAssociationEBEE = std::make_unique<edm::ValueMap<reco::CaloClusterPtr>>();
   auto pfClusterAssociationES = std::make_unique<edm::ValueMap<reco::CaloClusterPtr>>();
 
   //vectors to fill ValueMaps
   std::vector<reco::CaloClusterPtr> clusptrsEB(caloClustersEB->size());
   std::vector<reco::CaloClusterPtr> clusptrsEE(caloClustersEE->size());
   std::vector<reco::CaloClusterPtr> clusptrsES(caloClustersES->size());
 
   //put calocluster output collections in event and get orphan handles to create ptrs
   const edm::OrphanHandle<reco::CaloClusterCollection>& caloClusHandleEB =
       iEvent.put(std::move(caloClustersEB), PFBasicClusterCollectionBarrel_);
   const edm::OrphanHandle<reco::CaloClusterCollection>& caloClusHandleEE =
       iEvent.put(std::move(caloClustersEE), PFBasicClusterCollectionEndcap_);
   const edm::OrphanHandle<reco::CaloClusterCollection>& caloClusHandleES =
       iEvent.put(std::move(caloClustersES), PFBasicClusterCollectionPreshower_);
 
   //relink superclusters to output caloclusters and fill vectors for ValueMaps
   for (auto& ebsc : *(superClusterAlgo_.getEBOutputSCCollection())) {
     reco::CaloClusterPtr seedptr(caloClusHandleEB, pfClusterMapEB[ebsc.seed()]);
     ebsc.setSeed(seedptr);
 
     reco::CaloClusterPtrVector clusters;
     for (reco::CaloCluster_iterator pfclus = ebsc.clustersBegin(); pfclus != ebsc.clustersEnd(); ++pfclus) {
       int caloclusidx = pfClusterMapEB[*pfclus];
       reco::CaloClusterPtr clusptr(caloClusHandleEB, caloclusidx);
       clusters.push_back(clusptr);
       clusptrsEB[caloclusidx] = *pfclus;
     }
     ebsc.setClusters(clusters);
   }
   for (auto& eesc : *(superClusterAlgo_.getEEOutputSCCollection())) {
     reco::CaloClusterPtr seedptr(caloClusHandleEE, pfClusterMapEE[eesc.seed()]);
     eesc.setSeed(seedptr);
 
     reco::CaloClusterPtrVector clusters;
     for (reco::CaloCluster_iterator pfclus = eesc.clustersBegin(); pfclus != eesc.clustersEnd(); ++pfclus) {
       int caloclusidx = pfClusterMapEE[*pfclus];
       reco::CaloClusterPtr clusptr(caloClusHandleEE, caloclusidx);
       clusters.push_back(clusptr);
       clusptrsEE[caloclusidx] = *pfclus;
     }
     eesc.setClusters(clusters);
 
     reco::CaloClusterPtrVector psclusters;
     for (reco::CaloCluster_iterator pfclus = eesc.preshowerClustersBegin(); pfclus != eesc.preshowerClustersEnd();
          ++pfclus) {
       int caloclusidx = pfClusterMapES[*pfclus];
       reco::CaloClusterPtr clusptr(caloClusHandleES, caloclusidx);
       psclusters.push_back(clusptr);
       clusptrsES[caloclusidx] = *pfclus;
     }
     eesc.setPreshowerClusters(psclusters);
   }
 
   //fill association maps from output CaloClusters back to original PFClusters
   edm::ValueMap<reco::CaloClusterPtr>::Filler fillerEBEE(*pfClusterAssociationEBEE);
   fillerEBEE.insert(caloClusHandleEB, clusptrsEB.begin(), clusptrsEB.end());
   fillerEBEE.insert(caloClusHandleEE, clusptrsEE.begin(), clusptrsEE.end());
   fillerEBEE.fill();
 
   edm::ValueMap<reco::CaloClusterPtr>::Filler fillerES(*pfClusterAssociationES);
   fillerES.insert(caloClusHandleES, clusptrsES.begin(), clusptrsES.end());
   fillerES.fill();
 
   //store in the event
   iEvent.put(std::move(pfClusterAssociationEBEE), PFClusterAssociationEBEE_);
   iEvent.put(std::move(pfClusterAssociationES), PFClusterAssociationES_);
   iEvent.put(std::move(superClusterAlgo_.getEBOutputSCCollection()), PFSuperClusterCollectionBarrel_);
   iEvent.put(std::move(superClusterAlgo_.getEEOutputSCCollection()), PFSuperClusterCollectionEndcapWithPreshower_);
 }