#include <GEDPhotonProducer.h>

Inheritance diagram for GEDPhotonProducer:

Public Member Functions
virtual void	beginRun (edm::Run const &r, edm::EventSetup const &es) overridefinal

virtual void	endRun (edm::Run const &, edm::EventSetup const &) overridefinal

	GEDPhotonProducer (const edm::ParameterSet &ps)

virtual void	produce (edm::Event &evt, const edm::EventSetup &es)

	~GEDPhotonProducer ()

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

Public Member Functions inherited from edm::stream::EDProducerBase
	EDProducerBase ()

ModuleDescription const &	moduleDescription () const

virtual	~EDProducerBase ()

Public Member Functions inherited from edm::ProducerBase
	ProducerBase ()

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

virtual	~ProducerBase ()

Public Member Functions inherited from edm::EDConsumerBase
	EDConsumerBase ()

ProductHolderIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesDependentUpon (const std::string &iProcessName, std::vector< const char * > &oModuleLabels) const

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

Private Member Functions
void	fillPhotonCollection (edm::Event &evt, edm::EventSetup const &es, const edm::Handle< reco::PhotonCoreCollection > &photonCoreHandle, const CaloTopology topology, const EcalRecHitCollection ecalBarrelHits, const EcalRecHitCollection *ecalEndcapHits, const edm::Handle< CaloTowerCollection > &hcalTowersHandle, reco::VertexCollection &pvVertices, reco::PhotonCollection &outputCollection, int &iSC)

void	fillPhotonCollection (edm::Event &evt, edm::EventSetup const &es, const edm::Handle< reco::PhotonCollection > &photonHandle, const edm::Handle< reco::PFCandidateCollection > pfCandidateHandle, const edm::Handle< reco::PFCandidateCollection > pfEGCandidateHandle, edm::ValueMap< reco::PhotonRef > pfEGCandToPhotonMap, edm::Handle< reco::VertexCollection > &pvVertices, reco::PhotonCollection &outputCollection, int &iSC)

Private Attributes
edm::EDGetTokenT < EcalRecHitCollection >	barrelEcalHits_

std::string	candidateP4type_

edm::ParameterSet	conf_

std::string	conversionCollection_

std::string	conversionProducer_

edm::EDGetTokenT < EcalRecHitCollection >	endcapEcalHits_

EcalClusterFunctionBaseClass *	energyCorrectionF

std::vector< int >	flagsexclEB_

std::vector< int >	flagsexclEE_

edm::EDGetTokenT < CaloTowerCollection >	hcalTowers_

double	highEt_

double	hOverEConeSize_

double	maxHOverE_

double	minR9Barrel_

double	minR9Endcap_

double	minSCEt_

edm::EDGetTokenT < reco::PFCandidateCollection >	pfCandidates_

edm::EDGetTokenT < reco::PFCandidateCollection >	pfEgammaCandidates_

std::string	photonCollection_

edm::EDGetTokenT < reco::PhotonCoreCollection >	photonCoreProducerT_

edm::InputTag	photonProducer_

edm::EDGetTokenT < reco::PhotonCollection >	photonProducerT_

PositionCalc	posCalculator_

std::vector< double >	preselCutValuesBarrel_

std::vector< double >	preselCutValuesEndcap_

std::string	reconstructionStep_

bool	runMIPTagger_

std::vector< int >	severitiesexclEB_

std::vector< int >	severitiesexclEE_

edm::ESHandle< CaloGeometry >	theCaloGeom_

edm::ESHandle< CaloTopology >	theCaloTopo_

PFPhotonIsolationCalculator *	thePFBasedIsolationCalculator_

PhotonEnergyCorrector *	thePhotonEnergyCorrector_

PhotonIsolationCalculator *	thePhotonIsolationCalculator_

PhotonMIPHaloTagger *	thePhotonMIPHaloTagger_

bool	usePrimaryVertex_

bool	validConversions_

bool	validPixelSeeds_

std::string	valueMapPFCandPhoton_

edm::EDGetTokenT < reco::VertexCollection >	vertexProducer_

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

Public Types inherited from edm::stream::EDProducerBase
typedef EDProducerAdaptorBase	ModuleType

Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Static Public Member Functions inherited from edm::stream::EDProducerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Protected Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Detailed Description

Author: Nancy Marinelli, U. of Notre Dame, US

Definition at line 42 of file GEDPhotonProducer.h.

Constructor & Destructor Documentation

GEDPhotonProducer::GEDPhotonProducer ( const edm::ParameterSet & ps )

Definition at line 53 of file GEDPhotonProducer.cc.

