CombinedSVComputerV2 Class Reference

#include <CombinedSVComputerV2.h>

Classes
struct	IterationRange

Public Member Functions
	CombinedSVComputerV2 (const edm::ParameterSet &params)
reco::TaggingVariableList	operator() (const reco::TrackIPTagInfo &ipInfo, const reco::SecondaryVertexTagInfo &svInfo) const

Private Member Functions
IterationRange	flipIterate (int size, bool vertex) const
double	flipValue (double value, bool vertex) const
const reco::TrackIPTagInfo::TrackIPData &	threshTrack (const reco::TrackIPTagInfo &trackIPTagInfo, const reco::TrackIPTagInfo::SortCriteria sort, const reco::Jet &jet, const GlobalPoint &pv) const

Private Attributes
double	charmCut
double	minTrackWeight
unsigned int	pseudoMultiplicityMin
reco::V0Filter	pseudoVertexV0Filter
reco::TrackIPTagInfo::SortCriteria	sortCriterium
bool	trackFlip
unsigned int	trackMultiplicityMin
reco::TrackSelector	trackNoDeltaRSelector
reco::V0Filter	trackPairV0Filter
reco::TrackSelector	trackPseudoSelector
reco::TrackSelector	trackSelector
bool	useTrackWeights
bool	vertexFlip
bool	vertexMassCorrection

Detailed Description

Definition at line 14 of file CombinedSVComputerV2.h.

Constructor & Destructor Documentation

CombinedSVComputerV2::CombinedSVComputerV2

(

const edm::ParameterSet &

params

)

Definition at line 54 of file CombinedSVComputerV2.cc.

                                                                        :
    trackFlip(params.getParameter<bool>("trackFlip")),
    vertexFlip(params.getParameter<bool>("vertexFlip")),
    charmCut(params.getParameter<double>("charmCut")),
    sortCriterium(TrackSorting::getCriterium(params.getParameter<std::string>("trackSort"))),
    trackSelector(params.getParameter<edm::ParameterSet>("trackSelection")),
    trackNoDeltaRSelector(dropDeltaR(params.getParameter<edm::ParameterSet>("trackSelection"))),
    trackPseudoSelector(params.getParameter<edm::ParameterSet>("trackPseudoSelection")),
    pseudoMultiplicityMin(params.getParameter<unsigned int>("pseudoMultiplicityMin")),
    trackMultiplicityMin(params.getParameter<unsigned int>("trackMultiplicityMin")),
    minTrackWeight(params.getParameter<double>("minimumTrackWeight")),
    useTrackWeights(params.getParameter<bool>("useTrackWeights")),
    vertexMassCorrection(params.getParameter<bool>("correctVertexMass")),
    pseudoVertexV0Filter(params.getParameter<edm::ParameterSet>("pseudoVertexV0Filter")),
    trackPairV0Filter(params.getParameter<edm::ParameterSet>("trackPairV0Filter"))
{
}

Member Function Documentation

CombinedSVComputerV2::IterationRange CombinedSVComputerV2::flipIterate ( int  size, bool  vertex  ) const

inlineprivate

Definition at line 77 of file CombinedSVComputerV2.cc.

References CombinedSVComputerV2::IterationRange::begin, CombinedSVComputerV2::IterationRange::end, CombinedSVComputerV2::IterationRange::increment, findQualityFiles::size, trackFlip, and vertexFlip.

Referenced by operator()(), and threshTrack().

{
    IterationRange range;
    if (vertex ? vertexFlip : trackFlip) {
        range.begin = size - 1;
        range.end = -1;
        range.increment = -1;
    } else {
        range.begin = 0;
        range.end = size;
        range.increment = +1;
    }

    return range;
}

double CombinedSVComputerV2::flipValue ( double  value, bool  vertex  ) const

inlineprivate

Definition at line 72 of file CombinedSVComputerV2.cc.

References trackFlip, relativeConstraints::value, and vertexFlip.

Referenced by operator()().

{
    return (vertex ? vertexFlip : trackFlip) ? -value : value;
}

TaggingVariableList CombinedSVComputerV2::operator()	(	const reco::TrackIPTagInfo &	ipInfo,
		const reco::SecondaryVertexTagInfo &	svInfo
	)		const

