MultiTrackSelector Class Reference

#include <MultiTrackSelector.h>

Inheritance diagram for MultiTrackSelector:

Public Types
using	MVACollection = std::vector< float >
using	QualityMaskCollection = std::vector< unsigned char >
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

Public Member Functions
	MultiTrackSelector ()
	constructor More...
	MultiTrackSelector (const edm::ParameterSet &cfg)
	~MultiTrackSelector () override
	destructor More...
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

Protected Types
typedef math::XYZPoint	Point

Protected Member Functions
void	beginStream (edm::StreamID) final
Point	getBestVertex (const reco::TrackBaseRef, const reco::VertexCollection) const
void	processMVA (edm::Event &evt, const edm::EventSetup &es, const reco::BeamSpot &beamspot, const reco::VertexCollection &vertices, int selIndex, std::vector< float > &mvaVals_, bool writeIt=false) const
void	produce (edm::Event &evt, const edm::EventSetup &es) final
	process one event More...
virtual void	run (edm::Event &evt, const edm::EventSetup &es) const
bool	select (unsigned tsNum, const reco::BeamSpot &vertexBeamSpot, const TrackingRecHitCollection &recHits, const reco::Track &tk, const std::vector< Point > &points, std::vector< float > &vterr, std::vector< float > &vzerr, double mvaVal) const
	return class, or -1 if rejected More...
void	selectVertices (unsigned int tsNum, const reco::VertexCollection &vtxs, std::vector< Point > &points, std::vector< float > &vterr, std::vector< float > &vzerr) const

Protected Attributes
std::vector< bool >	applyAbsCutsIfNoPV_
std::vector< bool >	applyAdaptedPVCuts_
edm::EDGetTokenT< reco::BeamSpot >	beamspot_
std::vector< double >	chi2n_no1Dmod_par_
std::vector< double >	chi2n_par_
std::vector< std::vector< double > >	d0_par1_
std::vector< std::vector< double > >	d0_par2_
std::string	dbFileName_
std::vector< std::vector< double > >	dz_par1_
std::vector< std::vector< double > >	dz_par2_
std::vector< GBRForest * >	forest_
std::vector< std::string >	forestLabel_
std::vector< edm::ESGetToken< GBRForest, GBRWrapperRcd > >	forestToken_
edm::EDGetTokenT< TrackingRecHitCollection >	hSrc_
std::vector< bool >	keepAllTracks_
std::vector< double >	max_d0_
	Impact parameter absolute cuts. More...
std::vector< double >	max_d0NoPV_
std::vector< double >	max_eta_
std::vector< int32_t >	max_lostHitFraction_
std::vector< uint32_t >	max_lostLayers_
std::vector< int32_t >	max_minMissHitOutOrIn_
std::vector< double >	max_relpterr_
std::vector< double >	max_z0_
std::vector< double >	max_z0NoPV_
std::vector< uint32_t >	min_3Dlayers_
std::vector< double >	min_eta_
std::vector< uint32_t >	min_hits_bypass_
std::vector< uint32_t >	min_layers_
	Cuts on numbers of layers with hits/3D hits/lost hits. More...
std::vector< double >	min_MVA_
std::vector< uint32_t >	min_nhits_
std::vector< std::string >	mvaType_
std::vector< std::string >	name_
std::vector< double >	nSigmaZ_
std::vector< unsigned int >	preFilter_
std::vector< reco::TrackBase::TrackQuality >	qualityToSet_
std::vector< std::vector< double > >	res_par_
std::vector< bool >	setQualityBit_
	do I have to set a quality bit? More...
edm::EDGetTokenT< reco::TrackCollection >	src_
	source collection label More...
bool	useAnyMVA_
bool	useForestFromDB_
std::vector< bool >	useMVA_
std::vector< bool >	useMVAonly_
bool	useVertices_
bool	useVtxError_
std::vector< StringCutObjectSelector< reco::Vertex > >	vertexCut_
edm::EDGetTokenT< reco::VertexCollection >	vertices_
std::vector< int32_t >	vtxNumber_
	vertex cuts More...

Detailed Description

selects a subset of a track collection, copying extra information on demand

Author

David Lange

Definition at line 36 of file MultiTrackSelector.h.

Member Typedef Documentation

MVACollection

using MultiTrackSelector::MVACollection = std::vector<float>

Definition at line 45 of file MultiTrackSelector.h.

Point

typedef math::XYZPoint MultiTrackSelector::Point

protected

Definition at line 57 of file MultiTrackSelector.h.

QualityMaskCollection

using MultiTrackSelector::QualityMaskCollection = std::vector<unsigned char>

Definition at line 46 of file MultiTrackSelector.h.

Constructor & Destructor Documentation

MultiTrackSelector() [1/2]

MultiTrackSelector::MultiTrackSelector ( )

explicit

constructor

Definition at line 16 of file MultiTrackSelector.cc.

{ useForestFromDB_ = true; }

MultiTrackSelector() [2/2]

MultiTrackSelector::MultiTrackSelector ( const edm::ParameterSet &  cfg )

explicit

Definition at line 18 of file MultiTrackSelector.cc.

References applyAbsCutsIfNoPV_, applyAdaptedPVCuts_, looper::cfg, chi2n_no1Dmod_par_, chi2n_par_, d0_par1_, d0_par2_, dbFileName_, dz_par1_, dz_par2_, Exception, forest_, forestLabel_, forestToken_, mps_fire::i, dqmiolumiharvest::j, keepAllTracks_, label, max_d0_, max_d0NoPV_, max_eta_, max_lostHitFraction_, max_lostLayers_, max_minMissHitOutOrIn_, max_relpterr_, max_z0_, max_z0NoPV_, min_3Dlayers_, min_eta_, min_hits_bypass_, min_layers_, min_MVA_, min_nhits_, mvaType_, name_, nSigmaZ_, preFilter_, pixelTrack::qualityByName(), qualityToSet_, res_par_, setQualityBit_, AlCaHLTBitMon_QueryRunRegistry::string, useAnyMVA_, useForestFromDB_, useMVA_, useMVAonly_, useVertices_, useVtxError_, edm::vector_transform(), vertexCut_, vertices_, and vtxNumber_.

    : src_(consumes<reco::TrackCollection>(cfg.getParameter<edm::InputTag>("src"))),
      hSrc_(consumes<TrackingRecHitCollection>(cfg.getParameter<edm::InputTag>("src"))),
      beamspot_(consumes<reco::BeamSpot>(cfg.getParameter<edm::InputTag>("beamspot"))),
      useVertices_(cfg.getParameter<bool>("useVertices")),
      useVtxError_(cfg.getParameter<bool>("useVtxError"))