References barrelEcalHits_, candidateP4type_, conf_, edm::EDConsumerBase::consumesCollector(), endcapEcalHits_, edm::ParameterSet::existsAs(), flagsexclEB_, flagsexclEE_, edm::ParameterSet::getParameter(), edm::ParameterSet::getParameterSet(), hcalTowers_, highEt_, hOverEConeSize_, minR9Barrel_, minR9Endcap_, pfCandidates_, pfEgammaCandidates_, photonCollection_, photonCoreProducerT_, photonProducer_, photonProducerT_, posCalculator_, preselCutValuesBarrel_, preselCutValuesEndcap_, reconstructionStep_, runMIPTagger_, PhotonIsolationCalculator::setup(), PhotonMIPHaloTagger::setup(), severitiesexclEB_, severitiesexclEE_, AlCaHLTBitMon_QueryRunRegistry::string, thePhotonEnergyCorrector_, thePhotonIsolationCalculator_, thePhotonMIPHaloTagger_, usePrimaryVertex_, valueMapPFCandPhoton_, and vertexProducer_.

                                                                   : 
 
   conf_(config)
 {
 
   // use configuration file to setup input/output collection names
   //
   photonProducer_       = conf_.getParameter<edm::InputTag>("photonProducer");
   reconstructionStep_   = conf_.getParameter<std::string>("reconstructionStep");
 
   if (  reconstructionStep_ == "final" ) {
     photonProducerT_   = 
       consumes<reco::PhotonCollection>(photonProducer_);
     pfCandidates_      = 
       consumes<reco::PFCandidateCollection>(conf_.getParameter<edm::InputTag>("pfCandidates"));
 
   } else {
 
     photonCoreProducerT_   = 
       consumes<reco::PhotonCoreCollection>(photonProducer_);
 
   }
 
   pfEgammaCandidates_      = 
     consumes<reco::PFCandidateCollection>(conf_.getParameter<edm::InputTag>("pfEgammaCandidates"));
   barrelEcalHits_   = 
     consumes<EcalRecHitCollection>(conf_.getParameter<edm::InputTag>("barrelEcalHits"));
   endcapEcalHits_   = 
     consumes<EcalRecHitCollection>(conf_.getParameter<edm::InputTag>("endcapEcalHits"));
   vertexProducer_   = 
     consumes<reco::VertexCollection>(conf_.getParameter<edm::InputTag>("primaryVertexProducer"));
 
   hcalTowers_ = 
     consumes<CaloTowerCollection>(conf_.getParameter<edm::InputTag>("hcalTowers"));
   //
   photonCollection_     = conf_.getParameter<std::string>("outputPhotonCollection");
   hOverEConeSize_   = conf_.getParameter<double>("hOverEConeSize");
   highEt_        = conf_.getParameter<double>("highEt");
   // R9 value to decide converted/unconverted
   minR9Barrel_        = conf_.getParameter<double>("minR9Barrel");
   minR9Endcap_        = conf_.getParameter<double>("minR9Endcap");
   usePrimaryVertex_   = conf_.getParameter<bool>("usePrimaryVertex");
   runMIPTagger_       = conf_.getParameter<bool>("runMIPTagger");
 
   candidateP4type_ = config.getParameter<std::string>("candidateP4type") ;
   valueMapPFCandPhoton_ = config.getParameter<std::string>("valueMapPhotons");
 
 
   edm::ParameterSet posCalcParameters = 
     config.getParameter<edm::ParameterSet>("posCalcParameters");
   posCalculator_ = PositionCalc(posCalcParameters);
 
 
   //AA
   //Flags and Severities to be excluded from photon calculations
   const std::vector<std::string> flagnamesEB = 
     config.getParameter<std::vector<std::string> >("RecHitFlagToBeExcludedEB");
 
   const std::vector<std::string> flagnamesEE =
     config.getParameter<std::vector<std::string> >("RecHitFlagToBeExcludedEE");
 
   flagsexclEB_= 
     StringToEnumValue<EcalRecHit::Flags>(flagnamesEB);
 
   flagsexclEE_=
     StringToEnumValue<EcalRecHit::Flags>(flagnamesEE);
 
   const std::vector<std::string> severitynamesEB = 
     config.getParameter<std::vector<std::string> >("RecHitSeverityToBeExcludedEB");
 
   severitiesexclEB_= 
     StringToEnumValue<EcalSeverityLevel::SeverityLevel>(severitynamesEB);
 
   const std::vector<std::string> severitynamesEE = 
     config.getParameter<std::vector<std::string> >("RecHitSeverityToBeExcludedEE");
 
   severitiesexclEE_= 
     StringToEnumValue<EcalSeverityLevel::SeverityLevel>(severitynamesEE);
 
   thePhotonEnergyCorrector_ = 
     new PhotonEnergyCorrector(conf_, consumesCollector());
   if( config.existsAs<edm::ParameterSet>("regressionConfig") ) {
     const edm::ParameterSet regr_conf = 
       config.getParameterSet("regressionConfig");
     thePhotonEnergyCorrector_->gedRegression()->varCalc()->setTokens(regr_conf,consumesCollector());
   }
 
   //AA
 
   //
 
   // Parameters for the position calculation:
   //  std::map<std::string,double> providedParameters;
   // providedParameters.insert(std::make_pair("LogWeighted",conf_.getParameter<bool>("posCalc_logweight")));
   //providedParameters.insert(std::make_pair("T0_barl",conf_.getParameter<double>("posCalc_t0_barl")));
   //providedParameters.insert(std::make_pair("T0_endc",conf_.getParameter<double>("posCalc_t0_endc")));
   //providedParameters.insert(std::make_pair("T0_endcPresh",conf_.getParameter<double>("posCalc_t0_endcPresh")));
   //providedParameters.insert(std::make_pair("W0",conf_.getParameter<double>("posCalc_w0")));
   //providedParameters.insert(std::make_pair("X0",conf_.getParameter<double>("posCalc_x0")));
   //posCalculator_ = PositionCalc(providedParameters);
   // cut values for pre-selection
   preselCutValuesBarrel_.push_back(conf_.getParameter<double>("minSCEtBarrel")); 
   preselCutValuesBarrel_.push_back(conf_.getParameter<double>("maxHoverEBarrel")); 
   preselCutValuesBarrel_.push_back(conf_.getParameter<double>("ecalRecHitSumEtOffsetBarrel")); 
   preselCutValuesBarrel_.push_back(conf_.getParameter<double>("ecalRecHitSumEtSlopeBarrel")); 
   preselCutValuesBarrel_.push_back(conf_.getParameter<double>("hcalTowerSumEtOffsetBarrel"));
   preselCutValuesBarrel_.push_back(conf_.getParameter<double>("hcalTowerSumEtSlopeBarrel"));
   preselCutValuesBarrel_.push_back(conf_.getParameter<double>("nTrackSolidConeBarrel"));
   preselCutValuesBarrel_.push_back(conf_.getParameter<double>("nTrackHollowConeBarrel"));     
   preselCutValuesBarrel_.push_back(conf_.getParameter<double>("trackPtSumSolidConeBarrel"));     
   preselCutValuesBarrel_.push_back(conf_.getParameter<double>("trackPtSumHollowConeBarrel"));     
   preselCutValuesBarrel_.push_back(conf_.getParameter<double>("sigmaIetaIetaCutBarrel"));     
   //  
   preselCutValuesEndcap_.push_back(conf_.getParameter<double>("minSCEtEndcap")); 
   preselCutValuesEndcap_.push_back(conf_.getParameter<double>("maxHoverEEndcap")); 
   preselCutValuesEndcap_.push_back(conf_.getParameter<double>("ecalRecHitSumEtOffsetEndcap")); 
   preselCutValuesEndcap_.push_back(conf_.getParameter<double>("ecalRecHitSumEtSlopeEndcap")); 
   preselCutValuesEndcap_.push_back(conf_.getParameter<double>("hcalTowerSumEtOffsetEndcap"));
   preselCutValuesEndcap_.push_back(conf_.getParameter<double>("hcalTowerSumEtSlopeEndcap"));
   preselCutValuesEndcap_.push_back(conf_.getParameter<double>("nTrackSolidConeEndcap"));
   preselCutValuesEndcap_.push_back(conf_.getParameter<double>("nTrackHollowConeEndcap"));     
   preselCutValuesEndcap_.push_back(conf_.getParameter<double>("trackPtSumSolidConeEndcap"));     
   preselCutValuesEndcap_.push_back(conf_.getParameter<double>("trackPtSumHollowConeEndcap"));     
   preselCutValuesEndcap_.push_back(conf_.getParameter<double>("sigmaIetaIetaCutEndcap"));     
   //
 
   //moved from beginRun to here, I dont see how this could cause harm as its just reading in the exactly same parameters each run
   if ( reconstructionStep_ != "final"){
     thePhotonIsolationCalculator_ = new PhotonIsolationCalculator();
     edm::ParameterSet isolationSumsCalculatorSet = conf_.getParameter<edm::ParameterSet>("isolationSumsCalculatorSet"); 
     thePhotonIsolationCalculator_->setup(isolationSumsCalculatorSet, flagsexclEB_, flagsexclEE_, severitiesexclEB_, severitiesexclEE_,consumesCollector());
     thePhotonMIPHaloTagger_ = new PhotonMIPHaloTagger();
     edm::ParameterSet mipVariableSet = conf_.getParameter<edm::ParameterSet>("mipVariableSet"); 
     thePhotonMIPHaloTagger_->setup(mipVariableSet,consumesCollector());
     
   }else{
     thePhotonIsolationCalculator_=0;
     thePhotonMIPHaloTagger_=0;
   }
   // Register the product
   produces< reco::PhotonCollection >(photonCollection_);
   produces< edm::ValueMap<reco::PhotonRef> > (valueMapPFCandPhoton_);
 
 
 }

