CombinedSVComputer Class Reference

#include <CombinedSVComputer.h>

Inheritance diagram for CombinedSVComputer:

Classes
struct	IterationRange

Public Member Functions
	CombinedSVComputer (const edm::ParameterSet &params)
edm::ParameterSet	dropDeltaR (const edm::ParameterSet &pset) const
template<class SVTI , class IPTI >
void	fillCommonVariables (reco::TaggingVariableList &vars, reco::TrackKinematics &vertexKinematics, const IPTI &ipInfo, const SVTI &svInfo, double &vtx_track_ptSum, double &vtx_track_ESum) const
IterationRange	flipIterate (int size, bool vertex) const
double	flipValue (double value, bool vertex) const
virtual reco::TaggingVariableList	operator() (const reco::TrackIPTagInfo &ipInfo, const reco::SecondaryVertexTagInfo &svInfo) const
virtual reco::TaggingVariableList	operator() (const reco::CandIPTagInfo &ipInfo, const reco::CandSecondaryVertexTagInfo &svInfo) const
const reco::btag::TrackIPData &	threshTrack (const reco::CandIPTagInfo &trackIPTagInfo, const reco::btag::SortCriteria sort, const reco::Jet &jet, const GlobalPoint &pv) const
const reco::btag::TrackIPData &	threshTrack (const reco::TrackIPTagInfo &trackIPTagInfo, const reco::btag::SortCriteria sort, const reco::Jet &jet, const GlobalPoint &pv) const

Private Attributes
double	charmCut
double	minTrackWeight
unsigned int	pseudoMultiplicityMin
reco::V0Filter	pseudoVertexV0Filter
reco::btag::SortCriteria	sortCriterium
std::vector < reco::btau::TaggingVariableName >	taggingVariables
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 42 of file CombinedSVComputer.h.

Constructor & Destructor Documentation

CombinedSVComputer::CombinedSVComputer ( const edm::ParameterSet &  params )

explicit

Definition at line 13 of file CombinedSVComputer.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

edm::ParameterSet CombinedSVComputer::dropDeltaR ( const edm::ParameterSet &  pset ) const

inline

Definition at line 6 of file CombinedSVComputer.cc.

References edm::ParameterSet::addParameter().

{
    edm::ParameterSet psetCopy(pset);
    psetCopy.addParameter<double>("jetDeltaRMax", 99999.0);
    return psetCopy;
}

template<class SVTI , class IPTI >

void CombinedSVComputer::fillCommonVariables	(	reco::TaggingVariableList &	vars,
		reco::TrackKinematics &	vertexKinematics,
		const IPTI &	ipInfo,
		const SVTI &	svInfo,
		double &	vtx_track_ptSum,
		double &	vtx_track_ESum
	)		const

Definition at line 95 of file CombinedSVComputer.h.

