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
virtual	~CombinedSVComputer ()=default

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 39 of file CombinedSVComputer.h.

Constructor & Destructor Documentation

CombinedSVComputer()

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

explicit

Definition at line 11 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")) {}

~CombinedSVComputer()

virtual CombinedSVComputer::~CombinedSVComputer ( )

virtualdefault

Member Function Documentation

dropDeltaR()

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

inline

Definition at line 5 of file CombinedSVComputer.cc.

References edm::ParameterSet::addParameter(), and muonDTDigis_cfi::pset.

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

fillCommonVariables()

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 91 of file CombinedSVComputer.h.

References reco::TrackKinematics::add(), reco::PFJet::chargedHadronEnergyFraction(), reco::btau::chargedHadronEnergyFraction, pat::Jet::chargedHadronEnergyFraction(), reco::btau::chargedHadronMultiplicity, reco::PFJet::chargedHadronMultiplicity(), pat::Jet::chargedHadronMultiplicity(), data, electronAnalyzer_cfi::DeltaR, PbPb_ZMuSkimMuonDPG_cff::deltaR, DeadROC_duringRun::dir, reco::btau::electronEnergyFraction, reco::PFJet::electronEnergyFraction(), pat::Jet::electronEnergyFraction(), reco::btau::electronMultiplicity, reco::PFJet::electronMultiplicity(), pat::Jet::electronMultiplicity(), reco::btau::etaRel(), reco::btau::flightDistance1dSig, reco::btau::flightDistance1dVal, reco::btau::flightDistance2dSig, reco::btau::flightDistance2dVal, reco::btau::flightDistance3dSig, reco::btau::flightDistance3dVal, flipIterate(), flipValue(), reco::btau::hadronMultiplicity, reco::btau::hadronPhotonMultiplicity, mps_fire::i, heavyIonCSV_trainingSettings::idx, dqmdumpme::indices, reco::btag::IP2DSig, electrons_cff::ip3d, reco::btag::IP3DSig, pat::Jet::isPFJet(), dqmiolumiharvest::j, metsig::jet, reco::btau::jetAbsEta, reco::btau::jetEta, reco::btau::jetNSecondaryVertices, reco::btau::jetNTracks, reco::btau::jetPt, reco::btau::massVertexEnergyFraction, reco::btau::muonEnergyFraction, reco::PFJet::muonEnergyFraction(), pat::Jet::muonEnergyFraction(), reco::btau::muonMultiplicity, reco::PFJet::muonMultiplicity(), pat::Jet::muonMultiplicity(), reco::PFJet::neutralHadronEnergyFraction(), reco::btau::neutralHadronEnergyFraction, pat::Jet::neutralHadronEnergyFraction(), reco::btau::neutralHadronMultiplicity, reco::PFJet::neutralHadronMultiplicity(), pat::Jet::neutralHadronMultiplicity(), reco::btag::Vertices::NoVertex, reco::TrackKinematics::numberOfTracks(), convertSQLiteXML::ok, reco::btau::photonEnergyFraction, reco::PFJet::photonEnergyFraction(), pat::Jet::photonEnergyFraction(), reco::btau::photonMultiplicity, reco::PFJet::photonMultiplicity(), pat::Jet::photonMultiplicity(), reco::ParticleMasses::piPlus, pseudoMultiplicityMin, reco::btag::Vertices::PseudoVertex, pseudoVertexV0Filter, MetAnalyzer::pv(), FastTimerService_cff::range, range_for, reco::btag::Vertices::RecoVertex, sortCriterium, mathSSE::sqrt(), HGCalGeometryMode::Square, threshTrack(), reco::btau::totalMultiplicity, HLT_2023v12_cff::track, 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, DiMuonV_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, reco::TrackKinematics::vectorSum(), reco::btau::vertexBoostOverSqrtJetPt, reco::btau::vertexCategory, reco::btau::vertexEnergyRatio, vertexFlip, reco::btau::vertexJetDeltaR, reco::btau::vertexMass, vertexMassCorrection, reco::btau::vertexNTracks, L1BJetProducer_cff::vtx, and reco::TrackKinematics::weightedVectorSum().

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);
  vars.insert(btau::jetAbsEta, fabs(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::flightDistance1dVal, flipValue(svInfo.flightDistance(vtx, 1).value(), true), true);
    vars.insert(btau::flightDistance1dSig, flipValue(svInfo.flightDistance(vtx, 1).significance(), true), true);
    vars.insert(btau::flightDistance2dVal, flipValue(svInfo.flightDistance(vtx, 2).value(), true), true);
    vars.insert(btau::flightDistance2dSig, flipValue(svInfo.flightDistance(vtx, 2).significance(), true), true);
    vars.insert(btau::flightDistance3dVal, flipValue(svInfo.flightDistance(vtx, 3).value(), true), true);
    vars.insert(btau::flightDistance3dSig, flipValue(svInfo.flightDistance(vtx, 3).significance(), true), true);
    vars.insert(btau::vertexJetDeltaR, Geom::deltaR(svInfo.flightDirection(vtx), vertexFlip ? -jetDir : 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);

    // check for erroneous Perp^2 values before evaluating Perp (fix for DeepCSV NaN outputs)
    double perp_trackMom_jetDir = VectorUtil::Perp2(trackMom, jetDir);
    perp_trackMom_jetDir = (perp_trackMom_jetDir > 0. ? std::sqrt(perp_trackMom_jetDir) : 0.);

    vars.insert(btau::trackPtRel, 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, 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) {
      const 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 != nullptr) {
    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 != nullptr && 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);
  }
}