GEDPhotonProducer::~GEDPhotonProducer ( )

Definition at line 199 of file GEDPhotonProducer.cc.

References thePhotonEnergyCorrector_, thePhotonIsolationCalculator_, and thePhotonMIPHaloTagger_.

 {
   delete thePhotonEnergyCorrector_;
   delete thePhotonIsolationCalculator_;
   delete thePhotonMIPHaloTagger_;
  //delete energyCorrectionF;
 }

Member Function Documentation

void GEDPhotonProducer::beginRun	(	edm::Run const &	r,
		edm::EventSetup const &	es
	)

finaloverridevirtual

Reimplemented from edm::stream::EDProducerBase.

Definition at line 209 of file GEDPhotonProducer.cc.

References conf_, edm::ParameterSet::getParameter(), init, reconstructionStep_, PFPhotonIsolationCalculator::setup(), thePFBasedIsolationCalculator_, and thePhotonEnergyCorrector_.

                                                                                        {
 
  if ( reconstructionStep_ == "final" ) { 
     thePFBasedIsolationCalculator_ = new PFPhotonIsolationCalculator();
     edm::ParameterSet pfIsolationCalculatorSet = conf_.getParameter<edm::ParameterSet>("PFIsolationCalculatorSet"); 
     thePFBasedIsolationCalculator_->setup(pfIsolationCalculatorSet);
  }else{ 
     thePhotonEnergyCorrector_ -> init(theEventSetup); 
   }
 
 }

void GEDPhotonProducer::endRun	(	edm::Run const &	r,
		edm::EventSetup const &	theEventSetup
	)

finaloverridevirtual

Reimplemented from edm::stream::EDProducerBase.

Definition at line 221 of file GEDPhotonProducer.cc.

References reconstructionStep_, and thePFBasedIsolationCalculator_.

                                                                                      {
 
   if ( reconstructionStep_ == "final" ) { 
     delete thePFBasedIsolationCalculator_;
   }
 }

void GEDPhotonProducer::fillPhotonCollection	(	edm::Event &	evt,
		edm::EventSetup const &	es,
		const edm::Handle< reco::PhotonCoreCollection > &	photonCoreHandle,
		const CaloTopology *	topology,
		const EcalRecHitCollection *	ecalBarrelHits,
		const EcalRecHitCollection *	ecalEndcapHits,
		const edm::Handle< CaloTowerCollection > &	hcalTowersHandle,
		reco::VertexCollection &	pvVertices,
		reco::PhotonCollection &	outputCollection,
		int &	iSC
	)

private

fill shower shape block

get ecal photon specific corrected energy plus values from regressions and store them in the Photon

Pre-selection loose isolation cuts

Definition at line 425 of file GEDPhotonProducer.cc.

Referenced by produce().

                                                                                   {
   
   
   const CaloGeometry* geometry = theCaloGeom_.product();
   const EcalRecHitCollection* hits = 0 ;
   std::vector<double> preselCutValues;
   std::vector<int> flags_, severitiesexcl_;
 
   for(unsigned int lSC=0; lSC < photonCoreHandle->size(); lSC++) {
 
     reco::PhotonCoreRef coreRef(reco::PhotonCoreRef(photonCoreHandle, lSC));
     reco::SuperClusterRef parentSCRef = coreRef->parentSuperCluster();
     reco::SuperClusterRef scRef=coreRef->superCluster();
 
   
   
     //    const reco::SuperCluster* pClus=&(*scRef);
     iSC++;
 
     int subdet = scRef->seed()->hitsAndFractions()[0].first.subdetId();
     if (subdet==EcalBarrel) { 
       preselCutValues = preselCutValuesBarrel_;
       hits = ecalBarrelHits;
       flags_ = flagsexclEB_;
       severitiesexcl_ = severitiesexclEB_;
     } else if  (subdet==EcalEndcap)  { 
       preselCutValues = preselCutValuesEndcap_;
       hits = ecalEndcapHits;
       flags_ = flagsexclEE_;
       severitiesexcl_ = severitiesexclEE_;
     } else {
       edm::LogWarning("")<<"GEDPhotonProducer: do not know if it is a barrel or endcap SuperCluster"; 
     }
 
     
     
 
     // SC energy preselection
     if (parentSCRef.isNonnull() &&
     ptFast(parentSCRef->energy(),parentSCRef->position(),math::XYZPoint(0,0,0)) <= preselCutValues[0] ) continue;
     // calculate HoE    
 
     const CaloTowerCollection* hcalTowersColl = hcalTowersHandle.product();
     EgammaTowerIsolation towerIso1(hOverEConeSize_,0.,0.,1,hcalTowersColl) ;  
     EgammaTowerIsolation towerIso2(hOverEConeSize_,0.,0.,2,hcalTowersColl) ;  
     double HoE1=towerIso1.getTowerESum(&(*scRef))/scRef->energy();
     double HoE2=towerIso2.getTowerESum(&(*scRef))/scRef->energy(); 
     
     EgammaHadTower towerIsoBehindClus(es); 
     towerIsoBehindClus.setTowerCollection(hcalTowersHandle.product());
     std::vector<CaloTowerDetId> TowersBehindClus =  towerIsoBehindClus.towersOf(*scRef);
     float hcalDepth1OverEcalBc = towerIsoBehindClus.getDepth1HcalESum(TowersBehindClus)/scRef->energy();
     float hcalDepth2OverEcalBc = towerIsoBehindClus.getDepth2HcalESum(TowersBehindClus)/scRef->energy();
     //    std::cout << " GEDPhotonProducer calculation of HoE with towers in a cone " << HoE1  << "  " << HoE2 << std::endl;
     //std::cout << " GEDPhotonProducer calcualtion of HoE with towers behind the BCs " << hcalDepth1OverEcalBc  << "  " << hcalDepth2OverEcalBc << std::endl;
 
     float maxXtal =   EcalClusterTools::eMax( *(scRef->seed()), &(*hits) );
     //AA
     //Change these to consider severity level of hits
     float e1x5    =   EcalClusterTools::e1x5(  *(scRef->seed()), &(*hits), &(*topology));
     float e2x5    =   EcalClusterTools::e2x5Max(  *(scRef->seed()), &(*hits), &(*topology));
     float e3x3    =   EcalClusterTools::e3x3(  *(scRef->seed()), &(*hits), &(*topology));
     float e5x5    =   EcalClusterTools::e5x5( *(scRef->seed()), &(*hits), &(*topology));
     std::vector<float> cov =  EcalClusterTools::covariances( *(scRef->seed()), &(*hits), &(*topology), geometry);
     std::vector<float> locCov =  EcalClusterTools::localCovariances( *(scRef->seed()), &(*hits), &(*topology));
       
     float sigmaEtaEta = sqrt(cov[0]);
     float sigmaIetaIeta = sqrt(locCov[0]);
     // compute position of ECAL shower
     math::XYZPoint caloPosition = scRef->position();
     
 
     double photonEnergy=1.;
     math::XYZPoint vtx(0.,0.,0.);
     if (vertexCollection.size()>0) vtx = vertexCollection.begin()->position();
     // compute momentum vector of photon from primary vertex and cluster position
     math::XYZVector direction = caloPosition - vtx;
     //math::XYZVector momentum = direction.unit() * photonEnergy ;
     math::XYZVector momentum = direction.unit() ;
 
     // Create dummy candidate with unit momentum and zero energy to allow setting of all variables. The energy is set for last.
     math::XYZTLorentzVectorD p4(momentum.x(), momentum.y(), momentum.z(), photonEnergy );
     reco::Photon newCandidate(p4, caloPosition, coreRef, vtx);
 
     //std::cout << " standard p4 before " << newCandidate.p4() << " energy " << newCandidate.energy() <<  std::endl;
     //std::cout << " type " <<newCandidate.getCandidateP4type() <<  " standard p4 after " << newCandidate.p4() << " energy " << newCandidate.energy() << std::endl;
 
     // Calculate fiducial flags and isolation variable. Blocked are filled from the isolationCalculator
     reco::Photon::FiducialFlags fiducialFlags;
     reco::Photon::IsolationVariables isolVarR03, isolVarR04;
     thePhotonIsolationCalculator_-> calculate ( &newCandidate,evt,es,fiducialFlags,isolVarR04, isolVarR03);
     newCandidate.setFiducialVolumeFlags( fiducialFlags );
     newCandidate.setIsolationVariables(isolVarR04, isolVarR03 );
 
     
     reco::Photon::ShowerShape  showerShape;
     showerShape.e1x5= e1x5;
     showerShape.e2x5= e2x5;
     showerShape.e3x3= e3x3;
     showerShape.e5x5= e5x5;
     showerShape.maxEnergyXtal =  maxXtal;
     showerShape.sigmaEtaEta =    sigmaEtaEta;
     showerShape.sigmaIetaIeta =  sigmaIetaIeta;
     showerShape.hcalDepth1OverEcal = HoE1;
     showerShape.hcalDepth2OverEcal = HoE2;
     showerShape.hcalDepth1OverEcalBc = hcalDepth1OverEcalBc;
     showerShape.hcalDepth2OverEcalBc = hcalDepth2OverEcalBc;
     showerShape.hcalTowersBehindClusters =  TowersBehindClus;
     newCandidate.setShowerShapeVariables ( showerShape ); 
 
     // Photon candidate takes by default (set in photons_cfi.py) 
     // a 4-momentum derived from the ecal photon-specific corrections. 
     thePhotonEnergyCorrector_->calculate(evt, newCandidate, subdet, vertexCollection, es);
     if ( candidateP4type_ == "fromEcalEnergy") {
       newCandidate.setP4( newCandidate.p4(reco::Photon::ecal_photons) );
       newCandidate.setCandidateP4type(reco::Photon::ecal_photons);
     } else if ( candidateP4type_ == "fromRegression1") {
       newCandidate.setP4( newCandidate.p4(reco::Photon::regression1) );
       newCandidate.setCandidateP4type(reco::Photon::regression1);
     } else if ( candidateP4type_ == "fromRegression2") {
       newCandidate.setP4( newCandidate.p4(reco::Photon::regression2) );
       newCandidate.setCandidateP4type(reco::Photon::regression2);
     } else if ( candidateP4type_ == "fromRefinedSCRegression" ) {
       newCandidate.setP4( newCandidate.p4(reco::Photon::regression1) );
       newCandidate.setCandidateP4type(reco::Photon::regression1);
     }
 
     //       std::cout << " final p4 " << newCandidate.p4() << " energy " << newCandidate.energy() <<  std::endl;
 
 
     // std::cout << " GEDPhotonProducer from candidate HoE with towers in a cone " << newCandidate.hadronicOverEm()  << "  " <<  newCandidate.hadronicDepth1OverEm()  << " " <<  newCandidate.hadronicDepth2OverEm()  << std::endl;
     //    std::cout << " GEDPhotonProducer from candidate  of HoE with towers behind the BCs " <<  newCandidate.hadTowOverEm()  << "  " << newCandidate.hadTowDepth1OverEm() << " " << newCandidate.hadTowDepth2OverEm() << std::endl;
 
 
   // fill MIP Vairables for Halo: Block for MIP are filled from PhotonMIPHaloTagger
    reco::Photon::MIPVariables mipVar ;
    if(subdet==EcalBarrel && runMIPTagger_ )
     {
   
      thePhotonMIPHaloTagger_-> MIPcalculate( &newCandidate,evt,es,mipVar);
     newCandidate.setMIPVariables(mipVar);
     }
 
 
 
     bool isLooseEM=true; 
     if ( newCandidate.pt() < highEt_) { 
       if ( newCandidate.hadronicOverEm()                   >= preselCutValues[1] )                                            isLooseEM=false;
       if ( newCandidate.ecalRecHitSumEtConeDR04()          > preselCutValues[2]+ preselCutValues[3]*newCandidate.pt() )       isLooseEM=false;
       if ( newCandidate.hcalTowerSumEtConeDR04()           > preselCutValues[4]+ preselCutValues[5]*newCandidate.pt() )       isLooseEM=false;
       if ( newCandidate.nTrkSolidConeDR04()                > int(preselCutValues[6]) )                                        isLooseEM=false;
       if ( newCandidate.nTrkHollowConeDR04()               > int(preselCutValues[7]) )                                        isLooseEM=false;
       if ( newCandidate.trkSumPtSolidConeDR04()            > preselCutValues[8] )                                             isLooseEM=false;
       if ( newCandidate.trkSumPtHollowConeDR04()           > preselCutValues[9] )                                             isLooseEM=false;
       if ( newCandidate.sigmaIetaIeta()                    > preselCutValues[10] )                                            isLooseEM=false;
     } 
     
 
         
     if ( isLooseEM)  
       outputPhotonCollection.push_back(newCandidate);
       
         
   }
 }

