\ Algorithm for box particle flow super clustering in the ECAL More...

#include <PFECALSuperClusterAlgo.h>

Classes
class	CalibratedPFCluster

Public Types
typedef std::shared_ptr< CalibratedPFCluster >	CalibratedClusterPtr

typedef std::vector< CalibratedClusterPtr >	CalibratedClusterPtrVector

enum	clustering_type { kBOX = 1, kMustache = 2 }

enum	energy_weight { kRaw, kCalibratedNoPS, kCalibratedTotal }

Public Member Functions
std::unique_ptr< reco::SuperClusterCollection > &	getEBOutputSCCollection ()

std::unique_ptr< reco::SuperClusterCollection > &	getEEOutputSCCollection ()

void	loadAndSortPFClusters (const edm::Event &evt)

	PFECALSuperClusterAlgo ()
	constructor More...

void	run ()

void	setClusteringType (clustering_type thetype)

void	setCrackCorrections (bool applyCrackCorrections)

void	setDropUnseedable (const bool d)

void	setEnergyWeighting (energy_weight thetype)

void	setEtawidthSuperClusterBarrel (double etawidth)

void	setEtawidthSuperClusterEndcap (double etawidth)

void	setIsOOTCollection (bool isOOTCollection)

void	setMajorityFraction (const double f)

void	setPFClusterCalibration (const std::shared_ptr< PFEnergyCalibration > &)

void	setPhiwidthSuperClusterBarrel (double phiwidth)

void	setPhiwidthSuperClusterEndcap (double phiwidth)

void	setSatelliteMerging (const bool doit)

void	setSatelliteThreshold (const double t)

void	setThreshPFClusterBarrel (double thresh)

void	setThreshPFClusterEndcap (double thresh)

void	setThreshPFClusterSeedBarrel (double thresh)

void	setThreshPFClusterSeedEndcap (double thresh)

void	setThreshSuperClusterEt (double thresh)

void	setTokens (const edm::ParameterSet &, edm::ConsumesCollector &&)

void	setUseDynamicDPhi (bool useit)

void	setUseETForSeeding (bool useET)

void	setUseRegression (bool useRegression)

void	setVerbosityLevel (bool verbose)

void	update (const edm::EventSetup &)

void	updateSCParams (const edm::EventSetup &)

Private Member Functions
void	buildAllSuperClusters (CalibratedClusterPtrVector &, double seedthresh)

void	buildSuperCluster (CalibratedClusterPtr &, CalibratedClusterPtrVector &)

Private Attributes
CalibratedClusterPtrVector	_clustersEB

CalibratedClusterPtrVector	_clustersEE

clustering_type	_clustype

energy_weight	_eweight

std::shared_ptr< PFEnergyCalibration >	_pfEnergyCalibration

bool	applyCrackCorrections_

const EcalRecHitCollection *	barrelRecHits_

const reco::BeamSpot *	beamSpot_

const ESChannelStatus *	channelStatus_

bool	doSatelliteClusterMerge_

bool	dropUnseedable_

edm::ESGetToken< EcalMustacheSCParameters, EcalMustacheSCParametersRcd >	ecalMustacheSCParametersToken_

edm::ESGetToken< EcalSCDynamicDPhiParameters, EcalSCDynamicDPhiParametersRcd >	ecalSCDynamicDPhiParametersToken_

const reco::PFCluster::EEtoPSAssociation *	EEtoPS_

const EcalRecHitCollection *	endcapRecHits_

edm::ESGetToken< ESChannelStatus, ESChannelStatusRcd >	esChannelStatusToken_

edm::ESGetToken< ESEEIntercalibConstants, ESEEIntercalibConstantsRcd >	esEEInterCalibToken_

double	etawidthSuperClusterBarrel_

double	etawidthSuperClusterEndcap_

double	fractionForMajority_

edm::EDGetTokenT< EcalRecHitCollection >	inputTagBarrelRecHits_

edm::EDGetTokenT< reco::BeamSpot >	inputTagBeamSpot_

edm::EDGetTokenT< EcalRecHitCollection >	inputTagEndcapRecHits_

edm::EDGetTokenT< edm::View< reco::PFCluster > >	inputTagPFClusters_

edm::EDGetTokenT< reco::PFCluster::EEtoPSAssociation >	inputTagPFClustersES_

bool	isOOTCollection_

const EcalMustacheSCParameters *	mustacheSCParams_

double	phiwidthSuperClusterBarrel_

