#include <RecoBTag/SecondaryVertex/plugins/BoostedDoubleSVProducer.cc>

Inheritance diagram for BoostedDoubleSVProducer:

Public Member Functions
	BoostedDoubleSVProducer (const edm::ParameterSet &)

	~BoostedDoubleSVProducer () override

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

Private Member Functions
void	beginStream (edm::StreamID) override

void	calcNsubjettiness (const reco::JetBaseRef &jet, float &tau1, float &tau2, std::vector< fastjet::PseudoJet > &currentAxes) const

void	endStream () override

void	etaRelToTauAxis (const reco::VertexCompositePtrCandidate &vertex, const fastjet::PseudoJet &tauAxis, std::vector< float > &tau_trackEtaRel) const

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

void	setTracksPV (const reco::CandidatePtr &trackRef, const reco::VertexRef &vertexRef, float &PVweight) const

void	setTracksPVBase (const reco::TrackRef &trackRef, const reco::VertexRef &vertexRef, float &PVweight) const

Private Attributes
const double	beta_

const double	maxDecayLen_

const double	maxDistToAxis_

const double	maxSVDeltaRToJet_

const double	R0_

const edm::EDGetTokenT < std::vector < reco::CandSecondaryVertexTagInfo > >	svTagInfos_

edm::ESGetToken < TransientTrackBuilder, TransientTrackRecord >	trackBuilderToken_

reco::V0Filter	trackPairV0Filter

reco::TrackSelector	trackSelector

edm::Handle< edm::ValueMap < float > >	weightsHandle_

edm::EDGetTokenT < edm::ValueMap< float > >	weightsToken_

Static Private Attributes
static constexpr float	bottomThreshold = 5.2f

static constexpr float	charmThreshold = 1.5f

static constexpr float	dummyFlightDistance2dSig = -1.0f

static constexpr float	dummyTrackEtaRel = -1.0f

static constexpr float	dummyTrackSip2dSigAbove = -19.0f

static constexpr float	dummyTrackSip3dSig = -50.0f

static constexpr float	dummyVertexDeltaR = -1.0f

static constexpr float	dummyVertexEnergyRatio = -1.0f

static constexpr float	dummyVertexMass = -1.0f

static constexpr float	dummyZ_ratio = -3.0f

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
using	CacheTypes = CacheContexts< T...>

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T...>

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Detailed Description

Description: EDProducer that produces collection of BoostedDoubleSVTagInfos

Implementation: A collection of SecondaryVertexTagInfos is taken as input and a collection of BoostedDoubleSVTagInfos is produced as output.

Definition at line 62 of file BoostedDoubleSVProducer.cc.

Constructor & Destructor Documentation

BoostedDoubleSVProducer::BoostedDoubleSVProducer ( const edm::ParameterSet & iConfig )

explicit

Definition at line 125 of file BoostedDoubleSVProducer.cc.

References edm::ParameterSet::getParameter(), edm::InputTag::label(), HLT_FULL_cff::srcWeights, trackBuilderToken_, and weightsToken_.

     : svTagInfos_(
           consumes<std::vector<reco::CandSecondaryVertexTagInfo>>(iConfig.getParameter<edm::InputTag>("svTagInfos"))),
       beta_(iConfig.getParameter<double>("beta")),
       R0_(iConfig.getParameter<double>("R0")),
       maxSVDeltaRToJet_(iConfig.getParameter<double>("maxSVDeltaRToJet")),
       maxDistToAxis_(iConfig.getParameter<edm::ParameterSet>("trackSelection").getParameter<double>("maxDistToAxis")),
       maxDecayLen_(iConfig.getParameter<edm::ParameterSet>("trackSelection").getParameter<double>("maxDecayLen")),
       trackPairV0Filter(iConfig.getParameter<edm::ParameterSet>("trackPairV0Filter")),
       trackSelector(iConfig.getParameter<edm::ParameterSet>("trackSelection")) {
   edm::InputTag srcWeights = iConfig.getParameter<edm::InputTag>("weights");
   trackBuilderToken_ =
       esConsumes<TransientTrackBuilder, TransientTrackRecord>(edm::ESInputTag("", "TransientTrackBuilder"));
   if (!srcWeights.label().empty())
     weightsToken_ = consumes<edm::ValueMap<float>>(srcWeights);
   produces<std::vector<reco::BoostedDoubleSVTagInfo>>();
 }

BoostedDoubleSVProducer::~BoostedDoubleSVProducer ( )

override

Definition at line 143 of file BoostedDoubleSVProducer.cc.

                                                   {
   // do anything here that needs to be done at destruction time
   // (e.g. close files, deallocate resources etc.)
 }

Member Function Documentation

void BoostedDoubleSVProducer::beginStream ( edm::StreamID )

overrideprivate

Definition at line 776 of file BoostedDoubleSVProducer.cc.

776 {}

void BoostedDoubleSVProducer::calcNsubjettiness	(	const reco::JetBaseRef &	jet,
		float &	tau1,
		float &	tau2,
		std::vector< fastjet::PseudoJet > &	currentAxes
	)		const

private

Definition at line 649 of file BoostedDoubleSVProducer.cc.

References beta_, reco::CompositePtrCandidate::daughterPtr(), Exception, mps_fire::i, edm::Ptr< T >::isNonnull(), edm::isNotFinite(), edm::EDGetTokenT< T >::isUninitialized(), reco::Jet::isWeighted(), nJettinessAdder_cfi::Njettiness, reco::CompositePtrCandidate::numberOfDaughters(), R0_, w, weightsHandle_, and weightsToken_.

Referenced by produce().

                                                                                                 {
   std::vector<fastjet::PseudoJet> fjParticles;
 
   // loop over jet constituents and push them in the vector of FastJet constituents
   for (const reco::CandidatePtr& daughter : jet->daughterPtrVector()) {
     if (daughter.isNonnull() && daughter.isAvailable()) {
       const reco::Jet* subjet = dynamic_cast<const reco::Jet*>(daughter.get());
       // if the daughter is actually a subjet
       if (subjet && daughter->numberOfDaughters() > 1) {
         // loop over subjet constituents and push them in the vector of FastJet constituents
         for (size_t i = 0; i < daughter->numberOfDaughters(); ++i) {
           const reco::CandidatePtr& constit = subjet->daughterPtr(i);
 
           if (constit.isNonnull()) {
             // Check if any values were nan or inf
             float valcheck = constit->px() + constit->py() + constit->pz() + constit->energy();
             if (edm::isNotFinite(valcheck)) {
               edm::LogWarning("FaultyJetConstituent")
                   << "Jet constituent required for N-subjettiness computation contains Nan/Inf values!";
               continue;
             }
             if (subjet->isWeighted()) {
               float w = 0.0;
               if (!weightsToken_.isUninitialized())
                 w = (*weightsHandle_)[constit];
               else {
                 throw cms::Exception("MissingConstituentWeight")
                     << "BoostedDoubleSVProducer: No weights (e.g. PUPPI) given for weighted jet collection"
                     << std::endl;
               }
               fjParticles.push_back(
                   fastjet::PseudoJet(constit->px() * w, constit->py() * w, constit->pz() * w, constit->energy() * w));
             } else
               fjParticles.push_back(fastjet::PseudoJet(constit->px(), constit->py(), constit->pz(), constit->energy()));
           } else
             edm::LogWarning("MissingJetConstituent")
                 << "Jet constituent required for N-subjettiness computation is missing!";
         }
       } else {
         // Check if any values were nan or inf
         float valcheck = daughter->px() + daughter->py() + daughter->pz() + daughter->energy();
         if (edm::isNotFinite(valcheck)) {
           edm::LogWarning("FaultyJetConstituent")
               << "Jet constituent required for N-subjettiness computation contains Nan/Inf values!";
           continue;
         }
         if (jet->isWeighted()) {
           float w = 0.0;
           if (!weightsToken_.isUninitialized())
             w = (*weightsHandle_)[daughter];
           else {
             throw cms::Exception("MissingConstituentWeight")
                 << "BoostedDoubleSVProducer: No weights (e.g. PUPPI) given for weighted jet collection" << std::endl;
           }
           fjParticles.push_back(
               fastjet::PseudoJet(daughter->px() * w, daughter->py() * w, daughter->pz() * w, daughter->energy() * w));
         } else
           fjParticles.push_back(fastjet::PseudoJet(daughter->px(), daughter->py(), daughter->pz(), daughter->energy()));
       }
     } else
       edm::LogWarning("MissingJetConstituent") << "Jet constituent required for N-subjettiness computation is missing!";
   }
 
   // N-subjettiness calculator
   fastjet::contrib::Njettiness njettiness(fastjet::contrib::OnePass_KT_Axes(),
                                           fastjet::contrib::NormalizedMeasure(beta_, R0_));
 
   // calculate N-subjettiness
   tau1 = njettiness.getTau(1, fjParticles);
   tau2 = njettiness.getTau(2, fjParticles);
   currentAxes = njettiness.currentAxes();
 }

void BoostedDoubleSVProducer::endStream ( )

overrideprivate

Definition at line 779 of file BoostedDoubleSVProducer.cc.

779 {}

void BoostedDoubleSVProducer::etaRelToTauAxis	(	const reco::VertexCompositePtrCandidate &	vertex,
		const fastjet::PseudoJet &	tauAxis,
		std::vector< float > &	tau_trackEtaRel
	)		const

private

Definition at line 765 of file BoostedDoubleSVProducer.cc.

References funct::abs(), reco::CompositePtrCandidate::daughterPtrVector(), reco::btau::etaRel(), HLT_FULL_cff::track, and tracks.

Referenced by produce().

                                                                                        {
   math::XYZVector direction(tauAxis.px(), tauAxis.py(), tauAxis.pz());
   const std::vector<reco::CandidatePtr>& tracks = vertex.daughterPtrVector();
 
   for (std::vector<reco::CandidatePtr>::const_iterator track = tracks.begin(); track != tracks.end(); ++track)
     tau_trackEtaRel.push_back(std::abs(reco::btau::etaRel(direction.Unit(), (*track)->momentum())));
 }

void BoostedDoubleSVProducer::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 782 of file BoostedDoubleSVProducer.cc.