void GEDPhotonProducer::fillPhotonCollection	(	edm::Event &	evt,
		edm::EventSetup const &	es,
		const edm::Handle< reco::PhotonCollection > &	photonHandle,
		const edm::Handle< reco::PFCandidateCollection >	pfCandidateHandle,
		const edm::Handle< reco::PFCandidateCollection >	pfEGCandidateHandle,
		edm::ValueMap< reco::PhotonRef >	pfEGCandToPhotonMap,
		edm::Handle< reco::VertexCollection > &	pvVertices,
		reco::PhotonCollection &	outputCollection,
		int &	iSC
	)

private

Pre-selection loose isolation cuts

Definition at line 607 of file GEDPhotonProducer.cc.

References PFPhotonIsolationCalculator::calculate(), EcalBarrel, EcalEndcap, reco::Photon::ecalRecHitSumEtConeDR04(), reco::Photon::hadronicOverEm(), reco::Photon::hcalTowerSumEtConeDR04(), highEt_, edm::Ref< C, T, F >::isNonnull(), reco::Photon::nTrkHollowConeDR04(), reco::Photon::nTrkSolidConeDR04(), preselCutValuesBarrel_, preselCutValuesEndcap_, reco::LeafCandidate::pt(), ptFast(), reco::Photon::setPflowIDVariables(), reco::Photon::setPflowIsolationVariables(), reco::Photon::sigmaIetaIeta(), thePFBasedIsolationCalculator_, reco::Photon::trkSumPtHollowConeDR04(), and reco::Photon::trkSumPtSolidConeDR04().

                                                                                   {
 
   
  
   std::vector<double> preselCutValues;
 
 
   for(unsigned int lSC=0; lSC < photonHandle->size(); lSC++) {
     reco::PhotonRef phoRef(reco::PhotonRef(photonHandle, lSC));
     reco::SuperClusterRef parentSCRef = phoRef->parentSuperCluster();
     reco::SuperClusterRef scRef=phoRef->superCluster();
     int subdet = scRef->seed()->hitsAndFractions()[0].first.subdetId();
     if (subdet==EcalBarrel) { 
       preselCutValues = preselCutValuesBarrel_;
     } else if  (subdet==EcalEndcap)  { 
       preselCutValues = preselCutValuesEndcap_;
     } else {
       edm::LogWarning("")<<"GEDPhotonProducer: do not know if it is a barrel or endcap SuperCluster"; 
     }
 
 
   
     // SC energy preselection
     if (parentSCRef.isNonnull() &&
     ptFast(parentSCRef->energy(),parentSCRef->position(),math::XYZPoint(0,0,0)) <= preselCutValues[0] ) continue;
     reco::Photon newCandidate(*phoRef);
     iSC++;    
   
 
   // Calculate the PF isolation and ID - for the time being there is no calculation. Only the setting
     reco::Photon::PflowIsolationVariables pfIso;
     reco::Photon::PflowIDVariables pfID;
     thePFBasedIsolationCalculator_->calculate (&newCandidate, pfCandidateHandle, vertexHandle, evt, es, pfIso );
     newCandidate.setPflowIsolationVariables(pfIso);
     newCandidate.setPflowIDVariables(pfID);
 
     //    std::cout << " GEDPhotonProducer  pf based isolation  chargedHadron " << newCandidate.chargedHadronIso() << " neutralHadron " <<  newCandidate.neutralHadronIso() << " Photon " <<  newCandidate.photonIso() << std::endl;
     //std::cout << " GEDPhotonProducer from candidate HoE with towers in a cone " << newCandidate.hadronicOverEm()  << "  " <<  newCandidate.hadronicDepth1OverEm()  << " " <<  newCandidate.hadronicDepth2OverEm()  << std::endl;
     //std::cout << " GEDPhotonProducer from candidate  of HoE with towers behind the BCs " <<  newCandidate.hadTowOverEm()  << "  " << newCandidate.hadTowDepth1OverEm() << " " << newCandidate.hadTowDepth2OverEm() << std::endl;
     //std::cout << " standard p4 before " << newCandidate.p4() << " energy " << newCandidate.energy() <<  std::endl;
     //std::cout << " type " <<newCandidate.getCandidateP4type() <<  " standard p4 after " << newCandidate.p4() << " energy " << newCandidate.energy() << std::endl;
     //std::cout << " final p4 " << newCandidate.p4() << " energy " << newCandidate.energy() <<  std::endl;
 
 
 
     bool isLooseEM=true;
     if ( newCandidate.pt() < highEt_) { 
       if ( newCandidate.hadronicOverEm()                   >= preselCutValues[1] )                                            isLooseEM=false;
       if ( newCandidate.ecalRecHitSumEtConeDR04()          > preselCutValues[2]+ preselCutValues[3]*newCandidate.pt() )       isLooseEM=false;
       if ( newCandidate.hcalTowerSumEtConeDR04()           > preselCutValues[4]+ preselCutValues[5]*newCandidate.pt() )       isLooseEM=false;
       if ( newCandidate.nTrkSolidConeDR04()                > int(preselCutValues[6]) )                                        isLooseEM=false;
       if ( newCandidate.nTrkHollowConeDR04()               > int(preselCutValues[7]) )                                        isLooseEM=false;
       if ( newCandidate.trkSumPtSolidConeDR04()            > preselCutValues[8] )                                             isLooseEM=false;
       if ( newCandidate.trkSumPtHollowConeDR04()           > preselCutValues[9] )                                             isLooseEM=false;
       if ( newCandidate.sigmaIetaIeta()                    > preselCutValues[10] )                                            isLooseEM=false;
     } 
     
 
         
     if ( isLooseEM)  
       outputPhotonCollection.push_back(newCandidate);
       
         
   }
 
 
 
 }