double	phiwidthSuperClusterEndcap_

std::unique_ptr< SCEnergyCorrectorSemiParm >	regr_

double	satelliteThreshold_

const EcalSCDynamicDPhiParameters *	scDynamicDPhiParams_

std::unique_ptr< reco::SuperClusterCollection >	superClustersEB_

std::unique_ptr< reco::SuperClusterCollection >	superClustersEE_

bool	threshIsET_

double	threshPFClusterBarrel_

double	threshPFClusterEndcap_

double	threshPFClusterSeedBarrel_

double	threshPFClusterSeedEndcap_

double	threshSuperClusterEt_

bool	useDynamicDPhi_

bool	useRegression_

bool	verbose_

Detailed Description

\ Algorithm for box particle flow super clustering in the ECAL

Original Author: Nicolas Chanon Additional Authors (Mustache): Y. Gershtein, R. Patel, L. Gray

Date: July 2012

Definition at line 51 of file PFECALSuperClusterAlgo.h.

Member Typedef Documentation

◆ CalibratedClusterPtr

typedef std::shared_ptr<CalibratedPFCluster> PFECALSuperClusterAlgo::CalibratedClusterPtr

Definition at line 71 of file PFECALSuperClusterAlgo.h.

◆ CalibratedClusterPtrVector

typedef std::vector<CalibratedClusterPtr> PFECALSuperClusterAlgo::CalibratedClusterPtrVector

Definition at line 72 of file PFECALSuperClusterAlgo.h.

Member Enumeration Documentation

◆ clustering_type

enum PFECALSuperClusterAlgo::clustering_type

Enumerator
kBOX
kMustache

Definition at line 53 of file PFECALSuperClusterAlgo.h.

53 { kBOX = 1, kMustache = 2 };

◆ energy_weight

enum PFECALSuperClusterAlgo::energy_weight

Enumerator
kRaw
kCalibratedNoPS
kCalibratedTotal

Definition at line 54 of file PFECALSuperClusterAlgo.h.

54 { kRaw, kCalibratedNoPS, kCalibratedTotal };

Constructor & Destructor Documentation

◆ PFECALSuperClusterAlgo()

PFECALSuperClusterAlgo::PFECALSuperClusterAlgo ( )

constructor

Definition at line 110 of file PFECALSuperClusterAlgo.cc.

110 : beamSpot_(nullptr) {}

Member Function Documentation

◆ buildAllSuperClusters()

void PFECALSuperClusterAlgo::buildAllSuperClusters	(	CalibratedClusterPtrVector &	,
		double	seedthresh
	)

private

Definition at line 254 of file PFECALSuperClusterAlgo.cc.

                                                                                                      {
   auto seedable = std::bind(isSeed, _1, seedthresh, threshIsET_);
   // make sure only seeds appear at the front of the list of clusters
   std::stable_partition(clusters.begin(), clusters.end(), seedable);
   // in each iteration we are working on a list that is already sorted
   // in the cluster energy and remains so through each iteration
   // NB: since clusters is sorted in loadClusters any_of has O(1)
   //     timing until you run out of seeds!
   while (std::any_of(clusters.cbegin(), clusters.cend(), seedable)) {
     buildSuperCluster(clusters.front(), clusters);
   }
 }

References buildSuperCluster(), bsc_activity_cfg::clusters, and threshIsET_.

Referenced by run().

◆ buildSuperCluster()

void PFECALSuperClusterAlgo::buildSuperCluster	(	CalibratedClusterPtr &	,
		CalibratedClusterPtrVector &
	)

private

