AnalyticalTrackSelector Class Reference

Inheritance diagram for AnalyticalTrackSelector:

Public Member Functions
	AnalyticalTrackSelector (const edm::ParameterSet &cfg)
	constructor More...
virtual	~AnalyticalTrackSelector ()
	destructor More...
Public Member Functions inherited from MultiTrackSelector
	MultiTrackSelector ()
	constructor More...
	MultiTrackSelector (const edm::ParameterSet &cfg)
virtual	~MultiTrackSelector ()
	destructor More...
Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default
Public Member Functions inherited from edm::stream::EDProducerBase
	EDProducerBase ()
ModuleDescription const &	moduleDescription () const
virtual	~EDProducerBase ()
Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)
	ProducerBase ()
void	registerProducts (ProducerBase *, ProductRegistry *, ModuleDescription const &)
std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...
virtual	~ProducerBase ()
Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const
	EDConsumerBase ()
ProductHolderIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const
void	itemsMayGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const
void	itemsToGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const
std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const
void	labelsForToken (EDGetToken iToken, Labels &oLabels) const
void	modulesDependentUpon (const std::string &iProcessName, std::vector< const char * > &oModuleLabels) const
void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const
bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const
bool	registeredToConsumeMany (TypeID const &, BranchType) const
void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)
virtual	~EDConsumerBase ()

Private Types
typedef math::XYZPoint	Point

Private Member Functions
void	run (edm::Event &evt, const edm::EventSetup &es) const override
	process one event More...

Private Attributes
bool	copyExtras_
	copy only the tracks, not extras and rechits (for AOD) More...
bool	copyTrajectories_
	copy also trajectories and trajectory->track associations More...
double	maxEta_
double	minEta_
	eta restrictions More...
edm::EDGetTokenT < TrajTrackAssociationCollection >	srcTass_
edm::EDGetTokenT< std::vector < Trajectory > >	srcTraj_

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
typedef CacheContexts< T...>	CacheTypes
typedef CacheTypes::GlobalCache	GlobalCache
typedef AbilityChecker< T...>	HasAbility
typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache
typedef LuminosityBlockContextT < LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext
typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache
typedef CacheTypes::RunCache	RunCache
typedef RunContextT< RunCache, GlobalCache >	RunContext
typedef CacheTypes::RunSummaryCache	RunSummaryCache
Public Types inherited from edm::stream::EDProducerBase
typedef EDProducerAdaptorBase	ModuleType
Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList
Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels
Static Public Member Functions inherited from edm::stream::EDProducerBase
static const std::string &	baseType ()
static void	fillDescriptions (ConfigurationDescriptions &descriptions)
static void	prevalidate (ConfigurationDescriptions &descriptions)
Protected Types inherited from MultiTrackSelector
typedef math::XYZPoint	Point
Protected Member Functions inherited from MultiTrackSelector
void	beginStream (edm::StreamID) overridefinal
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) overridefinal
	process one event More...
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 Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)
EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)
template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)
ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...
template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()
void	consumesMany (const TypeToGet &id)
template<BranchType B>
void	consumesMany (const TypeToGet &id)
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)
template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)
Protected Attributes inherited from MultiTrackSelector
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_
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

Paolo Azzurri, Giovanni Petrucciani

Definition at line 36 of file AnalyticalTrackSelector.cc.

Member Typedef Documentation

typedef math::XYZPoint AnalyticalTrackSelector::Point

private

Definition at line 45 of file AnalyticalTrackSelector.cc.

Constructor & Destructor Documentation

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

explicit

constructor

Definition at line 73 of file AnalyticalTrackSelector.cc.

