#include <LowPtConversion.h>

Public Member Functions
void	addExtraUserVars (pat::Electron &ele) const

void	addUserVars (pat::Electron &ele) const

	LowPtConversion ()=default

bool	match (const reco::BeamSpot &beamSpot, const reco::ConversionCollection &conversions, const pat::Electron &ele)

bool	wpLoose () const

bool	wpOpen () const

bool	wpTight () const

	~LowPtConversion ()=default

Static Public Member Functions
static float	mee (float ipx1, float ipy1, float ipz1, float ipx2, float ipy2, float ipz2)

Private Attributes
float	chi2prob_ = -1.

float	delta_cot_from_Pin_ = -1.

int	delta_expected_nhits_inner_ = 0

int	ilead_ = -1

int	itrail_ = -1

float	l_xy_ = -1.

uint	lead_nhits_before_vtx_ = 0

float	mass_after_fit_ = -1.

float	mass_before_fit_ = -1.

float	mass_from_conv_ = -1.

float	mass_from_Pin_ = -1.

bool	matched_ = false

edm::RefToBase< reco::Track >	matched_lead_

edm::RefToBase< reco::Track >	matched_trail_

uint	max_nhits_before_vtx_ = 0

float	min_trk_pt_ = -1.

uint	ntracks_ = 0

bool	quality_high_efficiency_ = false

bool	quality_high_purity_ = false

uint	sum_nhits_before_vtx_ = 0

uint	trail_nhits_before_vtx_ = 0

bool	valid_ = false

float	vtx_radius_ = -1.

Detailed Description

Definition at line 13 of file LowPtConversion.h.

Constructor & Destructor Documentation

LowPtConversion::LowPtConversion ( )

default

LowPtConversion::~LowPtConversion ( )

default

Member Function Documentation

void LowPtConversion::addExtraUserVars ( pat::Electron & ele ) const

Definition at line 38 of file LowPtConversion.cc.

References pat::PATObject< ObjectType >::addUserFloat(), pat::PATObject< ObjectType >::addUserInt(), chi2prob_, delta_cot_from_Pin_, delta_expected_nhits_inner_, ilead_, itrail_, l_xy_, lead_nhits_before_vtx_, mass_after_fit_, mass_before_fit_, mass_from_conv_, mass_from_Pin_, max_nhits_before_vtx_, min_trk_pt_, ntracks_, quality_high_efficiency_, quality_high_purity_, sum_nhits_before_vtx_, trail_nhits_before_vtx_, valid_, and vtx_radius_.

Referenced by LowPtElectronModifier::modifyObject().

                                                              {
   // Flag that indicates if extra variables are added to electron userData
   ele.addUserInt("convExtra", 1, true);  // overwrite
 
   // quality
   ele.addUserInt("convValid", valid_ ? 1 : 0);
   ele.addUserFloat("convChi2Prob", chi2prob_);
   ele.addUserInt("convQualityHighPurity", quality_high_purity_ ? 1 : 0);
   ele.addUserInt("convQualityHighEff", quality_high_efficiency_ ? 1 : 0);
 
   // tracks
   ele.addUserInt("convTracksN", ntracks_);
   ele.addUserFloat("convMinTrkPt", min_trk_pt_);
   ele.addUserInt("convLeadIdx", ilead_);
   ele.addUserInt("convTrailIdx", itrail_);
 
   // displacement
   ele.addUserFloat("convLxy", l_xy_);
   ele.addUserFloat("convVtxRadius", vtx_radius_);
 
   // invariant mass
   ele.addUserFloat("convMass", mass_from_conv_);
   ele.addUserFloat("convMassFromPin", mass_from_Pin_);
   ele.addUserFloat("convMassBeforeFit", mass_before_fit_);
   ele.addUserFloat("convMassAfterFit", mass_after_fit_);
 
   // hits before vertex
   ele.addUserInt("convLeadNHitsBeforeVtx", lead_nhits_before_vtx_);
   ele.addUserInt("convTrailNHitsBeforeVtx", trail_nhits_before_vtx_);
   ele.addUserInt("convMaxNHitsBeforeVtx", max_nhits_before_vtx_);
   ele.addUserInt("convSumNHitsBeforeVtx", sum_nhits_before_vtx_);
   ele.addUserInt("convDeltaExpectedNHitsInner", delta_expected_nhits_inner_);
 
   // opening angle
   ele.addUserFloat("convDeltaCotFromPin", delta_cot_from_Pin_);
 }

void LowPtConversion::addUserVars ( pat::Electron & ele ) const

Definition at line 25 of file LowPtConversion.cc.

References pat::PATObject< ObjectType >::addUserInt(), pat::PATObject< ObjectType >::hasUserInt(), edm::RefToBase< T >::isNonnull(), matched_, matched_lead_, matched_trail_, wpLoose(), and wpTight().

