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 BlockElementImporterBase &)=delete

	BlockElementImporterBase (const edm::ParameterSet &conf, edm::ConsumesCollector &sumes)

const std::string &	name () const

BlockElementImporterBase &	operator= (const BlockElementImporterBase &)=delete

virtual	~BlockElementImporterBase ()=default

Private Attributes
const double	_maxHoverE

const double	_minSCPt

const double	_pTbyPass

edm::EDGetTokenT< reco::SuperClusterCollection >	_srcEB

edm::EDGetTokenT< reco::SuperClusterCollection >	_srcEE

edm::EDGetTokenT< CaloTowerCollection >	_srcTowers

bool	_superClustersArePF

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

Detailed Description

Definition at line 22 of file SuperClusterImporter.cc.

Constructor & Destructor Documentation

◆ SuperClusterImporter()

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

Definition at line 43 of file SuperClusterImporter.cc.

     : BlockElementImporterBase(conf, sumes),
       _srcEB(sumes.consumes<reco::SuperClusterCollection>(conf.getParameter<edm::InputTag>("source_eb"))),
       _srcEE(sumes.consumes<reco::SuperClusterCollection>(conf.getParameter<edm::InputTag>("source_ee"))),
       _srcTowers(sumes.consumes<CaloTowerCollection>(conf.getParameter<edm::InputTag>("source_towers"))),
       _maxHoverE(conf.getParameter<double>("maximumHoverE")),
       _pTbyPass(conf.getParameter<double>("minPTforBypass")),
       _minSCPt(conf.getParameter<double>("minSuperClusterPt")),
       _superClustersArePF(conf.getParameter<bool>("superClustersArePF")) {}

Member Function Documentation

◆ importToBlock()

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

overridevirtual

Implements BlockElementImporterBase.

Definition at line 59 of file SuperClusterImporter.cc.

                                                                                                             {
   auto eb_scs = e.getHandle(_srcEB);
   auto ee_scs = e.getHandle(_srcEE);
   auto const& towers = e.get(_srcTowers);
   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;
   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 auto towersBehindCluster = egamma::towersOf(*sc, *towerMap_);
     const double H_tower =
         (egamma::depth1HcalESum(towersBehindCluster, towers) + egamma::depth2HcalESum(towersBehindCluster, towers));
     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 auto towersBehindCluster = egamma::towersOf(*sc, *towerMap_);
     const double H_tower =
         (egamma::depth1HcalESum(towersBehindCluster, towers) + egamma::depth2HcalESum(towersBehindCluster, towers));
     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();
 }

References _maxHoverE, _minSCPt, _pTbyPass, _srcEB, _srcEE, _srcTowers, _superClustersArePF, _zero, a, bsc_activity_cfg::bsc, egamma::depth1HcalESum(), egamma::depth2HcalESum(), HLT_FULL_cff::distance, MillePedeFileConverter_cfg::e, ptFast(), reco::PFBlockElement::SC, reco::PFBlockElementSuperCluster::setFromPFSuperCluster(), towerMap_, HLT_FULL_cff::towers, and egamma::towersOf().

◆ updateEventSetup()

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

overridevirtual

Reimplemented from BlockElementImporterBase.

Definition at line 53 of file SuperClusterImporter.cc.

                                                                    {
   edm::ESHandle<CaloTowerConstituentsMap> ctmaph;
   es.get<CaloGeometryRecord>().get(ctmaph);
   towerMap_ = ctmaph.product();
 }