References reco::TrackKinematics::add(), reco::btau::chargedHadronEnergyFraction, reco::btau::chargedHadronMultiplicity, reco::btag::TrackIPData::closestToJetAxis, AlCaHLTBitMon_QueryRunRegistry::data, deltaR(), HLT_FULL_cff::DeltaR, dir, reco::btag::TrackIPData::distanceToJetAxis, reco::btau::electronEnergyFraction, reco::btau::electronMultiplicity, reco::btau::etaRel(), reco::btau::flightDistance2dSig, reco::btau::flightDistance2dVal, reco::btau::flightDistance3dSig, reco::btau::flightDistance3dVal, flipIterate(), flipValue(), reco::btau::hadronMultiplicity, reco::btau::hadronPhotonMultiplicity, i, customizeTrackingMonitorSeedNumber::idx, reco::TaggingVariableList::insert(), reco::btag::TrackIPData::ip2d, reco::btag::IP2DSig, reco::btag::TrackIPData::ip3d, reco::btag::IP3DSig, j, metsig::jet, reco::btau::jetEta, reco::btau::jetNSecondaryVertices, reco::btau::jetNTracks, reco::btau::jetPt, PV3DBase< T, PVType, FrameType >::mag2(), reco::btau::massVertexEnergyFraction, reco::btau::muonEnergyFraction, reco::btau::muonMultiplicity, reco::btau::neutralHadronEnergyFraction, reco::btau::neutralHadronMultiplicity, reco::btag::Vertices::NoVertex, reco::TrackKinematics::numberOfTracks(), convertSQLiteXML::ok, reco::btau::photonEnergyFraction, reco::btau::photonMultiplicity, reco::ParticleMasses::piPlus, pseudoMultiplicityMin, reco::btag::Vertices::PseudoVertex, pseudoVertexV0Filter, MetAnalyzer::pv(), range_for, dt_dqm_sourceclient_common_cff::reco, reco::btag::Vertices::RecoVertex, Measurement1D::significance(), sortCriterium, mathSSE::sqrt(), threshTrack(), reco::btau::totalMultiplicity, reco::btau::trackDecayLenVal, reco::btau::trackDeltaR, reco::btau::trackEta, reco::btau::trackEtaRel, reco::btau::trackJetDistVal, reco::btau::trackJetPt, reco::btau::trackMomentum, 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, useTrackWeights, Measurement1D::value(), reco::TrackKinematics::vectorSum(), reco::btau::vertexBoostOverSqrtJetPt, reco::btau::vertexCategory, reco::btau::vertexEnergyRatio, reco::btau::vertexJetDeltaR, reco::btau::vertexMass, vertexMassCorrection, reco::btau::vertexNTracks, reco::TrackKinematics::weightedVectorSum(), PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by operator()().

