#include <RecoEgamma/EgammaTools/plugins/HGCalPhotonIDValueMapProducer.cc>

Inheritance diagram for HGCalPhotonIDValueMapProducer:

Public Member Functions
	HGCalPhotonIDValueMapProducer (const edm::ParameterSet &)

	~HGCalPhotonIDValueMapProducer () override

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

bool	hasAbilityToProduceInLumis () const final

bool	hasAbilityToProduceInRuns () const final

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

Private Member Functions
void	beginStream (edm::StreamID) override

void	endStream () override

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

Private Attributes
std::map< const std::string, std::vector< float > >	maps_

std::unique_ptr< HGCalEgammaIDHelper >	phoIDHelper_

edm::EDGetTokenT< edm::View< reco::Photon > >	photonsToken_

float	radius_

Static Private Attributes
static const std::vector< std::string >	valuesProduced_

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

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T... >	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

Detailed Description

Description: [one line class summary]

Implementation: [Notes on implementation]

Definition at line 41 of file HGCalPhotonIDValueMapProducer.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 100 of file HGCalPhotonIDValueMapProducer.cc.

References crabWrapper::key, maps_, phoIDHelper_, and valuesProduced_.

                                                                                            :
   photonsToken_(consumes<edm::View<reco::Photon>>(iConfig.getParameter<edm::InputTag>("photons"))),
   radius_(iConfig.getParameter<double>("pcaRadius"))
 {
   for(const auto& key : valuesProduced_) {
     maps_[key] = {};
     produces<edm::ValueMap<float>>(key);
   }
 
   phoIDHelper_.reset(new HGCalEgammaIDHelper(iConfig, consumesCollector()));
 }

HGCalPhotonIDValueMapProducer::~HGCalPhotonIDValueMapProducer ( )

override

Definition at line 113 of file HGCalPhotonIDValueMapProducer.cc.

114 {

115 }

Member Function Documentation

void HGCalPhotonIDValueMapProducer::beginStream ( edm::StreamID )

overrideprivate

Definition at line 230 of file HGCalPhotonIDValueMapProducer.cc.

231 {

232 }

void HGCalPhotonIDValueMapProducer::endStream ( )

overrideprivate

Definition at line 236 of file HGCalPhotonIDValueMapProducer.cc.

236 {

237 }

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

static

Definition at line 241 of file HGCalPhotonIDValueMapProducer.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), DEFINE_FWK_MODULE, and valuesProduced_.

                                                                                           {
   // hgcalPhotonIDValueMap
   edm::ParameterSetDescription desc;
   desc.add<edm::InputTag>("photons", edm::InputTag("photonsFromMultiCl"));
   desc.add<double>("pcaRadius", 3.0);
   desc.add<std::vector<std::string>>("variables", valuesProduced_);
   desc.add<std::vector<double>>("dEdXWeights")->setComment("This must be copied from dEdX_weights in RecoLocalCalo.HGCalRecProducers.HGCalRecHit_cfi");
   desc.add<unsigned int>("isoNRings", 5);
   desc.add<double>("isoDeltaR", 0.15);
   desc.add<double>("isoDeltaRmin", 0.0);
   desc.add<edm::InputTag>("EERecHits", edm::InputTag("HGCalRecHit","HGCEERecHits"));
   desc.add<edm::InputTag>("FHRecHits", edm::InputTag("HGCalRecHit","HGCHEFRecHits"));
   desc.add<edm::InputTag>("BHRecHits", edm::InputTag("HGCalRecHit","HGCHEBRecHits"));
   descriptions.add("hgcalPhotonIDValueMap", desc);
 }

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

overrideprivate

Definition at line 120 of file HGCalPhotonIDValueMapProducer.cc.

