IPProducer< Container, Base, Helper > Class Template Reference

#include <IPProducer.h>

Inheritance diagram for IPProducer< Container, Base, Helper >:

Public Types
typedef std::vector< reco::IPTagInfo< Container, Base > >	Product
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 Member Functions
template<>
void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)
template<>
void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)
	IPProducer (const edm::ParameterSet &)
void	produce (edm::Event &, const edm::EventSetup &) override
	~IPProducer () override
Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default
bool	hasAbilityToProduceInBeginLumis () const final
bool	hasAbilityToProduceInBeginProcessBlocks () const final
bool	hasAbilityToProduceInBeginRuns () const final
bool	hasAbilityToProduceInEndLumis () const final
bool	hasAbilityToProduceInEndProcessBlocks () const final
bool	hasAbilityToProduceInEndRuns () const final

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

Private Member Functions
void	checkEventSetup (const edm::EventSetup &iSetup)

Private Attributes
unsigned long long	m_calibrationCacheId2D
unsigned long long	m_calibrationCacheId3D
bool	m_computeGhostTrack
bool	m_computeProbabilities
const edm::ParameterSet &	m_config
double	m_cutMaxChiSquared
double	m_cutMaxLIP
double	m_cutMaxTIP
double	m_cutMinPt
int	m_cutPixelHits
int	m_cutTotalHits
bool	m_directionWithGhostTrack
bool	m_directionWithTracks
double	m_ghostTrackPriorDeltaR
Helper	m_helper
std::unique_ptr< HistogramProbabilityEstimator >	m_probabilityEstimator
bool	m_useDB
bool	m_useTrackQuality
edm::ESGetToken< TrackProbabilityCalibration, BTagTrackProbability2DRcd >	token_calib2D
edm::ESGetToken< TrackProbabilityCalibration, BTagTrackProbability3DRcd >	token_calib3D
edm::EDGetTokenT< reco::VertexCollection >	token_primaryVertex
edm::ESGetToken< TransientTrackBuilder, TransientTrackRecord >	token_trackBuilder

Detailed Description

template<class Container, class Base, class Helper>
class IPProducer< Container, Base, Helper >

Description: <one line="" class="" summary>="">

Implementation: <Notes on="" implementation>="">

Definition at line 130 of file IPProducer.h.

Member Typedef Documentation

Product

template<class Container , class Base , class Helper >

typedef std::vector<reco::IPTagInfo<Container, Base> > IPProducer< Container, Base, Helper >::Product

Definition at line 132 of file IPProducer.h.

Constructor & Destructor Documentation

IPProducer()

template<class Container , class Base , class Helper >

IPProducer< Container, Base, Helper >::IPProducer ( const edm::ParameterSet &  iConfig )

explicit

Definition at line 191 of file IPProducer.h.

    : m_config(iConfig), m_helper(iConfig, consumesCollector()) {
  m_calibrationCacheId3D = 0;
  m_calibrationCacheId2D = 0;
 
  token_primaryVertex = consumes<reco::VertexCollection>(m_config.getParameter<edm::InputTag>("primaryVertex"));
  token_trackBuilder =
      esConsumes<TransientTrackBuilder, TransientTrackRecord>(edm::ESInputTag("", "TransientTrackBuilder"));
  token_calib2D = esConsumes<TrackProbabilityCalibration, BTagTrackProbability2DRcd>();
  token_calib3D = esConsumes<TrackProbabilityCalibration, BTagTrackProbability3DRcd>();
 
  m_computeProbabilities = m_config.getParameter<bool>("computeProbabilities");
  m_computeGhostTrack = m_config.getParameter<bool>("computeGhostTrack");
  m_ghostTrackPriorDeltaR = m_config.getParameter<double>("ghostTrackPriorDeltaR");
  m_cutPixelHits = m_config.getParameter<int>("minimumNumberOfPixelHits");
  m_cutTotalHits = m_config.getParameter<int>("minimumNumberOfHits");
  m_cutMaxTIP = m_config.getParameter<double>("maximumTransverseImpactParameter");
  m_cutMinPt = m_config.getParameter<double>("minimumTransverseMomentum");
  m_cutMaxChiSquared = m_config.getParameter<double>("maximumChiSquared");
  m_cutMaxLIP = m_config.getParameter<double>("maximumLongitudinalImpactParameter");
  m_directionWithTracks = m_config.getParameter<bool>("jetDirectionUsingTracks");
  m_directionWithGhostTrack = m_config.getParameter<bool>("jetDirectionUsingGhostTrack");
  m_useTrackQuality = m_config.getParameter<bool>("useTrackQuality");
 
  if (m_computeGhostTrack)
    produces<reco::TrackCollection>("ghostTracks");
  produces<Product>();
}

