HIMultiTrackSelector Class Reference

#include <HIMultiTrackSelector.h>

Inheritance diagram for HIMultiTrackSelector:

Public Member Functions
	HIMultiTrackSelector ()
	constructor More...
	HIMultiTrackSelector (const edm::ParameterSet &cfg)
	~HIMultiTrackSelector () override
	destructor More...
Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default
bool	hasAbilityToProduceInBeginLumis () const final
bool	hasAbilityToProduceInBeginRuns () const final
bool	hasAbilityToProduceInEndLumis () const final
bool	hasAbilityToProduceInEndRuns () const final

Protected Types
typedef math::XYZPoint	Point

Protected Member Functions
void	beginStream (edm::StreamID) final
void	ParseForestVars ()
void	processMVA (edm::Event &evt, const edm::EventSetup &es, std::vector< float > &mvaVals_, const reco::VertexCollection &hVtx) 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_
bool	applyPixelMergingCuts_
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_
GBRForest *	forest_
std::string	forestLabel_
std::vector< std::string >	forestVars_
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::string	mvaType_
std::vector< int >	mvavars_indices
std::vector< std::string >	name_
std::vector< double >	nSigmaZ_
std::vector< std::vector< double > >	pixel_pTMaxCut_
std::vector< std::vector< double > >	pixel_pTMinCut_
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_
bool	useVertices_
bool	useVtxError_
std::vector< StringCutObjectSelector< reco::Vertex > >	vertexCut_
edm::EDGetTokenT< reco::VertexCollection >	vertices_
std::vector< int32_t >	vtxNumber_
	vertex cuts More...

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
typedef CacheContexts< T... >	CacheTypes
typedef CacheTypes::GlobalCache	GlobalCache
typedef AbilityChecker< T... >	HasAbility
typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache
typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext
typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache
typedef CacheTypes::RunCache	RunCache
typedef RunContextT< RunCache, GlobalCache >	RunContext
typedef CacheTypes::RunSummaryCache	RunSummaryCache

Detailed Description

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

Author

David Lange

Definition at line 53 of file HIMultiTrackSelector.h.

Member Typedef Documentation

typedef math::XYZPoint HIMultiTrackSelector::Point

protected

Definition at line 71 of file HIMultiTrackSelector.h.

Constructor & Destructor Documentation

HIMultiTrackSelector::HIMultiTrackSelector ( )

explicit

constructor

Definition at line 74 of file HIMultiTrackSelector.cc.

                                           {
  useForestFromDB_ = true;
  forest_ = nullptr;
}

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

explicit

Definition at line 123 of file HIMultiTrackSelector.cc.

References applyAbsCutsIfNoPV_, applyAdaptedPVCuts_, applyPixelMergingCuts_, chi2n_no1Dmod_par_, chi2n_par_, d0_par1_, d0_par2_, dbFileName_, dz_par1_, dz_par2_, Exception, edm::ParameterSet::exists(), forest_, forestLabel_, forestVars_, edm::ParameterSet::getParameter(), mps_fire::i, dqmiolumiharvest::j, keepAllTracks_, 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_, ParseForestVars(), pixel_pTMaxCut_, pixel_pTMinCut_, preFilter_, qualityToSet_, res_par_, setQualityBit_, AlCaHLTBitMon_QueryRunRegistry::string, useAnyMVA_, useForestFromDB_, useMVA_, useVertices_, 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"));

  applyPixelMergingCuts_ = false;
  if (cfg.exists("applyPixelMergingCuts"))
    applyPixelMergingCuts_ = cfg.getParameter<bool>("applyPixelMergingCuts");

  useAnyMVA_ = false;
  forestLabel_ = "MVASelectorIter0";
  std::string type = "BDTG";
  useForestFromDB_ = true;
  dbFileName_ = "";

  forest_ = nullptr;

  if (cfg.exists("useAnyMVA"))
    useAnyMVA_ = cfg.getParameter<bool>("useAnyMVA");
  if (useAnyMVA_) {
    if (cfg.exists("mvaType"))
      type = cfg.getParameter<std::string>("mvaType");
    if (cfg.exists("GBRForestLabel"))
      forestLabel_ = cfg.getParameter<std::string>("GBRForestLabel");
    if (cfg.exists("GBRForestVars")) {
      forestVars_ = cfg.getParameter<std::vector<std::string>>("GBRForestVars");
      ParseForestVars();
    }
    if (cfg.exists("GBRForestFileName")) {
      dbFileName_ = cfg.getParameter<std::string>("GBRForestFileName");
      useForestFromDB_ = false;
    }
    mvaType_ = type;
  }
  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());
  pixel_pTMinCut_.reserve(trkSelectors.size());
  pixel_pTMaxCut_.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());
  //mvaReaders_.reserve(trkSelectors.size());
  min_MVA_.reserve(trkSelectors.size());
  //mvaType_.reserve(trkSelectors.size());

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

  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 HIMultiTrackSelector "
                                              << trkSelectors[i].getParameter<std::string>("preFilterName");
    }

    if (applyPixelMergingCuts_) {
      pixel_pTMinCut_.push_back(trkSelectors[i].getParameter<std::vector<double>>("pixel_pTMinCut"));
      pixel_pTMaxCut_.push_back(trkSelectors[i].getParameter<std::vector<double>>("pixel_pTMaxCut"));
    }

    //    produces<std::vector<int> >(name_[i]).setBranchAlias( name_[i] + "TrackQuals");
    produces<edm::ValueMap<int>>(name_[i]).setBranchAlias(name_[i] + "TrackQuals");
    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);

      } else {
        min_MVA_.push_back(-9999.0);
      }
    } else {
      min_MVA_.push_back(-9999.0);
    }
  }
}