Definition at line 142 of file CombinedSVComputerV2.cc.

References edm::RefVector< C, T, F >::begin(), reco::btau::chargedHadronEnergyFraction, reco::btau::chargedHadronMultiplicity, reco::TrackIPTagInfo::TrackIPData::closestToJetAxis, data, deltaR(), dir, reco::TrackIPTagInfo::TrackIPData::distanceToJetAxis, reco::btau::electronEnergyFraction, reco::btau::electronMultiplicity, edm::RefVector< C, T, F >::end(), reco::LeafCandidate::et(), etaRel(), edm::hlt::Exception, reco::SecondaryVertexTagInfo::flightDirection(), reco::SecondaryVertexTagInfo::flightDistance(), reco::btau::flightDistance2dSig, reco::btau::flightDistance2dVal, reco::btau::flightDistance3dSig, reco::btau::flightDistance3dVal, flipIterate(), flipValue(), reco::btau::hadronMultiplicity, reco::btau::hadronPhotonMultiplicity, reco::Vertex::hasRefittedTracks(), i, customizeTrackingMonitorSeedNumber::idx, reco::TrackIPTagInfo::impactParameterData(), reco::TaggingVariableList::insert(), reco::TrackIPTagInfo::TrackIPData::ip2d, reco::TrackIPTagInfo::TrackIPData::ip3d, edm::Ref< C, T, F >::isNonnull(), j, reco::JTATagInfo::jet(), metsig::jet, reco::btau::jetEta, reco::btau::jetNSecondaryVertices, reco::btau::jetNTracks, reco::btau::jetPt, PV3DBase< T, PVType, FrameType >::mag2(), reco::btau::massVertexEnergyFraction, minTrackWeight, reco::TrackBase::momentum(), reco::btau::muonEnergyFraction, reco::btau::muonMultiplicity, reco::btau::neutralHadronEnergyFraction, reco::btau::neutralHadronMultiplicity, reco::btag::Vertices::NoVertex, reco::SecondaryVertexTagInfo::nVertices(), convertSQLiteXML::ok, pfJet, reco::btau::photonEnergyFraction, reco::btau::photonMultiplicity, reco::ParticleMasses::piPlus, funct::pow(), reco::TrackIPTagInfo::primaryVertex(), pseudoMultiplicityMin, reco::btag::Vertices::PseudoVertex, pseudoVertexV0Filter, range_for, reco::btag::Vertices::RecoVertex, reco::Vertex::refittedTrack(), reco::SecondaryVertexTagInfo::secondaryVertex(), reco::TrackIPTagInfo::selectedTracks(), Measurement1D::significance(), edm::RefVector< C, T, F >::size(), sortCriterium, reco::TrackIPTagInfo::sortedIndexes(), mathSSE::sqrt(), threshTrack(), reco::btau::totalMultiplicity, reco::btau::trackDecayLenVal, reco::btau::trackDeltaR, reco::btau::trackEtaRel, reco::btau::trackJetDistVal, reco::btau::trackJetPt, trackMultiplicityMin, trackPairV0Filter, reco::btau::trackPPar, reco::btau::trackPParRatio, trackPseudoSelector, reco::btau::trackPtRatio, reco::btau::trackPtRel, testEve_cfg::tracks, trackSelector, reco::btau::trackSip2dSig, reco::btau::trackSip2dSigAboveCharm, reco::btau::trackSip2dVal, reco::btau::trackSip2dValAboveCharm, reco::btau::trackSip3dSig, reco::btau::trackSip3dSigAboveCharm, reco::btau::trackSip3dVal, reco::btau::trackSip3dValAboveCharm, reco::btau::trackSumJetDeltaR, reco::btau::trackSumJetEtRatio, reco::SecondaryVertexTagInfo::trackWeight(), useTrackWeights, Measurement1D::value(), reco::btau::vertexBoostOverSqrtJetPt, reco::btau::vertexCategory, reco::btau::vertexEnergyRatio, reco::btau::vertexFitProb, reco::btau::vertexJetDeltaR, reco::btau::vertexMass, vertexMassCorrection, reco::btau::vertexNTracks, reco::SecondaryVertexTagInfo::vertexTracks(), w(), PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