// now get the pset for each selector
{
  if (useVertices_)
    vertices_ = consumes<reco::VertexCollection>(cfg.getParameter<edm::InputTag>("vertices"));
  if (useVtxError_) {
    edm::LogWarning("MultiTRackSelector") << "you are executing buggy code, if intentional please help to fix it";
  }
  useAnyMVA_ = false;
  useForestFromDB_ = true;
  dbFileName_ = "";

  if (cfg.exists("useAnyMVA"))
    useAnyMVA_ = cfg.getParameter<bool>("useAnyMVA");

  if (useAnyMVA_) {
    if (cfg.exists("GBRForestFileName")) {
      dbFileName_ = cfg.getParameter<std::string>("GBRForestFileName");
      useForestFromDB_ = false;
    }
  }
  std::vector<edm::ParameterSet> trkSelectors(cfg.getParameter<std::vector<edm::ParameterSet>>("trackSelectors"));
  qualityToSet_.reserve(trkSelectors.size());
  vtxNumber_.reserve(trkSelectors.size());
  vertexCut_.reserve(trkSelectors.size());
  res_par_.reserve(trkSelectors.size());
  chi2n_par_.reserve(trkSelectors.size());
  chi2n_no1Dmod_par_.reserve(trkSelectors.size());
  d0_par1_.reserve(trkSelectors.size());
  dz_par1_.reserve(trkSelectors.size());
  d0_par2_.reserve(trkSelectors.size());
  dz_par2_.reserve(trkSelectors.size());
  applyAdaptedPVCuts_.reserve(trkSelectors.size());
  max_d0_.reserve(trkSelectors.size());
  max_z0_.reserve(trkSelectors.size());
  nSigmaZ_.reserve(trkSelectors.size());
  min_layers_.reserve(trkSelectors.size());
  min_3Dlayers_.reserve(trkSelectors.size());
  max_lostLayers_.reserve(trkSelectors.size());
  min_hits_bypass_.reserve(trkSelectors.size());
  applyAbsCutsIfNoPV_.reserve(trkSelectors.size());
  max_d0NoPV_.reserve(trkSelectors.size());
  max_z0NoPV_.reserve(trkSelectors.size());
  preFilter_.reserve(trkSelectors.size());
  max_relpterr_.reserve(trkSelectors.size());
  min_nhits_.reserve(trkSelectors.size());
  max_minMissHitOutOrIn_.reserve(trkSelectors.size());
  max_lostHitFraction_.reserve(trkSelectors.size());
  min_eta_.reserve(trkSelectors.size());
  max_eta_.reserve(trkSelectors.size());
  useMVA_.reserve(trkSelectors.size());
  useMVAonly_.reserve(trkSelectors.size());
  //mvaReaders_.reserve(trkSelectors.size());
  min_MVA_.reserve(trkSelectors.size());
  mvaType_.reserve(trkSelectors.size());
  forestLabel_.reserve(trkSelectors.size());
  forest_.reserve(trkSelectors.size());

  produces<edm::ValueMap<float>>("MVAVals");

  //foward compatibility
  produces<MVACollection>("MVAValues");

  for (unsigned int i = 0; i < trkSelectors.size(); i++) {
    qualityToSet_.push_back(TrackBase::undefQuality);
    // parameters for vertex selection
    vtxNumber_.push_back(useVertices_ ? trkSelectors[i].getParameter<int32_t>("vtxNumber") : 0);
    vertexCut_.push_back(useVertices_ ? trkSelectors[i].getParameter<std::string>("vertexCut") : nullptr);
    //  parameters for adapted optimal cuts on chi2 and primary vertex compatibility
    res_par_.push_back(trkSelectors[i].getParameter<std::vector<double>>("res_par"));
    chi2n_par_.push_back(trkSelectors[i].getParameter<double>("chi2n_par"));
    chi2n_no1Dmod_par_.push_back(trkSelectors[i].getParameter<double>("chi2n_no1Dmod_par"));
    d0_par1_.push_back(trkSelectors[i].getParameter<std::vector<double>>("d0_par1"));
    dz_par1_.push_back(trkSelectors[i].getParameter<std::vector<double>>("dz_par1"));
    d0_par2_.push_back(trkSelectors[i].getParameter<std::vector<double>>("d0_par2"));
    dz_par2_.push_back(trkSelectors[i].getParameter<std::vector<double>>("dz_par2"));
    // Boolean indicating if adapted primary vertex compatibility cuts are to be applied.
    applyAdaptedPVCuts_.push_back(trkSelectors[i].getParameter<bool>("applyAdaptedPVCuts"));
    // Impact parameter absolute cuts.
    max_d0_.push_back(trkSelectors[i].getParameter<double>("max_d0"));
    max_z0_.push_back(trkSelectors[i].getParameter<double>("max_z0"));
    nSigmaZ_.push_back(trkSelectors[i].getParameter<double>("nSigmaZ"));
    // Cuts on numbers of layers with hits/3D hits/lost hits.
    min_layers_.push_back(trkSelectors[i].getParameter<uint32_t>("minNumberLayers"));
    min_3Dlayers_.push_back(trkSelectors[i].getParameter<uint32_t>("minNumber3DLayers"));
    max_lostLayers_.push_back(trkSelectors[i].getParameter<uint32_t>("maxNumberLostLayers"));
    min_hits_bypass_.push_back(trkSelectors[i].getParameter<uint32_t>("minHitsToBypassChecks"));
    // Flag to apply absolute cuts if no PV passes the selection
    applyAbsCutsIfNoPV_.push_back(trkSelectors[i].getParameter<bool>("applyAbsCutsIfNoPV"));
    keepAllTracks_.push_back(trkSelectors[i].getParameter<bool>("keepAllTracks"));
    max_relpterr_.push_back(trkSelectors[i].getParameter<double>("max_relpterr"));
    min_nhits_.push_back(trkSelectors[i].getParameter<uint32_t>("min_nhits"));
    max_minMissHitOutOrIn_.push_back(trkSelectors[i].existsAs<int32_t>("max_minMissHitOutOrIn")
                                         ? trkSelectors[i].getParameter<int32_t>("max_minMissHitOutOrIn")
                                         : 99);
    max_lostHitFraction_.push_back(trkSelectors[i].existsAs<double>("max_lostHitFraction")
                                       ? trkSelectors[i].getParameter<double>("max_lostHitFraction")
                                       : 1.0);
    min_eta_.push_back(trkSelectors[i].existsAs<double>("min_eta") ? trkSelectors[i].getParameter<double>("min_eta")
                                                                   : -9999);
    max_eta_.push_back(trkSelectors[i].existsAs<double>("max_eta") ? trkSelectors[i].getParameter<double>("max_eta")
                                                                   : 9999);

    setQualityBit_.push_back(false);
    std::string qualityStr = trkSelectors[i].getParameter<std::string>("qualityBit");
    if (!qualityStr.empty()) {
      setQualityBit_[i] = true;
      qualityToSet_[i] = TrackBase::qualityByName(trkSelectors[i].getParameter<std::string>("qualityBit"));
    }

    if (setQualityBit_[i] && (qualityToSet_[i] == TrackBase::undefQuality))
      throw cms::Exception("Configuration")
          << "You can't set the quality bit " << trkSelectors[i].getParameter<std::string>("qualityBit")
          << " as it is 'undefQuality' or unknown.\n";

    if (applyAbsCutsIfNoPV_[i]) {
      max_d0NoPV_.push_back(trkSelectors[i].getParameter<double>("max_d0NoPV"));
      max_z0NoPV_.push_back(trkSelectors[i].getParameter<double>("max_z0NoPV"));
    } else {  //dummy values
      max_d0NoPV_.push_back(0.);
      max_z0NoPV_.push_back(0.);
    }

    name_.push_back(trkSelectors[i].getParameter<std::string>("name"));

    preFilter_[i] = trkSelectors.size();  // no prefilter

    std::string pfName = trkSelectors[i].getParameter<std::string>("preFilterName");
    if (!pfName.empty()) {
      bool foundPF = false;
      for (unsigned int j = 0; j < i; j++)
        if (name_[j] == pfName) {
          foundPF = true;
          preFilter_[i] = j;
        }
      if (!foundPF)
        throw cms::Exception("Configuration") << "Invalid prefilter name in MultiTrackSelector "
                                              << trkSelectors[i].getParameter<std::string>("preFilterName");
    }

    //    produces<std::vector<int> >(name_[i]).setBranchAlias( name_[i] + "TrackQuals");
    produces<edm::ValueMap<int>>(name_[i]).setBranchAlias(name_[i] + "TrackQuals");
    produces<QualityMaskCollection>(name_[i]).setBranchAlias(name_[i] + "QualityMasks");
    if (useAnyMVA_) {
      bool thisMVA = false;
      if (trkSelectors[i].exists("useMVA"))
        thisMVA = trkSelectors[i].getParameter<bool>("useMVA");
      useMVA_.push_back(thisMVA);
      if (thisMVA) {
        double minVal = -1;
        if (trkSelectors[i].exists("minMVA"))
          minVal = trkSelectors[i].getParameter<double>("minMVA");
        min_MVA_.push_back(minVal);
        mvaType_.push_back(trkSelectors[i].exists("mvaType") ? trkSelectors[i].getParameter<std::string>("mvaType")
                                                             : "Detached");
        forestLabel_.push_back(trkSelectors[i].exists("GBRForestLabel")
                                   ? trkSelectors[i].getParameter<std::string>("GBRForestLabel")
                                   : "MVASelectorIter0");
        useMVAonly_.push_back(trkSelectors[i].exists("useMVAonly") ? trkSelectors[i].getParameter<bool>("useMVAonly")
                                                                   : false);
      } else {
        min_MVA_.push_back(-9999.0);
        useMVAonly_.push_back(false);
        mvaType_.push_back("Detached");
        forestLabel_.push_back("MVASelectorIter0");
      }
    } else {
      useMVA_.push_back(false);
      useMVAonly_.push_back(false);
      min_MVA_.push_back(-9999.0);
      mvaType_.push_back("Detached");
      forestLabel_.push_back("MVASelectorIter0");
    }
  }

  if (useForestFromDB_) {
    forestToken_ = edm::vector_transform(forestLabel_, [this](auto const& label) {
      return esConsumes<GBRForest, GBRWrapperRcd>(edm::ESInputTag("", label));
    });
  }
}

