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 Types inherited from edm::stream::EDProducerBase
typedef EDProducerAdaptorBase	ModuleType
Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Member Functions
	IPProducer (const edm::ParameterSet &)
virtual void	produce (edm::Event &, const edm::EventSetup &)
	~IPProducer ()
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
	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
	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 (const std::string &iProcessName, std::vector< const char * > &oModuleLabels) const
bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const
bool	registeredToConsumeMany (TypeID const &, BranchType) const
void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)
virtual	~EDConsumerBase ()

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::auto_ptr < HistogramProbabilityEstimator >	m_probabilityEstimator
bool	m_useDB
bool	m_useTrackQuality
edm::EDGetTokenT < reco::VertexCollection >	token_primaryVertex

Additional Inherited Members
Static Public Member Functions inherited from edm::stream::EDProducerBase
static const std::string &	baseType ()
static void	fillDescriptions (ConfigurationDescriptions &descriptions)
static void	prevalidate (ConfigurationDescriptions &descriptions)
Protected Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)
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

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

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

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

Definition at line 123 of file IPProducer.h.

Member Typedef Documentation

template<class Container , class Base , class Helper >

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

Definition at line 125 of file IPProducer.h.

Constructor & Destructor Documentation

template<class Container , class Base , class Helper >

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

explicit

Definition at line 183 of file IPProducer.h.

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, and IPProducer< Container, Base, Helper >::token_primaryVertex.

                                                                                                                                 : 
  m_config(iConfig),m_helper(iConfig,consumesCollector())
{
  m_calibrationCacheId3D = 0;
  m_calibrationCacheId2D = 0;

  token_primaryVertex       = consumes<reco::VertexCollection>(m_config.getParameter<edm::InputTag>("primaryVertex"));

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

template<class Container , class Base , class Helper >

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

(

)

Definition at line 209 of file IPProducer.h.

{
}

Member Function Documentation

template<class Container , class Base , class Helper >

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

private

Definition at line 419 of file IPProducer.h.

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

 {
  using namespace edm;
  using namespace edm::eventsetup;

   const EventSetupRecord & re2D= iSetup.get<BTagTrackProbability2DRcd>();
   const 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);
     ESHandle<TrackProbabilityCalibration> calib2DHandle;
     iSetup.get<BTagTrackProbability2DRcd>().get(calib2DHandle);
     ESHandle<TrackProbabilityCalibration> calib3DHandle;
     iSetup.get<BTagTrackProbability3DRcd>().get(calib3DHandle);

     const TrackProbabilityCalibration *  ca2D= calib2DHandle.product();
     const TrackProbabilityCalibration *  ca3D= calib3DHandle.product();

     m_probabilityEstimator.reset(new HistogramProbabilityEstimator(ca3D,ca2D));

   }
   m_calibrationCacheId3D=cacheId3D;
   m_calibrationCacheId2D=cacheId2D;
}

template<class Container , class Base , class Helper >

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

virtual

Implements edm::stream::EDProducerBase.

Definition at line 218 of file IPProducer.h.

References funct::abs(), 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, reco::TrackBase::dxy(), reco::TrackBase::dz(), alignCSCRings::e, relativeConstraints::error, reco::Vertex::error(), reco::TransientTrack::field(), reco::GhostTrackFitter::fit(), edm::EventSetup::get(), edm::Event::getByToken(), edm::Event::getRefBeforePut(), ghostTrackES_cfi::ghostTrack, reco::btag::TrackIPData::ghostTrackWeight, TrajectoryStateOnSurface::globalPosition(), reco::TrackBase::hitPattern(), reco::TransientTrack::impactPointState(), reco::btag::TrackIPData::ip2d, reco::btag::TrackIPData::ip3d, TrajectoryStateOnSurface::isValid(), IPTools::jetTrackDistance(), reco::GhostTrackPrediction::lambda(), reco::TrackBase::normalizedChi2(), reco::HitPattern::numberOfValidHits(), reco::TrackBase::numberOfValidHits(), reco::HitPattern::numberOfValidPixelHits(), AlCaHLTBitMon_ParallelJobs::p, p1, p2, reco::GhostTrackPrediction::position(), reco::Vertex::position(), reco::GhostTrackPrediction::positionError(), reco::GhostTrackPrediction::prediction(), HWWFunctions::primaryVertex(), reco::TrackBase::pt(), edm::Event::put(), query::result, TrackCollections2monitor_cff::selectedTracks, IPTools::signedImpactParameter3D(), IPTools::signedTransverseImpactParameter(), edmStreamStallGrapher::states, reco::btag::toTrack(), reco::TransientTrack::track(), and testEve_cfg::tracks.