HIMultiTrackSelector::~HIMultiTrackSelector ( )

override

destructor

Definition at line 305 of file HIMultiTrackSelector.cc.

References forest_.

{ delete forest_; }

Member Function Documentation

void HIMultiTrackSelector::beginStream ( edm::StreamID  )

finalprotected

Definition at line 307 of file HIMultiTrackSelector.cc.

References dbFileName_, forest_, forestLabel_, and useForestFromDB_.

                                                  {
  if (!useForestFromDB_) {
    TFile gbrfile(dbFileName_.c_str());
    forest_ = (GBRForest *)gbrfile.Get(forestLabel_.c_str());
  }
}

void HIMultiTrackSelector::ParseForestVars ( )

protected

Definition at line 79 of file HIMultiTrackSelector.cc.

References chi2n, chi2n_no1dmod, chi2perdofperlayer, dxyperdxyerror, dzperdzerror, PVValHelper::eta, etaerror, mps_fire::i, lostmidfrac, minlost, ndof, nhits, nlayers, nlayers3d, nlayerslost, relpterr, AlCaHLTBitMon_QueryRunRegistry::string, and findQualityFiles::v.

Referenced by HIMultiTrackSelector().

                                           {
  mvavars_indices.clear();
  for (unsigned i = 0; i < forestVars_.size(); i++) {
    std::string v = forestVars_[i];
    int ind = -1;
    if (v == "chi2perdofperlayer")
      ind = chi2perdofperlayer;
    if (v == "dxyperdxyerror")
      ind = dxyperdxyerror;
    if (v == "dzperdzerror")
      ind = dzperdzerror;
    if (v == "relpterr")
      ind = relpterr;
    if (v == "lostmidfrac")
      ind = lostmidfrac;
    if (v == "minlost")
      ind = minlost;
    if (v == "nhits")
      ind = nhits;
    if (v == "eta")
      ind = eta;
    if (v == "chi2n_no1dmod")
      ind = chi2n_no1dmod;
    if (v == "chi2n")
      ind = chi2n;
    if (v == "nlayerslost")
      ind = nlayerslost;
    if (v == "nlayers3d")
      ind = nlayers3d;
    if (v == "nlayers")
      ind = nlayers;
    if (v == "ndof")
      ind = ndof;
    if (v == "etaerror")
      ind = etaerror;

    if (ind == -1)
      edm::LogWarning("HIMultiTrackSelector")
          << "Unknown forest variable " << v << ". Please make sure it's in the list of supported variables\n";

    mvavars_indices.push_back(ind);
  }
}

void HIMultiTrackSelector::processMVA ( edm::Event &  evt, const edm::EventSetup &  es, std::vector< float > &  mvaVals_, const reco::VertexCollection &  hVtx  ) const

protected

Definition at line 635 of file HIMultiTrackSelector.cc.