References HLT_25ns14e33_v1_cff::alias, MultiTrackSelector::applyAbsCutsIfNoPV_, MultiTrackSelector::applyAdaptedPVCuts_, MultiTrackSelector::beamspot_, MultiTrackSelector::chi2n_no1Dmod_par_, MultiTrackSelector::chi2n_par_, copyExtras_, copyTrajectories_, MultiTrackSelector::d0_par1_, MultiTrackSelector::d0_par2_, MultiTrackSelector::dz_par1_, MultiTrackSelector::dz_par2_, Exception, edm::ParameterSet::exists(), edm::ParameterSet::existsAs(), MultiTrackSelector::forest_, MultiTrackSelector::forestLabel_, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), MultiTrackSelector::hSrc_, MultiTrackSelector::keepAllTracks_, MultiTrackSelector::max_d0_, MultiTrackSelector::max_d0NoPV_, MultiTrackSelector::max_eta_, MultiTrackSelector::max_lostHitFraction_, MultiTrackSelector::max_lostLayers_, MultiTrackSelector::max_minMissHitOutOrIn_, MultiTrackSelector::max_relpterr_, MultiTrackSelector::max_z0_, MultiTrackSelector::max_z0NoPV_, MultiTrackSelector::min_3Dlayers_, MultiTrackSelector::min_eta_, MultiTrackSelector::min_hits_bypass_, MultiTrackSelector::min_layers_, MultiTrackSelector::min_MVA_, MultiTrackSelector::min_nhits_, MultiTrackSelector::mvaType_, MultiTrackSelector::nSigmaZ_, MultiTrackSelector::preFilter_, MultiTrackSelector::qualityToSet_, MultiTrackSelector::res_par_, MultiTrackSelector::setQualityBit_, findQualityFiles::size, MultiTrackSelector::src_, srcTass_, srcTraj_, AlCaHLTBitMon_QueryRunRegistry::string, MultiTrackSelector::useAnyMVA_, MultiTrackSelector::useMVA_, MultiTrackSelector::useMVAonly_, MultiTrackSelector::useVertices_, MultiTrackSelector::useVtxError_, MultiTrackSelector::vertexCut_, MultiTrackSelector::vertices_, and MultiTrackSelector::vtxNumber_.

                                                                              : MultiTrackSelector( )
{
    //Spoof the pset for each track selector!
    //Size is always 1!!!
    qualityToSet_.reserve(1);
    vtxNumber_.reserve(1);
    vertexCut_.reserve(1);
    res_par_.reserve(1);
    chi2n_par_.reserve(1);
    chi2n_no1Dmod_par_.reserve(1);
    d0_par1_.reserve(1);
    dz_par1_.reserve(1);
    d0_par2_.reserve(1);
    dz_par2_.reserve(1);
    applyAdaptedPVCuts_.reserve(1);
    max_d0_.reserve(1);
    max_z0_.reserve(1);
    nSigmaZ_.reserve(1);
    min_layers_.reserve(1);
    min_3Dlayers_.reserve(1);
    max_lostLayers_.reserve(1);
    min_hits_bypass_.reserve(1);
    applyAbsCutsIfNoPV_.reserve(1);
    max_d0NoPV_.reserve(1);
    max_z0NoPV_.reserve(1);
    preFilter_.reserve(1);
    max_relpterr_.reserve(1);
    min_nhits_.reserve(1);
    max_minMissHitOutOrIn_.reserve(1);
    max_lostHitFraction_.reserve(1);
    min_eta_.reserve(1);
    max_eta_.reserve(1);
    forest_.reserve(1);
    mvaType_.reserve(1);
    useMVA_.reserve(1);

    produces<edm::ValueMap<float> >("MVAVals");
    useAnyMVA_ = false;
    forest_[0] = nullptr;
    if(cfg.exists("useAnyMVA")) useAnyMVA_ = cfg.getParameter<bool>("useAnyMVA");

    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" );
    if (useVertices_) vertices_ = consumes<reco::VertexCollection>(cfg.getParameter<edm::InputTag>( "vertices" ));
    copyExtras_ = cfg.getUntrackedParameter<bool>("copyExtras", false);
    copyTrajectories_ = cfg.getUntrackedParameter<bool>("copyTrajectories", false);
    if (copyTrajectories_) {
        srcTraj_ = consumes<std::vector<Trajectory> >(cfg.getParameter<edm::InputTag>( "src" ));
        srcTass_ = consumes<TrajTrackAssociationCollection>(cfg.getParameter<edm::InputTag>( "src" ));
    }
    
    qualityToSet_.push_back( TrackBase::undefQuality );
    // parameters for vertex selection
    vtxNumber_.push_back( useVertices_ ? cfg.getParameter<int32_t>("vtxNumber") : 0 );
    vertexCut_.push_back( useVertices_ ? cfg.getParameter<std::string>("vertexCut") : "");
    //  parameters for adapted optimal cuts on chi2 and primary vertex compatibility
    res_par_.push_back(cfg.getParameter< std::vector<double> >("res_par") );
    chi2n_par_.push_back( cfg.getParameter<double>("chi2n_par") );
    chi2n_no1Dmod_par_.push_back( cfg.getParameter<double>("chi2n_no1Dmod_par") );
    d0_par1_.push_back(cfg.getParameter< std::vector<double> >("d0_par1"));
    dz_par1_.push_back(cfg.getParameter< std::vector<double> >("dz_par1"));
    d0_par2_.push_back(cfg.getParameter< std::vector<double> >("d0_par2"));
    dz_par2_.push_back(cfg.getParameter< std::vector<double> >("dz_par2"));

    // Boolean indicating if adapted primary vertex compatibility cuts are to be applied.
    applyAdaptedPVCuts_.push_back(cfg.getParameter<bool>("applyAdaptedPVCuts"));
    // Impact parameter absolute cuts.
    max_d0_.push_back(cfg.getParameter<double>("max_d0"));
    max_z0_.push_back(cfg.getParameter<double>("max_z0"));
    nSigmaZ_.push_back(cfg.getParameter<double>("nSigmaZ"));
    // Cuts on numbers of layers with hits/3D hits/lost hits.
    min_layers_.push_back(cfg.getParameter<uint32_t>("minNumberLayers") );
    min_3Dlayers_.push_back(cfg.getParameter<uint32_t>("minNumber3DLayers") );
    max_lostLayers_.push_back(cfg.getParameter<uint32_t>("maxNumberLostLayers"));
    min_hits_bypass_.push_back(cfg.getParameter<uint32_t>("minHitsToBypassChecks"));
    max_relpterr_.push_back(cfg.getParameter<double>("max_relpterr"));
    min_nhits_.push_back(cfg.getParameter<uint32_t>("min_nhits"));
    max_minMissHitOutOrIn_.push_back(
    cfg.existsAs<int32_t>("max_minMissHitOutOrIn") ? 
    cfg.getParameter<int32_t>("max_minMissHitOutOrIn") : 99);
    max_lostHitFraction_.push_back(
    cfg.existsAs<double>("max_lostHitFraction") ?
    cfg.getParameter<double>("max_lostHitFraction") : 1.0);
    min_eta_.push_back(cfg.getParameter<double>("min_eta"));
    max_eta_.push_back(cfg.getParameter<double>("max_eta"));

    // Flag to apply absolute cuts if no PV passes the selection
    applyAbsCutsIfNoPV_.push_back(cfg.getParameter<bool>("applyAbsCutsIfNoPV"));
    keepAllTracks_.push_back( cfg.exists("keepAllTracks") ?
                      cfg.getParameter<bool>("keepAllTracks") :
                      false ); 
 
    setQualityBit_.push_back( false );
    std::string qualityStr = cfg.getParameter<std::string>("qualityBit");
    
    if(d0_par1_[0].size()!=2 || dz_par1_[0].size()!=2 || d0_par2_[0].size()!=2 || dz_par2_[0].size()!=2)
    {
      edm::LogError("MisConfiguration")<<"vector of size less then 2";
      throw; 
    }

    if (cfg.exists("qualityBit")) {
      std::string qualityStr = cfg.getParameter<std::string>("qualityBit");
      if (qualityStr != "") {
        setQualityBit_[0] = true;
        qualityToSet_ [0] = TrackBase::qualityByName(cfg.getParameter<std::string>("qualityBit"));
      }
    }
  
    if (keepAllTracks_[0] && !setQualityBit_[0]) throw cms::Exception("Configuration") << 
      "If you set 'keepAllTracks' to true, you must specify which qualityBit to set.\n";
    if (setQualityBit_[0] && (qualityToSet_[0] == TrackBase::undefQuality)) throw cms::Exception("Configuration") <<
      "You can't set the quality bit " << cfg.getParameter<std::string>("qualityBit") << " as it is 'undefQuality' or unknown.\n";
    if (applyAbsCutsIfNoPV_[0]) {
      max_d0NoPV_.push_back(cfg.getParameter<double>("max_d0NoPV"));
      max_z0NoPV_.push_back(cfg.getParameter<double>("max_z0NoPV"));
    }
    else{//dummy values
      max_d0NoPV_.push_back(0.);
      max_z0NoPV_.push_back(0.);
    }

    if(useAnyMVA_){
      bool thisMVA = false;
      if(cfg.exists("useMVA"))thisMVA = cfg.getParameter<bool>("useMVA");
      useMVA_.push_back(thisMVA);
      if(thisMVA){
        double minVal = -1;
        if(cfg.exists("minMVA"))minVal = cfg.getParameter<double>("minMVA");
        min_MVA_.push_back(minVal);
        mvaType_.push_back(cfg.exists("mvaType") ? cfg.getParameter<std::string>("mvaType") : "Detached");
        forestLabel_.push_back(cfg.exists("GBRForestLabel") ? cfg.getParameter<std::string>("GBRForestLabel") : "MVASelectorIter0");
        useMVAonly_.push_back(cfg.exists("useMVAonly") ? cfg.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");
    }
    
    std::string alias( cfg.getParameter<std::string>( "@module_label" ) );
    produces<reco::TrackCollection>().setBranchAlias( alias + "Tracks");
    if (copyExtras_) {
      produces<reco::TrackExtraCollection>().setBranchAlias( alias + "TrackExtras");
      produces<TrackingRecHitCollection>().setBranchAlias( alias + "RecHits");
    }
    if (copyTrajectories_) {
      produces< std::vector<Trajectory> >().setBranchAlias( alias + "Trajectories");
      produces< TrajTrackAssociationCollection >().setBranchAlias( alias + "TrajectoryTrackAssociations");
    }
}

AnalyticalTrackSelector::~AnalyticalTrackSelector ( )

virtual

destructor

Definition at line 235 of file AnalyticalTrackSelector.cc.

                                                  {
}

Member Function Documentation

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

overrideprivatevirtual

process one event

Reimplemented from MultiTrackSelector.

Definition at line 239 of file AnalyticalTrackSelector.cc.

References MultiTrackSelector::beamspot_, edm::AssociationMap< edm::OneToOne< std::vector< Trajectory >, reco::TrackCollection, unsigned short > >::const_iterator, copyExtras_, copyTrajectories_, cond::rpcobimon::current, edm::Event::getByToken(), edm::Event::getRefBeforePut(), MultiTrackSelector::hSrc_, i, reco::Track::innerDetId(), reco::Track::innerMomentum(), reco::Track::innerOk(), reco::Track::innerPosition(), reco::Track::innerStateCovariance(), MultiTrackSelector::keepAllTracks_, edm::Ref< C, T, F >::key(), LogDebug, LogTrace, match(), gen::n, convertSQLiteXML::ok, reco::Track::outerDetId(), reco::Track::outerMomentum(), reco::Track::outerOk(), reco::Track::outerPosition(), reco::Track::outerStateCovariance(), MultiTrackSelector::processMVA(), reco::TrackBase::pt(), edm::Event::put(), MultiTrackSelector::qualityToSet_, reco::Track::recHitsBegin(), reco::Track::recHitsEnd(), dt_dqm_sourceclient_common_cff::reco, reco::Track::residuals(), reco::Track::seedDirection(), reco::Track::seedRef(), MultiTrackSelector::select(), MultiTrackSelector::selectVertices(), reco::TrackExtraBase::setHits(), MultiTrackSelector::setQualityBit_, reco::TrackExtra::setResiduals(), MultiTrackSelector::src_, srcTass_, srcTraj_, MultiTrackSelector::useAnyMVA_, MultiTrackSelector::useVertices_, and MultiTrackSelector::vertices_.

{

            // storage....
            std::auto_ptr<reco::TrackCollection> selTracks_;
            std::auto_ptr<reco::TrackExtraCollection> selTrackExtras_;
            std::auto_ptr< TrackingRecHitCollection>  selHits_;
            std::auto_ptr< std::vector<Trajectory> > selTrajs_;
            std::auto_ptr< std::vector<const Trajectory *> > selTrajPtrs_;
            std::auto_ptr< TrajTrackAssociationCollection >  selTTAss_;
            reco::TrackRefProd rTracks_;
            reco::TrackExtraRefProd rTrackExtras_;
            TrackingRecHitRefProd rHits_;
            edm::RefProd< std::vector<Trajectory> > rTrajectories_;
            std::vector<reco::TrackRef> trackRefs_;


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

  Handle<TrackCollection> hSrcTrack;
  Handle< vector<Trajectory> > hTraj;
  Handle< vector<Trajectory> > hTrajP;
  Handle< TrajTrackAssociationCollection > hTTAss;

  // looking for the beam spot
  edm::Handle<reco::BeamSpot> hBsp;
  evt.getByToken(beamspot_, hBsp);
  reco::BeamSpot vertexBeamSpot;
  vertexBeamSpot = *hBsp;
    
  // Select good primary vertices for use in subsequent track selection
  edm::Handle<reco::VertexCollection> hVtx;
  std::vector<Point> points;
  std::vector<float> vterr, vzerr;
  if (useVertices_) {
      evt.getByToken(vertices_, hVtx);
      selectVertices(0,*hVtx, points, vterr, vzerr);
      // Debug 
      LogDebug("SelectVertex") << points.size() << " good pixel vertices";
  }

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



  selTracks_ = auto_ptr<TrackCollection>(new TrackCollection());
  rTracks_ = evt.getRefBeforePut<TrackCollection>();      
  if (copyExtras_) {
    selTrackExtras_ = auto_ptr<TrackExtraCollection>(new TrackExtraCollection());
    selHits_ = auto_ptr<TrackingRecHitCollection>(new TrackingRecHitCollection());
    rHits_ = evt.getRefBeforePut<TrackingRecHitCollection>();
    rTrackExtras_ = evt.getRefBeforePut<TrackExtraCollection>();
  }

  if (copyTrajectories_) trackRefs_.resize(hSrcTrack->size());

  std::vector<float>  mvaVals_(hSrcTrack->size(),-99.f);
  processMVA(evt,es,vertexBeamSpot,*(hVtx.product()),0,mvaVals_,true);

  // Loop over tracks
  size_t current = 0;
  for (TrackCollection::const_iterator it = hSrcTrack->begin(), ed = hSrcTrack->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() ;

    float mvaVal = 0;
    if(useAnyMVA_)mvaVal = mvaVals_[current];
    bool ok = select(0,vertexBeamSpot, srcHits, trk, points, vterr, vzerr,mvaVal);
    if (!ok) {

      LogTrace("TrackSelection") << "track with pt="<< trk.pt() << " NOT selected";

      if (copyTrajectories_) trackRefs_[current] = reco::TrackRef();
      if (!keepAllTracks_[0]) continue;
    }
    LogTrace("TrackSelection") << "track with pt="<< trk.pt() << " selected";
    selTracks_->push_back( Track( trk ) ); // clone and store
    if (ok && setQualityBit_[0]) {
      selTracks_->back().setQuality(qualityToSet_[0]);
      if (qualityToSet_[0]==TrackBase::tight) {
    selTracks_->back().setQuality(TrackBase::loose);
      } 
      else if (qualityToSet_[0]==TrackBase::highPurity) {
    selTracks_->back().setQuality(TrackBase::loose);
    selTracks_->back().setQuality(TrackBase::tight);
      }
      if (!points.empty()) {
    if (qualityToSet_[0]==TrackBase::loose) {
      selTracks_->back().setQuality(TrackBase::looseSetWithPV);
    }
    else if (qualityToSet_[0]==TrackBase::highPurity) {
      selTracks_->back().setQuality(TrackBase::looseSetWithPV);
      selTracks_->back().setQuality(TrackBase::highPuritySetWithPV);
    }
      }
    }
    if (copyExtras_) {
      // TrackExtras
      selTrackExtras_->push_back( TrackExtra( trk.outerPosition(), trk.outerMomentum(), trk.outerOk(),
                          trk.innerPosition(), trk.innerMomentum(), trk.innerOk(),
                          trk.outerStateCovariance(), trk.outerDetId(),
                          trk.innerStateCovariance(), trk.innerDetId(),
                          trk.seedDirection(), trk.seedRef() ) );
      selTracks_->back().setExtra( TrackExtraRef( rTrackExtras_, selTrackExtras_->size() - 1) );
      TrackExtra & tx = selTrackExtras_->back();
      tx.setResiduals(trk.residuals());
      // TrackingRecHits
      auto const firstHitIndex = selHits_->size();
      for( trackingRecHit_iterator hit = trk.recHitsBegin(); hit != trk.recHitsEnd(); ++ hit ) {
    selHits_->push_back( (*hit)->clone() );
      }
      tx.setHits( rHits_, firstHitIndex, selHits_->size() - firstHitIndex);
    }
    if (copyTrajectories_) {
      trackRefs_[current] = TrackRef(rTracks_, selTracks_->size() - 1);
    }
  }
  if ( copyTrajectories_ ) {
    Handle< vector<Trajectory> > hTraj;
    Handle< TrajTrackAssociationCollection > hTTAss;
    evt.getByToken(srcTass_, hTTAss);
    evt.getByToken(srcTraj_, hTraj);
    selTrajs_ = auto_ptr< vector<Trajectory> >(new vector<Trajectory>()); 
    rTrajectories_ = evt.getRefBeforePut< vector<Trajectory> >();
    selTTAss_ = auto_ptr< TrajTrackAssociationCollection >(new TrajTrackAssociationCollection(rTrajectories_, rTracks_));
    for (size_t i = 0, n = hTraj->size(); i < n; ++i) {
      Ref< vector<Trajectory> > trajRef(hTraj, i);
      TrajTrackAssociationCollection::const_iterator match = hTTAss->find(trajRef);
      if (match != hTTAss->end()) {
    const Ref<TrackCollection> &trkRef = match->val; 
    short oldKey = static_cast<short>(trkRef.key());
    if (trackRefs_[oldKey].isNonnull()) {
      selTrajs_->push_back( Trajectory(*trajRef) );
      selTTAss_->insert ( Ref< vector<Trajectory> >(rTrajectories_, selTrajs_->size() - 1), trackRefs_[oldKey] );
    }
      }
    }
  }

  evt.put(selTracks_);
  if (copyExtras_ ) {
    evt.put(selTrackExtras_); 
    evt.put(selHits_);
  }
  if ( copyTrajectories_ ) {
    evt.put(selTrajs_);
    evt.put(selTTAss_);
  }
}

Member Data Documentation

bool AnalyticalTrackSelector::copyExtras_

private

copy only the tracks, not extras and rechits (for AOD)

Definition at line 50 of file AnalyticalTrackSelector.cc.

Referenced by AnalyticalTrackSelector(), and run().

bool AnalyticalTrackSelector::copyTrajectories_

private

copy also trajectories and trajectory->track associations

Definition at line 52 of file AnalyticalTrackSelector.cc.

Referenced by AnalyticalTrackSelector(), and run().

double AnalyticalTrackSelector::maxEta_

private

Definition at line 55 of file AnalyticalTrackSelector.cc.

double AnalyticalTrackSelector::minEta_

private

eta restrictions

Definition at line 54 of file AnalyticalTrackSelector.cc.

edm::EDGetTokenT<TrajTrackAssociationCollection > AnalyticalTrackSelector::srcTass_

private

Definition at line 58 of file AnalyticalTrackSelector.cc.

Referenced by AnalyticalTrackSelector(), and run().

edm::EDGetTokenT<std::vector<Trajectory> > AnalyticalTrackSelector::srcTraj_

private

Definition at line 57 of file AnalyticalTrackSelector.cc.

Referenced by AnalyticalTrackSelector(), and run().