{
    using namespace ROOT::Math;

    edm::RefToBase<Jet> jet = ipInfo.jet();

    math::XYZVector jetDir = jet->momentum().Unit();
    bool havePv = ipInfo.primaryVertex().isNonnull();
    GlobalPoint pv;
    if (havePv)
        pv = GlobalPoint(ipInfo.primaryVertex()->x(), ipInfo.primaryVertex()->y(), ipInfo.primaryVertex()->z());

    btag::Vertices::VertexType vtxType = btag::Vertices::NoVertex;

    TaggingVariableList vars; 

    vars.insert(btau::jetPt, jet->pt(), true);
    vars.insert(btau::jetEta, jet->eta(), true);

    if (ipInfo.selectedTracks().size() < trackMultiplicityMin)
        return vars;
    
    vars.insert(btau::jetNTracks, ipInfo.selectedTracks().size(), true);

    TrackKinematics allKinematics;
    TrackKinematics vertexKinematics;
    TrackKinematics trackJetKinematics;

    double vtx_track_ptSum= 0.; 
    double vtx_track_ESum= 0.; 
    double jet_track_ESum= 0.;

    int vtx = -1;
    unsigned int numberofvertextracks = 0;

    //IF THERE ARE SECONDARY VERTICES THE JET FALLS IN THE RECOVERTEX CATEGORY
    IterationRange range = flipIterate(svInfo.nVertices(), true);
    range_for(i, range) {
        if (vtx < 0) vtx = i; //RecoVertex category (vtx=0) if we enter at least one time in this loop!

        numberofvertextracks = numberofvertextracks + (svInfo.secondaryVertex(i)).nTracks();
            
        const Vertex &vertex = svInfo.secondaryVertex(i);
        bool hasRefittedTracks = vertex.hasRefittedTracks();
        TrackRefVector tracks = svInfo.vertexTracks(i);
        for(TrackRefVector::const_iterator track = tracks.begin(); track != tracks.end(); track++) {
            double w = svInfo.trackWeight(i, *track);
            if (w < minTrackWeight)
                continue;
            if (hasRefittedTracks) {
                Track actualTrack = vertex.refittedTrack(*track);
                vars.insert(btau::trackEtaRel, etaRel(jetDir,actualTrack.momentum()), true);
                vertexKinematics.add(actualTrack, w);
            if(i==0)
                {
                    math::XYZVector vtx_trackMom = actualTrack.momentum();
                    vtx_track_ptSum += std::sqrt(std::pow(vtx_trackMom.X(),2) + std::pow(vtx_trackMom.Y(),2)); 
                    vtx_track_ESum += std::sqrt(vtx_trackMom.Mag2() + ROOT::Math::Square(ParticleMasses::piPlus));  
                }
            } else { //THIS ONE IS TAKEN...
                vars.insert(btau::trackEtaRel, etaRel(jetDir,(*track)->momentum()), true);
                vertexKinematics.add(**track, w);
                if(i==0) // calculate this only for the first vertex
                {
                    math::XYZVector vtx_trackMom = (*track)->momentum();
                    vtx_track_ptSum += std::sqrt(std::pow(vtx_trackMom.X(),2) + std::pow(vtx_trackMom.Y(),2)); 
                    vtx_track_ESum += std::sqrt(vtx_trackMom.Mag2() + std::pow(ParticleMasses::piPlus,2)); 
                    }
            }
        }
    }

    if (vtx >= 0) {
        vtxType = btag::Vertices::RecoVertex;
        vars.insert(btau::flightDistance2dVal,flipValue(svInfo.flightDistance(vtx, true).value(),true),true);
        vars.insert(btau::flightDistance2dSig,flipValue(svInfo.flightDistance(vtx, true).significance(),true),true);
        vars.insert(btau::flightDistance3dVal,flipValue(svInfo.flightDistance(vtx, false).value(),true),true);
        vars.insert(btau::flightDistance3dSig,flipValue(svInfo.flightDistance(vtx, false).significance(),true),true);
        vars.insert(btau::vertexJetDeltaR,Geom::deltaR(svInfo.flightDirection(vtx), jetDir),true);
        vars.insert(btau::jetNSecondaryVertices, svInfo.nVertices(), true);
        vars.insert(btau::vertexNTracks, numberofvertextracks, true);   
        vars.insert(btau::vertexFitProb,(svInfo.secondaryVertex(vtx)).normalizedChi2(), true);
    }


    //NOW ATTEMPT TO RECONSTRUCT PSEUDOVERTEX!!!
    std::vector<std::size_t> indices = ipInfo.sortedIndexes(sortCriterium);
    const std::vector<TrackIPTagInfo::TrackIPData> &ipData = ipInfo.impactParameterData();
    const edm::RefVector<TrackCollection> &tracks = ipInfo.selectedTracks();
  
    std::vector<TrackRef> pseudoVertexTracks;

    range = flipIterate(indices.size(), false);
    range_for(i, range) {
        std::size_t idx = indices[i];
        const TrackIPTagInfo::TrackIPData &data = ipData[idx];
        const TrackRef &trackRef = tracks[idx];
        const Track &track = *trackRef;

        // if no vertex was reconstructed, attempt pseudo vertex
        if (vtxType == btag::Vertices::NoVertex && trackPseudoSelector(track, data, *jet, pv)) {
            pseudoVertexTracks.push_back(trackRef);
            vertexKinematics.add(track);
        }
    }

    if (vtxType == btag::Vertices::NoVertex && vertexKinematics.numberOfTracks() >= pseudoMultiplicityMin && pseudoVertexV0Filter(pseudoVertexTracks)) 
    { 
        vtxType = btag::Vertices::PseudoVertex;
        for(std::vector<TrackRef>::const_iterator track = pseudoVertexTracks.begin(); track != pseudoVertexTracks.end(); ++track)
        {
            vars.insert(btau::trackEtaRel, etaRel(jetDir, (*track)->momentum()), true);
            math::XYZVector vtx_trackMom = (*track)->momentum();
            vtx_track_ptSum += std::sqrt(std::pow(vtx_trackMom.X(),2) + std::pow(vtx_trackMom.Y(),2)); 
            vtx_track_ESum += std::sqrt(vtx_trackMom.Mag2() + std::pow(ParticleMasses::piPlus,2)); 
        }
    }

    vars.insert(btau::vertexCategory, vtxType, true);



    // do a tighter track selection to fill the variable plots...
    TrackRef trackPairV0Test[2];
    range = flipIterate(indices.size(), false);
    range_for(i, range) {

        std::size_t idx = indices[i];
        const TrackIPTagInfo::TrackIPData &data = ipData[idx];
        const TrackRef &trackRef = tracks[idx];
        const Track &track = *trackRef;

        jet_track_ESum += std::sqrt((track.momentum()).Mag2() + std::pow(ParticleMasses::piPlus,2)); 
        // add track to kinematics for all tracks in jet
        //allKinematics.add(track); //would make more sense for some variables, e.g. vertexEnergyRatio nicely between 0 and 1, but not necessarily the best option for the discriminating power...
                    
        // filter tracks -> this track selection can be more tight (used to fill the track related variables...)
        if (!trackSelector(track, data, *jet, pv))
            continue;

        // add track to kinematics for all tracks in jet
        allKinematics.add(track);

        // check against all other tracks for K0 track pairs setting the track mass to pi+
        trackPairV0Test[0] = tracks[idx];
        bool ok = true;
        range_for(j, range) {
            if (i == j)
                continue;

            std::size_t pairIdx = indices[j];
            const TrackIPTagInfo::TrackIPData &pairTrackData = ipData[pairIdx];
            const TrackRef &pairTrackRef = tracks[pairIdx];
            const Track &pairTrack = *pairTrackRef;

            if (!trackSelector(pairTrack, pairTrackData, *jet, pv))
                continue;

            trackPairV0Test[1] = pairTrackRef;
            if (!trackPairV0Filter(trackPairV0Test, 2)) { //V0 filter is more tight (0.03) than the one used for the RecoVertex and PseudoVertex tracks (0.05)
            ok = false;
            break;
            }
        }
        
        if (!ok)
            continue;
        
        trackJetKinematics.add(track);
        

        // add track variables
        math::XYZVector trackMom = track.momentum();
        double trackMag = std::sqrt(trackMom.Mag2());

        vars.insert(btau::trackSip3dVal,  flipValue(data.ip3d.value(), false), true);
        vars.insert(btau::trackSip3dSig, flipValue(data.ip3d.significance(), false), true);
        vars.insert(btau::trackSip2dVal, flipValue(data.ip2d.value(), false), true);
        vars.insert(btau::trackSip2dSig, flipValue(data.ip2d.significance(), false), true);
        vars.insert(btau::trackJetDistVal, data.distanceToJetAxis.value(), true);
        vars.insert(btau::trackDecayLenVal, havePv ? (data.closestToJetAxis - pv).mag() : -1.0, true);

        vars.insert(btau::trackPtRel, VectorUtil::Perp(trackMom, jetDir), true);
        vars.insert(btau::trackPPar, jetDir.Dot(trackMom), true);
        vars.insert(btau::trackDeltaR, VectorUtil::DeltaR(trackMom, jetDir), true);
        vars.insert(btau::trackPtRatio, VectorUtil::Perp(trackMom, jetDir) / trackMag, true);
        vars.insert(btau::trackPParRatio, jetDir.Dot(trackMom) / trackMag, true);
    }
    
    vars.insert(btau::trackJetPt, trackJetKinematics.vectorSum().Pt(), true);
     

    vars.insert(btau::trackSumJetDeltaR,VectorUtil::DeltaR(allKinematics.vectorSum(), jetDir), true);
    vars.insert(btau::trackSumJetEtRatio,allKinematics.vectorSum().Et() / ipInfo.jet()->et(), true);
    vars.insert(btau::trackSip3dSigAboveCharm, flipValue(threshTrack(ipInfo, TrackIPTagInfo::IP3DSig, *jet, pv).ip3d.significance(),false),true);
    vars.insert(btau::trackSip3dValAboveCharm, flipValue(threshTrack(ipInfo, TrackIPTagInfo::IP3DSig, *jet, pv).ip3d.value(),false),true);
    vars.insert(btau::trackSip2dSigAboveCharm, flipValue(threshTrack(ipInfo, TrackIPTagInfo::IP2DSig, *jet, pv).ip2d.significance(),false),true);
    vars.insert(btau::trackSip2dValAboveCharm, flipValue(threshTrack(ipInfo, TrackIPTagInfo::IP2DSig, *jet, pv).ip2d.value(),false),true);

    if (vtxType != btag::Vertices::NoVertex) {
        math::XYZTLorentzVector allSum = useTrackWeights ? allKinematics.weightedVectorSum() : allKinematics.vectorSum();
        math::XYZTLorentzVector vertexSum = useTrackWeights ? vertexKinematics.weightedVectorSum() : vertexKinematics.vectorSum();

        if (vtxType != btag::Vertices::RecoVertex) {
            vars.insert(btau::vertexNTracks,vertexKinematics.numberOfTracks(), true);
            vars.insert(btau::vertexJetDeltaR,VectorUtil::DeltaR(vertexSum, jetDir), true);
        }

        double vertexMass = vertexSum.M();
        double varPi = 0;
        double varB = 0;
        if (vtxType == btag::Vertices::RecoVertex) {
            if(vertexMassCorrection)
            {
                GlobalVector dir = svInfo.flightDirection(vtx);
                double vertexPt2 = math::XYZVector(dir.x(), dir.y(), dir.z()).Cross(vertexSum).Mag2() / dir.mag2();
                vertexMass = std::sqrt(vertexMass * vertexMass + vertexPt2) + std::sqrt(vertexPt2);
            }
        }
        vars.insert(btau::vertexMass, vertexMass, true);
        varPi = (vertexMass/5.2794) * (vtx_track_ESum /jet_track_ESum); //5.2794 should be average B meson mass of PDG! CHECK!!!
        vars.insert(btau::massVertexEnergyFraction, varPi, true);
        varB  = (std::sqrt(5.2794) * vtx_track_ptSum) / ( vertexMass * std::sqrt(jet->pt())); 
        vars.insert(btau::vertexBoostOverSqrtJetPt,varB*varB/(varB*varB + 10.), true);
        
        if (allKinematics.numberOfTracks())
            vars.insert(btau::vertexEnergyRatio, vertexSum.E() / allSum.E(), true);
        else
            vars.insert(btau::vertexEnergyRatio, 1, true);
    }

    reco::PFJet const * pfJet = dynamic_cast<reco::PFJet const *>( &* jet ) ;
    pat::Jet const * patJet = dynamic_cast<pat::Jet const *>( &* jet ) ;
    if ( pfJet != 0 ) {
        vars.insert(btau::chargedHadronEnergyFraction,pfJet->chargedHadronEnergyFraction(), true);
        vars.insert(btau::neutralHadronEnergyFraction,pfJet->neutralHadronEnergyFraction(), true);
        vars.insert(btau::photonEnergyFraction,pfJet->photonEnergyFraction(), true);
        vars.insert(btau::electronEnergyFraction,pfJet->electronEnergyFraction(), true);
        vars.insert(btau::muonEnergyFraction,pfJet->muonEnergyFraction(), true);
        vars.insert(btau::chargedHadronMultiplicity,pfJet->chargedHadronMultiplicity(), true);
        vars.insert(btau::neutralHadronMultiplicity,pfJet->neutralHadronMultiplicity(), true);
        vars.insert(btau::photonMultiplicity,pfJet->photonMultiplicity(), true);
        vars.insert(btau::electronMultiplicity,pfJet->electronMultiplicity(), true);
        vars.insert(btau::muonMultiplicity,pfJet->muonMultiplicity(), true);
        vars.insert(btau::hadronMultiplicity,pfJet->chargedHadronMultiplicity()+pfJet->neutralHadronMultiplicity(), true);
        vars.insert(btau::hadronPhotonMultiplicity,pfJet->chargedHadronMultiplicity()+pfJet->neutralHadronMultiplicity()+pfJet->photonMultiplicity(), true);
            vars.insert(btau::totalMultiplicity,pfJet->chargedHadronMultiplicity()+pfJet->neutralHadronMultiplicity()+pfJet->photonMultiplicity()+pfJet->electronMultiplicity()+pfJet->muonMultiplicity(), true);

    }
    else if( patJet != 0)
    {
        vars.insert(btau::chargedHadronEnergyFraction,patJet->chargedHadronEnergyFraction(), true);
        vars.insert(btau::neutralHadronEnergyFraction,patJet->neutralHadronEnergyFraction(), true);
        vars.insert(btau::photonEnergyFraction,patJet->photonEnergyFraction(), true);
        vars.insert(btau::electronEnergyFraction,patJet->electronEnergyFraction(), true);
        vars.insert(btau::muonEnergyFraction,patJet->muonEnergyFraction(), true);
        vars.insert(btau::chargedHadronMultiplicity,patJet->chargedHadronMultiplicity(), true);
        vars.insert(btau::neutralHadronMultiplicity,patJet->neutralHadronMultiplicity(), true);
        vars.insert(btau::photonMultiplicity,patJet->photonMultiplicity(), true);
        vars.insert(btau::electronMultiplicity,patJet->electronMultiplicity(), true);
        vars.insert(btau::muonMultiplicity,patJet->muonMultiplicity(), true);
        vars.insert(btau::hadronMultiplicity,patJet->chargedHadronMultiplicity()+patJet->neutralHadronMultiplicity(), true);
        vars.insert(btau::hadronPhotonMultiplicity,patJet->chargedHadronMultiplicity()+patJet->neutralHadronMultiplicity()+patJet->photonMultiplicity(), true);
            vars.insert(btau::totalMultiplicity,patJet->chargedHadronMultiplicity()+patJet->neutralHadronMultiplicity()+patJet->photonMultiplicity()+patJet->electronMultiplicity()+patJet->muonMultiplicity(), true);
    
    }
    else
    {
        throw cms::Exception("InvalidConfiguration") << "From CombinedSVComputerV2::operator: reco::PFJet OR pat::Jet are required by this module" << std::endl;    
    }
 
    vars.finalize();

    return vars;
}