References edm::ParameterSet::getParameter(), IPProducer< Container, Base, Helper >::m_calibrationCacheId2D, IPProducer< Container, Base, Helper >::m_calibrationCacheId3D, IPProducer< Container, Base, Helper >::m_computeGhostTrack, IPProducer< Container, Base, Helper >::m_computeProbabilities, IPProducer< Container, Base, Helper >::m_config, IPProducer< Container, Base, Helper >::m_cutMaxChiSquared, IPProducer< Container, Base, Helper >::m_cutMaxLIP, IPProducer< Container, Base, Helper >::m_cutMaxTIP, IPProducer< Container, Base, Helper >::m_cutMinPt, IPProducer< Container, Base, Helper >::m_cutPixelHits, IPProducer< Container, Base, Helper >::m_cutTotalHits, IPProducer< Container, Base, Helper >::m_directionWithGhostTrack, IPProducer< Container, Base, Helper >::m_directionWithTracks, IPProducer< Container, Base, Helper >::m_ghostTrackPriorDeltaR, IPProducer< Container, Base, Helper >::m_useTrackQuality, IPProducer< Container, Base, Helper >::token_calib2D, IPProducer< Container, Base, Helper >::token_calib3D, IPProducer< Container, Base, Helper >::token_primaryVertex, and IPProducer< Container, Base, Helper >::token_trackBuilder.

~IPProducer()

template<class Container , class Base , class Helper >

IPProducer< Container, Base, Helper >::~IPProducer ( )

override

Definition at line 221 of file IPProducer.h.

{}

Member Function Documentation

checkEventSetup()

template<class Container , class Base , class Helper >

void IPProducer< Container, Base, Helper >::checkEventSetup ( const edm::EventSetup &  iSetup )

private

Definition at line 420 of file IPProducer.h.

                                                                                     {
  const edm::eventsetup::EventSetupRecord& re2D = iSetup.get<BTagTrackProbability2DRcd>();
  const edm::eventsetup::EventSetupRecord& re3D = iSetup.get<BTagTrackProbability3DRcd>();
  unsigned long long cacheId2D = re2D.cacheIdentifier();
  unsigned long long cacheId3D = re3D.cacheIdentifier();
 
  if (cacheId2D != m_calibrationCacheId2D || cacheId3D != m_calibrationCacheId3D)  //Calibration changed
  {
    //iSetup.get<BTagTrackProbabilityRcd>().get(calib);
    edm::ESHandle<TrackProbabilityCalibration> calib2DHandle = iSetup.getHandle(token_calib2D);
    edm::ESHandle<TrackProbabilityCalibration> calib3DHandle = iSetup.getHandle(token_calib3D);
 
    const TrackProbabilityCalibration* ca2D = calib2DHandle.product();
    const TrackProbabilityCalibration* ca3D = calib3DHandle.product();
 
    m_probabilityEstimator.reset(new HistogramProbabilityEstimator(ca3D, ca2D));
  }
  m_calibrationCacheId3D = cacheId3D;
  m_calibrationCacheId2D = cacheId2D;
}

References edm::eventsetup::EventSetupRecord::cacheIdentifier(), edm::EventSetup::get(), edm::EventSetup::getHandle(), and edm::ESHandle< T >::product().

fillDescriptions() [1/3]

template<class Container , class Base , class Helper >

static void IPProducer< Container, Base, Helper >::fillDescriptions ( edm::ConfigurationDescriptions &  descriptions )

static

