Inheritance diagram for EGPhotonImporter:

Public Types
enum	SelectionChoices { SeparateDetectorIso, CombinedDetectorIso }

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

Public Member Functions
	EGPhotonImporter (const edm::ParameterSet &, edm::ConsumesCollector &)

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

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

	BlockElementImporterBase (const BlockElementImporterBase &)=delete

const std::string &	name () const

BlockElementImporterBase &	operator= (const BlockElementImporterBase &)=delete

virtual void	updateEventSetup (const edm::EventSetup &)

virtual	~BlockElementImporterBase ()=default

Private Attributes
SelectionChoices	_selectionChoice

const std::unordered_map< std::string, SelectionChoices >	_selectionTypes

std::unique_ptr< const PhotonSelectorAlgo >	_selector

edm::EDGetTokenT< reco::PhotonCollection >	_src

bool	_superClustersArePF

Detailed Description

Definition at line 13 of file EGPhotonImporter.cc.

Member Enumeration Documentation

enum EGPhotonImporter::SelectionChoices

Enumerator
SeparateDetectorIso
CombinedDetectorIso

Definition at line 15 of file EGPhotonImporter.cc.

15 {SeparateDetectorIso,CombinedDetectorIso};

EGPhotonImporter::SeparateDetectorIso

Definition: EGPhotonImporter.cc:15

EGPhotonImporter::CombinedDetectorIso

Definition: EGPhotonImporter.cc:15

Constructor & Destructor Documentation

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

Definition at line 35 of file EGPhotonImporter.cc.

References _selectionChoice, _selectionTypes, _selector, _superClustersArePF, CombinedDetectorIso, edm::ParameterSet::getParameter(), edm::ParameterSet::getParameterSet(), importToBlock(), SeparateDetectorIso, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                 :
     BlockElementImporterBase(conf,sumes),
     _src(sumes.consumes<reco::PhotonCollection>(conf.getParameter<edm::InputTag>("source"))),
     _selectionTypes({ {"SeparateDetectorIso",EGPhotonImporter::SeparateDetectorIso},
       {"CombinedDetectorIso",EGPhotonImporter::CombinedDetectorIso} }),
     _superClustersArePF(conf.getParameter<bool>("superClustersArePF")) {
   const std::string& selChoice = 
     conf.getParameter<std::string>("SelectionChoice");
   _selectionChoice = _selectionTypes.at(selChoice);
   const edm::ParameterSet& selDef = 
     conf.getParameterSet("SelectionDefinition");
   const float minEt = selDef.getParameter<double>("minEt");
   const float trackIso_const = selDef.getParameter<double>("trackIsoConstTerm");
   const float trackIso_slope = selDef.getParameter<double>("trackIsoSlopeTerm");
   const float ecalIso_const = selDef.getParameter<double>("ecalIsoConstTerm");
   const float ecalIso_slope = selDef.getParameter<double>("ecalIsoSlopeTerm");
   const float hcalIso_const = selDef.getParameter<double>("hcalIsoConstTerm");
   const float hcalIso_slope = selDef.getParameter<double>("hcalIsoSlopeTerm");
   const float hoe = selDef.getParameter<double>("HoverE");
   const float loose_hoe = selDef.getParameter<double>("LooseHoverE");
   const float combIso = selDef.getParameter<double>("combIsoConstTerm");
   _selector.reset(new PhotonSelectorAlgo((float)_selectionChoice,
                      minEt,
                      trackIso_const, trackIso_slope,
                      ecalIso_const, ecalIso_slope,
                      hcalIso_const, hcalIso_slope,
                      hoe,
                      combIso,
                      loose_hoe));
 }

Member Function Documentation

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

overridevirtual

Implements BlockElementImporterBase.

Definition at line 68 of file EGPhotonImporter.cc.

Referenced by EGPhotonImporter().

                                                               {
   typedef BlockElementImporterBase::ElementList::value_type ElementType;  
   edm::Handle<reco::PhotonCollection> photons;
   e.getByToken(_src,photons);
   elems.reserve(elems.size()+photons->size());
   // setup our elements so that all the SCs are grouped together
   auto SCs_end = std::partition(elems.begin(),elems.end(),
                 [](const ElementType& a){
                   return a->type() == reco::PFBlockElement::SC;
                 });  
   //now add the photons
   auto bphoton = photons->cbegin();
   auto ephoton = photons->cend();
   reco::PFBlockElementSuperCluster* scbe = NULL;
   reco::PhotonRef phoref;
   for( auto photon = bphoton; photon != ephoton; ++photon ) {
     if( _selector->passPhotonSelection(*photon) ) {
       phoref = reco::PhotonRef(photons,std::distance(bphoton,photon));
       const reco::SuperClusterRef& scref = photon->superCluster();
       PFBlockElementSCEqual myEqual(scref);
       auto sc_elem = std::find_if(elems.begin(),SCs_end,myEqual);
       if( sc_elem != SCs_end ) {
     scbe = static_cast<reco::PFBlockElementSuperCluster*>(sc_elem->get());
     scbe->setFromPhoton(true);
     scbe->setPhotonRef(phoref);
     scbe->setTrackIso(photon->trkSumPtHollowConeDR04());
     scbe->setEcalIso(photon->ecalRecHitSumEtConeDR04());
     scbe->setHcalIso(photon->hcalTowerSumEtConeDR04());
     scbe->setHoE(photon->hadronicOverEm());
       } else {
     scbe = new reco::PFBlockElementSuperCluster(scref);
     scbe->setFromPhoton(true);
     scbe->setFromPFSuperCluster(_superClustersArePF);
     scbe->setPhotonRef(phoref);
     scbe->setTrackIso(photon->trkSumPtHollowConeDR04());
     scbe->setEcalIso(photon->ecalRecHitSumEtConeDR04());
     scbe->setHcalIso(photon->hcalTowerSumEtConeDR04());
     scbe->setHoE(photon->hadronicOverEm());
     SCs_end = elems.insert(SCs_end,ElementType(scbe));
     ++SCs_end; // point to element *after* the new one
       }
     }
   }// loop on photons
   elems.shrink_to_fit();
 }