Definition at line 267 of file PFECALSuperClusterAlgo.cc.

                                                                                                      {
   double etawidthSuperCluster = 0.0;
   double phiwidthSuperCluster = 0.0;
   bool isEE = false;
   switch (seed->the_ptr()->layer()) {
     case PFLayer::ECAL_BARREL:
       phiwidthSuperCluster = phiwidthSuperClusterBarrel_;
       etawidthSuperCluster = etawidthSuperClusterBarrel_;
       edm::LogInfo("PFClustering") << "Building SC number " << superClustersEB_->size() + 1 << " in the ECAL barrel!";
       break;
     case PFLayer::HGCAL:
     case PFLayer::ECAL_ENDCAP:
  
       phiwidthSuperCluster = phiwidthSuperClusterEndcap_;
       etawidthSuperCluster = etawidthSuperClusterEndcap_;
       edm::LogInfo("PFClustering") << "Building SC number " << superClustersEE_->size() + 1 << " in the ECAL endcap!"
                                    << std::endl;
       isEE = true;
       break;
     default:
       break;
   }
   auto isClusteredWithSeed = std::bind(isClustered,
                                        _1,
                                        seed,
                                        _clustype,
                                        mustacheSCParams_,
                                        scDynamicDPhiParams_,
                                        useDynamicDPhi_,
                                        etawidthSuperCluster,
                                        phiwidthSuperCluster);
   auto matchesSeedByRecHit = std::bind(isLinkedByRecHit, _1, seed, satelliteThreshold_, fractionForMajority_, 0.1, 0.2);
  
   // this function shuffles the list of clusters into a list
   // where all clustered sub-clusters are at the front
   // and returns a pointer to the first unclustered cluster.
   // The relative ordering of clusters is preserved
   // (i.e. both resulting sub-lists are sorted by energy).
   auto not_clustered = std::stable_partition(clusters.begin(), clusters.end(), isClusteredWithSeed);
   // satellite cluster merging
   // it was found that large clusters can split!
   if (doSatelliteClusterMerge_) {
     not_clustered = std::stable_partition(not_clustered, clusters.end(), matchesSeedByRecHit);
   }
  
   if (verbose_) {
     edm::LogInfo("PFClustering") << "Dumping cluster detail";
     edm::LogVerbatim("PFClustering") << "\tPassed seed: e = " << seed->energy_nocalib() << " eta = " << seed->eta()
                                      << " phi = " << seed->phi() << std::endl;
     for (auto clus = clusters.cbegin(); clus != not_clustered; ++clus) {
       edm::LogVerbatim("PFClustering") << "\t\tClustered cluster: e = " << (*clus)->energy_nocalib()
                                        << " eta = " << (*clus)->eta() << " phi = " << (*clus)->phi() << std::endl;
     }
     for (auto clus = not_clustered; clus != clusters.end(); ++clus) {
       edm::LogVerbatim("PFClustering") << "\tNon-Clustered cluster: e = " << (*clus)->energy_nocalib()
                                        << " eta = " << (*clus)->eta() << " phi = " << (*clus)->phi() << std::endl;
     }
   }
  
   if (not_clustered == clusters.begin()) {
     if (dropUnseedable_) {
       clusters.erase(clusters.begin());
       return;
     } else {
       throw cms::Exception("PFECALSuperClusterAlgo::buildSuperCluster")
           << "Cluster is not seedable!" << std::endl
           << "\tNon-Clustered cluster: e = " << (*not_clustered)->energy_nocalib()
           << " eta = " << (*not_clustered)->eta() << " phi = " << (*not_clustered)->phi() << std::endl;
     }
   }
  
   // move the clustered clusters out of available cluster list
   // and into a temporary vector for building the SC
   CalibratedClusterPtrVector clustered(clusters.begin(), not_clustered);
   clusters.erase(clusters.begin(), not_clustered);
   // need the vector of raw pointers for a PF width class
   std::vector<const reco::PFCluster*> bare_ptrs;
   // calculate necessary parameters and build the SC
   double posX(0), posY(0), posZ(0), corrSCEnergy(0), corrPS1Energy(0), corrPS2Energy(0), energyweight(0),
       energyweighttot(0);
   for (auto& clus : clustered) {
     double ePS1 = 0.0;
     double ePS2 = 0.0;
     energyweight = clus->energy_nocalib();
     bare_ptrs.push_back(clus->the_ptr().get());
     // update EE calibrated super cluster energies
     if (isEE) {
       auto ee_key_val = std::make_pair(clus->the_ptr().key(), edm::Ptr<reco::PFCluster>());
       const auto clustops = std::equal_range(EEtoPS_->begin(), EEtoPS_->end(), ee_key_val, sortByKey);
       std::vector<reco::PFCluster const*> psClusterPointers;
       for (auto i_ps = clustops.first; i_ps != clustops.second; ++i_ps) {
         psClusterPointers.push_back(i_ps->second.get());
       }
       auto calibratedEnergies = _pfEnergyCalibration->calibrateEndcapClusterEnergies(
           *(clus->the_ptr()), psClusterPointers, *channelStatus_, applyCrackCorrections_);
       ePS1 = calibratedEnergies.ps1Energy;
       ePS2 = calibratedEnergies.ps2Energy;
     }
  
     if (ePS1 == -1.)
       ePS1 = 0;
     if (ePS2 == -1.)
       ePS2 = 0;
  
     switch (_eweight) {
       case kRaw:  // energyweight is initialized to raw cluster energy
         break;
       case kCalibratedNoPS:
         energyweight = clus->energy() - ePS1 - ePS2;
         break;
       case kCalibratedTotal:
         energyweight = clus->energy();
         break;
       default:
         break;
     }
     const math::XYZPoint& cluspos = clus->the_ptr()->position();
     posX += energyweight * cluspos.X();
     posY += energyweight * cluspos.Y();
     posZ += energyweight * cluspos.Z();
  
     energyweighttot += energyweight;
     corrSCEnergy += clus->energy();
     corrPS1Energy += ePS1;
     corrPS2Energy += ePS2;
   }
   posX /= energyweighttot;
   posY /= energyweighttot;
   posZ /= energyweighttot;
  
   // now build the supercluster
   reco::SuperCluster new_sc(corrSCEnergy, math::XYZPoint(posX, posY, posZ));
   new_sc.setCorrectedEnergy(corrSCEnergy);
   new_sc.setSeed(clustered.front()->the_ptr());
   new_sc.setPreshowerEnergy(corrPS1Energy + corrPS2Energy);
   new_sc.setPreshowerEnergyPlane1(corrPS1Energy);
   new_sc.setPreshowerEnergyPlane2(corrPS2Energy);
   for (const auto& clus : clustered) {
     new_sc.addCluster(clus->the_ptr());
  
     auto& hits_and_fractions = clus->the_ptr()->hitsAndFractions();
     for (auto& hit_and_fraction : hits_and_fractions) {
       new_sc.addHitAndFraction(hit_and_fraction.first, hit_and_fraction.second);
     }
     if (isEE) {
       auto ee_key_val = std::make_pair(clus->the_ptr().key(), edm::Ptr<reco::PFCluster>());
       const auto clustops = std::equal_range(EEtoPS_->begin(), EEtoPS_->end(), ee_key_val, sortByKey);
       // EE rechits should be uniquely matched to sets of pre-shower
       // clusters at this point, so we throw an exception if otherwise
       // now wrapped in EDM debug flags
       for (auto i_ps = clustops.first; i_ps != clustops.second; ++i_ps) {
         edm::Ptr<reco::PFCluster> psclus(i_ps->second);
 #ifdef EDM_ML_DEBUG
         auto found_pscluster = std::find_if(new_sc.preshowerClustersBegin(),
                                             new_sc.preshowerClustersEnd(),
                                             [&i_ps](const auto& i) { return i.key() == i_ps->first; });
         if (found_pscluster == new_sc.preshowerClustersEnd()) {
 #endif
           new_sc.addPreshowerCluster(psclus);
 #ifdef EDM_ML_DEBUG
         } else {
           throw cms::Exception("PFECALSuperClusterAlgo::buildSuperCluster")
               << "Found a PS cluster matched to more than one EE cluster!" << std::endl
               << std::hex << psclus.get() << " == " << found_pscluster->get() << std::dec << std::endl;
         }
 #endif
       }
     }
   }
  
   // calculate linearly weighted cluster widths
   PFClusterWidthAlgo pfwidth(bare_ptrs);
   new_sc.setEtaWidth(pfwidth.pflowEtaWidth());
   new_sc.setPhiWidth(pfwidth.pflowPhiWidth());
  
   // cache the value of the raw energy
   new_sc.rawEnergy();
  
   //apply regression energy corrections
   if (useRegression_) {
     regr_->modifyObject(new_sc);
   }
  
   // save the super cluster to the appropriate list (if it passes the final
   // Et threshold)
   //Note that Et is computed here with respect to the beamspot position
   //in order to be consistent with the cut applied in the
   //ElectronSeedProducer
   double scEtBS = ptFast(new_sc.energy(), new_sc.position(), beamSpot_->position());
  
   if (scEtBS > threshSuperClusterEt_) {
     switch (seed->the_ptr()->layer()) {
       case PFLayer::ECAL_BARREL:
         if (isOOTCollection_) {
           DetId seedId = new_sc.seed()->seed();
           EcalRecHitCollection::const_iterator seedRecHit = barrelRecHits_->find(seedId);
           if (!seedRecHit->checkFlag(EcalRecHit::kOutOfTime))
             break;
         }
         superClustersEB_->push_back(new_sc);
         break;
       case PFLayer::HGCAL:
       case PFLayer::ECAL_ENDCAP:
         if (isOOTCollection_) {
           DetId seedId = new_sc.seed()->seed();
           EcalRecHitCollection::const_iterator seedRecHit = endcapRecHits_->find(seedId);
           if (!seedRecHit->checkFlag(EcalRecHit::kOutOfTime))
             break;
         }
         superClustersEE_->push_back(new_sc);
         break;
       default:
         break;
     }
   }
 }

Referenced by buildAllSuperClusters().

◆ getEBOutputSCCollection()

std::unique_ptr<reco::SuperClusterCollection>& PFECALSuperClusterAlgo::getEBOutputSCCollection ( )

inline

Definition at line 116 of file PFECALSuperClusterAlgo.h.

116 { return superClustersEB_; }

References superClustersEB_.

◆ getEEOutputSCCollection()

std::unique_ptr<reco::SuperClusterCollection>& PFECALSuperClusterAlgo::getEEOutputSCCollection ( )

inline

Definition at line 117 of file PFECALSuperClusterAlgo.h.

117 { return superClustersEE_; }

References superClustersEE_.

◆ loadAndSortPFClusters()

void PFECALSuperClusterAlgo::loadAndSortPFClusters ( const edm::Event & evt )

Definition at line 167 of file PFECALSuperClusterAlgo.cc.

                                                                          {
   //load input collections
   //Load the pfcluster collections
   edm::Handle<edm::View<reco::PFCluster> > pfclustersHandle;
   iEvent.getByToken(inputTagPFClusters_, pfclustersHandle);
  
   edm::Handle<reco::PFCluster::EEtoPSAssociation> psAssociationHandle;
   iEvent.getByToken(inputTagPFClustersES_, psAssociationHandle);
  
   const PFClusterView& clusters = *pfclustersHandle.product();
   const reco::PFCluster::EEtoPSAssociation& psclusters = *psAssociationHandle.product();
  
   //load BeamSpot
   edm::Handle<reco::BeamSpot> bsHandle;
   iEvent.getByToken(inputTagBeamSpot_, bsHandle);
   beamSpot_ = bsHandle.product();
  
   //initialize regression for this event
   if (useRegression_) {
     regr_->setEvent(iEvent);
   }
  
   // reset the system for running
   superClustersEB_ = std::make_unique<reco::SuperClusterCollection>();
   _clustersEB.clear();
   superClustersEE_ = std::make_unique<reco::SuperClusterCollection>();
   _clustersEE.clear();
   EEtoPS_ = &psclusters;
  
   //Select PF clusters available for the clustering
   for (size_t i = 0; i < clusters.size(); ++i) {
     auto cluster = clusters.ptrAt(i);
     LogDebug("PFClustering") << "Loading PFCluster i=" << cluster.key() << " energy=" << cluster->energy() << std::endl;
  
     // protection for sim clusters
     if (cluster->caloID().detectors() == 0 && cluster->hitsAndFractions().empty())
       continue;
  
     CalibratedClusterPtr calib_cluster(new CalibratedPFCluster(cluster));
     switch (cluster->layer()) {
       case PFLayer::ECAL_BARREL:
         if (calib_cluster->energy() > threshPFClusterBarrel_) {
           _clustersEB.push_back(calib_cluster);
         }
         break;
       case PFLayer::HGCAL:
       case PFLayer::ECAL_ENDCAP:
         if (calib_cluster->energy() > threshPFClusterEndcap_) {
           _clustersEE.push_back(calib_cluster);
         }
         break;
       default:
         break;
     }
   }
   // sort full cluster collections by their calibrated energy
   // this will put all the seeds first by construction
   std::sort(_clustersEB.begin(), _clustersEB.end(), greaterByEt);
   std::sort(_clustersEE.begin(), _clustersEE.end(), greaterByEt);
  
   // set recHit collections for OOT photons
   if (isOOTCollection_) {
     edm::Handle<EcalRecHitCollection> barrelRecHitsHandle;
     iEvent.getByToken(inputTagBarrelRecHits_, barrelRecHitsHandle);
     if (!barrelRecHitsHandle.isValid()) {
       throw cms::Exception("PFECALSuperClusterAlgo")
           << "If you use OOT photons, need to specify proper barrel rec hit collection";
     }
     barrelRecHits_ = barrelRecHitsHandle.product();
  
     edm::Handle<EcalRecHitCollection> endcapRecHitsHandle;
     iEvent.getByToken(inputTagEndcapRecHits_, endcapRecHitsHandle);
     if (!endcapRecHitsHandle.isValid()) {
       throw cms::Exception("PFECALSuperClusterAlgo")
           << "If you use OOT photons, need to specify proper endcap rec hit collection";
     }
     endcapRecHits_ = endcapRecHitsHandle.product();
   }
 }

