#include <OniaPhotonConversionProducer.h>

Inheritance diagram for OniaPhotonConversionProducer:

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

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

ModuleDescription const &	moduleDescription () const

virtual	~EDProducer ()

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 &	itemsToGetFromEvent () 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	endJob ()

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	algo_fail

int	CInnerHits

int	convAlgo_

edm::EDGetTokenT < reco::ConversionCollection >	convCollectionToken_

std::vector< int >	convQuality_

std::string	convSelectionCuts_

int	duplicates

int	final_conversion

int	flag_fail

int	highpurity_count

edm::EDGetTokenT < reco::PFCandidateCollection >	pfCandidateCollectionToken_

std::vector< double >	pi0LargeWindow_

bool	pi0OnlineSwitch_

std::vector< double >	pi0SmallWindow_

int	pizero_fail

int	selection_fail

uint32_t	sigmaTkVtxComp_

int	store_conversion

edm::EDGetTokenT < reco::VertexCollection >	thePVsToken_

uint32_t	TkMinNumOfDOF_

int	TkVtxC

int	total_conversions

bool	wantCompatibleInnerHits_

bool	wantHighpurity_

bool	wantTkVtxCompatibility_

Additional Inherited Members
Public Types inherited from edm::EDProducer
typedef EDProducer	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::EDProducer
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 _minDistanceOfApproachMaxCut, _minDistanceOfApproachMinCut, _trackchi2Cut, _vertexChi2ProbCut, ecalcalib_dqm_sourceclient-live_cfg::algo, algo_fail, CInnerHits, convAlgo_, convCollectionToken_, convQuality_, convSelectionCuts_, duplicates, final_conversion, flag_fail, edm::ParameterSet::getParameter(), highpurity_count, pfCandidateCollectionToken_, pi0LargeWindow_, pi0OnlineSwitch_, pi0SmallWindow_, pizero_fail, selection_fail, sigmaTkVtxComp_, store_conversion, AlCaHLTBitMon_QueryRunRegistry::string, thePVsToken_, TkMinNumOfDOF_, TkVtxC, total_conversions, wantCompatibleInnerHits_, wantHighpurity_, and wantTkVtxCompatibility_.

                                                                                      {
   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");
 
   total_conversions = 0;
   selection_fail = 0;
   algo_fail = 0;
   flag_fail = 0;
   pizero_fail = 0;
   duplicates = 0;
   TkVtxC = 0;
   CInnerHits = 0;
   highpurity_count = 0;
   final_conversion = 0;
   store_conversion = 0;
 }

Member Function Documentation

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

private

Definition at line 353 of file OniaPhotonConversionProducer.cc.

References pi0LargeWindow_, pi0SmallWindow_, and reco::Conversion::refittedPair4Momentum().

