#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
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

	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
std::vector< ConsumesInfo >	consumesInfo () const

	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 (std::string const &iProcessName, std::string const &iModuleLabel, bool iPrint, std::vector< char const * > &oModuleLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) 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 EcalRecHitCollection preshowerHits, const edm::Handle< CaloTowerCollection > &hcalTowersHandle, const 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_

edm::EDGetTokenT < EcalRecHitCollection >	preshowerHits_

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

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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::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 41 of file GEDPhotonProducer.h.

Constructor & Destructor Documentation

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

Definition at line 54 of file GEDPhotonProducer.cc.

References barrelEcalHits_, candidateP4type_, conf_, edm::EDConsumerBase::consumesCollector(), endcapEcalHits_, edm::ParameterSet::existsAs(), flagsexclEB_, flagsexclEE_, edm::ParameterSet::getParameter(), hcalTowers_, highEt_, hOverEConeSize_, minR9Barrel_, minR9Endcap_, pfCandidates_, pfEgammaCandidates_, photonCollection_, photonCoreProducerT_, photonProducer_, photonProducerT_, HLT_FULL_cff::posCalcParameters, posCalculator_, preselCutValuesBarrel_, preselCutValuesEndcap_, preshowerHits_, reconstructionStep_, runMIPTagger_, PhotonMIPHaloTagger::setup(), PhotonIsolationCalculator::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"));
   preshowerHits_   = 
     consumes<EcalRecHitCollection>(conf_.getParameter<edm::InputTag>("preshowerHits"));
   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( conf_.existsAs<edm::ParameterSet>("regressionConfig") ) {
     auto sumes = consumesCollector();
     thePhotonEnergyCorrector_->gedRegression()->setConsumes(sumes);
   }
 
   //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 201 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 211 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 223 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 EcalRecHitCollection *	preshowerHits,
		const edm::Handle< CaloTowerCollection > &	hcalTowersHandle,
		const reco::VertexCollection &	pvVertices,
		reco::PhotonCollection &	outputCollection,
		int &	iSC
	)

private

fill shower shape block

fill extra shower shapes

fill full5x5 shower shape block

fill extra full5x5 shower shapes

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

Pre-selection loose isolation cuts

Definition at line 437 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]);
     
     float full5x5_maxXtal =   noZS::EcalClusterTools::eMax( *(scRef->seed()), &(*hits) );
     //AA
     //Change these to consider severity level of hits
     float full5x5_e1x5    =   noZS::EcalClusterTools::e1x5(  *(scRef->seed()), &(*hits), &(*topology));
     float full5x5_e2x5    =   noZS::EcalClusterTools::e2x5Max(  *(scRef->seed()), &(*hits), &(*topology));
     float full5x5_e3x3    =   noZS::EcalClusterTools::e3x3(  *(scRef->seed()), &(*hits), &(*topology));
     float full5x5_e5x5    =   noZS::EcalClusterTools::e5x5( *(scRef->seed()), &(*hits), &(*topology));
     std::vector<float> full5x5_cov =  noZS::EcalClusterTools::covariances( *(scRef->seed()), &(*hits), &(*topology), geometry);
     std::vector<float> full5x5_locCov =  noZS::EcalClusterTools::localCovariances( *(scRef->seed()), &(*hits), &(*topology));
       
     float full5x5_sigmaEtaEta = sqrt(full5x5_cov[0]);
     float full5x5_sigmaIetaIeta = sqrt(full5x5_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;
     const float spp = (!edm::isFinite(locCov[2]) ? 0. : sqrt(locCov[2]));
     const float sep = locCov[1];
     showerShape.sigmaIetaIphi = sep;
     showerShape.sigmaIphiIphi = spp;
     showerShape.e2nd          = EcalClusterTools::e2nd(*(scRef->seed()),&(*hits));
     showerShape.eTop          = EcalClusterTools::eTop(*(scRef->seed()), &(*hits), &(*topology));
     showerShape.eLeft         = EcalClusterTools::eLeft(*(scRef->seed()), &(*hits), &(*topology));
     showerShape.eRight        = EcalClusterTools::eRight(*(scRef->seed()), &(*hits), &(*topology));
     showerShape.eBottom       = EcalClusterTools::eBottom(*(scRef->seed()), &(*hits), &(*topology));
     showerShape.e1x3          = EcalClusterTools::e1x3(*(scRef->seed()), &(*hits), &(*topology));
     showerShape.e2x2          = EcalClusterTools::e2x2(*(scRef->seed()), &(*hits), &(*topology));
     showerShape.e2x5Max       = EcalClusterTools::e2x5Max(*(scRef->seed()), &(*hits), &(*topology));
     showerShape.e2x5Left      = EcalClusterTools::e2x5Left(*(scRef->seed()), &(*hits), &(*topology));
     showerShape.e2x5Right     = EcalClusterTools::e2x5Right(*(scRef->seed()), &(*hits), &(*topology));
     showerShape.e2x5Top       = EcalClusterTools::e2x5Top(*(scRef->seed()), &(*hits), &(*topology));
     showerShape.e2x5Bottom    = EcalClusterTools::e2x5Bottom(*(scRef->seed()), &(*hits), &(*topology));
     // fill preshower shapes
     EcalClusterLazyTools toolsforES(evt, es, barrelEcalHits_, endcapEcalHits_, preshowerHits_);
     const float sigmaRR =  toolsforES.eseffsirir( *scRef );
     showerShape.effSigmaRR = sigmaRR;
     newCandidate.setShowerShapeVariables ( showerShape ); 
     
     reco::Photon::ShowerShape  full5x5_showerShape;
     full5x5_showerShape.e1x5= full5x5_e1x5;
     full5x5_showerShape.e2x5= full5x5_e2x5;
     full5x5_showerShape.e3x3= full5x5_e3x3;
     full5x5_showerShape.e5x5= full5x5_e5x5;
     full5x5_showerShape.maxEnergyXtal =  full5x5_maxXtal;
     full5x5_showerShape.sigmaEtaEta =    full5x5_sigmaEtaEta;
     full5x5_showerShape.sigmaIetaIeta =  full5x5_sigmaIetaIeta;
     const float full5x5_spp = (!edm::isFinite(full5x5_locCov[2]) ? 0. : sqrt(full5x5_locCov[2]));
     const float full5x5_sep = full5x5_locCov[1];
     full5x5_showerShape.sigmaIetaIphi = full5x5_sep;
     full5x5_showerShape.sigmaIphiIphi = full5x5_spp;
     full5x5_showerShape.e2nd          = noZS::EcalClusterTools::e2nd(*(scRef->seed()),&(*hits));
     full5x5_showerShape.eTop          = noZS::EcalClusterTools::eTop(*(scRef->seed()), &(*hits), &(*topology));
     full5x5_showerShape.eLeft         = noZS::EcalClusterTools::eLeft(*(scRef->seed()), &(*hits), &(*topology));
     full5x5_showerShape.eRight        = noZS::EcalClusterTools::eRight(*(scRef->seed()), &(*hits), &(*topology));
     full5x5_showerShape.eBottom       = noZS::EcalClusterTools::eBottom(*(scRef->seed()), &(*hits), &(*topology));
     full5x5_showerShape.e1x3          = noZS::EcalClusterTools::e1x3(*(scRef->seed()), &(*hits), &(*topology));
     full5x5_showerShape.e2x2          = noZS::EcalClusterTools::e2x2(*(scRef->seed()), &(*hits), &(*topology));
     full5x5_showerShape.e2x5Max       = noZS::EcalClusterTools::e2x5Max(*(scRef->seed()), &(*hits), &(*topology));
     full5x5_showerShape.e2x5Left      = noZS::EcalClusterTools::e2x5Left(*(scRef->seed()), &(*hits), &(*topology));
     full5x5_showerShape.e2x5Right     = noZS::EcalClusterTools::e2x5Right(*(scRef->seed()), &(*hits), &(*topology));
     full5x5_showerShape.e2x5Top       = noZS::EcalClusterTools::e2x5Top(*(scRef->seed()), &(*hits), &(*topology));
     full5x5_showerShape.e2x5Bottom    = noZS::EcalClusterTools::e2x5Bottom(*(scRef->seed()), &(*hits), &(*topology));
      // fill preshower shapes
     full5x5_showerShape.effSigmaRR = sigmaRR;
     newCandidate.full5x5_setShowerShapeVariables ( full5x5_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::regression2) );
       newCandidate.setCandidateP4type(reco::Photon::regression2);
     }
 
     //       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

Definition at line 686 of file GEDPhotonProducer.cc.

References PhotonEnergyCorrector::calculate(), PFPhotonIsolationCalculator::calculate(), candidateP4type_, reco::Photon::ecal_photons, EcalBarrel, EcalEndcap, edm::Ref< C, T, F >::isNonnull(), reco::Photon::p4(), preselCutValuesBarrel_, preselCutValuesEndcap_, ptFast(), reco::Photon::regression1, reco::Photon::regression2, reco::Photon::setCandidateP4type(), reco::Photon::setP4(), reco::Photon::setPflowIDVariables(), reco::Photon::setPflowIsolationVariables(), thePFBasedIsolationCalculator_, and thePhotonEnergyCorrector_.

                                                                                   {
 
   
  
   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);
 
     // do the regression
     thePhotonEnergyCorrector_->calculate(evt, newCandidate, subdet, *vertexHandle, 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::regression2) );
       newCandidate.setCandidateP4type(reco::Photon::regression2);
     }
 
     //    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;
 
     outputPhotonCollection.push_back(newCandidate);        
     
   }
 
 }

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