References _clustersEB, _clustersEE, barrelRecHits_, beamSpot_, bsc_activity_cfg::clusters, PFLayer::ECAL_BARREL, PFLayer::ECAL_ENDCAP, EEtoPS_, endcapRecHits_, Exception, PFLayer::HGCAL, mps_fire::i, iEvent, inputTagBarrelRecHits_, inputTagBeamSpot_, inputTagEndcapRecHits_, inputTagPFClusters_, inputTagPFClustersES_, isOOTCollection_, edm::HandleBase::isValid(), LogDebug, edm::Handle< T >::product(), regr_, superClustersEB_, superClustersEE_, threshPFClusterBarrel_, threshPFClusterEndcap_, and useRegression_.

◆ run()

void PFECALSuperClusterAlgo::run ( )

Definition at line 247 of file PFECALSuperClusterAlgo.cc.

                                  {
   // clusterize the EB
   buildAllSuperClusters(_clustersEB, threshPFClusterSeedBarrel_);
   // clusterize the EE
   buildAllSuperClusters(_clustersEE, threshPFClusterSeedEndcap_);
 }

References _clustersEB, _clustersEE, buildAllSuperClusters(), threshPFClusterSeedBarrel_, and threshPFClusterSeedEndcap_.

◆ setClusteringType()