{
   // Update probability estimator if event setup is changed
   if (m_computeProbabilities)
     checkEventSetup(iSetup);
 
   
   Handle<reco::VertexCollection> primaryVertex;
   iEvent.getByToken(token_primaryVertex, primaryVertex);

   edm::ESHandle<TransientTrackBuilder> builder;
   iSetup.get<TransientTrackRecord>().get("TransientTrackBuilder", builder);
   // m_algo.setTransientTrackBuilder(builder.product());

   // output collections 
   auto_ptr<Product> result(new Product);

   auto_ptr<reco::TrackCollection> ghostTracks;
   TrackRefProd ghostTrackRefProd;
   if (m_computeGhostTrack) {
     ghostTracks.reset(new reco::TrackCollection);
     ghostTrackRefProd = iEvent.getRefBeforePut<TrackCollection>("ghostTracks");
   }

   // use first pv of the collection
   Vertex dummy;
   const Vertex *pv = &dummy;
   edm::Ref<VertexCollection> pvRef;
   if (primaryVertex->size() != 0) {
     pv = &*primaryVertex->begin();
     // we always use the first vertex (at the moment)
     pvRef = edm::Ref<VertexCollection>(primaryVertex, 0);
   } else { // create a dummy PV
     Vertex::Error e;
     e(0, 0) = 0.0015 * 0.0015;
     e(1, 1) = 0.0015 * 0.0015;
     e(2, 2) = 15. * 15.;
     Vertex::Point p(0, 0, 0);
     dummy = 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(iEvent,*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;
     vector<TransientTrack> transientTracks;

     for(typename Container::const_iterator itTrack = tracks.begin();
         itTrack != tracks.end(); ++itTrack) {
       TransientTrack transientTrack = builder->build(*itTrack);
       const 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());

     auto_ptr<GhostTrack> ghostTrack;
     TrackRef ghostTrackRef;
     if (m_computeGhostTrack) {
       GhostTrackFitter fitter;
       GlobalPoint origin = RecoVertex::convertPos(pv->position());
       GlobalError error = RecoVertex::convertError(pv->error());
       ghostTrack.reset(new 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 = TrackRef(ghostTrackRefProd, ghostTracks->size());
       ghostTracks->push_back(*ghostTrack);

       if (m_directionWithGhostTrack) { 
         const GhostTrackPrediction &pred = ghostTrack->prediction();
         double lambda = pred.lambda(origin);
         dummy = Vertex(RecoVertex::convertPos(pred.position(lambda)),
                        RecoVertex::convertError(pred.positionError(lambda)),
                        0, 0, 0);
         pv = &dummy;
         direction = pred.direction();
       }
     }

     vector<float> prob2D, prob3D;
     vector<reco::btag::TrackIPData> ipData;

     for(unsigned int ind = 0; ind < transientTracks.size(); ind++) {
       const TransientTrack &transientTrack = transientTracks[ind];
       const 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<GhostTrackState> &states = ghostTrack->states();
         std::vector<GhostTrackState>::const_iterator pos =
                std::find_if(states.begin(), states.end(),
                             bind(equal_to<TransientTrack>(),
                                  bind(&GhostTrackState::track, _1),
                                  transientTrack));

         if (pos != states.end() && pos->isValid()) {
           VertexDistance3D dist;
           const 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(-1. -1.);
           trackIP.ghostTrackWeight = 0.;
         }
       } else {
         trackIP.distanceToGhostTrack = Measurement1D(-1. -1.);
         trackIP.ghostTrackWeight = 1.;
       }

       ipData.push_back(trackIP);

       if (m_computeProbabilities) {
         //probability with 3D ip
         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(ghostTracks, "ghostTracks");
   iEvent.put(result);
}

Member Data Documentation

template<class Container , class Base , class Helper >

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

private

Definition at line 142 of file IPProducer.h.

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

template<class Container , class Base , class Helper >

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

private

Definition at line 143 of file IPProducer.h.

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

template<class Container , class Base , class Helper >

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

private

Definition at line 139 of file IPProducer.h.

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

template<class Container , class Base , class Helper >

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

private

Definition at line 138 of file IPProducer.h.

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

template<class Container , class Base , class Helper >

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

private

Definition at line 135 of file IPProducer.h.

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

template<class Container , class Base , class Helper >

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

private

Definition at line 150 of file IPProducer.h.

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

template<class Container , class Base , class Helper >

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

private

Definition at line 151 of file IPProducer.h.

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

template<class Container , class Base , class Helper >

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

private

Definition at line 148 of file IPProducer.h.

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

template<class Container , class Base , class Helper >

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

private

Definition at line 149 of file IPProducer.h.

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

template<class Container , class Base , class Helper >

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

private

Definition at line 146 of file IPProducer.h.

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

template<class Container , class Base , class Helper >

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

private

Definition at line 147 of file IPProducer.h.

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

template<class Container , class Base , class Helper >

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

private

Definition at line 153 of file IPProducer.h.

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

template<class Container , class Base , class Helper >

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

private

Definition at line 152 of file IPProducer.h.

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

template<class Container , class Base , class Helper >

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

private

Definition at line 140 of file IPProducer.h.

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

template<class Container , class Base , class Helper >

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

private

Definition at line 155 of file IPProducer.h.

template<class Container , class Base , class Helper >

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

private

Definition at line 141 of file IPProducer.h.

template<class Container , class Base , class Helper >

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

private

Definition at line 144 of file IPProducer.h.

template<class Container , class Base , class Helper >

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

private

Definition at line 154 of file IPProducer.h.

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

template<class Container , class Base , class Helper >

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

private

Definition at line 136 of file IPProducer.h.

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