Referenced by LowPtElectronModifier::modifyObject().

                                                         {
   ele.addUserInt("convOpen", matched_ ? 1 : 0);
   ele.addUserInt("convLoose", wpLoose() ? 1 : 0);
   ele.addUserInt("convTight", wpTight() ? 1 : 0);
   ele.addUserInt("convLead", matched_lead_.isNonnull() ? 1 : 0);
   ele.addUserInt("convTrail", matched_trail_.isNonnull() ? 1 : 0);
   if (ele.hasUserInt("convExtra") == false) {
     ele.addUserInt("convExtra", 0);
   }
 }

bool LowPtConversion::match	(	const reco::BeamSpot &	beamSpot,
		const reco::ConversionCollection &	conversions,
		const pat::Electron &	ele
	)

Definition at line 77 of file LowPtConversion.cc.

References chi2prob_, ChiSquaredProbability(), conv, pat::Electron::core(), delta_cot_from_Pin_, delta_expected_nhits_inner_, PVValHelper::dx, PVValHelper::dy, ntupleEnum::gsf, pat::Electron::gsfTrack(), reco::Conversion::highEfficiency, reco::Conversion::highPurity, edm::RefToBase< T >::id(), edm::Ref< C, T, F >::id(), ilead_, edm::RefToBase< T >::isAvailable(), edm::RefToBase< T >::isNonnull(), edm::RefToBase< T >::isNull(), edm::Ref< C, T, F >::isNull(), itrail_, edm::RefToBase< T >::key(), edm::Ref< C, T, F >::key(), l_xy_, lead_nhits_before_vtx_, mass_after_fit_, mass_before_fit_, mass_from_conv_, mass_from_Pin_, matched_, matched_lead_, matched_trail_, SiStripPI::max, max_nhits_before_vtx_, mee(), min_trk_pt_, reco::HitPattern::MISSING_INNER_HITS, ntracks_, reco::TrackBase::pt(), quality_high_efficiency_, quality_high_purity_, mathSSE::sqrt(), sum_nhits_before_vtx_, funct::tan(), trail_nhits_before_vtx_, parallelization::uint(), valid_, vtx_radius_, reco::BeamSpot::x0(), and reco::BeamSpot::y0().