flipIterate()

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

inline

Definition at line 31 of file CombinedSVComputer.cc.

References FastTimerService_cff::range, findQualityFiles::size, trackFlip, bphysicsOniaDQM_cfi::vertex, 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;
}

flipValue()

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

inline

Definition at line 27 of file CombinedSVComputer.cc.

References trackFlip, relativeConstraints::value, bphysicsOniaDQM_cfi::vertex, and vertexFlip.

Referenced by fillCommonVariables().

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

operator()() [1/2]

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

virtual

Definition at line 133 of file CombinedSVComputer.cc.

References reco::TrackKinematics::add(), reco::btau::etaRel(), fillCommonVariables(), flipIterate(), mps_fire::i, metsig::jet, minTrackWeight, reco::TrackBase::momentum(), TrackCollections2monitor_cff::normalizedChi2, beamSpotPI::nTracks, reco::TemplatedSecondaryVertexTagInfo< IPTI, VTX >::nVertices(), reco::ParticleMasses::piPlus, FastTimerService_cff::range, range_for, reco::TemplatedSecondaryVertexTagInfo< IPTI, VTX >::secondaryVertex(), mathSSE::sqrt(), HGCalGeometryMode::Square, HLT_2023v12_cff::track, reco::btau::trackEtaRel, bphysicsOniaDQM_cfi::vertex, reco::btau::vertexFitProb, reco::btau::vertexNTracks, L1BJetProducer_cff::vtx, 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;
}

operator()() [2/2]

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

virtual

Definition at line 195 of file CombinedSVComputer.cc.

References reco::TrackKinematics::add(), reco::btau::etaRel(), fillCommonVariables(), flipIterate(), mps_fire::i, metsig::jet, reco::TemplatedSecondaryVertexTagInfo< IPTI, VTX >::nVertices(), reco::ParticleMasses::piPlus, FastTimerService_cff::range, range_for, reco::TemplatedSecondaryVertexTagInfo< IPTI, VTX >::secondaryVertex(), mathSSE::sqrt(), HGCalGeometryMode::Square, HLT_2023v12_cff::track, reco::btau::trackEtaRel, DiMuonV_cfg::tracks, bphysicsOniaDQM_cfi::vertex, reco::btau::vertexFitProb, reco::btau::vertexNTracks, and L1BJetProducer_cff::vtx.

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

threshTrack() [1/2]

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().

threshTrack() [2/2]

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

charmCut

double CombinedSVComputer::charmCut

private

Definition at line 75 of file CombinedSVComputer.h.

minTrackWeight

double CombinedSVComputer::minTrackWeight

private

Definition at line 82 of file CombinedSVComputer.h.

Referenced by operator()().

pseudoMultiplicityMin

unsigned int CombinedSVComputer::pseudoMultiplicityMin

private

Definition at line 80 of file CombinedSVComputer.h.

Referenced by fillCommonVariables().

pseudoVertexV0Filter

reco::V0Filter CombinedSVComputer::pseudoVertexV0Filter

private

Definition at line 85 of file CombinedSVComputer.h.

Referenced by fillCommonVariables().

sortCriterium

reco::btag::SortCriteria CombinedSVComputer::sortCriterium

private

Definition at line 76 of file CombinedSVComputer.h.

Referenced by fillCommonVariables().

taggingVariables

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

private

Definition at line 87 of file CombinedSVComputer.h.

trackFlip

bool CombinedSVComputer::trackFlip

private

Definition at line 73 of file CombinedSVComputer.h.

Referenced by flipIterate(), and flipValue().

trackMultiplicityMin

unsigned int CombinedSVComputer::trackMultiplicityMin

private

Definition at line 81 of file CombinedSVComputer.h.

Referenced by fillCommonVariables().

trackNoDeltaRSelector

reco::TrackSelector CombinedSVComputer::trackNoDeltaRSelector

private

Definition at line 78 of file CombinedSVComputer.h.

trackPairV0Filter

reco::V0Filter CombinedSVComputer::trackPairV0Filter

private

Definition at line 86 of file CombinedSVComputer.h.

Referenced by fillCommonVariables().

trackPseudoSelector

reco::TrackSelector CombinedSVComputer::trackPseudoSelector

private

Definition at line 79 of file CombinedSVComputer.h.

Referenced by fillCommonVariables().

trackSelector

reco::TrackSelector CombinedSVComputer::trackSelector

private

Definition at line 77 of file CombinedSVComputer.h.

Referenced by fillCommonVariables().

useTrackWeights

bool CombinedSVComputer::useTrackWeights

private

Definition at line 83 of file CombinedSVComputer.h.

Referenced by fillCommonVariables().

vertexFlip

bool CombinedSVComputer::vertexFlip

private

Definition at line 74 of file CombinedSVComputer.h.

Referenced by fillCommonVariables(), flipIterate(), and flipValue().

vertexMassCorrection

bool CombinedSVComputer::vertexMassCorrection

private

Definition at line 84 of file CombinedSVComputer.h.

Referenced by fillCommonVariables().