fillDescriptions() [2/3]

template<>

void IPProducer< reco::TrackRefVector, reco::JTATagInfo, IPProducerHelpers::FromJTA >::fillDescriptions

(

edm::ConfigurationDescriptions &

descriptions

)

Definition at line 444 of file IPProducer.h.

                                                {
  edm::ParameterSetDescription desc;
  desc.add<double>("maximumTransverseImpactParameter", 0.2);
  desc.add<int>("minimumNumberOfHits", 8);
  desc.add<double>("minimumTransverseMomentum", 1.0);
  desc.add<edm::InputTag>("primaryVertex", edm::InputTag("offlinePrimaryVertices"));
  desc.add<double>("maximumLongitudinalImpactParameter", 17.0);
  desc.add<bool>("computeGhostTrack", true);
  desc.add<double>("ghostTrackPriorDeltaR", 0.03);
  desc.add<edm::InputTag>("jetTracks", edm::InputTag("ak4JetTracksAssociatorAtVertexPF"));
  desc.add<bool>("jetDirectionUsingGhostTrack", false);
  desc.add<int>("minimumNumberOfPixelHits", 2);
  desc.add<bool>("jetDirectionUsingTracks", false);
  desc.add<bool>("computeProbabilities", true);
  desc.add<bool>("useTrackQuality", false);
  desc.add<double>("maximumChiSquared", 5.0);
  descriptions.addDefault(desc);
}

References edm::ConfigurationDescriptions::addDefault(), submitPVResolutionJobs::desc, and HLT_FULL_cff::InputTag.

fillDescriptions() [3/3]

template<>

void IPProducer< std::vector< reco::CandidatePtr >, reco::JetTagInfo, IPProducerHelpers::FromJetAndCands >::fillDescriptions

(

edm::ConfigurationDescriptions &

descriptions

)

Definition at line 465 of file IPProducer.h.

                                                {
  edm::ParameterSetDescription desc;
  desc.add<double>("maximumTransverseImpactParameter", 0.2);
  desc.add<int>("minimumNumberOfHits", 8);
  desc.add<double>("minimumTransverseMomentum", 1.0);
  desc.add<edm::InputTag>("primaryVertex", edm::InputTag("offlinePrimaryVertices"));
  desc.add<double>("maximumLongitudinalImpactParameter", 17.0);
  desc.add<bool>("computeGhostTrack", true);
  desc.add<double>("maxDeltaR", 0.4);
  desc.add<edm::InputTag>("candidates", edm::InputTag("particleFlow"));
  desc.add<bool>("jetDirectionUsingGhostTrack", false);
  desc.add<int>("minimumNumberOfPixelHits", 2);
  desc.add<bool>("jetDirectionUsingTracks", false);
  desc.add<bool>("computeProbabilities", true);
  desc.add<bool>("useTrackQuality", false);
  desc.add<edm::InputTag>("jets", edm::InputTag("ak4PFJetsCHS"));
  desc.add<double>("ghostTrackPriorDeltaR", 0.03);
  desc.add<double>("maximumChiSquared", 5.0);
  desc.addOptional<bool>("explicitJTA", false);
  descriptions.addDefault(desc);
}

References edm::ConfigurationDescriptions::addDefault(), submitPVResolutionJobs::desc, and HLT_FULL_cff::InputTag.

produce()

template<class Container , class Base , class Helper >

void IPProducer< Container, Base, Helper >::produce ( edm::Event &  iEvent, const edm::EventSetup &  iSetup  )

override