Referenced by LowPtElectronModifier::modifyObject().

                                                     {
   // Iterate through conversions and calculate quantities (requirement from Nancy)
   for (const auto& conv : conversions) {
     // Filter
     if (conv.tracks().size() != 2) {
       continue;
     }
 
     // Quality
     valid_ = conv.conversionVertex().isValid();                                                         // (=true)
     chi2prob_ = ChiSquaredProbability(conv.conversionVertex().chi2(), conv.conversionVertex().ndof());  // (<0.005)
     quality_high_purity_ = conv.quality(reco::Conversion::highPurity);                                  // (=true)
     quality_high_efficiency_ = conv.quality(reco::Conversion::highEfficiency);                          // (none)
 
     // Tracks
     ntracks_ = conv.tracks().size();  // (=2)
     min_trk_pt_ = -1.;                // (>0.5)
     for (const auto& trk : conv.tracks()) {
       if (trk.isNonnull() && trk.isAvailable() && (min_trk_pt_ < 0. || trk->pt() < min_trk_pt_)) {
         min_trk_pt_ = trk->pt();
       }
     }
     ilead_ = -1;
     itrail_ = -1;
     if (conv.tracks().size() == 2) {
       const edm::RefToBase<reco::Track>& trk1 = conv.tracks().front();
       const edm::RefToBase<reco::Track>& trk2 = conv.tracks().back();
       if (trk1.isNonnull() && trk1.isAvailable() && trk2.isNonnull() && trk2.isAvailable()) {
         if (trk1->pt() > trk2->pt()) {
           ilead_ = 0;
           itrail_ = 1;
         } else {
           ilead_ = 1;
           itrail_ = 0;
         }
       }
     }
 
     // Transverse displacement (with respect to beamspot) and vertex radius
     math::XYZVectorF p_refitted = conv.refittedPairMomentum();
     float dx = conv.conversionVertex().x() - beamSpot.x0();
     float dy = conv.conversionVertex().y() - beamSpot.y0();
     l_xy_ = (p_refitted.x() * dx + p_refitted.y() * dy) / p_refitted.rho();
     vtx_radius_ = sqrt(conv.conversionVertex().position().perp2());  // (1.5<r<4.)
 
     // invariant mass from track pair from conversion
     mass_from_conv_ = conv.pairInvariantMass();
 
     // Invariant mass from Pin before fit to common vertex
     if (conv.tracksPin().size() >= 2 && ilead_ > -1 && itrail_ > -1) {
       math::XYZVectorF lead_Pin = conv.tracksPin().at(ilead_);
       math::XYZVectorF trail_Pin = conv.tracksPin().at(itrail_);
       mass_from_Pin_ = mee(lead_Pin.x(), lead_Pin.y(), lead_Pin.z(), trail_Pin.x(), trail_Pin.y(), trail_Pin.z());
       // Opening angle
       delta_cot_from_Pin_ = 1. / tan(trail_Pin.theta()) - 1. / tan(lead_Pin.theta());
     }
 
     // Invariant mass before fit to common vertex
     if (conv.tracks().size() >= 2 && ilead_ > -1 && itrail_ > -1) {
       auto lead_before_vtx_fit = conv.tracks().at(ilead_)->momentum();
       auto trail_before_vtx_fit = conv.tracks().at(itrail_)->momentum();
       mass_before_fit_ = mee(lead_before_vtx_fit.x(),
                              lead_before_vtx_fit.y(),
                              lead_before_vtx_fit.z(),
                              trail_before_vtx_fit.x(),
                              trail_before_vtx_fit.y(),
                              trail_before_vtx_fit.z());
     }
 
     // Invariant mass after the fit to common vertex
     if (conv.conversionVertex().refittedTracks().size() >= 2 && ilead_ > -1 && itrail_ > -1) {
       auto const& lead_after_vtx_fit = conv.conversionVertex().refittedTracks().at(ilead_);
       auto const& trail_after_vtx_fit = conv.conversionVertex().refittedTracks().at(itrail_);
       mass_after_fit_ = mee(lead_after_vtx_fit.px(),
                             lead_after_vtx_fit.py(),
                             lead_after_vtx_fit.pz(),
                             trail_after_vtx_fit.px(),
                             trail_after_vtx_fit.py(),
                             trail_after_vtx_fit.pz());
       // Difference in expeted hits
       delta_expected_nhits_inner_ =
           lead_after_vtx_fit.hitPattern().numberOfLostHits(reco::HitPattern::MISSING_INNER_HITS) -
           trail_after_vtx_fit.hitPattern().numberOfLostHits(reco::HitPattern::MISSING_INNER_HITS);
     }
 
     // Hits prior to vertex
     if (ilead_ > -1 && itrail_ > -1) {
       auto const& nHits = conv.nHitsBeforeVtx();
       bool enoughTracks = nHits.size() > 1;
       lead_nhits_before_vtx_ = enoughTracks ? nHits.at(ilead_) : 0;
       trail_nhits_before_vtx_ = enoughTracks ? nHits.at(itrail_) : 0;
       max_nhits_before_vtx_ = enoughTracks ? std::max(nHits[0], nHits[1]) : 0;
       sum_nhits_before_vtx_ = enoughTracks ? nHits[0] + nHits[1] : 0;
     }
 
     // Attempt to match conversion track to electron
     for (uint itrk = 0; itrk < conv.tracks().size(); ++itrk) {
       const edm::RefToBase<reco::Track> trk = conv.tracks()[itrk];
       if (trk.isNull()) {
         continue;
       }
       reco::GsfTrackRef ref = ele.core()->gsfTrack();
       reco::GsfTrackRef gsf = ele.gsfTrack();
       if (gsf.isNull()) {
         continue;
       }
       if (ref.id() == trk.id() && ref.key() == trk.key()) {
         matched_ = true;
         if (static_cast<int>(itrk) == ilead_) {
           matched_lead_ = trk;
         }
         if (static_cast<int>(itrk) == itrail_) {
           matched_trail_ = trk;
         }
       }
     }  // track loop
   }    // conversions loop
 
   return matched_;
 }

float LowPtConversion::mee	(	float	ipx1,
		float	ipy1,
		float	ipz1,
		float	ipx2,
		float	ipy2,
		float	ipz2
	)

static

Definition at line 202 of file LowPtConversion.cc.

References MillePedeFileConverter_cfg::e, funct::m, ResonanceBuilder::mass, p1, p2, and mathSSE::sqrt().

Referenced by match().

                                                                                            {
   const float m = 0.000511;
   const float px = px1 + px2;
   const float py = py1 + py2;
   const float pz = pz1 + pz2;
   const float p1 = px1 * px1 + py1 * py1 + pz1 * pz1;
   const float p2 = px2 * px2 + py2 * py2 + pz2 * pz2;
   const float e = sqrt(p1 + m * m) + sqrt(p2 + m * m);
   const float mass = (e * e - px * px - py * py - pz * pz);
   return mass > 0. ? sqrt(mass) : -1.;
 }

bool LowPtConversion::wpLoose ( ) const

Definition at line 11 of file LowPtConversion.cc.

References chi2prob_, ntracks_, quality_high_purity_, valid_, and wpOpen().

Referenced by addUserVars(), and wpTight().

                                     {
   return (wpOpen() && ntracks_ == 2 && valid_ && quality_high_purity_ && chi2prob_ > 0.0005);
 }

bool LowPtConversion::wpOpen ( ) const

Definition at line 6 of file LowPtConversion.cc.

References matched_.

Referenced by wpLoose().

6 { return matched_; }

LowPtConversion::matched_

bool matched_

Definition: LowPtConversion.h:63

bool LowPtConversion::wpTight ( ) const

Definition at line 18 of file LowPtConversion.cc.

References mass_from_conv_, and wpLoose().

Referenced by addUserVars().

                                     {
   return (wpLoose() && sum_nhits_before_vtx_ <= 1 && l_xy_ > 0. && mass_from_conv_ > 0. &&  // sanity check
           mass_from_conv_ < 0.05);
 }