References edm::ParameterSetDescription::add(), edm::ConfigurationDescriptions::addDefault(), submitPVResolutionJobs::desc, HLT_FULL_cff::InputTag, edm::ParameterSetDescription::setAllowAnything(), trackPairV0Filter, and HLT_FULL_cff::trackSelection.

                                                                                          {
   edm::ParameterSetDescription desc;
   desc.add<double>("beta", 1.0);
   desc.add<double>("R0", 0.8);
   desc.add<double>("maxSVDeltaRToJet", 0.7);
   {
     edm::ParameterSetDescription trackSelection;
     trackSelection.setAllowAnything();
     desc.add<edm::ParameterSetDescription>("trackSelection", trackSelection);
   }
   {
     edm::ParameterSetDescription trackPairV0Filter;
     trackPairV0Filter.add<double>("k0sMassWindow", 0.03);
     desc.add<edm::ParameterSetDescription>("trackPairV0Filter", trackPairV0Filter);
   }
   desc.add<edm::InputTag>("svTagInfos", edm::InputTag("pfInclusiveSecondaryVertexFinderAK8TagInfos"));
   desc.add<edm::InputTag>("weights", edm::InputTag(""));
   descriptions.addDefault(desc);
 }

void BoostedDoubleSVProducer::produce	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overrideprivate

Definition at line 153 of file BoostedDoubleSVProducer.cc.

References funct::abs(), reco::TrackKinematics::add(), bottomThreshold, calcNsubjettiness(), charmThreshold, IPTools::closestApproachToJet(), generateEDF::cont, RecoVertex::convertPos(), data, reco::deltaR(), reco::deltaR2(), dummyFlightDistance2dSig, dummyTrackEtaRel, dummyTrackSip2dSigAbove, dummyTrackSip3dSig, dummyVertexDeltaR, dummyVertexEnergyRatio, dummyVertexMass, dummyZ_ratio, Measurement1D::error(), etaRelToTauAxis(), reco::TransientTrack::field(), reco::TaggingVariableList::finalize(), reco::TemplatedSecondaryVertexTagInfo< IPTI, VTX >::flightDirection(), reco::TemplatedSecondaryVertexTagInfo< IPTI, VTX >::flightDistance(), edm::Event::getByToken(), edm::EventSetup::getHandle(), TrajectoryStateOnSurface::globalPosition(), mps_fire::i, reco::IPTagInfo< Container, Base >::impactParameterData(), reco::TransientTrack::impactPointState(), dqmdumpme::indices, reco::TaggingVariableList::insert(), reco::btag::TrackIPData::ip2d, reco::btag::IP2DSig, edm::Ref< C, T, F >::isNonnull(), isSelected(), edm::EDGetTokenT< T >::isUninitialized(), TrajectoryStateOnSurface::isValid(), metsig::jet, reco::TemplatedSecondaryVertexTagInfo< IPTI, VTX >::jet(), reco::btau::jetNSecondaryVertices, reco::btau::jetNTracks, IPTools::jetTrackDistance(), ResonanceBuilder::mass, maxDecayLen_, maxDistToAxis_, maxSVDeltaRToJet_, eostools::move(), reco::TemplatedSecondaryVertexTagInfo< IPTI, VTX >::nVertices(), reco::LeafCandidate::p4(), reco::IPTagInfo< Container, Base >::primaryVertex(), edm::Event::put(), MetAnalyzer::pv(), edm::second(), reco::TemplatedSecondaryVertexTagInfo< IPTI, VTX >::secondaryVertex(), TrackCollections2monitor_cff::selectedTracks, reco::IPTagInfo< Container, Base >::selectedTracks(), setTracksPV(), Measurement1D::significance(), reco::IPTagInfo< Container, Base >::sortedIndexes(), HLT_FULL_cff::svTagInfos, svTagInfos_, HLT_FULL_cff::tagInfos, reco::btau::tau1_flightDistance2dSig, reco::btau::tau1_trackEtaRel_0, reco::btau::tau1_trackEtaRel_1, reco::btau::tau1_trackEtaRel_2, reco::btau::tau1_trackSip3dSig_0, reco::btau::tau1_trackSip3dSig_1, reco::btau::tau1_vertexDeltaR, reco::btau::tau1_vertexEnergyRatio, reco::btau::tau1_vertexMass, reco::btau::tau2_flightDistance2dSig, reco::btau::tau2_trackEtaRel_0, reco::btau::tau2_trackEtaRel_1, reco::btau::tau2_trackEtaRel_2, reco::btau::tau2_trackSip3dSig_0, reco::btau::tau2_trackSip3dSig_1, reco::btau::tau2_vertexDeltaR, reco::btau::tau2_vertexEnergyRatio, reco::btau::tau2_vertexMass, groupFilesInBlocks::temp, trackBuilderToken_, trackPairV0Filter, trackSelector, reco::btau::trackSip2dSigAboveBottom_0, reco::btau::trackSip2dSigAboveBottom_1, reco::btau::trackSip2dSigAboveCharm, reco::btau::trackSip3dSig_0, reco::btau::trackSip3dSig_1, reco::btau::trackSip3dSig_2, reco::btau::trackSip3dSig_3, reco::TrackKinematics::vectorSum(), reco::TrackKinematics::weightedVectorSum(), weightsHandle_, weightsToken_, and reco::btau::z_ratio.

                                                                                    {
   // get the track builder
   edm::ESHandle<TransientTrackBuilder> trackBuilder = iSetup.getHandle(trackBuilderToken_);
 
   // get input secondary vertex TagInfos
   edm::Handle<std::vector<reco::CandSecondaryVertexTagInfo>> svTagInfos;
   iEvent.getByToken(svTagInfos_, svTagInfos);
 
   if (!weightsToken_.isUninitialized())
     iEvent.getByToken(weightsToken_, weightsHandle_);
 
   // create the output collection
   auto tagInfos = std::make_unique<std::vector<reco::BoostedDoubleSVTagInfo>>();
 
   // loop over TagInfos
   for (std::vector<reco::CandSecondaryVertexTagInfo>::const_iterator iterTI = svTagInfos->begin();
        iterTI != svTagInfos->end();
        ++iterTI) {
     // get TagInfos
     const reco::CandIPTagInfo& ipTagInfo = *(iterTI->trackIPTagInfoRef().get());
     const reco::CandSecondaryVertexTagInfo& svTagInfo = *(iterTI);
 
     // default variable values
     float z_ratio = dummyZ_ratio;
     float trackSip3dSig_3 = dummyTrackSip3dSig, trackSip3dSig_2 = dummyTrackSip3dSig,
           trackSip3dSig_1 = dummyTrackSip3dSig, trackSip3dSig_0 = dummyTrackSip3dSig;
     float tau2_trackSip3dSig_0 = dummyTrackSip3dSig, tau1_trackSip3dSig_0 = dummyTrackSip3dSig,
           tau2_trackSip3dSig_1 = dummyTrackSip3dSig, tau1_trackSip3dSig_1 = dummyTrackSip3dSig;
     float trackSip2dSigAboveCharm_0 = dummyTrackSip2dSigAbove, trackSip2dSigAboveBottom_0 = dummyTrackSip2dSigAbove,
           trackSip2dSigAboveBottom_1 = dummyTrackSip2dSigAbove;
     float tau1_trackEtaRel_0 = dummyTrackEtaRel, tau1_trackEtaRel_1 = dummyTrackEtaRel,
           tau1_trackEtaRel_2 = dummyTrackEtaRel;
     float tau2_trackEtaRel_0 = dummyTrackEtaRel, tau2_trackEtaRel_1 = dummyTrackEtaRel,
           tau2_trackEtaRel_2 = dummyTrackEtaRel;
     float tau1_vertexMass = dummyVertexMass, tau1_vertexEnergyRatio = dummyVertexEnergyRatio,
           tau1_vertexDeltaR = dummyVertexDeltaR, tau1_flightDistance2dSig = dummyFlightDistance2dSig;
     float tau2_vertexMass = dummyVertexMass, tau2_vertexEnergyRatio = dummyVertexEnergyRatio,
           tau2_vertexDeltaR = dummyVertexDeltaR, tau2_flightDistance2dSig = dummyFlightDistance2dSig;
     float jetNTracks = 0, nSV = 0, tau1_nSecondaryVertices = 0, tau2_nSecondaryVertices = 0;
 
     // get the jet reference
     const reco::JetBaseRef jet = svTagInfo.jet();
 
     std::vector<fastjet::PseudoJet> currentAxes;
     float tau2, tau1;
     // calculate N-subjettiness
     calcNsubjettiness(jet, tau1, tau2, currentAxes);
 
     const reco::VertexRef& vertexRef = ipTagInfo.primaryVertex();
     GlobalPoint pv(0., 0., 0.);
     if (ipTagInfo.primaryVertex().isNonnull())
       pv = GlobalPoint(vertexRef->x(), vertexRef->y(), vertexRef->z());
 
     const std::vector<reco::CandidatePtr>& selectedTracks = ipTagInfo.selectedTracks();
     const std::vector<reco::btag::TrackIPData>& ipData = ipTagInfo.impactParameterData();
     size_t trackSize = selectedTracks.size();
 
     reco::TrackKinematics allKinematics;
     std::vector<float> IP3Ds, IP3Ds_1, IP3Ds_2;
     int contTrk = 0;
 
     // loop over tracks associated to the jet
     for (size_t itt = 0; itt < trackSize; ++itt) {
       const reco::CandidatePtr trackRef = selectedTracks[itt];
 
       float track_PVweight = 0.;
       setTracksPV(trackRef, vertexRef, track_PVweight);
       if (track_PVweight > 0.5)
         allKinematics.add(trackRef);
 
       const reco::btag::TrackIPData& data = ipData[itt];
       bool isSelected = false;
       if (trackSelector(trackRef, data, *jet, pv))
         isSelected = true;
 
       // check if the track is from V0
       bool isfromV0 = false, isfromV0Tight = false;
       std::vector<reco::CandidatePtr> trackPairV0Test(2);
 
       trackPairV0Test[0] = trackRef;
 
       for (size_t jtt = 0; jtt < trackSize; ++jtt) {
         if (itt == jtt)
           continue;
 
         const reco::btag::TrackIPData& pairTrackData = ipData[jtt];
         const reco::CandidatePtr pairTrackRef = selectedTracks[jtt];
 
         trackPairV0Test[1] = pairTrackRef;
 
         if (!trackPairV0Filter(trackPairV0Test)) {
           isfromV0 = true;
 
           if (trackSelector(pairTrackRef, pairTrackData, *jet, pv))
             isfromV0Tight = true;
         }
 
         if (isfromV0 && isfromV0Tight)
           break;
       }
 
       if (isSelected && !isfromV0Tight)
         jetNTracks += 1.;
 
       reco::TransientTrack transientTrack = trackBuilder->build(trackRef);
       GlobalVector direction(jet->px(), jet->py(), jet->pz());
 
       int index = 0;
       if (currentAxes.size() > 1 &&
           reco::deltaR2(trackRef->momentum(), currentAxes[1]) < reco::deltaR2(trackRef->momentum(), currentAxes[0]))
         index = 1;
       direction = GlobalVector(currentAxes[index].px(), currentAxes[index].py(), currentAxes[index].pz());
 
       // decay distance and track distance wrt to the closest tau axis
       float decayLengthTau = -1;
       float distTauAxis = -1;
 
       TrajectoryStateOnSurface closest = IPTools::closestApproachToJet(
           transientTrack.impactPointState(), *vertexRef, direction, transientTrack.field());
       if (closest.isValid())
         decayLengthTau = (closest.globalPosition() - RecoVertex::convertPos(vertexRef->position())).mag();
 
       distTauAxis = std::abs(IPTools::jetTrackDistance(transientTrack, direction, *vertexRef).second.value());
 
       float IP3Dsig = ipTagInfo.impactParameterData()[itt].ip3d.significance();
 
       if (!isfromV0 && decayLengthTau < maxDecayLen_ && distTauAxis < maxDistToAxis_) {
         IP3Ds.push_back(IP3Dsig < -50. ? -50. : IP3Dsig);
         ++contTrk;
         if (currentAxes.size() > 1) {
           if (reco::deltaR2(trackRef->momentum(), currentAxes[0]) < reco::deltaR2(trackRef->momentum(), currentAxes[1]))
             IP3Ds_1.push_back(IP3Dsig < -50. ? -50. : IP3Dsig);
           else
             IP3Ds_2.push_back(IP3Dsig < -50. ? -50. : IP3Dsig);
         } else
           IP3Ds_1.push_back(IP3Dsig < -50. ? -50. : IP3Dsig);
       }
     }
 
     std::vector<size_t> indices = ipTagInfo.sortedIndexes(reco::btag::IP2DSig);
     bool charmThreshSet = false;
 
     reco::TrackKinematics kin;
     for (size_t i = 0; i < indices.size(); ++i) {
       size_t idx = indices[i];
       const reco::btag::TrackIPData& data = ipData[idx];
       const reco::CandidatePtr trackRef = selectedTracks[idx];
 
       kin.add(trackRef);
 
       if (kin.vectorSum().M() > charmThreshold  // charm cut
           && !charmThreshSet) {
         trackSip2dSigAboveCharm_0 = data.ip2d.significance();
 
         charmThreshSet = true;
       }
 
       if (kin.vectorSum().M() > bottomThreshold)  // bottom cut
       {
         trackSip2dSigAboveBottom_0 = data.ip2d.significance();
         if ((i + 1) < indices.size())
           trackSip2dSigAboveBottom_1 = (ipData[indices[i + 1]]).ip2d.significance();
 
         break;
       }
     }
 
     float dummyTrack = -50.;
 
     std::sort(IP3Ds.begin(), IP3Ds.end(), std::greater<float>());
     std::sort(IP3Ds_1.begin(), IP3Ds_1.end(), std::greater<float>());
     std::sort(IP3Ds_2.begin(), IP3Ds_2.end(), std::greater<float>());
     int num_1 = IP3Ds_1.size();
     int num_2 = IP3Ds_2.size();
 
     switch (contTrk) {
       case 0:
 
         trackSip3dSig_0 = dummyTrack;
         trackSip3dSig_1 = dummyTrack;
         trackSip3dSig_2 = dummyTrack;
         trackSip3dSig_3 = dummyTrack;
 
         break;
 
       case 1:
 
         trackSip3dSig_0 = IP3Ds.at(0);
         trackSip3dSig_1 = dummyTrack;
         trackSip3dSig_2 = dummyTrack;
         trackSip3dSig_3 = dummyTrack;
 
         break;
 
       case 2:
 
         trackSip3dSig_0 = IP3Ds.at(0);
         trackSip3dSig_1 = IP3Ds.at(1);
         trackSip3dSig_2 = dummyTrack;
         trackSip3dSig_3 = dummyTrack;
 
         break;
 
       case 3:
 
         trackSip3dSig_0 = IP3Ds.at(0);
         trackSip3dSig_1 = IP3Ds.at(1);
         trackSip3dSig_2 = IP3Ds.at(2);
         trackSip3dSig_3 = dummyTrack;
 
         break;
 
       default:
 
         trackSip3dSig_0 = IP3Ds.at(0);
         trackSip3dSig_1 = IP3Ds.at(1);
         trackSip3dSig_2 = IP3Ds.at(2);
         trackSip3dSig_3 = IP3Ds.at(3);
     }
 
     switch (num_1) {
       case 0:
 
         tau1_trackSip3dSig_0 = dummyTrack;
         tau1_trackSip3dSig_1 = dummyTrack;
 
         break;
 
       case 1:
 
         tau1_trackSip3dSig_0 = IP3Ds_1.at(0);
         tau1_trackSip3dSig_1 = dummyTrack;
 
         break;
 
       default:
 
         tau1_trackSip3dSig_0 = IP3Ds_1.at(0);
         tau1_trackSip3dSig_1 = IP3Ds_1.at(1);
     }
 
     switch (num_2) {
       case 0:
 
         tau2_trackSip3dSig_0 = dummyTrack;
         tau2_trackSip3dSig_1 = dummyTrack;
 
         break;
 
       case 1:
         tau2_trackSip3dSig_0 = IP3Ds_2.at(0);
         tau2_trackSip3dSig_1 = dummyTrack;
 
         break;
 
       default:
 
         tau2_trackSip3dSig_0 = IP3Ds_2.at(0);
         tau2_trackSip3dSig_1 = IP3Ds_2.at(1);
     }
 
     math::XYZVector jetDir = jet->momentum().Unit();
     reco::TrackKinematics tau1Kinematics;
     reco::TrackKinematics tau2Kinematics;
     std::vector<float> tau1_trackEtaRels, tau2_trackEtaRels;
 
     std::map<double, size_t> VTXmap;
     for (size_t vtx = 0; vtx < svTagInfo.nVertices(); ++vtx) {
       const reco::VertexCompositePtrCandidate& vertex = svTagInfo.secondaryVertex(vtx);
       // get the vertex kinematics
       reco::TrackKinematics vertexKinematic(vertex);
 
       if (currentAxes.size() > 1) {
         if (reco::deltaR2(svTagInfo.flightDirection(vtx), currentAxes[1]) <
             reco::deltaR2(svTagInfo.flightDirection(vtx), currentAxes[0])) {
           tau2Kinematics = tau2Kinematics + vertexKinematic;
           if (tau2_flightDistance2dSig < 0) {
             tau2_flightDistance2dSig = svTagInfo.flightDistance(vtx, true).significance();
             tau2_vertexDeltaR = reco::deltaR(svTagInfo.flightDirection(vtx), currentAxes[1]);
           }
           etaRelToTauAxis(vertex, currentAxes[1], tau2_trackEtaRels);
           tau2_nSecondaryVertices += 1.;
         } else {
           tau1Kinematics = tau1Kinematics + vertexKinematic;
           if (tau1_flightDistance2dSig < 0) {
             tau1_flightDistance2dSig = svTagInfo.flightDistance(vtx, true).significance();
             tau1_vertexDeltaR = reco::deltaR(svTagInfo.flightDirection(vtx), currentAxes[0]);
           }
           etaRelToTauAxis(vertex, currentAxes[0], tau1_trackEtaRels);
           tau1_nSecondaryVertices += 1.;
         }
 
       } else if (!currentAxes.empty()) {
         tau1Kinematics = tau1Kinematics + vertexKinematic;
         if (tau1_flightDistance2dSig < 0) {
           tau1_flightDistance2dSig = svTagInfo.flightDistance(vtx, true).significance();
           tau1_vertexDeltaR = reco::deltaR(svTagInfo.flightDirection(vtx), currentAxes[0]);
         }
         etaRelToTauAxis(vertex, currentAxes[0], tau1_trackEtaRels);
         tau1_nSecondaryVertices += 1.;
       }
 
       const GlobalVector& flightDir = svTagInfo.flightDirection(vtx);
       if (reco::deltaR2(flightDir, jetDir) < (maxSVDeltaRToJet_ * maxSVDeltaRToJet_))
         VTXmap[svTagInfo.flightDistance(vtx).error()] = vtx;
     }
     nSV = VTXmap.size();
 
     math::XYZTLorentzVector allSum = allKinematics.weightedVectorSum();
     if (tau1_nSecondaryVertices > 0.) {
       const math::XYZTLorentzVector& tau1_vertexSum = tau1Kinematics.weightedVectorSum();
       if (allSum.E() > 0.)
         tau1_vertexEnergyRatio = tau1_vertexSum.E() / allSum.E();
       if (tau1_vertexEnergyRatio > 50.)
         tau1_vertexEnergyRatio = 50.;
 
       tau1_vertexMass = tau1_vertexSum.M();
     }
 
     if (tau2_nSecondaryVertices > 0.) {
       const math::XYZTLorentzVector& tau2_vertexSum = tau2Kinematics.weightedVectorSum();
       if (allSum.E() > 0.)
         tau2_vertexEnergyRatio = tau2_vertexSum.E() / allSum.E();
       if (tau2_vertexEnergyRatio > 50.)
         tau2_vertexEnergyRatio = 50.;
 
       tau2_vertexMass = tau2_vertexSum.M();
     }
 
     float dummyEtaRel = -1.;
 
     std::sort(tau1_trackEtaRels.begin(), tau1_trackEtaRels.end());
     std::sort(tau2_trackEtaRels.begin(), tau2_trackEtaRels.end());
 
     switch (tau2_trackEtaRels.size()) {
       case 0:
 
         tau2_trackEtaRel_0 = dummyEtaRel;
         tau2_trackEtaRel_1 = dummyEtaRel;
         tau2_trackEtaRel_2 = dummyEtaRel;
 
         break;
 
       case 1:
 
         tau2_trackEtaRel_0 = tau2_trackEtaRels.at(0);
         tau2_trackEtaRel_1 = dummyEtaRel;
         tau2_trackEtaRel_2 = dummyEtaRel;
 
         break;
 
       case 2:
 
         tau2_trackEtaRel_0 = tau2_trackEtaRels.at(0);
         tau2_trackEtaRel_1 = tau2_trackEtaRels.at(1);
         tau2_trackEtaRel_2 = dummyEtaRel;
 
         break;
 
       default:
 
         tau2_trackEtaRel_0 = tau2_trackEtaRels.at(0);
         tau2_trackEtaRel_1 = tau2_trackEtaRels.at(1);
         tau2_trackEtaRel_2 = tau2_trackEtaRels.at(2);
     }
 
     switch (tau1_trackEtaRels.size()) {
       case 0:
 
         tau1_trackEtaRel_0 = dummyEtaRel;
         tau1_trackEtaRel_1 = dummyEtaRel;
         tau1_trackEtaRel_2 = dummyEtaRel;
 
         break;
 
       case 1:
 
         tau1_trackEtaRel_0 = tau1_trackEtaRels.at(0);
         tau1_trackEtaRel_1 = dummyEtaRel;
         tau1_trackEtaRel_2 = dummyEtaRel;
 
         break;
 
       case 2:
 
         tau1_trackEtaRel_0 = tau1_trackEtaRels.at(0);
         tau1_trackEtaRel_1 = tau1_trackEtaRels.at(1);
         tau1_trackEtaRel_2 = dummyEtaRel;
 
         break;
 
       default:
 
         tau1_trackEtaRel_0 = tau1_trackEtaRels.at(0);
         tau1_trackEtaRel_1 = tau1_trackEtaRels.at(1);
         tau1_trackEtaRel_2 = tau1_trackEtaRels.at(2);
     }
 
     int cont = 0;
     GlobalVector flightDir_0, flightDir_1;
     reco::Candidate::LorentzVector SV_p4_0, SV_p4_1;
     double vtxMass = 0.;
 
     for (std::map<double, size_t>::iterator iVtx = VTXmap.begin(); iVtx != VTXmap.end(); ++iVtx) {
       ++cont;
       const reco::VertexCompositePtrCandidate& vertex = svTagInfo.secondaryVertex(iVtx->second);
       if (cont == 1) {
         flightDir_0 = svTagInfo.flightDirection(iVtx->second);
         SV_p4_0 = vertex.p4();
         vtxMass = SV_p4_0.mass();
 
         if (vtxMass > 0.)
           z_ratio = reco::deltaR(currentAxes[1], currentAxes[0]) * SV_p4_0.pt() / vtxMass;
       }
       if (cont == 2) {
         flightDir_1 = svTagInfo.flightDirection(iVtx->second);
         SV_p4_1 = vertex.p4();
         vtxMass = (SV_p4_1 + SV_p4_0).mass();
 
         if (vtxMass > 0.)
           z_ratio = reco::deltaR(flightDir_0, flightDir_1) * SV_p4_1.pt() / vtxMass;
 
         break;
       }
     }
 
     // when only one tau axis has SVs assigned, they are all assigned to the 1st tau axis
     // in the special case below need to swap values
     if ((tau1_vertexMass < 0 && tau2_vertexMass > 0)) {
       float temp = tau1_trackEtaRel_0;
       tau1_trackEtaRel_0 = tau2_trackEtaRel_0;
       tau2_trackEtaRel_0 = temp;
 
       temp = tau1_trackEtaRel_1;
       tau1_trackEtaRel_1 = tau2_trackEtaRel_1;
       tau2_trackEtaRel_1 = temp;
 
       temp = tau1_trackEtaRel_2;
       tau1_trackEtaRel_2 = tau2_trackEtaRel_2;
       tau2_trackEtaRel_2 = temp;
 
       temp = tau1_flightDistance2dSig;
       tau1_flightDistance2dSig = tau2_flightDistance2dSig;
       tau2_flightDistance2dSig = temp;
 
       tau1_vertexDeltaR = tau2_vertexDeltaR;
 
       temp = tau1_vertexEnergyRatio;
       tau1_vertexEnergyRatio = tau2_vertexEnergyRatio;
       tau2_vertexEnergyRatio = temp;
 
       temp = tau1_vertexMass;
       tau1_vertexMass = tau2_vertexMass;
       tau2_vertexMass = temp;
     }
 
     reco::TaggingVariableList vars;
 
     vars.insert(reco::btau::jetNTracks, jetNTracks, true);
     vars.insert(reco::btau::jetNSecondaryVertices, nSV, true);
     vars.insert(reco::btau::trackSip3dSig_0, trackSip3dSig_0, true);
     vars.insert(reco::btau::trackSip3dSig_1, trackSip3dSig_1, true);
     vars.insert(reco::btau::trackSip3dSig_2, trackSip3dSig_2, true);
     vars.insert(reco::btau::trackSip3dSig_3, trackSip3dSig_3, true);
     vars.insert(reco::btau::tau1_trackSip3dSig_0, tau1_trackSip3dSig_0, true);
     vars.insert(reco::btau::tau1_trackSip3dSig_1, tau1_trackSip3dSig_1, true);
     vars.insert(reco::btau::tau2_trackSip3dSig_0, tau2_trackSip3dSig_0, true);
     vars.insert(reco::btau::tau2_trackSip3dSig_1, tau2_trackSip3dSig_1, true);
     vars.insert(reco::btau::trackSip2dSigAboveCharm, trackSip2dSigAboveCharm_0, true);
     vars.insert(reco::btau::trackSip2dSigAboveBottom_0, trackSip2dSigAboveBottom_0, true);
     vars.insert(reco::btau::trackSip2dSigAboveBottom_1, trackSip2dSigAboveBottom_1, true);
     vars.insert(reco::btau::tau1_trackEtaRel_0, tau1_trackEtaRel_0, true);
     vars.insert(reco::btau::tau1_trackEtaRel_1, tau1_trackEtaRel_1, true);
     vars.insert(reco::btau::tau1_trackEtaRel_2, tau1_trackEtaRel_2, true);
     vars.insert(reco::btau::tau2_trackEtaRel_0, tau2_trackEtaRel_0, true);
     vars.insert(reco::btau::tau2_trackEtaRel_1, tau2_trackEtaRel_1, true);
     vars.insert(reco::btau::tau2_trackEtaRel_2, tau2_trackEtaRel_2, true);
     vars.insert(reco::btau::tau1_vertexMass, tau1_vertexMass, true);
     vars.insert(reco::btau::tau1_vertexEnergyRatio, tau1_vertexEnergyRatio, true);
     vars.insert(reco::btau::tau1_flightDistance2dSig, tau1_flightDistance2dSig, true);
     vars.insert(reco::btau::tau1_vertexDeltaR, tau1_vertexDeltaR, true);
     vars.insert(reco::btau::tau2_vertexMass, tau2_vertexMass, true);
     vars.insert(reco::btau::tau2_vertexEnergyRatio, tau2_vertexEnergyRatio, true);
     vars.insert(reco::btau::tau2_flightDistance2dSig, tau2_flightDistance2dSig, true);
     vars.insert(reco::btau::z_ratio, z_ratio, true);
 
     vars.finalize();
 
     tagInfos->push_back(reco::BoostedDoubleSVTagInfo(
         vars, edm::Ref<std::vector<reco::CandSecondaryVertexTagInfo>>(svTagInfos, iterTI - svTagInfos->begin())));
   }
 
   // put the output in the event
   iEvent.put(std::move(tagInfos));
 }

void BoostedDoubleSVProducer::setTracksPV	(	const reco::CandidatePtr &	trackRef,
		const reco::VertexRef &	vertexRef,
		float &	PVweight
	)		const

private

Definition at line 746 of file BoostedDoubleSVProducer.cc.

References pat::PackedCandidate::fromPV(), edm::Ptr< T >::get(), pat::PackedCandidate::PVUsedInFit, setTracksPVBase(), and reco::PFCandidate::trackRef().

Referenced by produce().

                                                                  {
   PVweight = 0.;
 
   const pat::PackedCandidate* pcand = dynamic_cast<const pat::PackedCandidate*>(trackRef.get());
 
   if (pcand)  // MiniAOD case
   {
     if (pcand->fromPV() == pat::PackedCandidate::PVUsedInFit) {
       PVweight = 1.;
     }
   } else {
     const reco::PFCandidate* pfcand = dynamic_cast<const reco::PFCandidate*>(trackRef.get());
 
     setTracksPVBase(pfcand->trackRef(), vertexRef, PVweight);
   }
 }

void BoostedDoubleSVProducer::setTracksPVBase	(	const reco::TrackRef &	trackRef,
		const reco::VertexRef &	vertexRef,
		float &	PVweight
	)		const

private

Definition at line 725 of file BoostedDoubleSVProducer.cc.

References reco::Vertex::tracks_begin(), reco::Vertex::tracks_end(), and reco::Vertex::trackWeight().

Referenced by setTracksPV().

                                                                      {
   PVweight = 0.;
 
   const reco::TrackBaseRef trackBaseRef(trackRef);
 
   typedef reco::Vertex::trackRef_iterator IT;
 
   const reco::Vertex& vtx = *(vertexRef);
   // loop over tracks in vertices
   for (IT it = vtx.tracks_begin(); it != vtx.tracks_end(); ++it) {
     const reco::TrackBaseRef& baseRef = *it;
     // one of the tracks in the vertex is the same as the track considered in the function
     if (baseRef == trackBaseRef) {
       PVweight = vtx.trackWeight(baseRef);
       break;
     }
   }
 }