const TrackIPTagInfo::TrackIPData & CombinedSVComputerV2::threshTrack ( const reco::TrackIPTagInfo &  trackIPTagInfo, const reco::TrackIPTagInfo::SortCriteria  sort, const reco::Jet &  jet, const GlobalPoint &  pv  ) const

private

Definition at line 95 of file CombinedSVComputerV2.cc.

References charmCut, data, flipIterate(), i, customizeTrackingMonitorSeedNumber::idx, reco::TrackIPTagInfo::impactParameterData(), range_for, reco::TrackIPTagInfo::selectedTracks(), reco::TrackIPTagInfo::sortedIndexes(), trackNoDeltaRSelector, and testEve_cfg::tracks.

Referenced by operator()().

{
    const edm::RefVector<TrackCollection> &tracks =
                    trackIPTagInfo.selectedTracks();
    const std::vector<TrackIPTagInfo::TrackIPData> &ipData =
                    trackIPTagInfo.impactParameterData();
    std::vector<std::size_t> indices = trackIPTagInfo.sortedIndexes(sort);

    IterationRange range = flipIterate(indices.size(), false);
    TrackKinematics kin;
    range_for(i, range) {
        std::size_t idx = indices[i];
        const TrackIPTagInfo::TrackIPData &data = ipData[idx];
        const Track &track = *tracks[idx];

        if (!trackNoDeltaRSelector(track, data, jet, pv))
            continue;

        kin.add(track);
        if (kin.vectorSum().M() > charmCut) 
            return data;
    }

    static const TrackIPTagInfo::TrackIPData dummy = {
        GlobalPoint(),
        GlobalPoint(),
        Measurement1D(-1.0, 1.0),
        Measurement1D(-1.0, 1.0),
        Measurement1D(-1.0, 1.0),
        Measurement1D(-1.0, 1.0),
        0.
    };
    return dummy;
}