~MultiTrackSelector()

MultiTrackSelector::~MultiTrackSelector ( )

override

destructor

Definition at line 205 of file MultiTrackSelector.cc.

References forest_.

                                        {
  for (auto forest : forest_)
    delete forest;
}

Member Function Documentation

beginStream()

void MultiTrackSelector::beginStream ( edm::StreamID  )

finalprotected

Definition at line 210 of file MultiTrackSelector.cc.

References dbFileName_, forest_, forestLabel_, mps_fire::i, createfilelist::int, and useForestFromDB_.

                                                {
  if (!useForestFromDB_) {
    TFile gbrfile(dbFileName_.c_str());
    for (int i = 0; i < (int)forestLabel_.size(); i++) {
      forest_[i] = (GBRForest*)gbrfile.Get(forestLabel_[i].c_str());
    }
  }
}

getBestVertex()

MultiTrackSelector::Point MultiTrackSelector::getBestVertex ( const reco::TrackBaseRef  track, const reco::VertexCollection  vertices  ) const

protected

Definition at line 656 of file MultiTrackSelector.cc.

References PVValHelper::dz, AlCaHLTBitMon_ParallelJobs::p, HLT_2022v11_cff::track, bphysicsOniaDQM_cfi::vertex, AlignmentTracksFromVertexSelector_cfi::vertices, and w().

Referenced by processMVA().

                                                                                                             {
  Point p(0, 0, -99999);
  Point p_dz(0, 0, -99999);
  float bestWeight = 0;
  float dzmin = 10000;
  bool weightMatch = false;
  for (auto const& vertex : vertices) {
    float w = vertex.trackWeight(track);
    const Point& v_pos = vertex.position();
    if (w > bestWeight) {
      p = v_pos;
      bestWeight = w;
      weightMatch = true;
    }
    float dz = fabs(track.get()->dz(v_pos));
    if (dz < dzmin) {
      p_dz = v_pos;
      dzmin = dz;
    }
  }
  if (weightMatch)
    return p;
  else
    return p_dz;
}

processMVA()

void MultiTrackSelector::processMVA ( edm::Event &  evt, const edm::EventSetup &  es, const reco::BeamSpot &  beamspot, const reco::VertexCollection &  vertices, int  selIndex, std::vector< float > &  mvaVals_, bool  writeIt = false  ) const

protected

Definition at line 532 of file MultiTrackSelector.cc.

References cms::cuda::assert(), hltPixelTracks_cff::chi2, reco::TrackBase::chi2(), chi2n, reco::TrackBase::dxy(), reco::TrackBase::dz(), reco::TrackBase::eta(), reco::Track::extra(), f, dqmMemoryStats::float, forest_, forestToken_, getBestVertex(), edm::Event::getByToken(), GBRForest::GetClassifier(), edm::EventSetup::getData(), reco::TrackBase::hitPattern(), hSrc_, SiStripPI::max, SiStripPI::min, reco::HitPattern::MISSING_INNER_HITS, reco::HitPattern::MISSING_OUTER_HITS, eostools::move(), mvaType_, ndof, reco::TrackBase::ndof(), reco::TrackBase::normalizedChi2(), reco::TrackBase::numberOfLostHits(), reco::HitPattern::numberOfLostTrackerHits(), reco::TrackBase::numberOfValidHits(), reco::HitPattern::numberOfValidStripLayersWithMonoAndStereo(), reco::HitPattern::pixelLayersWithMeasurement(), reco::TrackBase::pt(), reco::TrackBase::ptError(), edm::Event::put(), reco::Track::recHitsSize(), src_, gmt_cfi::srcTracks, reco::HitPattern::TRACK_HITS, reco::HitPattern::trackerLayersWithMeasurement(), reco::HitPattern::trackerLayersWithoutMeasurement(), useAnyMVA_, useForestFromDB_, useMVA_, and AlignmentTracksFromVertexSelector_cfi::vertices.