void PFECALSuperClusterAlgo::setClusteringType ( clustering_type thetype )

inline

Definition at line 79 of file PFECALSuperClusterAlgo.h.

79 { _clustype = thetype; }

References _clustype.

◆ setCrackCorrections()

void PFECALSuperClusterAlgo::setCrackCorrections ( bool applyCrackCorrections )

inline

Definition at line 110 of file PFECALSuperClusterAlgo.h.

110 { applyCrackCorrections_ = applyCrackCorrections; }

References HLT_FULL_cff::applyCrackCorrections, and applyCrackCorrections_.

◆ setDropUnseedable()

void PFECALSuperClusterAlgo::setDropUnseedable ( const bool d )

inline

Definition at line 106 of file PFECALSuperClusterAlgo.h.

106 { dropUnseedable_ = d; }

References ztail::d, and dropUnseedable_.

◆ setEnergyWeighting()

void PFECALSuperClusterAlgo::setEnergyWeighting ( energy_weight thetype )

inline

Definition at line 81 of file PFECALSuperClusterAlgo.h.

81 { _eweight = thetype; }

References _eweight.

◆ setEtawidthSuperClusterBarrel()

void PFECALSuperClusterAlgo::setEtawidthSuperClusterBarrel ( double etawidth )

inline

Definition at line 97 of file PFECALSuperClusterAlgo.h.

97 { etawidthSuperClusterBarrel_ = etawidth; }

References etawidthSuperClusterBarrel_.

◆ setEtawidthSuperClusterEndcap()

void PFECALSuperClusterAlgo::setEtawidthSuperClusterEndcap ( double etawidth )

inline

Definition at line 99 of file PFECALSuperClusterAlgo.h.

99 { etawidthSuperClusterEndcap_ = etawidth; }

References etawidthSuperClusterEndcap_.

◆ setIsOOTCollection()

void PFECALSuperClusterAlgo::setIsOOTCollection ( bool isOOTCollection )

inline

Definition at line 108 of file PFECALSuperClusterAlgo.h.

108 { isOOTCollection_ = isOOTCollection; }

References HLT_FULL_cff::isOOTCollection, and isOOTCollection_.

◆ setMajorityFraction()

void PFECALSuperClusterAlgo::setMajorityFraction ( const double f )

inline

Definition at line 105 of file PFECALSuperClusterAlgo.h.

105 { fractionForMajority_ = f; }

References f, and fractionForMajority_.

◆ setPFClusterCalibration()

void PFECALSuperClusterAlgo::setPFClusterCalibration ( const std::shared_ptr< PFEnergyCalibration > & calib )

Definition at line 112 of file PFECALSuperClusterAlgo.cc.

                                                                                                     {
   _pfEnergyCalibration = calib;
 }