References Exception, objects.autophobj::filler, edm::Event::getByToken(), maps_, eostools::move(), MillePedeFileConverter_cfg::out, phoIDHelper_, photonsToken_, edm::Event::put(), radius_, and valuesProduced_.

 {
   using namespace edm;
 
   Handle<edm::View<reco::Photon>> photonsH;
   iEvent.getByToken(photonsToken_, photonsH);
 
   // Clear previous map
   for(auto&& kv : maps_) {
     kv.second.clear();
     kv.second.reserve(photonsH->size());
   }
 
   // Set up helper tool
   phoIDHelper_->eventInit(iEvent,iSetup);
 
   for(const auto& pho : *photonsH) {
     if(pho.isEB()) {
       // Fill some dummy value
       for(auto&& kv : maps_) {
         kv.second.push_back(0.);
       }
     }
     else {
       phoIDHelper_->computeHGCAL(pho, radius_);
 
       // check the PCA has worked out
       if (phoIDHelper_->sigmaUU() == -1){
         for(auto&& kv : maps_) {
           kv.second.push_back(0.);
         }
         continue;
       }
 
       hgcal::LongDeps ld(phoIDHelper_->energyPerLayer(radius_, true));
       float measuredDepth, expectedDepth, expectedSigma;
       float depthCompatibility = phoIDHelper_->clusterDepthCompatibility(ld, measuredDepth, expectedDepth, expectedSigma);
 
       // Fill here all the ValueMaps from their appropriate functions
 
       // energies calculated in an cylinder around the axis of the pho cluster
       float seed_tot_energy = ld.energyEE() + ld.energyFH() + ld.energyBH();
       const double div_cosh_eta = pho.superCluster()->seed()->position().rho() / pho.superCluster()->seed()->position().r();
       maps_["seedEt"].push_back(seed_tot_energy * div_cosh_eta );
       maps_["seedEnergy"].push_back(seed_tot_energy);
       maps_["seedEnergyEE"].push_back(ld.energyEE());
       maps_["seedEnergyFH"].push_back(ld.energyFH());
       maps_["seedEnergyBH"].push_back(ld.energyBH());
 
       // Cluster shapes
       // PCA related
       maps_["pcaEig1"].push_back(phoIDHelper_->eigenValues()(0));
       maps_["pcaEig2"].push_back(phoIDHelper_->eigenValues()(1));
       maps_["pcaEig3"].push_back(phoIDHelper_->eigenValues()(2));
       maps_["pcaSig1"].push_back(phoIDHelper_->sigmas()(0));
       maps_["pcaSig2"].push_back(phoIDHelper_->sigmas()(1));
       maps_["pcaSig3"].push_back(phoIDHelper_->sigmas()(2));
 
       // transverse shapes
       maps_["sigmaUU"].push_back(phoIDHelper_->sigmaUU());
       maps_["sigmaVV"].push_back(phoIDHelper_->sigmaVV());
       maps_["sigmaEE"].push_back(phoIDHelper_->sigmaEE());
       maps_["sigmaPP"].push_back(phoIDHelper_->sigmaPP());
 
       // long profile
       maps_["nLayers"].push_back(ld.nLayers());
       maps_["firstLayer"].push_back(ld.firstLayer());
       maps_["lastLayer"].push_back(ld.lastLayer());
       maps_["e4oEtot"].push_back(ld.e4oEtot());
       maps_["layerEfrac10"].push_back(ld.layerEfrac10());
       maps_["layerEfrac90"].push_back(ld.layerEfrac90());
 
       // depth
       maps_["measuredDepth"].push_back(measuredDepth);
       maps_["expectedDepth"].push_back(expectedDepth);
       maps_["expectedSigma"].push_back(expectedSigma);
       maps_["depthCompatibility"].push_back(depthCompatibility);
 
       // Isolation
       maps_["caloIsoRing0"].push_back(phoIDHelper_->getIsolationRing(0));
       maps_["caloIsoRing1"].push_back(phoIDHelper_->getIsolationRing(1));
       maps_["caloIsoRing2"].push_back(phoIDHelper_->getIsolationRing(2));
       maps_["caloIsoRing3"].push_back(phoIDHelper_->getIsolationRing(3));
       maps_["caloIsoRing4"].push_back(phoIDHelper_->getIsolationRing(4));
     }
   }
 
   // Check we didn't make up a new variable and forget it in the constructor
   // (or some other pathology)
   if ( maps_.size() != valuesProduced_.size() ) {
     throw cms::Exception("HGCalPhotonIDValueMapProducer") << "We have a miscoded value map producer, since map size changed";
   }
 
   for(auto&& kv : maps_) {
     // Check we didn't forget any values
     if ( kv.second.size() != photonsH->size() ) {
       throw cms::Exception("HGCalPhotonIDValueMapProducer") << "We have a miscoded value map producer, since the variable " << kv.first << " wasn't filled.";
     }
     // Do the filling
     auto out = std::make_unique<edm::ValueMap<float>>();
     edm::ValueMap<float>::Filler filler(*out);
     filler.insert(photonsH, kv.second.begin(), kv.second.end());
     filler.fill();
     // and put it into the event
     iEvent.put(std::move(out), kv.first);
   }
 }