{
        using namespace ROOT::Math;
        using namespace reco;

        typedef typename IPTI::input_container Container;
        typedef typename Container::value_type TrackRef;

        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;


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

        if (ipInfo.selectedTracks().size() < trackMultiplicityMin)
                return;

    vars.insert(btau::jetNTracks, ipInfo.selectedTracks().size(), true);
    
        TrackKinematics allKinematics;
    TrackKinematics trackJetKinematics;
    
    double jet_track_ESum= 0.;
    
    int vtx = -1;
    
    IterationRange range = flipIterate(svInfo.nVertices(), true);
    range_for(i , range) {
        if (vtx < 0) vtx = i;
    }

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

    std::vector<std::size_t> indices = ipInfo.sortedIndexes(sortCriterium);
    const std::vector<reco::btag::TrackIPData> &ipData = ipInfo.impactParameterData();

    const Container &tracks = ipInfo.selectedTracks();
    std::vector<TrackRef> pseudoVertexTracks;

        std::vector<TrackRef> trackPairV0Test(2);
        range = flipIterate(indices.size(), false);
        range_for(i, range) {
                std::size_t idx = indices[i];
                const reco::btag::TrackIPData &data = ipData[idx];
                const TrackRef &track = tracks[idx];

                jet_track_ESum += std::sqrt(track->momentum().Mag2() + ROOT::Math::Square(ParticleMasses::piPlus));

                // 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 track -> this track selection can be tighter than the vertex track selection (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);

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

                // check against all other tracks for V0 track pairs
                trackPairV0Test[0] = track;
                bool ok = true;
                range_for(j, range) {
                        if (i == j)
                                continue;

                        std::size_t pairIdx = indices[j];
                        const reco::btag::TrackIPData &pairTrackData = ipData[pairIdx];
                        const TrackRef &pairTrack = tracks[pairIdx];

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

                        trackPairV0Test[1] = pairTrack;
                        if (!trackPairV0Filter(trackPairV0Test)) {
                                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::trackJetDistSig, data.distanceToJetAxis.significance(), true);
//              vars.insert(btau::trackFirstTrackDist, data.distanceToFirstTrack, true);
//              vars.insert(btau::trackGhostTrackVal, data.distanceToGhostTrack.value(), true);
//              vars.insert(btau::trackGhostTrackSig, data.distanceToGhostTrack.significance(), true);
                vars.insert(btau::trackDecayLenVal, havePv ? (data.closestToJetAxis - pv).mag() : -1.0, true);

                vars.insert(btau::trackMomentum, trackMag, true);
                vars.insert(btau::trackEta, trackMom.Eta(), 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);
        }

        if (vtxType == btag::Vertices::NoVertex && vertexKinematics.numberOfTracks() >= pseudoMultiplicityMin && pseudoVertexV0Filter(pseudoVertexTracks))
        {
                vtxType = btag::Vertices::PseudoVertex;
                for(typename std::vector<TrackRef>::const_iterator trkIt = pseudoVertexTracks.begin(); trkIt != pseudoVertexTracks.end(); ++trkIt)
                {
                        vars.insert(btau::trackEtaRel, reco::btau::etaRel(jetDir,(*trkIt)->momentum()), true);
                        vtx_track_ptSum += std::sqrt((*trkIt)->momentum().Perp2());
                        vtx_track_ESum  += std::sqrt((*trkIt)->momentum().Mag2() + ROOT::Math::Square(ParticleMasses::piPlus));
                }
        }

    vars.insert(btau::vertexCategory, vtxType, 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, reco::btag::IP3DSig, *jet, pv).ip3d.significance(),false),true);
    vars.insert(btau::trackSip3dValAboveCharm, flipValue(threshTrack(ipInfo, reco::btag::IP3DSig, *jet, pv).ip3d.value(),false),true);
    vars.insert(btau::trackSip2dSigAboveCharm, flipValue(threshTrack(ipInfo, reco::btag::IP2DSig, *jet, pv).ip2d.significance(),false),true);
    vars.insert(btau::trackSip2dValAboveCharm, flipValue(threshTrack(ipInfo, reco::btag::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();
                if (vtxType == btag::Vertices::RecoVertex &&
                    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);

                double varPi = (vertexMass/5.2794) * (vtx_track_ESum /jet_track_ESum); // 5.2794 should be the average B meson mass of PDG! CHECK!!!
                vars.insert(btau::massVertexEnergyFraction, varPi / (varPi + 0.04), true);
                double 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 && patJet->isPFJet() )
    {
        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
    {
        vars.insert(btau::chargedHadronEnergyFraction,0., true);
        vars.insert(btau::neutralHadronEnergyFraction,0., true);
        vars.insert(btau::photonEnergyFraction,0., true);
        vars.insert(btau::electronEnergyFraction,0., true);
        vars.insert(btau::muonEnergyFraction,0., true);
        vars.insert(btau::chargedHadronMultiplicity,0, true);
        vars.insert(btau::neutralHadronMultiplicity,0, true);
        vars.insert(btau::photonMultiplicity,0, true);
        vars.insert(btau::electronMultiplicity,0, true);
        vars.insert(btau::muonMultiplicity,0, true);
        vars.insert(btau::hadronMultiplicity,0, true);
        vars.insert(btau::hadronPhotonMultiplicity,0, true);
        vars.insert(btau::totalMultiplicity,0, true);
    }
}

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

inline

Definition at line 37 of file CombinedSVComputer.cc.

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

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

{
    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 CombinedSVComputer::flipValue ( double  value, bool  vertex  ) const

inline

Definition at line 32 of file CombinedSVComputer.cc.

References trackFlip, relativeConstraints::value, and vertexFlip.

Referenced by fillCommonVariables().

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

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

virtual

Definition at line 134 of file CombinedSVComputer.cc.

References reco::btau::etaRel(), fillCommonVariables(), flipIterate(), reco::Vertex::hasRefittedTracks(), i, minTrackWeight, reco::LeafCandidate::momentum(), reco::TrackBase::momentum(), nTracks(), reco::TemplatedSecondaryVertexTagInfo< IPTI, VTX >::nVertices(), reco::ParticleMasses::piPlus, range_for, reco::Vertex::refittedTrack(), reco::TemplatedSecondaryVertexTagInfo< IPTI, VTX >::secondaryVertex(), mathSSE::sqrt(), reco::btau::trackEtaRel, reco::Vertex::tracks_begin(), reco::Vertex::tracks_end(), reco::Vertex::trackWeight(), reco::btau::vertexFitProb, reco::btau::vertexNTracks, and w.

Referenced by CombinedSVSoftLeptonComputer::operator()().

{
    using namespace ROOT::Math;

    edm::RefToBase<Jet> jet = ipInfo.jet();
    math::XYZVector jetDir = jet->momentum().Unit();
    TaggingVariableList vars;

        TrackKinematics vertexKinematics;
    
    double vtx_track_ptSum = 0.;
    double vtx_track_ESum  = 0.;
    
    // the following is specific depending on the type of vertex
        int vtx = -1;
        unsigned int numberofvertextracks = 0;

    IterationRange range = flipIterate(svInfo.nVertices(), true);
    range_for(i, range) {

        numberofvertextracks = numberofvertextracks + (svInfo.secondaryVertex(i)).nTracks();

        const Vertex &vertex = svInfo.secondaryVertex(i);
        bool hasRefittedTracks = vertex.hasRefittedTracks();
        for(reco::Vertex::trackRef_iterator track = vertex.tracks_begin(); track != vertex.tracks_end(); track++) {
            double w = vertex.trackWeight(*track);
            if (w < minTrackWeight)
                continue;
            if (hasRefittedTracks) {
                const Track actualTrack = vertex.refittedTrack(*track);
                vertexKinematics.add(actualTrack, w);
                vars.insert(btau::trackEtaRel, reco::btau::etaRel(jetDir,actualTrack.momentum()), true);
                if(vtx < 0) // calculate this only for the first vertex
                {
                    vtx_track_ptSum += std::sqrt(actualTrack.momentum().Perp2());
                    vtx_track_ESum  += std::sqrt(actualTrack.momentum().Mag2() + ROOT::Math::Square(ParticleMasses::piPlus));
                }
            } else {
                vertexKinematics.add(**track, w);
                vars.insert(btau::trackEtaRel, reco::btau::etaRel(jetDir,(*track)->momentum()), true);
                if(vtx < 0) // calculate this only for the first vertex
                {
                    vtx_track_ptSum += std::sqrt((*track)->momentum().Perp2());
                    vtx_track_ESum  += std::sqrt((*track)->momentum().Mag2() + ROOT::Math::Square(ParticleMasses::piPlus));
                }
            }
        }
        
        if (vtx < 0) vtx = i;
        }
    if(vtx>=0){
        vars.insert(btau::vertexNTracks, numberofvertextracks, true);
        vars.insert(btau::vertexFitProb,(svInfo.secondaryVertex(vtx)).normalizedChi2(), true);
    }

    // after we collected vertex information we let the common code complete the job
    fillCommonVariables(vars,vertexKinematics,ipInfo,svInfo,vtx_track_ptSum,vtx_track_ESum);

    vars.finalize();
    return vars;
}

TaggingVariableList CombinedSVComputer::operator() ( const reco::CandIPTagInfo &  ipInfo, const reco::CandSecondaryVertexTagInfo &  svInfo  ) const

virtual

Definition at line 198 of file CombinedSVComputer.cc.

References reco::CompositePtrCandidate::daughterPtrVector(), reco::btau::etaRel(), fillCommonVariables(), flipIterate(), i, reco::LeafCandidate::momentum(), reco::TemplatedSecondaryVertexTagInfo< IPTI, VTX >::nVertices(), reco::ParticleMasses::piPlus, range_for, reco::TemplatedSecondaryVertexTagInfo< IPTI, VTX >::secondaryVertex(), mathSSE::sqrt(), reco::btau::trackEtaRel, reco::btau::vertexFitProb, and reco::btau::vertexNTracks.

{
        using namespace ROOT::Math;

        edm::RefToBase<Jet> jet = ipInfo.jet();
        math::XYZVector jetDir = jet->momentum().Unit();
        TaggingVariableList vars;

        TrackKinematics vertexKinematics;
    
    double vtx_track_ptSum = 0.;
    double vtx_track_ESum  = 0.;
    
    // the following is specific depending on the type of vertex
        int vtx = -1;
        unsigned int numberofvertextracks = 0;

    IterationRange range = flipIterate(svInfo.nVertices(), true);
    range_for(i, range) {

        numberofvertextracks = numberofvertextracks + (svInfo.secondaryVertex(i)).numberOfSourceCandidatePtrs();

        const reco::VertexCompositePtrCandidate &vertex = svInfo.secondaryVertex(i);
        const std::vector<CandidatePtr> & tracks = vertex.daughterPtrVector();
        for(std::vector<CandidatePtr>::const_iterator track = tracks.begin(); track != tracks.end(); ++track) {
            vertexKinematics.add(*track);
            vars.insert(btau::trackEtaRel, reco::btau::etaRel(jetDir,(*track)->momentum()), true);
            if(vtx < 0) // calculate this only for the first vertex
            {
                vtx_track_ptSum += std::sqrt((*track)->momentum().Perp2());
                vtx_track_ESum  += std::sqrt((*track)->momentum().Mag2() + ROOT::Math::Square(ParticleMasses::piPlus));
            }
        }
        
        if (vtx < 0) vtx = i;
    }
    if(vtx>=0){
        vars.insert(btau::vertexNTracks, numberofvertextracks, true);
        vars.insert(btau::vertexFitProb,(svInfo.secondaryVertex(vtx)).vertexNormalizedChi2(), true);
    }
    
    // after we collected vertex information we let the common code complete the job
    fillCommonVariables(vars,vertexKinematics,ipInfo,svInfo,vtx_track_ptSum,vtx_track_ESum);
    
    vars.finalize();
    return vars;
}

const reco::btag::TrackIPData& CombinedSVComputer::threshTrack	(	const reco::CandIPTagInfo &	trackIPTagInfo,
		const reco::btag::SortCriteria	sort,
		const reco::Jet &	jet,
		const GlobalPoint &	pv
	)		const

Referenced by fillCommonVariables().

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

Member Data Documentation

double CombinedSVComputer::charmCut

private

Definition at line 79 of file CombinedSVComputer.h.

double CombinedSVComputer::minTrackWeight

private

Definition at line 86 of file CombinedSVComputer.h.

Referenced by operator()().

unsigned int CombinedSVComputer::pseudoMultiplicityMin

private

Definition at line 84 of file CombinedSVComputer.h.

Referenced by fillCommonVariables().

reco::V0Filter CombinedSVComputer::pseudoVertexV0Filter

private

Definition at line 89 of file CombinedSVComputer.h.

Referenced by fillCommonVariables().

reco::btag::SortCriteria CombinedSVComputer::sortCriterium

private

Definition at line 80 of file CombinedSVComputer.h.

Referenced by fillCommonVariables().

std::vector<reco::btau::TaggingVariableName> CombinedSVComputer::taggingVariables

private

Definition at line 91 of file CombinedSVComputer.h.

bool CombinedSVComputer::trackFlip

private

Definition at line 77 of file CombinedSVComputer.h.

Referenced by flipIterate(), and flipValue().

unsigned int CombinedSVComputer::trackMultiplicityMin

private

Definition at line 85 of file CombinedSVComputer.h.

Referenced by fillCommonVariables().

reco::TrackSelector CombinedSVComputer::trackNoDeltaRSelector

private

Definition at line 82 of file CombinedSVComputer.h.

reco::V0Filter CombinedSVComputer::trackPairV0Filter

private

Definition at line 90 of file CombinedSVComputer.h.

Referenced by fillCommonVariables().

reco::TrackSelector CombinedSVComputer::trackPseudoSelector

private

Definition at line 83 of file CombinedSVComputer.h.

Referenced by fillCommonVariables().

reco::TrackSelector CombinedSVComputer::trackSelector

private

Definition at line 81 of file CombinedSVComputer.h.

Referenced by fillCommonVariables().

bool CombinedSVComputer::useTrackWeights

private

Definition at line 87 of file CombinedSVComputer.h.

Referenced by fillCommonVariables().

bool CombinedSVComputer::vertexFlip

private

Definition at line 78 of file CombinedSVComputer.h.

Referenced by flipIterate(), and flipValue().

bool CombinedSVComputer::vertexMassCorrection

private

Definition at line 88 of file CombinedSVComputer.h.

Referenced by fillCommonVariables().