References _pfEnergyCalibration, and L1EGammaCrystalsEmulatorProducer_cfi::calib.

◆ setPhiwidthSuperClusterBarrel()

void PFECALSuperClusterAlgo::setPhiwidthSuperClusterBarrel ( double phiwidth )

inline

Definition at line 96 of file PFECALSuperClusterAlgo.h.

96 { phiwidthSuperClusterBarrel_ = phiwidth; }

References phiwidthSuperClusterBarrel_.

◆ setPhiwidthSuperClusterEndcap()

void PFECALSuperClusterAlgo::setPhiwidthSuperClusterEndcap ( double phiwidth )

inline

Definition at line 98 of file PFECALSuperClusterAlgo.h.

98 { phiwidthSuperClusterEndcap_ = phiwidth; }

References phiwidthSuperClusterEndcap_.

◆ setSatelliteMerging()

void PFECALSuperClusterAlgo::setSatelliteMerging ( const bool doit )

inline

Definition at line 103 of file PFECALSuperClusterAlgo.h.

103 { doSatelliteClusterMerge_ = doit; }

References doSatelliteClusterMerge_.

◆ setSatelliteThreshold()

void PFECALSuperClusterAlgo::setSatelliteThreshold ( const double t )

inline

Definition at line 104 of file PFECALSuperClusterAlgo.h.

104 { satelliteThreshold_ = t; }

References satelliteThreshold_, and submitPVValidationJobs::t.

◆ setThreshPFClusterBarrel()

void PFECALSuperClusterAlgo::setThreshPFClusterBarrel ( double thresh )

inline

Definition at line 92 of file PFECALSuperClusterAlgo.h.

92 { threshPFClusterBarrel_ = thresh; }

References GOODCOLL_filter_cfg::thresh, and threshPFClusterBarrel_.

◆ setThreshPFClusterEndcap()

void PFECALSuperClusterAlgo::setThreshPFClusterEndcap ( double thresh )

inline

Definition at line 94 of file PFECALSuperClusterAlgo.h.

94 { threshPFClusterEndcap_ = thresh; }

References GOODCOLL_filter_cfg::thresh, and threshPFClusterEndcap_.

◆ setThreshPFClusterSeedBarrel()

void PFECALSuperClusterAlgo::setThreshPFClusterSeedBarrel ( double thresh )

inline

Definition at line 91 of file PFECALSuperClusterAlgo.h.

91 { threshPFClusterSeedBarrel_ = thresh; }

References GOODCOLL_filter_cfg::thresh, and threshPFClusterSeedBarrel_.

◆ setThreshPFClusterSeedEndcap()

void PFECALSuperClusterAlgo::setThreshPFClusterSeedEndcap ( double thresh )

inline

Definition at line 93 of file PFECALSuperClusterAlgo.h.

93 { threshPFClusterSeedEndcap_ = thresh; }

References GOODCOLL_filter_cfg::thresh, and threshPFClusterSeedEndcap_.

◆ setThreshSuperClusterEt()

void PFECALSuperClusterAlgo::setThreshSuperClusterEt ( double thresh )

inline

Definition at line 89 of file PFECALSuperClusterAlgo.h.

89 { threshSuperClusterEt_ = thresh; }

References GOODCOLL_filter_cfg::thresh, and threshSuperClusterEt_.

◆ setTokens()

void PFECALSuperClusterAlgo::setTokens	(	const edm::ParameterSet &	iConfig,
		edm::ConsumesCollector &&	cc
	)

Definition at line 116 of file PFECALSuperClusterAlgo.cc.

                                                                                                 {
   inputTagPFClusters_ = cc.consumes<edm::View<reco::PFCluster> >(iConfig.getParameter<edm::InputTag>("PFClusters"));
   inputTagPFClustersES_ =
       cc.consumes<reco::PFCluster::EEtoPSAssociation>(iConfig.getParameter<edm::InputTag>("ESAssociation"));
   inputTagBeamSpot_ = cc.consumes<reco::BeamSpot>(iConfig.getParameter<edm::InputTag>("BeamSpot"));
  
   esEEInterCalibToken_ =
       cc.esConsumes<ESEEIntercalibConstants, ESEEIntercalibConstantsRcd, edm::Transition::BeginLuminosityBlock>();
   esChannelStatusToken_ = cc.esConsumes<ESChannelStatus, ESChannelStatusRcd, edm::Transition::BeginLuminosityBlock>();
  
   if (_clustype == PFECALSuperClusterAlgo::kMustache) {
     ecalMustacheSCParametersToken_ = cc.esConsumes<EcalMustacheSCParameters, EcalMustacheSCParametersRcd>();
   }
   if (useDynamicDPhi_) {
     ecalSCDynamicDPhiParametersToken_ = cc.esConsumes<EcalSCDynamicDPhiParameters, EcalSCDynamicDPhiParametersRcd>();
   }
  
   if (useRegression_) {
     const edm::ParameterSet& regconf = iConfig.getParameter<edm::ParameterSet>("regressionConfig");
  
     regr_ = std::make_unique<SCEnergyCorrectorSemiParm>();
     regr_->setTokens(regconf, cc);
   }
  
   if (isOOTCollection_) {  // OOT photons only
     inputTagBarrelRecHits_ = cc.consumes<EcalRecHitCollection>(iConfig.getParameter<edm::InputTag>("barrelRecHits"));
     inputTagEndcapRecHits_ = cc.consumes<EcalRecHitCollection>(iConfig.getParameter<edm::InputTag>("endcapRecHits"));
   }
 }

References _clustype, edm::BeginLuminosityBlock, ecalMustacheSCParametersToken_, ecalSCDynamicDPhiParametersToken_, esChannelStatusToken_, esEEInterCalibToken_, edm::ParameterSet::getParameter(), inputTagBarrelRecHits_, inputTagBeamSpot_, inputTagEndcapRecHits_, inputTagPFClusters_, inputTagPFClustersES_, isOOTCollection_, kMustache, regr_, useDynamicDPhi_, and useRegression_.

◆ setUseDynamicDPhi()

void PFECALSuperClusterAlgo::setUseDynamicDPhi ( bool useit )

inline

Definition at line 85 of file PFECALSuperClusterAlgo.h.

85 { useDynamicDPhi_ = useit; }

References useDynamicDPhi_.

◆ setUseETForSeeding()

void PFECALSuperClusterAlgo::setUseETForSeeding ( bool useET )

inline

Definition at line 83 of file PFECALSuperClusterAlgo.h.

83 { threshIsET_ = useET; }

References threshIsET_.

◆ setUseRegression()

void PFECALSuperClusterAlgo::setUseRegression ( bool useRegression )

inline

Definition at line 87 of file PFECALSuperClusterAlgo.h.

87 { useRegression_ = useRegression; }

References HLT_FULL_cff::useRegression, and useRegression_.

◆ setVerbosityLevel()

void PFECALSuperClusterAlgo::setVerbosityLevel ( bool verbose )

inline

Definition at line 77 of file PFECALSuperClusterAlgo.h.

77 { verbose_ = verbose; }

References verbose, and verbose_.

◆ update()

void PFECALSuperClusterAlgo::update ( const edm::EventSetup & setup )

Definition at line 146 of file PFECALSuperClusterAlgo.cc.

                                                               {
   if (useRegression_) {
     regr_->setEventSetup(setup);
   }
  
   edm::ESHandle<ESEEIntercalibConstants> esEEInterCalibHandle_ = setup.getHandle(esEEInterCalibToken_);
   _pfEnergyCalibration->initAlphaGamma_ESplanes_fromDB(esEEInterCalibHandle_.product());
  
   edm::ESHandle<ESChannelStatus> esChannelStatusHandle_ = setup.getHandle(esChannelStatusToken_);
   channelStatus_ = esChannelStatusHandle_.product();
 }

References _pfEnergyCalibration, channelStatus_, esChannelStatusToken_, esEEInterCalibToken_, edm::ESHandle< T >::product(), regr_, singleTopDQM_cfi::setup, and useRegression_.

Referenced by progressbar.ProgressBar::__next__(), MatrixUtil.Matrix::__setitem__(), MatrixUtil.Steps::__setitem__(), progressbar.ProgressBar::finish(), and MatrixUtil.Steps::overwrite().

◆ updateSCParams()

void PFECALSuperClusterAlgo::updateSCParams ( const edm::EventSetup & setup )

Definition at line 158 of file PFECALSuperClusterAlgo.cc.

                                                                       {
   if (_clustype == PFECALSuperClusterAlgo::kMustache) {
     mustacheSCParams_ = &setup.getData(ecalMustacheSCParametersToken_);
   }
   if (useDynamicDPhi_) {
     scDynamicDPhiParams_ = &setup.getData(ecalSCDynamicDPhiParametersToken_);
   }
 }