Referenced by AnalyticalTrackSelector::run(), and run().

                                                        {
  using namespace std;
  using namespace edm;
  using namespace reco;

  // Get tracks
  Handle<TrackCollection> hSrcTrack;
  evt.getByToken(src_, hSrcTrack);
  const TrackCollection& srcTracks(*hSrcTrack);
  RefToBaseProd<Track> rtbpTrackCollection(hSrcTrack);
  assert(mvaVals_.size() == srcTracks.size());

  // get hits in track..
  Handle<TrackingRecHitCollection> hSrcHits;
  evt.getByToken(hSrc_, hSrcHits);
  const TrackingRecHitCollection& srcHits(*hSrcHits);

  auto mvaValValueMap = std::make_unique<edm::ValueMap<float>>();
  edm::ValueMap<float>::Filler mvaFiller(*mvaValValueMap);

  if (!useAnyMVA_ && writeIt) {
    // mvaVals_ already initalized...
    mvaFiller.insert(hSrcTrack, mvaVals_.begin(), mvaVals_.end());
    mvaFiller.fill();
    evt.put(std::move(mvaValValueMap), "MVAVals");
    auto mvas = std::make_unique<MVACollection>(mvaVals_.begin(), mvaVals_.end());
    evt.put(std::move(mvas), "MVAValues");
    return;
  }

  if (!useMVA_[selIndex] && !writeIt)
    return;

  size_t current = 0;
  for (TrackCollection::const_iterator it = srcTracks.begin(), ed = srcTracks.end(); it != ed; ++it, ++current) {
    const Track& trk = *it;
    RefToBase<Track> trackRef(rtbpTrackCollection, current);
    auto tmva_ndof_ = trk.ndof();
    auto tmva_nlayers_ = trk.hitPattern().trackerLayersWithMeasurement();
    auto tmva_nlayers3D_ =
        trk.hitPattern().pixelLayersWithMeasurement() + trk.hitPattern().numberOfValidStripLayersWithMonoAndStereo();
    auto tmva_nlayerslost_ = trk.hitPattern().trackerLayersWithoutMeasurement(reco::HitPattern::TRACK_HITS);
    float chi2n = trk.normalizedChi2();
    float chi2n_no1Dmod = chi2n;

    int count1dhits = 0;
    auto ith = trk.extra()->firstRecHit();
    auto edh = ith + trk.recHitsSize();
    for (; ith < edh; ++ith) {
      const TrackingRecHit& hit = srcHits[ith];
      if (hit.dimension() == 1)
        ++count1dhits;
    }
    if (count1dhits > 0) {
      float chi2 = trk.chi2();
      float ndof = trk.ndof();
      chi2n = (chi2 + count1dhits) / float(ndof + count1dhits);
    }
    auto tmva_chi2n_ = chi2n;
    auto tmva_chi2n_no1dmod_ = chi2n_no1Dmod;
    auto tmva_eta_ = trk.eta();
    auto tmva_relpterr_ = float(trk.ptError()) / std::max(float(trk.pt()), 0.000001f);
    auto tmva_nhits_ = trk.numberOfValidHits();
    int lostIn = trk.hitPattern().numberOfLostTrackerHits(reco::HitPattern::MISSING_INNER_HITS);
    int lostOut = trk.hitPattern().numberOfLostTrackerHits(reco::HitPattern::MISSING_OUTER_HITS);
    auto tmva_minlost_ = std::min(lostIn, lostOut);
    auto tmva_lostmidfrac_ = trk.numberOfLostHits() / (trk.numberOfValidHits() + trk.numberOfLostHits());
    auto tmva_absd0_ = fabs(-trk.dxy(beamspot.position()));
    auto tmva_absdz_ = fabs(trk.dz(beamspot.position()));
    Point bestVertex = getBestVertex(trackRef, vertices);
    auto tmva_absd0PV_ = fabs(trk.dxy(bestVertex));
    auto tmva_absdzPV_ = fabs(trk.dz(bestVertex));
    auto tmva_pt_ = trk.pt();

    GBRForest const* forest = forest_[selIndex];
    if (useForestFromDB_) {
      forest = &es.getData(forestToken_[selIndex]);
    }

    float gbrVals_[16];
    gbrVals_[0] = tmva_pt_;
    gbrVals_[1] = tmva_lostmidfrac_;
    gbrVals_[2] = tmva_minlost_;
    gbrVals_[3] = tmva_nhits_;
    gbrVals_[4] = tmva_relpterr_;
    gbrVals_[5] = tmva_eta_;
    gbrVals_[6] = tmva_chi2n_no1dmod_;
    gbrVals_[7] = tmva_chi2n_;
    gbrVals_[8] = tmva_nlayerslost_;
    gbrVals_[9] = tmva_nlayers3D_;
    gbrVals_[10] = tmva_nlayers_;
    gbrVals_[11] = tmva_ndof_;
    gbrVals_[12] = tmva_absd0PV_;
    gbrVals_[13] = tmva_absdzPV_;
    gbrVals_[14] = tmva_absdz_;
    gbrVals_[15] = tmva_absd0_;

    if (mvaType_[selIndex] == "Prompt") {
      auto gbrVal = forest->GetClassifier(gbrVals_);
      mvaVals_[current] = gbrVal;
    } else {
      float detachedGbrVals_[12];
      for (int jjj = 0; jjj < 12; jjj++)
        detachedGbrVals_[jjj] = gbrVals_[jjj];
      auto gbrVal = forest->GetClassifier(detachedGbrVals_);
      mvaVals_[current] = gbrVal;
    }
  }

  if (writeIt) {
    mvaFiller.insert(hSrcTrack, mvaVals_.begin(), mvaVals_.end());
    mvaFiller.fill();
    evt.put(std::move(mvaValValueMap), "MVAVals");
    auto mvas = std::make_unique<MVACollection>(mvaVals_.begin(), mvaVals_.end());
    evt.put(std::move(mvas), "MVAValues");
  }
}

produce()

void MultiTrackSelector::produce ( edm::Event &  evt, const edm::EventSetup &  es  )

inlinefinalprotected

process one event

Definition at line 59 of file MultiTrackSelector.h.

References writedatasetfile::run.

{ run(evt, es); }

run()

void MultiTrackSelector::run ( edm::Event &  evt, const edm::EventSetup &  es  ) const

protectedvirtual

Reimplemented in AnalyticalTrackSelector.

Definition at line 219 of file MultiTrackSelector.cc.