Member Data Documentation

double CombinedSVComputerV2::charmCut

private

Definition at line 36 of file CombinedSVComputerV2.h.

Referenced by threshTrack().

double CombinedSVComputerV2::minTrackWeight

private

Definition at line 43 of file CombinedSVComputerV2.h.

Referenced by operator()().

unsigned int CombinedSVComputerV2::pseudoMultiplicityMin

private

Definition at line 41 of file CombinedSVComputerV2.h.

Referenced by operator()().

reco::V0Filter CombinedSVComputerV2::pseudoVertexV0Filter

private

Definition at line 46 of file CombinedSVComputerV2.h.

Referenced by operator()().

reco::TrackIPTagInfo::SortCriteria CombinedSVComputerV2::sortCriterium

private

Definition at line 37 of file CombinedSVComputerV2.h.

Referenced by operator()().

bool CombinedSVComputerV2::trackFlip

private

Definition at line 34 of file CombinedSVComputerV2.h.

Referenced by flipIterate(), and flipValue().

unsigned int CombinedSVComputerV2::trackMultiplicityMin

private

Definition at line 42 of file CombinedSVComputerV2.h.

Referenced by operator()().

reco::TrackSelector CombinedSVComputerV2::trackNoDeltaRSelector

private

Definition at line 39 of file CombinedSVComputerV2.h.

Referenced by threshTrack().

reco::V0Filter CombinedSVComputerV2::trackPairV0Filter

private

Definition at line 47 of file CombinedSVComputerV2.h.

Referenced by operator()().

reco::TrackSelector CombinedSVComputerV2::trackPseudoSelector

private

Definition at line 40 of file CombinedSVComputerV2.h.

Referenced by operator()().

reco::TrackSelector CombinedSVComputerV2::trackSelector

private

Definition at line 38 of file CombinedSVComputerV2.h.

Referenced by operator()().

bool CombinedSVComputerV2::useTrackWeights

private

Definition at line 44 of file CombinedSVComputerV2.h.

Referenced by operator()().

bool CombinedSVComputerV2::vertexFlip

private

Definition at line 35 of file CombinedSVComputerV2.h.

Referenced by flipIterate(), and flipValue().

bool CombinedSVComputerV2::vertexMassCorrection

private

Definition at line 45 of file CombinedSVComputerV2.h.

Referenced by operator()().