void GEDPhotonProducer::produce	(	edm::Event &	evt,
		const edm::EventSetup &	es
	)

virtual

Implements edm::stream::EDProducerBase.

Definition at line 229 of file GEDPhotonProducer.cc.

References barrelEcalHits_, endcapEcalHits_, edm::helper::Filler< Map >::fill(), fillPhotonCollection(), edm::EventSetup::get(), edm::Event::getByToken(), hcalTowers_, edm::helper::Filler< Map >::insert(), edm::InputTag::label(), pfCandidates_, pfEgammaCandidates_, photonCollection_, photonCoreProducerT_, photonProducer_, photonProducerT_, edm::ESHandle< class >::product(), edm::Event::put(), reconstructionStep_, theCaloGeom_, theCaloTopo_, ecaldqm::topology(), usePrimaryVertex_, valueMapPFCandPhoton_, makeHLTPrescaleTable::values, GoodVertex_cfg::vertexCollection, and vertexProducer_.

                                                                                       {
 
   using namespace edm;
   //  nEvt_++;
  
   reco::PhotonCollection outputPhotonCollection;
   std::auto_ptr< reco::PhotonCollection > outputPhotonCollection_p(new reco::PhotonCollection);
   edm::ValueMap<reco::PhotonRef> pfEGCandToPhotonMap;
 
 
   // Get the PhotonCore collection
   bool validPhotonCoreHandle=false;
   Handle<reco::PhotonCoreCollection> photonCoreHandle;
   bool validPhotonHandle= false;
   Handle<reco::PhotonCollection> photonHandle;
 
   if ( reconstructionStep_ == "final" ) { 
     theEvent.getByToken(photonProducerT_,photonHandle);
     if ( photonHandle.isValid()) {
       validPhotonHandle=true;  
     } else {
       edm::LogError("GEDPhotonProducer") << "Error! Can't get the product " <<   photonProducer_.label() << "\n";
     }
 
   } else {
     
     theEvent.getByToken(photonCoreProducerT_,photonCoreHandle);
     if (photonCoreHandle.isValid()) {
       validPhotonCoreHandle=true;
     } else {
       edm::LogError("GEDPhotonProducer") 
     << "Error! Can't get the photonCoreProducer" <<  photonProducer_.label() << "\n";
     }
 
    
  
   }
 
 
  // Get EcalRecHits
   bool validEcalRecHits=true;
   Handle<EcalRecHitCollection> barrelHitHandle;
   EcalRecHitCollection barrelRecHits;
   theEvent.getByToken(barrelEcalHits_, barrelHitHandle);
   if (!barrelHitHandle.isValid()) {
     edm::LogError("GEDPhotonProducer") 
       << "Error! Can't get the barrelEcalHits";
     validEcalRecHits=false; 
   }
   if (  validEcalRecHits)  barrelRecHits = *(barrelHitHandle.product());
 
   
   Handle<EcalRecHitCollection> endcapHitHandle;
   theEvent.getByToken(endcapEcalHits_, endcapHitHandle);
   EcalRecHitCollection endcapRecHits;
   if (!endcapHitHandle.isValid()) {
     edm::LogError("GEDPhotonProducer") 
       << "Error! Can't get the endcapEcalHits";
     validEcalRecHits=false; 
   }
   if( validEcalRecHits) endcapRecHits = *(endcapHitHandle.product());
 
 
 
   Handle<reco::PFCandidateCollection> pfEGCandidateHandle;
   // Get the  PF refined cluster  collection
   theEvent.getByToken(pfEgammaCandidates_,pfEGCandidateHandle);
   if (!pfEGCandidateHandle.isValid()) {
     edm::LogError("GEDPhotonProducer") 
       << "Error! Can't get the pfEgammaCandidates";
   }
   
   Handle<reco::PFCandidateCollection> pfCandidateHandle;
 
   if ( reconstructionStep_ == "final" ) {  
     // Get the  PF candidates collection
     theEvent.getByToken(pfCandidates_,pfCandidateHandle);
     if (!pfCandidateHandle.isValid()) {
       edm::LogError("GEDPhotonProducer") 
     << "Error! Can't get the pfCandidates";
     }
 
   } 
 
 
 
 
   //AA
   //Get the severity level object
   edm::ESHandle<EcalSeverityLevelAlgo> sevLv;
   theEventSetup.get<EcalSeverityLevelAlgoRcd>().get(sevLv);
   //
 
 
 // get Hcal towers collection 
   Handle<CaloTowerCollection> hcalTowersHandle;
   theEvent.getByToken(hcalTowers_, hcalTowersHandle);
 
 
   // get the geometry from the event setup:
   theEventSetup.get<CaloGeometryRecord>().get(theCaloGeom_);
 
   //
   // update energy correction function
   //  energyCorrectionF->init(theEventSetup);  
 
   edm::ESHandle<CaloTopology> pTopology;
   theEventSetup.get<CaloTopologyRecord>().get(theCaloTopo_);
   const CaloTopology *topology = theCaloTopo_.product();
 
   // Get the primary event vertex
   Handle<reco::VertexCollection> vertexHandle;
   reco::VertexCollection vertexCollection;
   bool validVertex=true;
   if ( usePrimaryVertex_ ) {
     theEvent.getByToken(vertexProducer_, vertexHandle);
     if (!vertexHandle.isValid()) {
       edm::LogWarning("GEDPhotonProducer") 
     << "Error! Can't get the product primary Vertex Collection";
       validVertex=false;
     }
     if (validVertex) vertexCollection = *(vertexHandle.product());
   }
   //  math::XYZPoint vtx(0.,0.,0.);
   //if (vertexCollection.size()>0) vtx = vertexCollection.begin()->position();
 
 
   int iSC=0; // index in photon collection
   // Loop over barrel and endcap SC collections and fill the  photon collection
   if ( validPhotonCoreHandle) 
     fillPhotonCollection(theEvent,
              theEventSetup,
              photonCoreHandle,
              topology,
              &barrelRecHits,
              &endcapRecHits,
              hcalTowersHandle,
              //vtx,
              vertexCollection,
              outputPhotonCollection,
              iSC);
 
   iSC=0;
   if ( validPhotonHandle &&  reconstructionStep_ == "final" )
     fillPhotonCollection(theEvent,
              theEventSetup,
              photonHandle,
              pfCandidateHandle,
              pfEGCandidateHandle,
              pfEGCandToPhotonMap,
              vertexHandle,
              outputPhotonCollection,
              iSC);
 
 
 
   // put the product in the event
   edm::LogInfo("GEDPhotonProducer") << " Put in the event " << iSC << " Photon Candidates \n";
   outputPhotonCollection_p->assign(outputPhotonCollection.begin(),outputPhotonCollection.end());
   const edm::OrphanHandle<reco::PhotonCollection> photonOrphHandle = theEvent.put(outputPhotonCollection_p, photonCollection_);
 
 
   if ( reconstructionStep_ != "final" ) { 
     std::auto_ptr<edm::ValueMap<reco::PhotonRef> >  pfEGCandToPhotonMap_p(new edm::ValueMap<reco::PhotonRef>());
     edm::ValueMap<reco::PhotonRef>::Filler filler(*pfEGCandToPhotonMap_p);
     unsigned nObj = pfEGCandidateHandle->size();
     std::vector<reco::PhotonRef> values(nObj);
     for(unsigned int lCand=0; lCand < nObj; lCand++) {
       reco::PFCandidateRef pfCandRef (reco::PFCandidateRef(pfEGCandidateHandle,lCand));
       reco::SuperClusterRef pfScRef = pfCandRef -> superClusterRef(); 
       
       for(unsigned int lSC=0; lSC < photonOrphHandle->size(); lSC++) {
     reco::PhotonRef photonRef(reco::PhotonRef(photonOrphHandle, lSC));
     reco::SuperClusterRef scRef=photonRef->superCluster();
     if ( pfScRef != scRef ) continue;
     values[lCand] = photonRef; 
       }
     }
     
     
     filler.insert(pfEGCandidateHandle,values.begin(),values.end());
     filler.fill(); 
     theEvent.put(pfEGCandToPhotonMap_p,valueMapPFCandPhoton_);
 
 
   }
     
     
     
 
 
 
 }