References beamspot_, edm::HandleBase::failedToGet(), trigObjTnPSource_cfi::filler, edm::Event::getByToken(), muons_cff::highPurity, hSrc_, mps_fire::i, dqmiolumiharvest::j, keepAllTracks_, LogTrace, loose, SiStripPI::max, eostools::move(), name_, convertSQLiteXML::ok, HLT_FULL_cff::points, preFilter_, processMVA(), edm::Handle< T >::product(), reco::TrackBase::pt(), edm::Event::put(), submitPVResolutionJobs::q, reco::TrackBase::qualityMask(), qualityToSet_, select(), selectVertices(), setQualityBit_, src_, gmt_cfi::srcTracks, useAnyMVA_, useVertices_, and vertices_.

                                                                         {
  using namespace std;
  using namespace edm;
  using namespace reco;

  // Get tracks
  Handle<TrackCollection> hSrcTrack;
  evt.getByToken(src_, hSrcTrack);

  const TrackCollection& srcTracks(*hSrcTrack);
  if (hSrcTrack.failedToGet())
    edm::LogWarning("MultiTrackSelector") << "could not get Track collection";

  // get hits in track..
  Handle<TrackingRecHitCollection> hSrcHits;
  evt.getByToken(hSrc_, hSrcHits);
  const TrackingRecHitCollection& srcHits(*hSrcHits);

  // looking for the beam spot
  edm::Handle<reco::BeamSpot> hBsp;
  evt.getByToken(beamspot_, hBsp);
  const reco::BeamSpot& vertexBeamSpot(*hBsp);

  // Select good primary vertices for use in subsequent track selection
  edm::Handle<reco::VertexCollection> hVtx;
  if (useVertices_) {
    evt.getByToken(vertices_, hVtx);
    if (hVtx.failedToGet())
      edm::LogWarning("MultiTrackSelector") << "could not get Vertex collection";
  }

  unsigned int trkSize = srcTracks.size();
  std::vector<int> selTracksSave(qualityToSet_.size() * trkSize, 0);

  std::vector<Point> points;
  std::vector<float> vterr, vzerr;
  if (useVertices_)
    selectVertices(0, *hVtx, points, vterr, vzerr);
  //auto vtxP = points.empty() ? vertexBeamSpot.position() : points[0]; // rare, very rare, still happens!
  for (unsigned int i = 0; i < qualityToSet_.size(); i++) {
    std::vector<float> mvaVals_(srcTracks.size(), -99.f);
    processMVA(evt, es, vertexBeamSpot, *(hVtx.product()), i, mvaVals_, i == 0 ? true : false);
    std::vector<int> selTracks(trkSize, 0);
    auto selTracksValueMap = std::make_unique<edm::ValueMap<int>>();
    edm::ValueMap<int>::Filler filler(*selTracksValueMap);

    if (useVertices_)
      selectVertices(i, *hVtx, points, vterr, vzerr);

    // Loop over tracks
    size_t current = 0;
    for (TrackCollection::const_iterator it = srcTracks.begin(), ed = srcTracks.end(); it != ed; ++it, ++current) {
      const Track& trk = *it;
      // Check if this track passes cuts

      LogTrace("TrackSelection") << "ready to check track with pt=" << trk.pt();

      //already removed
      bool ok = true;
      if (preFilter_[i] < i && selTracksSave[preFilter_[i] * trkSize + current] < 0) {
        selTracks[current] = -1;
        ok = false;
        if (!keepAllTracks_[i])
          continue;
      } else {
        float mvaVal = 0;
        if (useAnyMVA_)
          mvaVal = mvaVals_[current];
        ok = select(i, vertexBeamSpot, srcHits, trk, points, vterr, vzerr, mvaVal);
        if (!ok) {
          LogTrace("TrackSelection") << "track with pt=" << trk.pt() << " NOT selected";
          if (!keepAllTracks_[i]) {
            selTracks[current] = -1;
            continue;
          }
        } else
          LogTrace("TrackSelection") << "track with pt=" << trk.pt() << " selected";
      }

      if (preFilter_[i] < i) {
        selTracks[current] = selTracksSave[preFilter_[i] * trkSize + current];
      } else {
        selTracks[current] = trk.qualityMask();
      }
      if (ok && setQualityBit_[i]) {
        selTracks[current] = (selTracks[current] | (1 << qualityToSet_[i]));
        if (qualityToSet_[i] == TrackBase::tight) {
          selTracks[current] = (selTracks[current] | (1 << TrackBase::loose));
        } else if (qualityToSet_[i] == TrackBase::highPurity) {
          selTracks[current] = (selTracks[current] | (1 << TrackBase::loose));
          selTracks[current] = (selTracks[current] | (1 << TrackBase::tight));
        }
        if (!points.empty()) {
          if (qualityToSet_[i] == TrackBase::loose) {
            selTracks[current] = (selTracks[current] | (1 << TrackBase::looseSetWithPV));
          } else if (qualityToSet_[i] == TrackBase::highPurity) {
            selTracks[current] = (selTracks[current] | (1 << TrackBase::looseSetWithPV));
            selTracks[current] = (selTracks[current] | (1 << TrackBase::highPuritySetWithPV));
          }
        }
      }
    }
    for (unsigned int j = 0; j < trkSize; j++)
      selTracksSave[j + i * trkSize] = selTracks[j];
    filler.insert(hSrcTrack, selTracks.begin(), selTracks.end());
    filler.fill();

    //    evt.put(std::move(selTracks),name_[i]);
    evt.put(std::move(selTracksValueMap), name_[i]);
    for (auto& q : selTracks)
      q = std::max(q, 0);
    auto quals = std::make_unique<QualityMaskCollection>(selTracks.begin(), selTracks.end());
    evt.put(std::move(quals), name_[i]);
  }
}

select()

bool MultiTrackSelector::select ( unsigned  tsNum, const reco::BeamSpot &  vertexBeamSpot, const TrackingRecHitCollection &  recHits, const reco::Track &  tk, const std::vector< Point > &  points, std::vector< float > &  vterr, std::vector< float > &  vzerr, double  mvaVal  ) const

protected

return class, or -1 if rejected

Definition at line 335 of file MultiTrackSelector.cc.

References funct::abs(), applyAbsCutsIfNoPV_, applyAdaptedPVCuts_, hltPixelTracks_cff::chi2, reco::TrackBase::chi2(), chi2n, chi2n_no1Dmod_par_, chi2n_par_, d0, d0_par1_, d0_par2_, TrackSplittingMonitor_cfi::d0Cut, reco::TrackBase::d0Error(), reco::TrackBase::dxy(), PVValHelper::dz, reco::TrackBase::dz(), dz_par1_, dz_par2_, TrackSplittingMonitor_cfi::dzCut, reco::TrackBase::dzError(), mps_fire::end, PVValHelper::eta, reco::TrackBase::eta(), reco::Track::extra(), f, dqmMemoryStats::float, reco::TrackBase::hitPattern(), gpuVertexFinder::iv, LogDebug, LogTrace, SiStripPI::max, max_d0_, max_d0NoPV_, max_eta_, max_lostHitFraction_, max_lostLayers_, max_minMissHitOutOrIn_, max_relpterr_, max_z0_, max_z0NoPV_, SiStripPI::min, min_3Dlayers_, min_eta_, min_hits_bypass_, min_layers_, min_MVA_, min_nhits_, reco::HitPattern::MISSING_INNER_HITS, reco::HitPattern::MISSING_OUTER_HITS, ndof, reco::TrackBase::ndof(), nhits, nlayers, reco::TrackBase::normalizedChi2(), nSigmaZ_, reco::TrackBase::numberOfLostHits(), reco::HitPattern::numberOfLostTrackerHits(), reco::TrackBase::numberOfValidHits(), reco::HitPattern::numberOfValidStripLayersWithMonoAndStereo(), reco::HitPattern::pixelLayersWithMeasurement(), point, HLT_FULL_cff::points, reco::BeamSpot::position(), funct::pow(), DiDispStaMuonMonitor_cfi::pt, reco::TrackBase::pt(), reco::TrackBase::ptError(), FastTrackerRecHitMaskProducer_cfi::recHits, reco::Track::recHitsSize(), relpterr, res_par_, reco::BeamSpot::sigmaZ(), mathSSE::sqrt(), reco::HitPattern::TRACK_HITS, reco::HitPattern::trackerLayersWithMeasurement(), reco::HitPattern::trackerLayersWithoutMeasurement(), useAnyMVA_, useMVA_, useMVAonly_, and useVtxError_.