References hltPixelTracks_cff::chi2, reco::TrackBase::chi2(), chi2n, chi2n_no1dmod, chi2perdofperlayer, DEFINE_FWK_MODULE, TrackingRecHit::dimension(), PVValHelper::dxy, reco::TrackBase::dxy(), reco::TrackBase::dxyError(), dxyperdxyerror, PVValHelper::dz, reco::TrackBase::dz(), reco::TrackBase::dzError(), dzperdzerror, PVValHelper::eta, reco::TrackBase::eta(), etaerror, reco::TrackBase::etaError(), reco::Track::extra(), f, spr::find(), dqmMemoryStats::float, forest_, forestLabel_, edm::EventSetup::get(), edm::Event::getByToken(), GBRForest::GetClassifier(), reco::TrackBase::hitPattern(), hSrc_, mps_fire::i, lostmidfrac, SiStripPI::max, min(), minlost, reco::HitPattern::MISSING_INNER_HITS, reco::HitPattern::MISSING_OUTER_HITS, eostools::move(), mvavars_indices, ndof, reco::TrackBase::ndof(), nhits, nlayers, nlayers3d, nlayerslost, reco::TrackBase::normalizedChi2(), reco::TrackBase::numberOfLostHits(), reco::HitPattern::numberOfLostTrackerHits(), reco::TrackBase::numberOfValidHits(), reco::HitPattern::numberOfValidStripLayersWithMonoAndStereo(), reco::HitPattern::pixelLayersWithMeasurement(), position, edm::ESHandle< T >::product(), reco::TrackBase::pt(), reco::TrackBase::ptError(), edm::Event::put(), reco::Track::recHitsSize(), relpterr, mathSSE::sqrt(), src_, HiCentrality_cfi::srcTracks, reco::HitPattern::TRACK_HITS, reco::HitPattern::trackerLayersWithMeasurement(), reco::HitPattern::trackerLayersWithoutMeasurement(), useAnyMVA_, and useForestFromDB_.

Referenced by run().

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

  // Get tracks
  Handle<TrackCollection> hSrcTrack;
  evt.getByToken(src_, hSrcTrack);
  const TrackCollection &srcTracks(*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_) {
    // mvaVals_ already initalized...
    mvaFiller.insert(hSrcTrack, mvaVals_.begin(), mvaVals_.end());
    mvaFiller.fill();
    evt.put(std::move(mvaValValueMap), "MVAVals");
    return;
  }

  bool checkvertex =
      std::find(mvavars_indices.begin(), mvavars_indices.end(), dxyperdxyerror) != mvavars_indices.end() ||
      std::find(mvavars_indices.begin(), mvavars_indices.end(), dzperdzerror) != mvavars_indices.end();

  size_t current = 0;
  for (TrackCollection::const_iterator it = srcTracks.begin(), ed = srcTracks.end(); it != ed; ++it, ++current) {
    const Track &trk = *it;

    float mvavalues[15];
    mvavalues[ndof] = trk.ndof();
    mvavalues[nlayers] = trk.hitPattern().trackerLayersWithMeasurement();
    mvavalues[nlayers3d] =
        trk.hitPattern().pixelLayersWithMeasurement() + trk.hitPattern().numberOfValidStripLayersWithMonoAndStereo();
    mvavalues[nlayerslost] = trk.hitPattern().trackerLayersWithoutMeasurement(reco::HitPattern::TRACK_HITS);
    mvavalues[chi2n_no1dmod] = trk.normalizedChi2();
    mvavalues[chi2perdofperlayer] = mvavalues[chi2n_no1dmod] / mvavalues[nlayers];

    float chi2n1d = trk.normalizedChi2();
    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();
      chi2n1d = (chi2 + count1dhits) / float(ndof + count1dhits);
    }

    mvavalues[chi2n] = chi2n1d;  //chi2 and 1d modes

    mvavalues[eta] = trk.eta();
    mvavalues[relpterr] = float(trk.ptError()) / std::max(float(trk.pt()), 0.000001f);
    mvavalues[nhits] = trk.numberOfValidHits();

    int lostIn = trk.hitPattern().numberOfLostTrackerHits(reco::HitPattern::MISSING_INNER_HITS);
    int lostOut = trk.hitPattern().numberOfLostTrackerHits(reco::HitPattern::MISSING_OUTER_HITS);
    mvavalues[minlost] = std::min(lostIn, lostOut);
    mvavalues[lostmidfrac] = trk.numberOfLostHits() / (trk.numberOfValidHits() + trk.numberOfLostHits());

    mvavalues[etaerror] = trk.etaError();

    float reldz = 0;
    float reldxy = 0;
    if (checkvertex) {
      int vtxind = 0;  // only first vertex is taken into account for the speed purposes
      float dxy = trk.dxy(vertices[vtxind].position()),
            dxyE = sqrt(trk.dxyError() * trk.dxyError() + vertices[vtxind].xError() * vertices[vtxind].yError());
      float dz = trk.dz(vertices[vtxind].position()),
            dzE = sqrt(trk.dzError() * trk.dzError() + vertices[vtxind].zError() * vertices[vtxind].zError());
      reldz = dz / dzE;
      reldxy = dxy / dxyE;
    }
    mvavalues[dxyperdxyerror] = reldxy;
    mvavalues[dzperdzerror] = reldz;

    std::vector<float> gbrValues;

    //fill in the gbrValues vector with the necessary variables
    for (unsigned i = 0; i < mvavars_indices.size(); i++) {
      gbrValues.push_back(mvavalues[mvavars_indices[i]]);
    }

    GBRForest const *forest = forest_;
    if (useForestFromDB_) {
      edm::ESHandle<GBRForest> forestHandle;
      es.get<GBRWrapperRcd>().get(forestLabel_, forestHandle);
      forest = forestHandle.product();
    }

    auto gbrVal = forest->GetClassifier(&gbrValues[0]);
    mvaVals_[current] = gbrVal;
  }
  mvaFiller.insert(hSrcTrack, mvaVals_.begin(), mvaVals_.end());
  mvaFiller.fill();
  evt.put(std::move(mvaValValueMap), "MVAVals");
}

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

inlinefinalprotected

process one event

Definition at line 73 of file HIMultiTrackSelector.h.

References HLT_2018_cff::points, FastTrackerRecHitMaskProducer_cfi::recHits, writedatasetfile::run, and singleTopDQM_cfi::select.

{ run(evt, es); }

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

protectedvirtual

Definition at line 314 of file HIMultiTrackSelector.cc.

References beamspot_, trigObjTnPSource_cfi::filler, edm::Event::getByToken(), tkConvValidator_cfi::highPurity, hSrc_, mps_fire::i, dqmiolumiharvest::j, keepAllTracks_, LogTrace, eostools::move(), name_, convertSQLiteXML::ok, HLT_2018_cff::points, preFilter_, processMVA(), reco::TrackBase::pt(), edm::Event::put(), reco::TrackBase::qualityMask(), qualityToSet_, select(), selectVertices(), setQualityBit_, src_, HiCentrality_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);

  // 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);

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

  std::vector<float> mvaVals_(srcTracks.size(), -99.f);
  processMVA(evt, es, mvaVals_, *hVtx);

  for (unsigned int i = 0; i < qualityToSet_.size(); i++) {
    std::vector<int> selTracks(trkSize, 0);
    auto selTracksValueMap = std::make_unique<edm::ValueMap<int>>();
    edm::ValueMap<int>::Filler filler(*selTracksValueMap);

    std::vector<Point> points;
    std::vector<float> vterr, vzerr;
    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;
      float mvaVal = 0;
      if (preFilter_[i] < i && selTracksSave[preFilter_[i] * trkSize + current] < 0) {
        selTracks[current] = -1;
        ok = false;
        if (!keepAllTracks_[i])
          continue;
      } else {
        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]);
  }
}

bool HIMultiTrackSelector::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 419 of file HIMultiTrackSelector.cc.

References funct::abs(), applyAbsCutsIfNoPV_, applyAdaptedPVCuts_, applyPixelMergingCuts_, hltPixelTracks_cff::chi2, reco::TrackBase::chi2(), chi2n, chi2n_no1Dmod_par_, chi2n_par_, HLTMuonOfflineAnalyzer_cfi::d0, d0_par1_, d0_par2_, TrackSplittingMonitor_cfi::d0Cut, reco::TrackBase::d0Error(), TrackingRecHit::dimension(), reco::TrackBase::dxy(), PVValHelper::dz, reco::TrackBase::dz(), dz_par1_, dz_par2_, TrackSplittingMonitor_cfi::dzCut, reco::TrackBase::dzError(), end, PVValHelper::eta, reco::TrackBase::eta(), reco::Track::extra(), f, dqmMemoryStats::float, reco::TrackBase::hitPattern(), LogDebug, LogTrace, SiStripPI::max, max_d0_, max_d0NoPV_, max_eta_, max_lostHitFraction_, max_lostLayers_, max_minMissHitOutOrIn_, max_relpterr_, max_z0_, max_z0NoPV_, 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(), pixel_pTMaxCut_, pixel_pTMinCut_, reco::HitPattern::pixelLayersWithMeasurement(), point, reco::BeamSpot::position(), funct::pow(), DiDispStaMuonMonitor_cfi::pt, reco::TrackBase::pt(), reco::TrackBase::ptError(), reco::Track::recHitsSize(), relpterr, res_par_, reco::BeamSpot::sigmaZ(), mathSSE::sqrt(), reco::HitPattern::TRACK_HITS, reco::HitPattern::trackerLayersWithMeasurement(), reco::HitPattern::trackerLayersWithoutMeasurement(), useAnyMVA_, useMVA_, and useVtxError_.

Referenced by 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 (mvaVal < min_MVA_[tsNum])
      return false;
    else
      return true;
  }
  //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() == 0 ? 0. : tk.numberOfLostHits() / (tk.numberOfValidHits() + tk.numberOfLostHits());
  if (lostMidFrac > max_lostHitFraction_[tsNum])
    return false;

  // Pixel Track Merging pT dependent cuts
  if (applyPixelMergingCuts_) {
    // hard cut at absolute min/max pt
    if (pt < pixel_pTMinCut_[tsNum][0])
      return false;
    if (pt > pixel_pTMaxCut_[tsNum][0])
      return false;
    // tapering cuts with chi2n_no1Dmod
    double pTMaxCutPos = (pixel_pTMaxCut_[tsNum][0] - pt) / (pixel_pTMaxCut_[tsNum][0] - pixel_pTMaxCut_[tsNum][1]);
    double pTMinCutPos = (pt - pixel_pTMinCut_[tsNum][0]) / (pixel_pTMinCut_[tsNum][1] - pixel_pTMinCut_[tsNum][0]);
    if (pt > pixel_pTMaxCut_[tsNum][1] &&
        chi2n_no1Dmod > pixel_pTMaxCut_[tsNum][2] * nlayers * pow(pTMaxCutPos, pixel_pTMaxCut_[tsNum][3]))
      return false;
    if (pt < pixel_pTMinCut_[tsNum][1] &&
        chi2n_no1Dmod > pixel_pTMinCut_[tsNum][2] * nlayers * pow(pTMinCutPos, pixel_pTMinCut_[tsNum][3]))
      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;
  }
}

void HIMultiTrackSelector::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 610 of file HIMultiTrackSelector.cc.

References LogDebug, LogTrace, mathSSE::sqrt(), vertexCut_, badGlobalMuonTaggersAOD_cff::vtx, and vtxNumber_.

Referenced by 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

std::vector<bool> HIMultiTrackSelector::applyAbsCutsIfNoPV_

protected

Definition at line 157 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and select().

std::vector<bool> HIMultiTrackSelector::applyAdaptedPVCuts_

protected

Definition at line 127 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and select().

bool HIMultiTrackSelector::applyPixelMergingCuts_

protected

Definition at line 107 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and select().

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

protected

Definition at line 100 of file HIMultiTrackSelector.h.

Referenced by run().

std::vector<double> HIMultiTrackSelector::chi2n_no1Dmod_par_

protected

Definition at line 121 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and select().

std::vector<double> HIMultiTrackSelector::chi2n_par_

protected

Definition at line 120 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and select().

std::vector<std::vector<double> > HIMultiTrackSelector::d0_par1_

protected

Definition at line 122 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and select().

std::vector<std::vector<double> > HIMultiTrackSelector::d0_par2_

protected

Definition at line 124 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and select().

std::string HIMultiTrackSelector::dbFileName_

protected

Definition at line 179 of file HIMultiTrackSelector.h.

Referenced by beginStream(), and HIMultiTrackSelector().

std::vector<std::vector<double> > HIMultiTrackSelector::dz_par1_

protected

Definition at line 123 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and select().

std::vector<std::vector<double> > HIMultiTrackSelector::dz_par2_

protected

Definition at line 125 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and select().

GBRForest* HIMultiTrackSelector::forest_

protected

Definition at line 177 of file HIMultiTrackSelector.h.

Referenced by beginStream(), HIMultiTrackSelector(), processMVA(), and ~HIMultiTrackSelector().

std::string HIMultiTrackSelector::forestLabel_

protected

Definition at line 175 of file HIMultiTrackSelector.h.

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

std::vector<std::string> HIMultiTrackSelector::forestVars_

protected

Definition at line 176 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector().

edm::EDGetTokenT<TrackingRecHitCollection> HIMultiTrackSelector::hSrc_

protected

Definition at line 99 of file HIMultiTrackSelector.h.

Referenced by processMVA(), and run().

std::vector<bool> HIMultiTrackSelector::keepAllTracks_

protected

Definition at line 159 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and run().

std::vector<double> HIMultiTrackSelector::max_d0_

protected

Impact parameter absolute cuts.

Definition at line 130 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and select().

std::vector<double> HIMultiTrackSelector::max_d0NoPV_

protected

Definition at line 155 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and select().

std::vector<double> HIMultiTrackSelector::max_eta_

protected

Definition at line 152 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and select().

std::vector<int32_t> HIMultiTrackSelector::max_lostHitFraction_

protected

Definition at line 149 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and select().

std::vector<uint32_t> HIMultiTrackSelector::max_lostLayers_

protected

Definition at line 141 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and select().

std::vector<int32_t> HIMultiTrackSelector::max_minMissHitOutOrIn_

protected

Definition at line 148 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and select().

std::vector<double> HIMultiTrackSelector::max_relpterr_

protected

Definition at line 145 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and select().

std::vector<double> HIMultiTrackSelector::max_z0_

protected

Definition at line 131 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and select().

std::vector<double> HIMultiTrackSelector::max_z0NoPV_

protected

Definition at line 156 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and select().

std::vector<uint32_t> HIMultiTrackSelector::min_3Dlayers_

protected

Definition at line 140 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and select().

std::vector<double> HIMultiTrackSelector::min_eta_

protected

Definition at line 151 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and select().

std::vector<uint32_t> HIMultiTrackSelector::min_hits_bypass_

protected

Definition at line 142 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and select().

std::vector<uint32_t> HIMultiTrackSelector::min_layers_

protected

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

Definition at line 139 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and select().

std::vector<double> HIMultiTrackSelector::min_MVA_

protected

Definition at line 171 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and select().

std::vector<uint32_t> HIMultiTrackSelector::min_nhits_

protected

Definition at line 146 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and select().

std::string HIMultiTrackSelector::mvaType_

protected

Definition at line 174 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector().

std::vector<int> HIMultiTrackSelector::mvavars_indices

protected

Definition at line 169 of file HIMultiTrackSelector.h.

Referenced by processMVA().

std::vector<std::string> HIMultiTrackSelector::name_

protected

Definition at line 163 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and run().

std::vector<double> HIMultiTrackSelector::nSigmaZ_

protected

Definition at line 132 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and select().

std::vector<std::vector<double> > HIMultiTrackSelector::pixel_pTMaxCut_

protected

Definition at line 136 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and select().

std::vector<std::vector<double> > HIMultiTrackSelector::pixel_pTMinCut_

protected

Definition at line 135 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and select().

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

protected

Definition at line 162 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and run().

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

protected

Definition at line 111 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and run().

std::vector<std::vector<double> > HIMultiTrackSelector::res_par_

protected

Definition at line 119 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and select().

std::vector<bool> HIMultiTrackSelector::setQualityBit_

protected

do I have to set a quality bit?

Definition at line 110 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and run().

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

protected

source collection label

Definition at line 98 of file HIMultiTrackSelector.h.

Referenced by processMVA(), and run().

bool HIMultiTrackSelector::useAnyMVA_

protected

Definition at line 103 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), processMVA(), run(), and select().

bool HIMultiTrackSelector::useForestFromDB_

protected

Definition at line 178 of file HIMultiTrackSelector.h.

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

std::vector<bool> HIMultiTrackSelector::useMVA_

protected

Definition at line 166 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and select().

bool HIMultiTrackSelector::useVertices_

protected

Definition at line 101 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and run().

bool HIMultiTrackSelector::useVtxError_

protected

Definition at line 102 of file HIMultiTrackSelector.h.

Referenced by select().

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

protected

Definition at line 116 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and selectVertices().

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

protected

Definition at line 104 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and run().

std::vector<int32_t> HIMultiTrackSelector::vtxNumber_

protected

vertex cuts

Definition at line 114 of file HIMultiTrackSelector.h.

Referenced by HIMultiTrackSelector(), and selectVertices().