virtual

Implements edm::stream::EDProducerBase.

Definition at line 231 of file GEDPhotonProducer.cc.

References barrelEcalHits_, endcapEcalHits_, Exception, edm::helper::Filler< Map >::fill(), fillPhotonCollection(), PhotonEnergyCorrector::gedRegression(), edm::EventSetup::get(), edm::Event::getByToken(), hcalTowers_, PhotonEnergyCorrector::init(), edm::helper::Filler< Map >::insert(), edm::InputTag::label(), pfCandidates_, pfEgammaCandidates_, photonCollection_, photonCoreProducerT_, photonProducer_, photonProducerT_, preshowerHits_, edm::ESHandle< class >::product(), edm::Event::put(), reconstructionStep_, theCaloGeom_, theCaloTopo_, thePhotonEnergyCorrector_, 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 {
       throw cms::Exception("GEDPhotonProducer") << "Error! Can't get the product " <<   photonProducer_.label() << "\n";
     }
   } else {
     
     theEvent.getByToken(photonCoreProducerT_,photonCoreHandle);
     if (photonCoreHandle.isValid()) {
       validPhotonCoreHandle=true;
     } else {
       throw cms::Exception("GEDPhotonProducer") 
     << "Error! Can't get the photonCoreProducer" <<  photonProducer_.label() << "\n";
     } 
   }
 
   // Get EcalRecHits
   bool validEcalRecHits=true;
   Handle<EcalRecHitCollection> barrelHitHandle;
   const EcalRecHitCollection dummyEB;
   theEvent.getByToken(barrelEcalHits_, barrelHitHandle);
   if (!barrelHitHandle.isValid()) {
     validEcalRecHits=false; 
     throw cms::Exception("GEDPhotonProducer") 
       << "Error! Can't get the barrelEcalHits";
   }
   const EcalRecHitCollection& barrelRecHits(validEcalRecHits ? *(barrelHitHandle.product()) : dummyEB);
   
   Handle<EcalRecHitCollection> endcapHitHandle;
   theEvent.getByToken(endcapEcalHits_, endcapHitHandle);
   const EcalRecHitCollection dummyEE;
   if (!endcapHitHandle.isValid()) {
     validEcalRecHits=false; 
     throw cms::Exception("GEDPhotonProducer") 
       << "Error! Can't get the endcapEcalHits";
   }
   const EcalRecHitCollection& endcapRecHits(validEcalRecHits ? *(endcapHitHandle.product()) : dummyEE);
 
   bool validPreshowerRecHits=true;
   Handle<EcalRecHitCollection> preshowerHitHandle;
   theEvent.getByToken(preshowerHits_, preshowerHitHandle);
   EcalRecHitCollection preshowerRecHits;
   if (!preshowerHitHandle.isValid()) {
     validPreshowerRecHits=false; 
     throw cms::Exception("GEDPhotonProducer") 
       << "Error! Can't get the preshowerEcalHits";
   }
   if( validPreshowerRecHits ) preshowerRecHits = *(preshowerHitHandle.product());
 
 
 
   Handle<reco::PFCandidateCollection> pfEGCandidateHandle;
   // Get the  PF refined cluster  collection
   theEvent.getByToken(pfEgammaCandidates_,pfEGCandidateHandle);
   if (!pfEGCandidateHandle.isValid()) {
     throw cms::Exception("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()) {
       throw cms::Exception("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;
   const reco::VertexCollection dummyVC;
   bool validVertex=true;
   if ( usePrimaryVertex_ ) {
     theEvent.getByToken(vertexProducer_, vertexHandle);
     if (!vertexHandle.isValid()) {
       validVertex=false;
       throw cms::Exception("GEDPhotonProducer") 
     << "Error! Can't get the product primary Vertex Collection";
     }
   }
   const reco::VertexCollection& vertexCollection(usePrimaryVertex_ && validVertex ? *(vertexHandle.product()) : dummyVC);
 
   //  math::XYZPoint vtx(0.,0.,0.);
   //if (vertexCollection.size()>0) vtx = vertexCollection.begin()->position();
 
   // get the regression calculator ready
   thePhotonEnergyCorrector_->init(theEventSetup);
   if( thePhotonEnergyCorrector_->gedRegression() ) {
     thePhotonEnergyCorrector_->gedRegression()->setEvent(theEvent);
     thePhotonEnergyCorrector_->gedRegression()->setEventContent(theEventSetup);
   }
 
 
   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,
                          &preshowerRecHits,
              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_);
 
 
   }
     
     
     
 
 
 
 }