Referenced by AnalyticalTrackSelector::run(), and run().

                                                     {
  // Decide if the given track passes selection cuts.

  using namespace std;

  //cuts on number of valid hits
  auto nhits = tk.numberOfValidHits();
  if (nhits >= min_hits_bypass_[tsNum])
    return true;
  if (nhits < min_nhits_[tsNum])
    return false;

  if (tk.ndof() < 1E-5)
    return false;

  //Adding the MVA selection before any other cut//
  if (useAnyMVA_ && useMVA_[tsNum]) {
    if (useMVAonly_[tsNum])
      return mvaVal > min_MVA_[tsNum];
    if (mvaVal < min_MVA_[tsNum])
      return false;
  }
  //End of MVA selection section//

  // Cuts on numbers of layers with hits/3D hits/lost hits.
  uint32_t nlayers = tk.hitPattern().trackerLayersWithMeasurement();
  uint32_t nlayers3D =
      tk.hitPattern().pixelLayersWithMeasurement() + tk.hitPattern().numberOfValidStripLayersWithMonoAndStereo();
  uint32_t nlayersLost = tk.hitPattern().trackerLayersWithoutMeasurement(reco::HitPattern::TRACK_HITS);
  LogDebug("TrackSelection") << "cuts on nlayers: " << nlayers << " " << nlayers3D << " " << nlayersLost << " vs "
                             << min_layers_[tsNum] << " " << min_3Dlayers_[tsNum] << " " << max_lostLayers_[tsNum];
  if (nlayers < min_layers_[tsNum])
    return false;
  if (nlayers3D < min_3Dlayers_[tsNum])
    return false;
  if (nlayersLost > max_lostLayers_[tsNum])
    return false;
  LogTrace("TrackSelection") << "cuts on nlayers passed";

  float chi2n = tk.normalizedChi2();
  float chi2n_no1Dmod = chi2n;

  int count1dhits = 0;
  auto ith = tk.extra()->firstRecHit();
  auto edh = ith + tk.recHitsSize();
  for (; ith < edh; ++ith) {
    const TrackingRecHit& hit = recHits[ith];
    if (hit.dimension() == 1)
      ++count1dhits;
  }
  if (count1dhits > 0) {
    float chi2 = tk.chi2();
    float ndof = tk.ndof();
    chi2n = (chi2 + count1dhits) / float(ndof + count1dhits);
  }
  // For each 1D rechit, the chi^2 and ndof is increased by one.  This is a way of retaining approximately
  // the same normalized chi^2 distribution as with 2D rechits.
  if (chi2n > chi2n_par_[tsNum] * nlayers)
    return false;

  if (chi2n_no1Dmod > chi2n_no1Dmod_par_[tsNum] * nlayers)
    return false;

  // Get track parameters
  float pt = std::max(float(tk.pt()), 0.000001f);
  float eta = tk.eta();
  if (eta < min_eta_[tsNum] || eta > max_eta_[tsNum])
    return false;

  //cuts on relative error on pt
  float relpterr = float(tk.ptError()) / pt;
  if (relpterr > max_relpterr_[tsNum])
    return false;

  int lostIn = tk.hitPattern().numberOfLostTrackerHits(reco::HitPattern::MISSING_INNER_HITS);
  int lostOut = tk.hitPattern().numberOfLostTrackerHits(reco::HitPattern::MISSING_OUTER_HITS);
  int minLost = std::min(lostIn, lostOut);
  if (minLost > max_minMissHitOutOrIn_[tsNum])
    return false;
  float lostMidFrac = tk.numberOfLostHits() / (tk.numberOfValidHits() + tk.numberOfLostHits());
  if (lostMidFrac > max_lostHitFraction_[tsNum])
    return false;

  //other track parameters
  float d0 = -tk.dxy(vertexBeamSpot.position()), d0E = tk.d0Error(), dz = tk.dz(vertexBeamSpot.position()),
        dzE = tk.dzError();

  // parametrized d0 resolution for the track pt
  float nomd0E = sqrt(res_par_[tsNum][0] * res_par_[tsNum][0] + (res_par_[tsNum][1] / pt) * (res_par_[tsNum][1] / pt));
  // parametrized z0 resolution for the track pt and eta
  float nomdzE = nomd0E * (std::cosh(eta));

  float dzCut = std::min(powN(dz_par1_[tsNum][0] * nlayers, int(dz_par1_[tsNum][1] + 0.5)) * nomdzE,
                         powN(dz_par2_[tsNum][0] * nlayers, int(dz_par2_[tsNum][1] + 0.5)) * dzE);
  float d0Cut = std::min(powN(d0_par1_[tsNum][0] * nlayers, int(d0_par1_[tsNum][1] + 0.5)) * nomd0E,
                         powN(d0_par2_[tsNum][0] * nlayers, int(d0_par2_[tsNum][1] + 0.5)) * d0E);

  // ---- PrimaryVertex compatibility cut
  bool primaryVertexZCompatibility(false);
  bool primaryVertexD0Compatibility(false);

  if (points.empty()) {  //If not primaryVertices are reconstructed, check just the compatibility with the BS
    //z0 within (n sigma + dzCut) of the beam spot z, if no good vertex is found
    if (abs(dz) < hypot(vertexBeamSpot.sigmaZ() * nSigmaZ_[tsNum], dzCut))
      primaryVertexZCompatibility = true;
    // d0 compatibility with beam line
    if (abs(d0) < d0Cut)
      primaryVertexD0Compatibility = true;
  }

  int iv = 0;
  for (std::vector<Point>::const_iterator point = points.begin(), end = points.end(); point != end; ++point) {
    LogTrace("TrackSelection") << "Test track w.r.t. vertex with z position " << point->z();
    if (primaryVertexZCompatibility && primaryVertexD0Compatibility)
      break;
    float dzPV = tk.dz(*point);   //re-evaluate the dz with respect to the vertex position
    float d0PV = tk.dxy(*point);  //re-evaluate the dxy with respect to the vertex position
    if (useVtxError_) {
      float dzErrPV = std::sqrt(dzE * dzE + vzerr[iv] * vzerr[iv]);  // include vertex error in z
      float d0ErrPV = std::sqrt(d0E * d0E + vterr[iv] * vterr[iv]);  // include vertex error in xy
      iv++;
      if (abs(dzPV) < dz_par1_[tsNum][0] * pow(nlayers, dz_par1_[tsNum][1]) * nomdzE &&
          abs(dzPV) < dz_par2_[tsNum][0] * pow(nlayers, dz_par2_[tsNum][1]) * dzErrPV && abs(dzPV) < max_z0_[tsNum])
        primaryVertexZCompatibility = true;
      if (abs(d0PV) < d0_par1_[tsNum][0] * pow(nlayers, d0_par1_[tsNum][1]) * nomd0E &&
          abs(d0PV) < d0_par2_[tsNum][0] * pow(nlayers, d0_par2_[tsNum][1]) * d0ErrPV && abs(d0PV) < max_d0_[tsNum])
        primaryVertexD0Compatibility = true;
    } else {
      if (abs(dzPV) < dzCut)
        primaryVertexZCompatibility = true;
      if (abs(d0PV) < d0Cut)
        primaryVertexD0Compatibility = true;
    }
    LogTrace("TrackSelection") << "distances " << dzPV << " " << d0PV << " vs " << dzCut << " " << d0Cut;
  }

  if (points.empty() && applyAbsCutsIfNoPV_[tsNum]) {
    if (abs(dz) > max_z0NoPV_[tsNum] || abs(d0) > max_d0NoPV_[tsNum])
      return false;
  } else {
    // Absolute cuts on all tracks impact parameters with respect to beam-spot.
    // If BS is not compatible, verify if at least the reco-vertex is compatible (useful for incorrect BS settings)
    if (abs(d0) > max_d0_[tsNum] && !primaryVertexD0Compatibility)
      return false;
    LogTrace("TrackSelection") << "absolute cuts on d0 passed";
    if (abs(dz) > max_z0_[tsNum] && !primaryVertexZCompatibility)
      return false;
    LogTrace("TrackSelection") << "absolute cuts on dz passed";
  }

  LogTrace("TrackSelection") << "cuts on PV: apply adapted PV cuts? " << applyAdaptedPVCuts_[tsNum]
                             << " d0 compatibility? " << primaryVertexD0Compatibility << " z compatibility? "
                             << primaryVertexZCompatibility;

  if (applyAdaptedPVCuts_[tsNum]) {
    return (primaryVertexD0Compatibility && primaryVertexZCompatibility);
  } else {
    return true;
  }
}

