#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

bool	hasAbilityToProduceInLumis () const final

bool	hasAbilityToProduceInRuns () const final

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 &)

void	endStream () override

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)

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

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::unique_ptr< StringCutObjectSelector< reco::Conversion > >	convSelection_

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

Detailed Description

Select photon conversions and produce a conversion candidate collection

Definition at line 37 of file OniaPhotonConversionProducer.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 54 of file OniaPhotonConversionProducer.cc.

References patPFMETCorrections_cff::algo, relativeConstraints::empty, 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].empty() ) convQuality_ =StringToEnumValue<reco::Conversion::ConversionQuality>(qual);
 
   convSelectionCuts_ = ps.getParameter<std::string>("convSelection");
   convSelection_ = std::make_unique<StringCutObjectSelector<reco::Conversion>>(convSelectionCuts_);
   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 325 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 229 of file OniaPhotonConversionProducer.cc.

References begin, KineDebug3::count(), reco::Vertex::covariance(), reco::TrackBase::dz(), reco::TrackBase::dzError(), relativeConstraints::empty, 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].empty()) return false;
     if (idx[ik].size()>1) std::stable_sort(idx[ik].begin(),idx[ik].end(),lt_);
   }
   if (ik!=1) return false;
   if (idx[0][0].second==idx[1][0].second) return true;
   if (idx[0].size()>1 && idx[0][1].second==idx[1][0].second) return true;
   if (idx[1].size()>1 && 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 351 of file OniaPhotonConversionProducer.cc.

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

void OniaPhotonConversionProducer::endStream ( )

overrideprivate

Definition at line 356 of file OniaPhotonConversionProducer.cc.

References DEFINE_FWK_MODULE.

356 {

357 }

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

private

Definition at line 255 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::numberOfAllHits(), reco::HitPattern::trackerHitFilter(), and reco::HitPattern::validHitFilter().

                                                                                                                         {
   size_t count=0;
   uint32_t oldSubStr=0;
   for (int i=0; i<hitPatA.numberOfAllHits(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 275 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 303 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 178 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
	)

overrideprivate

Definition at line 86 of file OniaPhotonConversionProducer.cc.

References 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);  
 
   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_.empty()){
     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);
         std::unique_ptr<pat::CompositeCandidate> pat_conv(makePhotonCandidate(*conv));
         pat_conv->addUserInt("flags",flags);
         patoutCollection->push_back(*pat_conv);
      }
   }
   event.put(std::move(patoutCollection),"conversions");
 }

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 211 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 317 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;
 }