Referenced by produce().

                                                     {
   // 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 258 of file OniaPhotonConversionProducer.cc.

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

Referenced by produce().

                                                                                                                           {
   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 379 of file OniaPhotonConversionProducer.cc.

Referenced by makePhotonCandidate().

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

void OniaPhotonConversionProducer::endJob ( void )

privatevirtual

Reimplemented from edm::EDProducer.

Definition at line 384 of file OniaPhotonConversionProducer.cc.

References algo_fail, CInnerHits, gather_cfg::cout, duplicates, final_conversion, flag_fail, highpurity_count, pizero_fail, selection_fail, store_conversion, TkVtxC, and total_conversions.

                                          {
    std::cout << "############################" << std::endl;
    std::cout << "Conversion Candidate producer report" << std::endl;
    std::cout << "############################" << std::endl;
    std::cout << "Total examined conversions: " << total_conversions << std::endl;
    std::cout << "Selection fail candidates:  " << selection_fail << std::endl;
    std::cout << "Algo fail candidates:       " << algo_fail << std::endl;
    std::cout << "Quality fail candidates:    " << flag_fail << std::endl;
    std::cout << "Pi0 fail:                   " << pizero_fail << std::endl;
    std::cout << "Total duplicates found:     " << duplicates << std::endl;
    std::cout << "Vertex compatibility fail:  " << TkVtxC << std::endl;
    std::cout << "Compatible inner hits fail: " << CInnerHits << std::endl;
    std::cout << "Highpurity Subset fail:     " << highpurity_count << std::endl;
    std::cout << "############################" << std::endl;
    std::cout << "Final number of conversions:  " << final_conversion << std::endl;
    std::cout << "Stored number of conversions: " << store_conversion << std::endl;
    std::cout << "############################" << std::endl;
 }

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

private

Definition at line 283 of file OniaPhotonConversionProducer.cc.

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

Referenced by produce().

                                                                                                                         {
   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 303 of file OniaPhotonConversionProducer.cc.

References _minDistanceOfApproachMaxCut, _minDistanceOfApproachMinCut, _trackchi2Cut, _vertexChi2ProbCut, reco::TrackBase::charge(), reco::Vertex::chi2(), ChiSquaredProbability(), reco::Conversion::conversionVertex(), reco::Conversion::distOfMinimumApproach(), reco::TrackBase::dxy(), reco::TrackBase::dxyError(), i, reco::Vertex::ndof(), reco::TrackBase::ndof(), reco::TrackBase::normalizedChi2(), reco::Vertex::position(), TkMinNumOfDOF_, reco::Conversion::tracks(), and reco::Conversion::zOfPrimaryVertexFromTracks().

Referenced by produce().

                                                                                  {
   // 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 331 of file OniaPhotonConversionProducer.cc.

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

Referenced by produce().

                                                                                                   {
 
   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 206 of file OniaPhotonConversionProducer.cc.

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

Referenced by produce().

                                                                                              {
    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

Implements edm::EDProducer.

Definition at line 100 of file OniaPhotonConversionProducer.cc.

References pat::PATObject< ObjectType >::addUserInt(), algo_fail, CheckPi0(), checkTkVtxCompatibility(), CInnerHits, conv, convAlgo_, convCollectionToken_, convQuality_, convSelectionCuts_, final_conversion, flag_fail, flags, foundCompatibleInnerHits(), highpurity_count, HighpuritySubset(), makePhotonCandidate(), eostools::move(), PackFlags(), pfCandidateCollectionToken_, pi0OnlineSwitch_, pizero_fail, edm::Handle< T >::product(), lumiQueryAPI::q, removeDuplicates(), selection_fail, selectPFPhotons(), store_conversion, thePVsToken_, TkVtxC, total_conversions, wantCompatibleInnerHits_, wantHighpurity_, and wantTkVtxCompatibility_.

                                                                                       {
 
   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){
     total_conversions++;
 
     if (! ( *convSelection_)(*conv)){
     selection_fail++;   
     continue; // selection string
     }
     if (convAlgo_ != 0 && conv->algo()!= convAlgo_){
     algo_fail++;    
     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){
        flag_fail++;
        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_) {
           TkVtxC++;
           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) {
        CInnerHits++;
        flag2 = false;
      }
      bool flagHighpurity = true;
      if (!HighpuritySubset(*conv,*priVtxs.product())) {
        flagHighpurity = false;
        if (wantHighpurity_) {
           highpurity_count++;
           flag3 = false;
        }
      }
      bool pizero_rejected = false;
      bool large_pizero_window = CheckPi0(*conv, pfphotons, pizero_rejected);
      if (pi0OnlineSwitch_ && pizero_rejected) {
        pizero_fail++;
        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);
         final_conversion++;
      }
   }
   store_conversion += patoutCollection->size();
   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 239 of file OniaPhotonConversionProducer.cc.

References ConversionEqualByTrack(), ConversionLessByChi2(), and duplicates.

Referenced by produce().

                                                                               {
   // 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 );
     duplicates++;
         }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 345 of file OniaPhotonConversionProducer.cc.

References reco::PFCandidate::gamma.

Referenced by produce().

                                                                                                                             {
   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;
 }