selectVertices()

void MultiTrackSelector::selectVertices ( unsigned int  tsNum, const reco::VertexCollection &  vtxs, std::vector< Point > &  points, std::vector< float > &  vterr, std::vector< float > &  vzerr  ) const

protected

Definition at line 507 of file MultiTrackSelector.cc.

References LogDebug, LogTrace, HLT_FULL_cff::points, mathSSE::sqrt(), vertexCut_, extraflags_cff::vtx, and vtxNumber_.

Referenced by AnalyticalTrackSelector::run(), and run().

                                                                       {
  // Select good primary vertices
  using namespace reco;
  int32_t toTake = vtxNumber_[tsNum];
  for (VertexCollection::const_iterator it = vtxs.begin(), ed = vtxs.end(); it != ed; ++it) {
    LogDebug("SelectVertex") << " select vertex with z position " << it->z() << " " << it->chi2() << " " << it->ndof()
                             << " " << TMath::Prob(it->chi2(), static_cast<int32_t>(it->ndof()));
    Vertex vtx = *it;
    bool pass = vertexCut_[tsNum](vtx);
    if (pass) {
      points.push_back(it->position());
      vterr.push_back(sqrt(it->yError() * it->xError()));
      vzerr.push_back(it->zError());
      LogTrace("SelectVertex") << " SELECTED vertex with z position " << it->z();
      toTake--;
      if (toTake == 0)
        break;
    }
  }
}

Member Data Documentation

applyAbsCutsIfNoPV_

std::vector<bool> MultiTrackSelector::applyAbsCutsIfNoPV_

protected

Definition at line 139 of file MultiTrackSelector.h.

Referenced by AnalyticalTrackSelector::AnalyticalTrackSelector(), MultiTrackSelector(), and select().

applyAdaptedPVCuts_

std::vector<bool> MultiTrackSelector::applyAdaptedPVCuts_

protected

Definition at line 113 of file MultiTrackSelector.h.

Referenced by AnalyticalTrackSelector::AnalyticalTrackSelector(), MultiTrackSelector(), and select().

beamspot_

edm::EDGetTokenT<reco::BeamSpot> MultiTrackSelector::beamspot_

protected

Definition at line 89 of file MultiTrackSelector.h.

Referenced by AnalyticalTrackSelector::AnalyticalTrackSelector(), AnalyticalTrackSelector::run(), and run().

chi2n_no1Dmod_par_

std::vector<double> MultiTrackSelector::chi2n_no1Dmod_par_

protected

Definition at line 107 of file MultiTrackSelector.h.

Referenced by AnalyticalTrackSelector::AnalyticalTrackSelector(), MultiTrackSelector(), and select().

chi2n_par_

std::vector<double> MultiTrackSelector::chi2n_par_

protected

Definition at line 106 of file MultiTrackSelector.h.

Referenced by AnalyticalTrackSelector::AnalyticalTrackSelector(), MultiTrackSelector(), and select().

d0_par1_

std::vector<std::vector<double> > MultiTrackSelector::d0_par1_

protected

Definition at line 108 of file MultiTrackSelector.h.

Referenced by AnalyticalTrackSelector::AnalyticalTrackSelector(), MultiTrackSelector(), and select().

d0_par2_

std::vector<std::vector<double> > MultiTrackSelector::d0_par2_

protected

Definition at line 110 of file MultiTrackSelector.h.

Referenced by AnalyticalTrackSelector::AnalyticalTrackSelector(), MultiTrackSelector(), and select().

dbFileName_

std::string MultiTrackSelector::dbFileName_

protected

Definition at line 158 of file MultiTrackSelector.h.

Referenced by beginStream(), and MultiTrackSelector().

dz_par1_

std::vector<std::vector<double> > MultiTrackSelector::dz_par1_

protected

Definition at line 109 of file MultiTrackSelector.h.

Referenced by AnalyticalTrackSelector::AnalyticalTrackSelector(), MultiTrackSelector(), and select().

dz_par2_

std::vector<std::vector<double> > MultiTrackSelector::dz_par2_

protected

Definition at line 111 of file MultiTrackSelector.h.

Referenced by AnalyticalTrackSelector::AnalyticalTrackSelector(), MultiTrackSelector(), and select().

forest_

std::vector<GBRForest *> MultiTrackSelector::forest_

protected

Definition at line 156 of file MultiTrackSelector.h.

Referenced by AnalyticalTrackSelector::AnalyticalTrackSelector(), beginStream(), MultiTrackSelector(), processMVA(), and ~MultiTrackSelector().

forestLabel_

std::vector<std::string> MultiTrackSelector::forestLabel_

protected

Definition at line 154 of file MultiTrackSelector.h.

Referenced by AnalyticalTrackSelector::AnalyticalTrackSelector(), beginStream(), and MultiTrackSelector().

forestToken_

std::vector<edm::ESGetToken<GBRForest, GBRWrapperRcd> > MultiTrackSelector::forestToken_

protected

Definition at line 155 of file MultiTrackSelector.h.

Referenced by MultiTrackSelector(), and processMVA().

hSrc_

edm::EDGetTokenT<TrackingRecHitCollection> MultiTrackSelector::hSrc_

protected

Definition at line 88 of file MultiTrackSelector.h.

Referenced by AnalyticalTrackSelector::AnalyticalTrackSelector(), processMVA(), AnalyticalTrackSelector::run(), and run().

keepAllTracks_

std::vector<bool> MultiTrackSelector::keepAllTracks_

protected

Definition at line 141 of file MultiTrackSelector.h.

Referenced by AnalyticalTrackSelector::AnalyticalTrackSelector(), MultiTrackSelector(), AnalyticalTrackSelector::run(), and run().

max_d0_

std::vector<double> MultiTrackSelector::max_d0_

protected

Impact parameter absolute cuts.

Definition at line 116 of file MultiTrackSelector.h.

Referenced by AnalyticalTrackSelector::AnalyticalTrackSelector(), MultiTrackSelector(), and select().

max_d0NoPV_

std::vector<double> MultiTrackSelector::max_d0NoPV_

protected

Definition at line 137 of file MultiTrackSelector.h.

Referenced by AnalyticalTrackSelector::AnalyticalTrackSelector(), MultiTrackSelector(), and select().

max_eta_

std::vector<double> MultiTrackSelector::max_eta_

protected

Definition at line 134 of file MultiTrackSelector.h.

Referenced by AnalyticalTrackSelector::AnalyticalTrackSelector(), MultiTrackSelector(), and select().

max_lostHitFraction_

std::vector<int32_t> MultiTrackSelector::max_lostHitFraction_

protected

Definition at line 131 of file MultiTrackSelector.h.

Referenced by AnalyticalTrackSelector::AnalyticalTrackSelector(), MultiTrackSelector(), and select().

max_lostLayers_

std::vector<uint32_t> MultiTrackSelector::max_lostLayers_

protected

Definition at line 123 of file MultiTrackSelector.h.

Referenced by AnalyticalTrackSelector::AnalyticalTrackSelector(), MultiTrackSelector(), and select().

max_minMissHitOutOrIn_

std::vector<int32_t> MultiTrackSelector::max_minMissHitOutOrIn_

protected