Definition at line 228 of file IPProducer.h.

                                                                                               {
  // Update probability estimator if event setup is changed
  if (m_computeProbabilities)
    checkEventSetup(iSetup);
 
  edm::Handle<reco::VertexCollection> primaryVertex;
  iEvent.getByToken(token_primaryVertex, primaryVertex);
 
  edm::ESHandle<TransientTrackBuilder> builder = iSetup.getHandle(token_trackBuilder);
  // m_algo.setTransientTrackBuilder(builder.product());
 
  // output collections
  auto result = std::make_unique<Product>();
 
  std::unique_ptr<reco::TrackCollection> ghostTracks;
  reco::TrackRefProd ghostTrackRefProd;
  if (m_computeGhostTrack) {
    ghostTracks = std::make_unique<reco::TrackCollection>();
    ghostTrackRefProd = iEvent.getRefBeforePut<reco::TrackCollection>("ghostTracks");
  }
 
  // use first pv of the collection
  reco::Vertex dummy;
  const reco::Vertex* pv = &dummy;
  edm::Ref<reco::VertexCollection> pvRef;
  if (!primaryVertex->empty()) {
    pv = &*primaryVertex->begin();
    // we always use the first vertex (at the moment)
    pvRef = edm::Ref<reco::VertexCollection>(primaryVertex, 0);
  } else {  // create a dummy PV
    reco::Vertex::Error e;
    e(0, 0) = 0.0015 * 0.0015;
    e(1, 1) = 0.0015 * 0.0015;
    e(2, 2) = 15. * 15.;
    reco::Vertex::Point p(0, 0, 0);
    dummy = reco::Vertex(p, e, 0, 0, 0);
  }
 
  std::vector<Base> baseTagInfos = m_helper.makeBaseVector(iEvent);
  for (typename std::vector<Base>::const_iterator it = baseTagInfos.begin(); it != baseTagInfos.end(); it++) {
    Container tracks = m_helper.tracks(*it);
    math::XYZVector jetMomentum = it->jet()->momentum();
 
    if (m_directionWithTracks) {
      jetMomentum *= 0.5;
      for (typename Container::const_iterator itTrack = tracks.begin(); itTrack != tracks.end(); ++itTrack)
        if (reco::btag::toTrack(*itTrack)->numberOfValidHits() >= m_cutTotalHits)  //minimal quality cuts
          jetMomentum += (*itTrack)->momentum();
    }
 
    Container selectedTracks;
    std::vector<reco::TransientTrack> transientTracks;
 
    for (typename Container::const_iterator itTrack = tracks.begin(); itTrack != tracks.end(); ++itTrack) {
      reco::TransientTrack transientTrack = builder->build(*itTrack);
      const reco::Track& track = transientTrack.track();  //**itTrack;
                                                          /*    cout << " pt " <<  track.pt() <<
               " d0 " <<  fabs(track.d0()) <<
               " #hit " <<    track.hitPattern().numberOfValidHits()<<
               " ipZ " <<   fabs(track.dz()-pv->z())<<
               " chi2 " <<  track.normalizedChi2()<<
               " #pixel " <<    track.hitPattern().numberOfValidPixelHits()<< endl;
*/
      if (track.pt() > m_cutMinPt &&
          track.hitPattern().numberOfValidHits() >= m_cutTotalHits &&  // min num tracker hits
          track.hitPattern().numberOfValidPixelHits() >= m_cutPixelHits &&
          track.normalizedChi2() < m_cutMaxChiSquared && std::abs(track.dxy(pv->position())) < m_cutMaxTIP &&
          std::abs(track.dz(pv->position())) < m_cutMaxLIP) {
        //   std::cout << "selected" << std::endl;
        selectedTracks.push_back(*itTrack);
        transientTracks.push_back(transientTrack);
      }
    }
    //  std::cout <<"SIZE: " << transientTracks.size() << std::endl;
    GlobalVector direction(jetMomentum.x(), jetMomentum.y(), jetMomentum.z());
 
    std::unique_ptr<reco::GhostTrack> ghostTrack;
    reco::TrackRef ghostTrackRef;
    if (m_computeGhostTrack) {
      reco::GhostTrackFitter fitter;
      GlobalPoint origin = RecoVertex::convertPos(pv->position());
      GlobalError error = RecoVertex::convertError(pv->error());
      ghostTrack.reset(
          new reco::GhostTrack(fitter.fit(origin, error, direction, m_ghostTrackPriorDeltaR, transientTracks)));
 
      /*
    if (std::sqrt(jetMomentum.Perp2()) > 30) {
        double offset = ghostTrack->prediction().lambda(origin);
        std::cout << "------------------ jet pt " << std::sqrt(jetMomentum.Perp2()) << std::endl;
        const std::vector<GhostTrackState> *states = &ghostTrack->states();
        for(std::vector<GhostTrackState>::const_iterator state = states->begin();
            state != states->end(); ++state) {
            double dist = state->lambda() - offset;
            double err = state->lambdaError(ghostTrack->prediction(), error);
            double ipSig = IPTools::signedImpactParameter3D(state->track(), direction, *pv).second.significance();
            double axisDist = state->axisDistance(ghostTrack->prediction());
            std::cout << state->track().impactPointState().freeState()->momentum().perp()
                      << ": " << dist << "/" << err << " [" << (dist / err) << "], ipsig = " << ipSig << ", dist = " << axisDist << ", w = " << state->weight() << std::endl;
        }
    }
*/
      ghostTrackRef = reco::TrackRef(ghostTrackRefProd, ghostTracks->size());
      ghostTracks->push_back(*ghostTrack);
 
      if (m_directionWithGhostTrack) {
        const reco::GhostTrackPrediction& pred = ghostTrack->prediction();
        double lambda = pred.lambda(origin);
        dummy = reco::Vertex(RecoVertex::convertPos(pred.position(lambda)),
                             RecoVertex::convertError(pred.positionError(lambda)),
                             0,
                             0,
                             0);
        pv = &dummy;
        direction = pred.direction();
      }
    }
 
    std::vector<float> prob2D, prob3D;
    std::vector<reco::btag::TrackIPData> ipData;
 
    for (unsigned int ind = 0; ind < transientTracks.size(); ind++) {
      const reco::TransientTrack& transientTrack = transientTracks[ind];
      const reco::Track& track = transientTrack.track();
 
      reco::btag::TrackIPData trackIP;
      trackIP.ip3d = IPTools::signedImpactParameter3D(transientTrack, direction, *pv).second;
      trackIP.ip2d = IPTools::signedTransverseImpactParameter(transientTrack, direction, *pv).second;
 
      TrajectoryStateOnSurface closest =
          IPTools::closestApproachToJet(transientTrack.impactPointState(), *pv, direction, transientTrack.field());
      if (closest.isValid())
        trackIP.closestToJetAxis = closest.globalPosition();
 
      // TODO: cross check if it is the same using other methods
      trackIP.distanceToJetAxis = IPTools::jetTrackDistance(transientTrack, direction, *pv).second;
 
      if (ghostTrack.get()) {
        const std::vector<reco::GhostTrackState>& states = ghostTrack->states();
        std::vector<reco::GhostTrackState>::const_iterator pos =
            std::find_if(states.begin(), states.end(), [&](auto& arg) { return arg.track() == transientTrack; });
 
        if (pos != states.end() && pos->isValid()) {
          VertexDistance3D dist;
          const reco::GhostTrackPrediction& pred = ghostTrack->prediction();
          GlobalPoint p1 = pos->tsos().globalPosition();
          GlobalError e1 = pos->tsos().cartesianError().position();
          GlobalPoint p2 = pred.position(pos->lambda());
          GlobalError e2 = pred.positionError(pos->lambda());
          trackIP.closestToGhostTrack = p1;
          trackIP.distanceToGhostTrack = dist.distance(VertexState(p1, e1), VertexState(p2, e2));
          trackIP.ghostTrackWeight = pos->weight();
        } else {
          trackIP.distanceToGhostTrack = Measurement1D(0., -1.);
          trackIP.ghostTrackWeight = 0.;
        }
      } else {
        trackIP.distanceToGhostTrack = Measurement1D(0., -1.);
        trackIP.ghostTrackWeight = 1.;
      }
 
      ipData.push_back(trackIP);
 
      if (m_computeProbabilities) {
        //probability with 3D ip
        std::pair<bool, double> probability = m_probabilityEstimator->probability(
            m_useTrackQuality, 0, ipData.back().ip3d.significance(), track, *(it->jet()), *pv);
        prob3D.push_back(probability.first ? probability.second : -1.);
 
        //probability with 2D ip
        probability = m_probabilityEstimator->probability(
            m_useTrackQuality, 1, ipData.back().ip2d.significance(), track, *(it->jet()), *pv);
        prob2D.push_back(probability.first ? probability.second : -1.);
      }
    }
 
    result->push_back(
        typename Product::value_type(ipData, prob2D, prob3D, selectedTracks, *it, pvRef, direction, ghostTrackRef));
  }
 
  if (m_computeGhostTrack)
    iEvent.put(std::move(ghostTracks), "ghostTracks");
  iEvent.put(std::move(result));
}

References funct::abs(), TransientTrackBuilder::build(), IPTools::closestApproachToJet(), reco::btag::TrackIPData::closestToGhostTrack, reco::btag::TrackIPData::closestToJetAxis, RecoVertex::convertError(), RecoVertex::convertPos(), reco::GhostTrackPrediction::direction(), VertexDistance3D::distance(), reco::btag::TrackIPData::distanceToGhostTrack, reco::btag::TrackIPData::distanceToJetAxis, MillePedeFileConverter_cfg::e, StorageManager_cfg::e1, relativeConstraints::error, reco::TransientTrack::field(), reco::GhostTrackFitter::fit(), edm::EventSetup::getHandle(), reco::btag::TrackIPData::ghostTrackWeight, TrajectoryStateOnSurface::globalPosition(), iEvent, reco::TransientTrack::impactPointState(), reco::btag::TrackIPData::ip2d, reco::btag::TrackIPData::ip3d, TrajectoryStateOnSurface::isValid(), IPTools::jetTrackDistance(), reco::GhostTrackPrediction::lambda(), eostools::move(), reco::TrackBase::numberOfValidHits(), AlCaHLTBitMon_ParallelJobs::p, p1, p2, reco::GhostTrackPrediction::position(), reco::GhostTrackPrediction::positionError(), reco::GhostTrackPrediction::prediction(), BeamMonitor_cff::primaryVertex, MetAnalyzer::pv(), mps_fire::result, TrackCollections2monitor_cff::selectedTracks, IPTools::signedImpactParameter3D(), IPTools::signedTransverseImpactParameter(), reco::btag::toTrack(), reco::TransientTrack::track(), HLT_FULL_cff::track, tracks, and HltBtagValidation_cff::Vertex.

Member Data Documentation

m_calibrationCacheId2D

template<class Container , class Base , class Helper >

unsigned long long IPProducer< Container, Base, Helper >::m_calibrationCacheId2D

private

Definition at line 153 of file IPProducer.h.

Referenced by IPProducer< Container, Base, Helper >::IPProducer().

m_calibrationCacheId3D

template<class Container , class Base , class Helper >

unsigned long long IPProducer< Container, Base, Helper >::m_calibrationCacheId3D

private

Definition at line 154 of file IPProducer.h.

Referenced by IPProducer< Container, Base, Helper >::IPProducer().

m_computeGhostTrack

template<class Container , class Base , class Helper >

bool IPProducer< Container, Base, Helper >::m_computeGhostTrack

private

Definition at line 150 of file IPProducer.h.

Referenced by IPProducer< Container, Base, Helper >::IPProducer().

m_computeProbabilities

template<class Container , class Base , class Helper >

bool IPProducer< Container, Base, Helper >::m_computeProbabilities

private

Definition at line 149 of file IPProducer.h.

Referenced by IPProducer< Container, Base, Helper >::IPProducer().

m_config

template<class Container , class Base , class Helper >

const edm::ParameterSet& IPProducer< Container, Base, Helper >::m_config

private

Definition at line 143 of file IPProducer.h.

Referenced by IPProducer< Container, Base, Helper >::IPProducer().

m_cutMaxChiSquared

template<class Container , class Base , class Helper >

double IPProducer< Container, Base, Helper >::m_cutMaxChiSquared

private

Definition at line 161 of file IPProducer.h.

Referenced by IPProducer< Container, Base, Helper >::IPProducer().

m_cutMaxLIP

template<class Container , class Base , class Helper >

double IPProducer< Container, Base, Helper >::m_cutMaxLIP

private

Definition at line 162 of file IPProducer.h.

