Inheritance diagram for SuperClusterImporter:

Public Member Functions
void	importToBlock (const edm::Event &, ElementList &) const override

	SuperClusterImporter (const edm::ParameterSet &, edm::ConsumesCollector &)

void	updateEventSetup (const edm::EventSetup &es) override

Public Member Functions inherited from BlockElementImporterBase
	BlockElementImporterBase (const edm::ParameterSet &conf, edm::ConsumesCollector &cc)

	BlockElementImporterBase (const BlockElementImporterBase &)=delete

const std::string &	name () const

BlockElementImporterBase &	operator= (const BlockElementImporterBase &)=delete

virtual	~BlockElementImporterBase ()=default

Private Attributes
const edm::ESGetToken< CaloTowerConstituentsMap, CaloGeometryRecord >	_ctmapToken

const double	_maxHoverE

const double	_minSCPt

const double	_pTbyPass

edm::EDGetTokenT< reco::SuperClusterCollection >	_srcEB

edm::EDGetTokenT< reco::SuperClusterCollection >	_srcEE

bool	_superClustersArePF

CaloGeometry const *	caloGeom_

const edm::ESGetToken< CaloGeometry, CaloGeometryRecord >	caloGeometryToken_

bool	cutsFromDB

const edm::EDGetTokenT< HBHERecHitCollection >	hbheRecHitsTag_

HcalChannelQuality const *	hcalChannelQual_

const edm::ESGetToken< HcalChannelQuality, HcalChannelQualityRcd >	hcalChannelQualityToken_

HcalPFCuts const *	hcalCuts = nullptr

edm::ESGetToken< HcalPFCuts, HcalPFCutsRcd >	hcalCutsToken_

HcalSeverityLevelComputer const *	hcalSev_

const edm::ESGetToken< HcalSeverityLevelComputer, HcalSeverityLevelComputerRcd >	hcalSevLvlComputerToken_

HcalTopology const *	hcalTopo_

const edm::ESGetToken< HcalTopology, HcalRecNumberingRecord >	hcalTopologyToken_

const int	maxSeverityHB_

const int	maxSeverityHE_

CaloTowerConstituentsMap const *	towerMap_

Static Private Attributes
static const math::XYZPoint	_zero = math::XYZPoint(0, 0, 0)

Additional Inherited Members
Public Types inherited from BlockElementImporterBase
typedef std::vector< std::unique_ptr< reco::PFBlockElement > >	ElementList

enum	VetoMode { pfRecTrackCollection = 0, ticlSeedingRegion = 1, pfCandidateCollection = 2 }

Detailed Description

Definition at line 29 of file SuperClusterImporter.cc.

Constructor & Destructor Documentation

◆ SuperClusterImporter()

SuperClusterImporter::SuperClusterImporter	(	const edm::ParameterSet &	conf,
		edm::ConsumesCollector &	cc
	)

Definition at line 65 of file SuperClusterImporter.cc.

References edm::BeginLuminosityBlock, and gpuPixelDoublets::cc.

     : BlockElementImporterBase(conf, cc),
       _srcEB(cc.consumes<reco::SuperClusterCollection>(conf.getParameter<edm::InputTag>("source_eb"))),
       _srcEE(cc.consumes<reco::SuperClusterCollection>(conf.getParameter<edm::InputTag>("source_ee"))),
       _maxHoverE(conf.getParameter<double>("maximumHoverE")),
       _pTbyPass(conf.getParameter<double>("minPTforBypass")),
       _minSCPt(conf.getParameter<double>("minSuperClusterPt")),
       hbheRecHitsTag_(cc.consumes(conf.getParameter<edm::InputTag>("hbheRecHitsTag"))),
       maxSeverityHB_(conf.getParameter<int>("maxSeverityHB")),
       maxSeverityHE_(conf.getParameter<int>("maxSeverityHE")),
       cutsFromDB(conf.getParameter<bool>("usePFThresholdsFromDB")),
       _superClustersArePF(conf.getParameter<bool>("superClustersArePF")),
       _ctmapToken(cc.esConsumes<edm::Transition::BeginLuminosityBlock>()),
       caloGeometryToken_{cc.esConsumes<edm::Transition::BeginLuminosityBlock>()},
       hcalTopologyToken_{cc.esConsumes<edm::Transition::BeginLuminosityBlock>()},
       hcalChannelQualityToken_{cc.esConsumes<edm::Transition::BeginLuminosityBlock>(edm::ESInputTag("", "withTopo"))},
       hcalSevLvlComputerToken_{cc.esConsumes<edm::Transition::BeginLuminosityBlock>()} {
   if (cutsFromDB) {
     hcalCutsToken_ = cc.esConsumes<HcalPFCuts, HcalPFCutsRcd, edm::Transition::BeginLuminosityBlock>(
         edm::ESInputTag("", "withTopo"));
   }
 }

Member Function Documentation

◆ importToBlock()

void SuperClusterImporter::importToBlock	(	const edm::Event &	e,
		BlockElementImporterBase::ElementList &	elems
	)		const

overridevirtual

Implements BlockElementImporterBase.

Definition at line 99 of file SuperClusterImporter.cc.

