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

Inheritance diagram for BoostedDoubleSVProducer:

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

	~BoostedDoubleSVProducer ()

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

Public Member Functions inherited from edm::stream::EDProducerBase
	EDProducerBase ()

ModuleDescription const &	moduleDescription () const

virtual	~EDProducerBase ()

Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

	ProducerBase ()

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

virtual	~ProducerBase ()

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

	EDConsumerBase ()

ProductHolderIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesDependentUpon (std::string const &iProcessName, std::string const &iModuleLabel, bool iPrint, std::vector< char const * > &oModuleLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

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

Static Public Member Functions inherited from edm::stream::EDProducerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

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

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

virtual void	endStream () override

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

virtual 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_

reco::V0Filter	trackPairV0Filter

reco::TrackSelector	trackSelector

Static Private Attributes
static float	bottomThreshold = 5.2f

static float	charmThreshold = 1.5f

static float	dummyFlightDistance2dSig = -1.0f

static float	dummyTrackEtaRel = -1.0f

static float	dummyTrackSip2dSigAbove = -19.0f

static float	dummyTrackSip3dSig = -50.0f

static float	dummyVertexDeltaR = -1.0f

static float	dummyVertexEnergyRatio = -1.0f

static float	dummyVertexMass = -1.0f

static float	dummyZ_ratio = -3.0f

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

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T...>	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT < LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

Public Types inherited from edm::stream::EDProducerBase
typedef EDProducerAdaptorBase	ModuleType

Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

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 61 of file BoostedDoubleSVProducer.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 116 of file BoostedDoubleSVProducer.cc.

                                                                                :
   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"))
 {
     produces<std::vector<reco::BoostedDoubleSVTagInfo> >();
 }

BoostedDoubleSVProducer::~BoostedDoubleSVProducer ( )

Definition at line 130 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 )

overrideprivatevirtual

Reimplemented from edm::stream::EDProducerBase.

Definition at line 753 of file BoostedDoubleSVProducer.cc.

754 {

755 }

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

private

Definition at line 653 of file BoostedDoubleSVProducer.cc.

References beta_, reco::Candidate::daughter(), reco::CompositePtrCandidate::daughterPtrVector(), reco::Candidate::energy(), i, nJettinessAdder_cfi::Njettiness, reco::CompositePtrCandidate::numberOfDaughters(), reco::Candidate::px(), reco::Candidate::py(), reco::Candidate::pz(), and R0_.

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::Candidate * constit = daughter->daughter(i);
 
           if ( constit )
             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
         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 ( )

overrideprivatevirtual

Reimplemented from edm::stream::EDProducerBase.

Definition at line 759 of file BoostedDoubleSVProducer.cc.

759 {

760 }

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

private

Definition at line 742 of file BoostedDoubleSVProducer.cc.

References funct::abs(), reco::CompositePtrCandidate::daughterPtrVector(), reco::btau::etaRel(), and testEve_cfg::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 764 of file BoostedDoubleSVProducer.cc.

References edm::ConfigurationDescriptions::addDefault(), and edm::ParameterSetDescription::setUnknown().

                                                                                     {
   //The following says we do not know what parameters are allowed so do no validation
   // Please change this to state exactly what you do use, even if it is no parameters
   edm::ParameterSetDescription desc;
   desc.setUnknown();
   descriptions.addDefault(desc);
 }

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

overrideprivatevirtual

Implements edm::stream::EDProducerBase.