Definition at line 130 of file MultiTrackSelector.h.

Referenced by AnalyticalTrackSelector::AnalyticalTrackSelector(), MultiTrackSelector(), and select().

max_relpterr_

std::vector<double> MultiTrackSelector::max_relpterr_

protected

Definition at line 127 of file MultiTrackSelector.h.

Referenced by AnalyticalTrackSelector::AnalyticalTrackSelector(), MultiTrackSelector(), and select().

max_z0_

std::vector<double> MultiTrackSelector::max_z0_

protected

Definition at line 117 of file MultiTrackSelector.h.

Referenced by AnalyticalTrackSelector::AnalyticalTrackSelector(), MultiTrackSelector(), and select().

max_z0NoPV_

std::vector<double> MultiTrackSelector::max_z0NoPV_

protected

Definition at line 138 of file MultiTrackSelector.h.

Referenced by AnalyticalTrackSelector::AnalyticalTrackSelector(), MultiTrackSelector(), and select().

min_3Dlayers_

std::vector<uint32_t> MultiTrackSelector::min_3Dlayers_

protected

Definition at line 122 of file MultiTrackSelector.h.

Referenced by AnalyticalTrackSelector::AnalyticalTrackSelector(), MultiTrackSelector(), and select().

min_eta_

std::vector<double> MultiTrackSelector::min_eta_

protected

Definition at line 133 of file MultiTrackSelector.h.

Referenced by AnalyticalTrackSelector::AnalyticalTrackSelector(), MultiTrackSelector(), and select().

min_hits_bypass_

std::vector<uint32_t> MultiTrackSelector::min_hits_bypass_

protected

Definition at line 124 of file MultiTrackSelector.h.

Referenced by AnalyticalTrackSelector::AnalyticalTrackSelector(), MultiTrackSelector(), and select().

min_layers_

std::vector<uint32_t> MultiTrackSelector::min_layers_

protected

Cuts on numbers of layers with hits/3D hits/lost hits.

Definition at line 121 of file MultiTrackSelector.h.

Referenced by AnalyticalTrackSelector::AnalyticalTrackSelector(), MultiTrackSelector(), and select().

min_MVA_

std::vector<double> MultiTrackSelector::min_MVA_

protected

Definition at line 151 of file MultiTrackSelector.h.

Referenced by AnalyticalTrackSelector::AnalyticalTrackSelector(), MultiTrackSelector(), and select().

min_nhits_

std::vector<uint32_t> MultiTrackSelector::min_nhits_

protected

Definition at line 128 of file MultiTrackSelector.h.

Referenced by AnalyticalTrackSelector::AnalyticalTrackSelector(), MultiTrackSelector(), and select().

mvaType_

std::vector<std::string> MultiTrackSelector::mvaType_

protected

Definition at line 153 of file MultiTrackSelector.h.

Referenced by AnalyticalTrackSelector::AnalyticalTrackSelector(), MultiTrackSelector(), and processMVA().

name_

std::vector<std::string> MultiTrackSelector::name_

protected

Definition at line 145 of file MultiTrackSelector.h.

Referenced by MultiTrackSelector(), and run().

nSigmaZ_

std::vector<double> MultiTrackSelector::nSigmaZ_

protected

Definition at line 118 of file MultiTrackSelector.h.

Referenced by AnalyticalTrackSelector::AnalyticalTrackSelector(), MultiTrackSelector(), and select().

preFilter_

std::vector<unsigned int> MultiTrackSelector::preFilter_

protected

Definition at line 144 of file MultiTrackSelector.h.

Referenced by AnalyticalTrackSelector::AnalyticalTrackSelector(), MultiTrackSelector(), and run().

qualityToSet_

std::vector<reco::TrackBase::TrackQuality> MultiTrackSelector::qualityToSet_

protected

Definition at line 97 of file MultiTrackSelector.h.

Referenced by AnalyticalTrackSelector::AnalyticalTrackSelector(), MultiTrackSelector(), AnalyticalTrackSelector::run(), and run().

res_par_

std::vector<std::vector<double> > MultiTrackSelector::res_par_

protected

Definition at line 105 of file MultiTrackSelector.h.

Referenced by AnalyticalTrackSelector::AnalyticalTrackSelector(), MultiTrackSelector(), and select().

setQualityBit_

std::vector<bool> MultiTrackSelector::setQualityBit_

protected

do I have to set a quality bit?

Definition at line 96 of file MultiTrackSelector.h.

Referenced by AnalyticalTrackSelector::AnalyticalTrackSelector(), MultiTrackSelector(), AnalyticalTrackSelector::run(), and run().

src_

edm::EDGetTokenT<reco::TrackCollection> MultiTrackSelector::src_

protected

source collection label

Definition at line 87 of file MultiTrackSelector.h.

Referenced by AnalyticalTrackSelector::AnalyticalTrackSelector(), processMVA(), AnalyticalTrackSelector::run(), and run().

useAnyMVA_

bool MultiTrackSelector::useAnyMVA_

protected

Definition at line 92 of file MultiTrackSelector.h.

Referenced by AnalyticalTrackSelector::AnalyticalTrackSelector(), MultiTrackSelector(), processMVA(), AnalyticalTrackSelector::run(), run(), and select().

useForestFromDB_

bool MultiTrackSelector::useForestFromDB_

protected

Definition at line 157 of file MultiTrackSelector.h.

Referenced by beginStream(), MultiTrackSelector(), and processMVA().

useMVA_

std::vector<bool> MultiTrackSelector::useMVA_

protected

Definition at line 148 of file MultiTrackSelector.h.

Referenced by AnalyticalTrackSelector::AnalyticalTrackSelector(), MultiTrackSelector(), processMVA(), and select().

useMVAonly_

std::vector<bool> MultiTrackSelector::useMVAonly_

protected

Definition at line 149 of file MultiTrackSelector.h.

Referenced by AnalyticalTrackSelector::AnalyticalTrackSelector(), MultiTrackSelector(), and select().

useVertices_

bool MultiTrackSelector::useVertices_

protected

Definition at line 90 of file MultiTrackSelector.h.

Referenced by AnalyticalTrackSelector::AnalyticalTrackSelector(), MultiTrackSelector(), AnalyticalTrackSelector::run(), and run().

useVtxError_

bool MultiTrackSelector::useVtxError_

protected

Definition at line 91 of file MultiTrackSelector.h.

Referenced by AnalyticalTrackSelector::AnalyticalTrackSelector(), MultiTrackSelector(), and select().

vertexCut_

std::vector<StringCutObjectSelector<reco::Vertex> > MultiTrackSelector::vertexCut_

protected

Definition at line 102 of file MultiTrackSelector.h.

Referenced by AnalyticalTrackSelector::AnalyticalTrackSelector(), MultiTrackSelector(), and selectVertices().

vertices_

edm::EDGetTokenT<reco::VertexCollection> MultiTrackSelector::vertices_

protected

Definition at line 93 of file MultiTrackSelector.h.

Referenced by AnalyticalTrackSelector::AnalyticalTrackSelector(), MultiTrackSelector(), AnalyticalTrackSelector::run(), and run().

vtxNumber_

std::vector<int32_t> MultiTrackSelector::vtxNumber_

protected

vertex cuts

Definition at line 100 of file MultiTrackSelector.h.

Referenced by AnalyticalTrackSelector::AnalyticalTrackSelector(), MultiTrackSelector(), and selectVertices().