Referenced by IPProducer< Container, Base, Helper >::IPProducer().

m_cutMaxTIP

template<class Container , class Base , class Helper >

double IPProducer< Container, Base, Helper >::m_cutMaxTIP

private

Definition at line 159 of file IPProducer.h.

Referenced by IPProducer< Container, Base, Helper >::IPProducer().

m_cutMinPt

template<class Container , class Base , class Helper >

double IPProducer< Container, Base, Helper >::m_cutMinPt

private

Definition at line 160 of file IPProducer.h.

Referenced by IPProducer< Container, Base, Helper >::IPProducer().

m_cutPixelHits

template<class Container , class Base , class Helper >

int IPProducer< Container, Base, Helper >::m_cutPixelHits

private

Definition at line 157 of file IPProducer.h.

Referenced by IPProducer< Container, Base, Helper >::IPProducer().

m_cutTotalHits

template<class Container , class Base , class Helper >

int IPProducer< Container, Base, Helper >::m_cutTotalHits

private

Definition at line 158 of file IPProducer.h.

Referenced by IPProducer< Container, Base, Helper >::IPProducer().

m_directionWithGhostTrack

template<class Container , class Base , class Helper >

bool IPProducer< Container, Base, Helper >::m_directionWithGhostTrack

private

Definition at line 164 of file IPProducer.h.

Referenced by IPProducer< Container, Base, Helper >::IPProducer().

m_directionWithTracks

template<class Container , class Base , class Helper >

bool IPProducer< Container, Base, Helper >::m_directionWithTracks

private

Definition at line 163 of file IPProducer.h.

Referenced by IPProducer< Container, Base, Helper >::IPProducer().

m_ghostTrackPriorDeltaR

template<class Container , class Base , class Helper >

double IPProducer< Container, Base, Helper >::m_ghostTrackPriorDeltaR

private

Definition at line 151 of file IPProducer.h.

Referenced by IPProducer< Container, Base, Helper >::IPProducer().

m_helper

template<class Container , class Base , class Helper >

Helper IPProducer< Container, Base, Helper >::m_helper

private

Definition at line 166 of file IPProducer.h.

m_probabilityEstimator

template<class Container , class Base , class Helper >

std::unique_ptr<HistogramProbabilityEstimator> IPProducer< Container, Base, Helper >::m_probabilityEstimator

private

Definition at line 152 of file IPProducer.h.

m_useDB

template<class Container , class Base , class Helper >

bool IPProducer< Container, Base, Helper >::m_useDB

private

Definition at line 155 of file IPProducer.h.

m_useTrackQuality

template<class Container , class Base , class Helper >

bool IPProducer< Container, Base, Helper >::m_useTrackQuality

private

Definition at line 165 of file IPProducer.h.

Referenced by IPProducer< Container, Base, Helper >::IPProducer().

token_calib2D

template<class Container , class Base , class Helper >

edm::ESGetToken<TrackProbabilityCalibration, BTagTrackProbability2DRcd> IPProducer< Container, Base, Helper >::token_calib2D

private

Definition at line 146 of file IPProducer.h.

Referenced by IPProducer< Container, Base, Helper >::IPProducer().

token_calib3D

template<class Container , class Base , class Helper >

edm::ESGetToken<TrackProbabilityCalibration, BTagTrackProbability3DRcd> IPProducer< Container, Base, Helper >::token_calib3D

private

Definition at line 147 of file IPProducer.h.

Referenced by IPProducer< Container, Base, Helper >::IPProducer().

token_primaryVertex

template<class Container , class Base , class Helper >

edm::EDGetTokenT<reco::VertexCollection> IPProducer< Container, Base, Helper >::token_primaryVertex

private

Definition at line 144 of file IPProducer.h.

Referenced by IPProducer< Container, Base, Helper >::IPProducer().

token_trackBuilder

template<class Container , class Base , class Helper >

edm::ESGetToken<TransientTrackBuilder, TransientTrackRecord> IPProducer< Container, Base, Helper >::token_trackBuilder

private

Definition at line 145 of file IPProducer.h.

Referenced by IPProducer< Container, Base, Helper >::IPProducer().