Definition at line 145 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::EventSetup::get(), edm::Event::getByToken(), TrajectoryStateOnSurface::globalPosition(), i, customizeTrackingMonitorSeedNumber::idx, reco::IPTagInfo< Container, Base >::impactParameterData(), reco::TransientTrack::impactPointState(), cmsHarvester::index, reco::TaggingVariableList::insert(), reco::btag::TrackIPData::ip2d, reco::btag::IP2DSig, edm::Ref< C, T, F >::isNonnull(), TrajectoryStateOnSurface::isValid(), metsig::jet, reco::TemplatedSecondaryVertexTagInfo< IPTI, VTX >::jet(), reco::btau::jetNSecondaryVertices, reco::btau::jetNTracks, IPTools::jetTrackDistance(), ResonanceBuilder::mass, maxDecayLen_, maxDistToAxis_, maxSVDeltaRToJet_, reco::LeafCandidate::momentum(), eostools::move(), reco::TemplatedSecondaryVertexTagInfo< IPTI, VTX >::nVertices(), reco::LeafCandidate::p4(), reco::IPTagInfo< Container, Base >::primaryVertex(), edm::Event::put(), MetAnalyzer::pv(), reco::LeafCandidate::px(), reco::LeafCandidate::py(), reco::LeafCandidate::pz(), edm::second(), reco::TemplatedSecondaryVertexTagInfo< IPTI, VTX >::secondaryVertex(), TrackCollections2monitor_cff::selectedTracks, reco::IPTagInfo< Container, Base >::selectedTracks(), setTracksPV(), Measurement1D::significance(), reco::IPTagInfo< Container, Base >::sortedIndexes(), svTagInfos_, HLT_25ns10e33_v2_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, 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(), and reco::btau::z_ratio.

 {
    // get the track builder
    edm::ESHandle<TransientTrackBuilder> trackBuilder;
    iSetup.get<TransientTrackRecord>().get("TransientTrackBuilder",trackBuilder);
 
    // get input secondary vertex TagInfos
    edm::Handle<std::vector<reco::CandSecondaryVertexTagInfo> > svTagInfos;
    iEvent.getByToken(svTagInfos_, svTagInfos);
 
    // 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.size() > 0)
        {
                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.;
        }
 
        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. )
      {
        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. )
      {
        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 719 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 695 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;
     }
   }
 }

Member Data Documentation

const double BoostedDoubleSVProducer::beta_

private

Definition at line 81 of file BoostedDoubleSVProducer.cc.

Referenced by calcNsubjettiness().

float BoostedDoubleSVProducer::bottomThreshold = 5.2f

staticprivate

Definition at line 101 of file BoostedDoubleSVProducer.cc.

Referenced by produce().

float BoostedDoubleSVProducer::charmThreshold = 1.5f

staticprivate

Definition at line 100 of file BoostedDoubleSVProducer.cc.

Referenced by produce().

float BoostedDoubleSVProducer::dummyFlightDistance2dSig = -1.0f

staticprivate

Definition at line 98 of file BoostedDoubleSVProducer.cc.

Referenced by produce().

float BoostedDoubleSVProducer::dummyTrackEtaRel = -1.0f

staticprivate

Definition at line 94 of file BoostedDoubleSVProducer.cc.

Referenced by produce().

float BoostedDoubleSVProducer::dummyTrackSip2dSigAbove = -19.0f

staticprivate

Definition at line 93 of file BoostedDoubleSVProducer.cc.

Referenced by produce().

float BoostedDoubleSVProducer::dummyTrackSip3dSig = -50.0f

staticprivate

Definition at line 92 of file BoostedDoubleSVProducer.cc.

Referenced by produce().

float BoostedDoubleSVProducer::dummyVertexDeltaR = -1.0f

staticprivate

Definition at line 97 of file BoostedDoubleSVProducer.cc.

Referenced by produce().

float BoostedDoubleSVProducer::dummyVertexEnergyRatio = -1.0f

staticprivate

Definition at line 96 of file BoostedDoubleSVProducer.cc.

Referenced by produce().

float BoostedDoubleSVProducer::dummyVertexMass = -1.0f

staticprivate

Definition at line 95 of file BoostedDoubleSVProducer.cc.

Referenced by produce().

float BoostedDoubleSVProducer::dummyZ_ratio = -3.0f

staticprivate

Definition at line 91 of file BoostedDoubleSVProducer.cc.

Referenced by produce().

const double BoostedDoubleSVProducer::maxDecayLen_

private

Definition at line 86 of file BoostedDoubleSVProducer.cc.

Referenced by produce().

const double BoostedDoubleSVProducer::maxDistToAxis_

private

Definition at line 85 of file BoostedDoubleSVProducer.cc.

Referenced by produce().

const double BoostedDoubleSVProducer::maxSVDeltaRToJet_

private

Definition at line 84 of file BoostedDoubleSVProducer.cc.

Referenced by produce().

const double BoostedDoubleSVProducer::R0_

private

Definition at line 82 of file BoostedDoubleSVProducer.cc.

Referenced by calcNsubjettiness().

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

private

Definition at line 79 of file BoostedDoubleSVProducer.cc.

Referenced by produce().

reco::V0Filter BoostedDoubleSVProducer::trackPairV0Filter

private

Definition at line 87 of file BoostedDoubleSVProducer.cc.

Referenced by produce().

reco::TrackSelector BoostedDoubleSVProducer::trackSelector

private

Definition at line 88 of file BoostedDoubleSVProducer.cc.

Referenced by produce().

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Static Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation