#include <OniaPhotonConversionProducer.h>

Inheritance diagram for OniaPhotonConversionProducer:

Public Member Functions
	OniaPhotonConversionProducer (const edm::ParameterSet &ps)

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)

std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const

	ProducerBase ()

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

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

void	resolvePutIndicies (BranchType iBranchType, std::unordered_multimap< std::string, edm::ProductResolverIndex > const &iIndicies, std::string const &moduleLabel)

virtual	~ProducerBase () noexcept(false)

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

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

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

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

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

virtual	~EDConsumerBase () noexcept(false)

Private Member Functions
bool	CheckPi0 (const reco::Conversion &, const reco::PFCandidateCollection &, bool &)

bool	checkTkVtxCompatibility (const reco::Conversion &, const reco::VertexCollection &)

reco::Candidate::LorentzVector	convertVector (const math::XYZTLorentzVectorF &)

virtual void	endStream ()

bool	foundCompatibleInnerHits (const reco::HitPattern &hitPatA, const reco::HitPattern &hitPatB)

bool	HighpuritySubset (const reco::Conversion &, const reco::VertexCollection &)

pat::CompositeCandidate *	makePhotonCandidate (const reco::Conversion &)

int	PackFlags (const reco::Conversion &, bool, bool, bool, bool, bool)

virtual void	produce (edm::Event &event, const edm::EventSetup &esetup)

void	removeDuplicates (reco::ConversionCollection &)

const reco::PFCandidateCollection	selectPFPhotons (const reco::PFCandidateCollection &)

Private Attributes
double	_minDistanceOfApproachMaxCut

double	_minDistanceOfApproachMinCut

double	_trackchi2Cut

double	_vertexChi2ProbCut

int	convAlgo_

edm::EDGetTokenT< reco::ConversionCollection >	convCollectionToken_

std::vector< int >	convQuality_

std::string	convSelectionCuts_

edm::EDGetTokenT< reco::PFCandidateCollection >	pfCandidateCollectionToken_

std::vector< double >	pi0LargeWindow_

bool	pi0OnlineSwitch_

std::vector< double >	pi0SmallWindow_

uint32_t	sigmaTkVtxComp_

edm::EDGetTokenT< reco::VertexCollection >	thePVsToken_

uint32_t	TkMinNumOfDOF_

bool	wantCompatibleInnerHits_

bool	wantHighpurity_

bool	wantTkVtxCompatibility_

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

Select photon conversions and produce a conversion candidate collection

Definition at line 36 of file OniaPhotonConversionProducer.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 55 of file OniaPhotonConversionProducer.cc.

References patPFMETCorrections_cff::algo, edm::ParameterSet::getParameter(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                      {
   convCollectionToken_     = consumes<reco::ConversionCollection>(ps.getParameter<edm::InputTag>("conversions"));
   thePVsToken_             = consumes<reco::VertexCollection>(ps.getParameter<edm::InputTag>("primaryVertexTag"));
 
   wantTkVtxCompatibility_  = ps.getParameter<bool>("wantTkVtxCompatibility");
   sigmaTkVtxComp_          = ps.getParameter<uint32_t>("sigmaTkVtxComp");
   wantCompatibleInnerHits_ = ps.getParameter<bool>("wantCompatibleInnerHits");
   TkMinNumOfDOF_           = ps.getParameter<uint32_t>("TkMinNumOfDOF");
 
   wantHighpurity_          = ps.getParameter<bool>("wantHighpurity");
   _vertexChi2ProbCut       = ps.getParameter<double>("vertexChi2ProbCut");
   _trackchi2Cut            = ps.getParameter<double>("trackchi2Cut");
   _minDistanceOfApproachMinCut = ps.getParameter<double>("minDistanceOfApproachMinCut");
   _minDistanceOfApproachMaxCut = ps.getParameter<double>("minDistanceOfApproachMaxCut");
 
   pfCandidateCollectionToken_  = consumes<reco::PFCandidateCollection>(ps.getParameter<edm::InputTag>("pfcandidates"));
 
   pi0OnlineSwitch_        = ps.getParameter<bool>("pi0OnlineSwitch");
   pi0SmallWindow_         = ps.getParameter<std::vector<double> >("pi0SmallWindow");
   pi0LargeWindow_         = ps.getParameter<std::vector<double> >("pi0LargeWindow");
 
   std::string algo = ps.getParameter<std::string>("convAlgo");
   convAlgo_ = StringToEnumValue<reco::Conversion::ConversionAlgorithm>(algo);
 
   std::vector<std::string> qual = ps.getParameter<std::vector<std::string> >("convQuality"); 
   if( qual[0] != "" ) convQuality_ =StringToEnumValue<reco::Conversion::ConversionQuality>(qual);
 
   convSelectionCuts_ = ps.getParameter<std::string>("convSelection");
   produces<pat::CompositeCandidateCollection>("conversions");
 }

Member Function Documentation

bool OniaPhotonConversionProducer::CheckPi0	(	const reco::Conversion &	conv,
		const reco::PFCandidateCollection &	photons,
		bool &	pizero_rejected
	)

private

Definition at line 328 of file OniaPhotonConversionProducer.cc.

References muons2muons_cfi::photon, and reco::Conversion::refittedPair4Momentum().

                                                     {
   // 2 windows are defined for Pi0 rejection, Conversions that, paired with others photons from the event, have an
   // invariant mass inside the "small" window will be pizero_rejected and those that falls in the large window will
   // be CheckPi0.
   bool check_small = false;
   bool check_large = false;
 
   float small1 = pi0SmallWindow_[0];
   float small2 = pi0SmallWindow_[1];
   float large1 = pi0LargeWindow_[0];
   float large2 = pi0LargeWindow_[1];
   for (reco::PFCandidateCollection::const_iterator photon = photons.begin(); photon!=photons.end(); ++photon) {
     float inv = (conv.refittedPair4Momentum() + photon->p4()).M(); 
     if (inv > large1 && inv < large2) {
       check_large = true;
       if (inv > small1 && inv < small2) { 
          check_small = true;
          break;
       }
     }
   }
   pizero_rejected = check_small;
   return check_large;
 }

bool OniaPhotonConversionProducer::checkTkVtxCompatibility	(	const reco::Conversion &	conv,
		const reco::VertexCollection &	priVtxs
	)

private

Definition at line 233 of file OniaPhotonConversionProducer.cc.

References begin, KineDebug3::count(), reco::Vertex::covariance(), reco::TrackBase::dz(), reco::TrackBase::dzError(), end, training_settings::idx, lt_(), reco::Vertex::position(), edm::second(), findQualityFiles::size, mathSSE::sqrt(), reco::Conversion::tracks(), and badGlobalMuonTaggersAOD_cff::vtx.

                                                                                                                           {
   std::vector< std::pair< double, short> > idx[2];
   short ik=-1;
   BOOST_FOREACH(edm::RefToBase<reco::Track> tk, conv.tracks()){
     ik++;
     short count=-1;
     BOOST_FOREACH(const reco::Vertex& vtx,priVtxs){
       count++;
     
       double dz_= tk->dz(vtx.position());
       double dzError_=tk->dzError();
       dzError_=sqrt(dzError_*dzError_+vtx.covariance(2,2));
 
       if(fabs(dz_)/dzError_ > sigmaTkVtxComp_) continue;
       
       idx[ik].push_back(std::pair<double,short>(fabs(dz_),count));
     }
     if(idx[ik].size()==0) {return false;}
     
     std::stable_sort(idx[ik].begin(),idx[ik].end(),lt_);
   }
   if (idx[0][0].second==idx[1][0].second || idx[0][1].second==idx[1][0].second || idx[0][0].second==idx[1][1].second) return true;
   return false;
 }

reco::Candidate::LorentzVector OniaPhotonConversionProducer::convertVector ( const math::XYZTLorentzVectorF & v )

private

Definition at line 354 of file OniaPhotonConversionProducer.cc.

                                                                                                      {
   return reco::Candidate::LorentzVector(v.x(),v.y(), v.z(), v.t());
 }

void OniaPhotonConversionProducer::endStream ( )

privatevirtual

Reimplemented from edm::stream::EDProducerBase.

Definition at line 359 of file OniaPhotonConversionProducer.cc.

References DEFINE_FWK_MODULE.

359 {

360 }

bool OniaPhotonConversionProducer::foundCompatibleInnerHits	(	const reco::HitPattern &	hitPatA,
		const reco::HitPattern &	hitPatB
	)

private

Definition at line 258 of file OniaPhotonConversionProducer.cc.

References KineDebug3::count(), reco::HitPattern::getHitPattern(), reco::HitPattern::getLayer(), reco::HitPattern::getSubStructure(), reco::HitPattern::getTrackerMonoStereo(), HighpuritySubset(), mps_fire::i, reco::HitPattern::numberOfHits(), reco::HitPattern::trackerHitFilter(), and reco::HitPattern::validHitFilter().

                                                                                                                         {
   size_t count=0;
   uint32_t oldSubStr=0;
   for (int i=0; i<hitPatA.numberOfHits(reco::HitPattern::HitCategory::TRACK_HITS) && count<2; i++) {
     uint32_t hitA = hitPatA.getHitPattern(reco::HitPattern::HitCategory::TRACK_HITS,i);
     if (!hitPatA.validHitFilter(hitA) || !hitPatA.trackerHitFilter(hitA)) continue;
     
     if(hitPatA.getSubStructure(hitA)==oldSubStr && hitPatA.getLayer(hitA)==oldSubStr)
       continue;
 
     if(hitPatB.getTrackerMonoStereo(reco::HitPattern::HitCategory::TRACK_HITS,hitPatA.getSubStructure(hitA),hitPatA.getLayer(hitA)) != 0)
       return true;
     
     oldSubStr=hitPatA.getSubStructure(hitA);
     count++;
   } 
   return false;  
 }

bool OniaPhotonConversionProducer::HighpuritySubset	(	const reco::Conversion &	conv,
		const reco::VertexCollection &	priVtxs
	)

private

Definition at line 278 of file OniaPhotonConversionProducer.cc.

References reco::TrackBase::charge(), reco::Vertex::chi2(), ChiSquaredProbability(), reco::Conversion::conversionVertex(), reco::Conversion::distOfMinimumApproach(), reco::TrackBase::dxy(), reco::TrackBase::dxyError(), mps_fire::i, reco::Vertex::ndof(), reco::TrackBase::ndof(), reco::TrackBase::normalizedChi2(), reco::Vertex::position(), reco::Conversion::tracks(), badGlobalMuonTaggersAOD_cff::vtx, and reco::Conversion::zOfPrimaryVertexFromTracks().

Referenced by foundCompatibleInnerHits().

                                                                                  {
   // select high purity conversions our way:
   // vertex chi2 cut
   if(ChiSquaredProbability(conv.conversionVertex().chi2(),conv.conversionVertex().ndof())< _vertexChi2ProbCut) return false;
 
   // d0 cut
   // Find closest primary vertex
   int closest_pv_index = 0;
   int i=0;
   BOOST_FOREACH(const reco::Vertex& vtx,priVtxs){
     if( conv.zOfPrimaryVertexFromTracks( vtx.position() ) < conv.zOfPrimaryVertexFromTracks( priVtxs[closest_pv_index].position() ) ) closest_pv_index = i;
     i++;
   }
   // Now check impact parameter wtr with the just found closest primary vertex
   BOOST_FOREACH(const edm::RefToBase<reco::Track> tk, conv.tracks()) if(-tk->dxy(priVtxs[closest_pv_index].position())*tk->charge()/tk->dxyError()<0) return false;
   
   // chi2 of single tracks
   BOOST_FOREACH(const edm::RefToBase<reco::Track> tk, conv.tracks()) if(tk->normalizedChi2() > _trackchi2Cut) return false;
 
   // dof for each track  
   BOOST_FOREACH(const edm::RefToBase<reco::Track> tk, conv.tracks()) if(tk->ndof()< TkMinNumOfDOF_) return false;
   
   // distance of approach cut
   if (conv.distOfMinimumApproach() < _minDistanceOfApproachMinCut || conv.distOfMinimumApproach() > _minDistanceOfApproachMaxCut ) return false;
   
   return true;
 }

pat::CompositeCandidate * OniaPhotonConversionProducer::makePhotonCandidate ( const reco::Conversion & conv )

private

Definition at line 306 of file OniaPhotonConversionProducer.cc.

References pat::PATObject< ObjectType >::addUserData(), reco::Conversion::conversionVertex(), reco::Vertex::position(), reco::Conversion::refittedPair4Momentum(), reco::LeafCandidate::setP4(), reco::LeafCandidate::setVertex(), and reco::Conversion::tracks().

                                                                                                   {
 
   pat::CompositeCandidate *photonCand = new pat::CompositeCandidate();
   photonCand->setP4(convertVector(conv.refittedPair4Momentum()));
   photonCand->setVertex(conv.conversionVertex().position());
 
   photonCand->addUserData<reco::Track>( "track0", *conv.tracks()[0] );
   photonCand->addUserData<reco::Track>( "track1", *conv.tracks()[1] );
 
   return photonCand;
 
 }

int OniaPhotonConversionProducer::PackFlags	(	const reco::Conversion &	conv,
		bool	flagTkVtxCompatibility,
		bool	flagCompatibleInnerHits,
		bool	flagHighpurity,
		bool	pizero_rejected,
		bool	large_pizero_window
	)

private

Definition at line 182 of file OniaPhotonConversionProducer.cc.

References reco::Conversion::algo(), flags, lumiQueryAPI::q, and reco::Conversion::quality().

                                                                                              {
    int flags = 0;
    if ( flagTkVtxCompatibility ) flags += 1;
    if ( flagCompatibleInnerHits ) flags += 2;
    if ( flagHighpurity ) flags += 4;
    if ( pizero_rejected ) flags += 8;
    if ( large_pizero_window ) flags += 16;
 
    flags += (conv.algo()*32);
    int q_mask = 0;
    std::vector<std::string> s_quals;
    s_quals.push_back("generalTracksOnly");
    s_quals.push_back("arbitratedEcalSeeded");
    s_quals.push_back("arbitratedMerged");
    s_quals.push_back("arbitratedMergedEcalGeneral");
    s_quals.push_back("highPurity");
    s_quals.push_back("highEfficiency");
    s_quals.push_back("ecalMatched1Track");
    s_quals.push_back("ecalMatched2Track");
    std::vector<int>  i_quals = StringToEnumValue<reco::Conversion::ConversionQuality>(s_quals);
    for (std::vector<int>::const_iterator qq = i_quals.begin(); qq!=i_quals.end(); ++qq) {
       reco::Conversion::ConversionQuality q = (reco::Conversion::ConversionQuality)(*qq);
       if (conv.quality(q)) q_mask = *qq;
    }
    flags += (q_mask*32*8);
    return flags;
 }

void OniaPhotonConversionProducer::produce	(	edm::Event &	event,
		const edm::EventSetup &	esetup
	)

privatevirtual

Definition at line 86 of file OniaPhotonConversionProducer.cc.

References pat::PATObject< ObjectType >::addUserInt(), conv, RemoveAddSevLevel::flag, flags, eostools::move(), edm::Handle< T >::product(), and lumiQueryAPI::q.

                                                                                       {
 
   std::unique_ptr<reco::ConversionCollection> outCollection(new reco::ConversionCollection);
   std::unique_ptr<pat::CompositeCandidateCollection> patoutCollection(new pat::CompositeCandidateCollection);
 
   edm::Handle<reco::VertexCollection> priVtxs;
   event.getByToken(thePVsToken_, priVtxs);
     
   edm::Handle<reco::ConversionCollection> pConv;
   event.getByToken(convCollectionToken_,pConv);
 
   edm::Handle<reco::PFCandidateCollection> pfcandidates;
   event.getByToken(pfCandidateCollectionToken_,pfcandidates);
 
   const reco::PFCandidateCollection pfphotons = selectPFPhotons(*pfcandidates);  
 
   StringCutObjectSelector<reco::Conversion> *convSelection_ = new StringCutObjectSelector<reco::Conversion>(convSelectionCuts_);
 
   for(reco::ConversionCollection::const_iterator conv = pConv->begin(); conv != pConv->end(); ++conv){
 
     if (! ( *convSelection_)(*conv)){
     continue; // selection string
     }
     if (convAlgo_ != 0 && conv->algo()!= convAlgo_){
     continue; // select algorithm
     }
     if(convQuality_.size() > 0){
     bool flagsok=true;
     for (std::vector<int>::const_iterator flag = convQuality_.begin(); flag!=convQuality_.end(); ++flag){
     reco::Conversion::ConversionQuality q = (reco::Conversion::ConversionQuality)(*flag);
            if (!conv->quality(q)) {
           flagsok=false;
           break;
            }
         }
     if (!flagsok){
        continue;
         }
     }
     outCollection->push_back(*conv);
   }
     
   removeDuplicates(*outCollection);
   
   for (reco::ConversionCollection::const_iterator conv = outCollection->begin(); conv != outCollection->end(); ++conv){
 
      bool flag1 = true;
      bool flag2 = true;
      bool flag3 = true;
      bool flag4 = true;
 
     // The logic implies that by default this flags are true and if the check are not wanted conversions are saved.
     // If checks are required and failed then don't save the conversion.
 
      bool flagTkVtxCompatibility  = true;
      if (! checkTkVtxCompatibility(*conv,*priVtxs.product())) {
        flagTkVtxCompatibility = false;
        if (wantTkVtxCompatibility_) {
           flag1 = false;
        }
      }
      bool flagCompatibleInnerHits = false;
      if (conv->tracks().size()==2) {
        reco::HitPattern hitPatA=conv->tracks().at(0)->hitPattern();
        reco::HitPattern hitPatB=conv->tracks().at(1)->hitPattern();
        if ( foundCompatibleInnerHits(hitPatA,hitPatB) && foundCompatibleInnerHits(hitPatB,hitPatA) ) flagCompatibleInnerHits = true;
      }
      if (wantCompatibleInnerHits_ && ! flagCompatibleInnerHits) {
        flag2 = false;
      }
      bool flagHighpurity = true;
      if (!HighpuritySubset(*conv,*priVtxs.product())) {
        flagHighpurity = false;
        if (wantHighpurity_) {
           flag3 = false;
        }
      }
      bool pizero_rejected = false;
      bool large_pizero_window = CheckPi0(*conv, pfphotons, pizero_rejected);
      if (pi0OnlineSwitch_ && pizero_rejected) {
        flag4 = false;
      }
 
      int flags = 0;
      if (flag1 && flag2 && flag3 && flag4){
         flags = PackFlags(*conv,flagTkVtxCompatibility,flagCompatibleInnerHits,flagHighpurity,pizero_rejected,large_pizero_window);
         pat::CompositeCandidate *pat_conv = makePhotonCandidate(*conv);
         pat_conv->addUserInt("flags",flags);
         patoutCollection->push_back(*pat_conv);
      }
   }
   event.put(std::move(patoutCollection),"conversions");
 
   delete convSelection_;
 }

void OniaPhotonConversionProducer::removeDuplicates ( reco::ConversionCollection & c )

private

Put in out collection only those conversion candidates that are not sharing tracks. If sharing, keep the one with the best chi2.

Definition at line 215 of file OniaPhotonConversionProducer.cc.

References ConversionEqualByTrack(), and ConversionLessByChi2().

                                                                               {
   // first sort from high to low chi2 prob
   std::sort(c.begin(),c.end(),ConversionLessByChi2);
   int iter1 = 0;
   // Cycle over all the elements of the collection and compare to all the following, 
   // if two elements have at least one track in common delete the element with the lower chi2
   while(iter1 < (( (int) c.size() ) - 1) ){
      int iter2 = iter1+1;
      while( iter2 < (int) c.size()) if(ConversionEqualByTrack( c[iter1], c[iter2] ) ){
         c.erase( c.begin() + iter2 );
         }else{
         iter2++;    // Increment index only if this element is no duplicate. 
             // If it is duplicate check again the same index since the vector rearranged elements index after erasing
         }
      iter1++;
   }
 }

const reco::PFCandidateCollection OniaPhotonConversionProducer::selectPFPhotons ( const reco::PFCandidateCollection & pfcandidates )

private

Definition at line 320 of file OniaPhotonConversionProducer.cc.

References reco::PFCandidate::gamma.

                                                                                                                             {
   reco::PFCandidateCollection pfphotons;
   for (reco::PFCandidateCollection::const_iterator cand =   pfcandidates.begin(); cand != pfcandidates.end(); ++cand){
     if (cand->particleId() == reco::PFCandidate::gamma) pfphotons.push_back(*cand);
   }
   return  pfphotons;
 }