References _maxHoverE, _minSCPt, _pTbyPass, _srcEB, _srcEE, _superClustersArePF, _zero, a, bsc_activity_cfg::bsc, caloGeom_, HLT_2024v11_cff::distance, MillePedeFileConverter_cfg::e, edm::Ref< C, T, F >::get(), EgammaHcalIsolation::getHcalESumBc(), hbheRecHitsTag_, hcalChannelQual_, hcalCuts, hcalSev_, hcalTopo_, EgammaHcalIsolation::isBehindClusterSeed, maxSeverityHB_, maxSeverityHE_, l1ctLayer1_patternWriters_cff::partition, ptFast(), reco::PFBlockElement::SC, reco::PFBlockElementSuperCluster::setFromPFSuperCluster(), towerMap_, and EgammaHcalIsolation::withinConeAroundCluster.

                                                                                                             {
   auto eb_scs = e.getHandle(_srcEB);
   auto ee_scs = e.getHandle(_srcEE);
   elems.reserve(elems.size() + eb_scs->size() + ee_scs->size());
   // setup our elements so that all the SCs are grouped together
   auto SCs_end =
       std::partition(elems.begin(), elems.end(), [](auto const& a) { return a->type() == reco::PFBlockElement::SC; });
   // add eb superclusters
   auto bsc = eb_scs->cbegin();
   auto esc = eb_scs->cend();
   reco::PFBlockElementSuperCluster* scbe = nullptr;
   reco::SuperClusterRef scref;
 
   EgammaHcalIsolation thisHcalVar_ = EgammaHcalIsolation(EgammaHcalIsolation::InclusionRule::isBehindClusterSeed,
                                                          0,  //outercone
                                                          EgammaHcalIsolation::InclusionRule::withinConeAroundCluster,
                                                          0,  //innercone
                                                          {{0, 0, 0, 0}},
                                                          {{0, 0, 0, 0}},
                                                          maxSeverityHB_,
                                                          {{0, 0, 0, 0, 0, 0, 0}},
                                                          {{0, 0, 0, 0, 0, 0, 0}},
                                                          maxSeverityHE_,
                                                          e.get(hbheRecHitsTag_),
                                                          caloGeom_,
                                                          hcalTopo_,
                                                          hcalChannelQual_,
                                                          hcalSev_,
                                                          towerMap_);
 
   for (auto sc = bsc; sc != esc; ++sc) {
     scref = reco::SuperClusterRef(eb_scs, std::distance(bsc, sc));
     PFBlockElementSCEqual myEqual(scref);
     auto sc_elem = std::find_if(elems.begin(), SCs_end, myEqual);
     const double scpT = ptFast(sc->energy(), sc->position(), _zero);
     const double H_tower = thisHcalVar_.getHcalESumBc(scref.get(), 0, hcalCuts);
     const double HoverE = H_tower / sc->energy();
     if (sc_elem == SCs_end && scpT > _minSCPt && (scpT > _pTbyPass || HoverE < _maxHoverE)) {
       scbe = new reco::PFBlockElementSuperCluster(scref);
       scbe->setFromPFSuperCluster(_superClustersArePF);
       SCs_end = elems.emplace(SCs_end, scbe);
       ++SCs_end;  // point to element *after* the new one
     }
   }  // loop on eb superclusters
   // add ee superclusters
   bsc = ee_scs->cbegin();
   esc = ee_scs->cend();
   for (auto sc = bsc; sc != esc; ++sc) {
     scref = reco::SuperClusterRef(ee_scs, std::distance(bsc, sc));
     PFBlockElementSCEqual myEqual(scref);
     auto sc_elem = std::find_if(elems.begin(), SCs_end, myEqual);
     const double scpT = ptFast(sc->energy(), sc->position(), _zero);
     const double H_tower = thisHcalVar_.getHcalESumBc(scref.get(), 0, hcalCuts);
     const double HoverE = H_tower / sc->energy();
     if (sc_elem == SCs_end && scpT > _minSCPt && (scpT > _pTbyPass || HoverE < _maxHoverE)) {
       scbe = new reco::PFBlockElementSuperCluster(scref);
       scbe->setFromPFSuperCluster(_superClustersArePF);
       SCs_end = elems.emplace(SCs_end, scbe);
       ++SCs_end;  // point to element *after* the new one
     }
   }  // loop on ee superclusters
   elems.shrink_to_fit();
 }

◆ updateEventSetup()

void SuperClusterImporter::updateEventSetup ( const edm::EventSetup & es )

overridevirtual

Reimplemented from BlockElementImporterBase.

Definition at line 88 of file SuperClusterImporter.cc.

References _ctmapToken, caloGeom_, caloGeometryToken_, cutsFromDB, edm::EventSetup::getData(), hcalChannelQual_, hcalChannelQualityToken_, hcalCuts, hcalCutsToken_, hcalSev_, hcalSevLvlComputerToken_, hcalTopo_, hcalTopologyToken_, and towerMap_.

                                                                    {
   towerMap_ = &es.getData(_ctmapToken);
   if (cutsFromDB) {
     hcalCuts = &es.getData(hcalCutsToken_);
   }
   caloGeom_ = &es.getData(caloGeometryToken_);
   hcalTopo_ = &es.getData(hcalTopologyToken_);
   hcalChannelQual_ = &es.getData(hcalChannelQualityToken_);
   hcalSev_ = &es.getData(hcalSevLvlComputerToken_);
 }