pat::PATSingleVertexSelector Class Reference

Produces a list containing a single vertex selected by some criteria. More...

#include "PhysicsTools/PatAlgos/plugins/PATSingleVertexSelector.h"

Inheritance diagram for pat::PATSingleVertexSelector:

Public Member Functions
virtual bool	filter (edm::Event &iEvent, const edm::EventSetup &iSetup) override
	PATSingleVertexSelector (const edm::ParameterSet &iConfig)
	~PATSingleVertexSelector ()
Public Member Functions inherited from edm::stream::EDFilter<>
	EDFilter ()=default
Public Member Functions inherited from edm::stream::EDFilterBase
	EDFilterBase ()
ModuleDescription const &	moduleDescription () const
virtual	~EDFilterBase ()
Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)
std::vector < edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const
	ProducerBase ()
void	registerProducts (ProducerBase *, ProductRegistry *, ModuleDescription const &)
std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...
void	resolvePutIndicies (BranchType iBranchType, std::unordered_multimap< std::string, edm::ProductResolverIndex > const &iIndicies, std::string const &moduleLabel)
virtual	~ProducerBase () noexcept(false)
Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const
	EDConsumerBase ()
	EDConsumerBase (EDConsumerBase const &)=delete
	EDConsumerBase (EDConsumerBase &&)=default
ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const
void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
std::vector < ProductResolverIndexAndSkipBit > const &	itemsToGetFromEvent () const
void	labelsForToken (EDGetToken iToken, Labels &oLabels) const
void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const
EDConsumerBase const &	operator= (EDConsumerBase const &)=delete
EDConsumerBase &	operator= (EDConsumerBase &&)=default
bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const
bool	registeredToConsumeMany (TypeID const &, BranchType) const
void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)
virtual	~EDConsumerBase () noexcept(false)

Private Types
typedef StringCutObjectSelector < reco::Candidate >	CandSel
enum	Mode { First, NearestToCand, FromCand, FromBeamSpot }
typedef StringCutObjectSelector < reco::Vertex >	VtxSel

Private Member Functions
std::unique_ptr< std::vector < reco::Vertex > >	filter_ (Mode mode, const edm::Event &iEvent, const edm::EventSetup &iSetup)
bool	hasMode_ (Mode mode) const
Mode	parseMode (const std::string &name) const

Private Attributes
edm::EDGetTokenT< reco::BeamSpot >	beamSpotToken_
reco::CandidatePtr	bestCand_
std::vector< edm::EDGetTokenT < edm::View< reco::Candidate > > >	candidatesToken_
const CandSel	candPreselection_
bool	doFilterEvents_
std::vector< Mode >	modes_
std::vector< reco::VertexRef >	selVtxs_
edm::EDGetTokenT< std::vector < reco::Vertex > >	verticesToken_
const VtxSel	vtxPreselection_

Additional Inherited Members
Public Types inherited from edm::stream::EDFilter<>
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::EDFilterBase
typedef EDFilterAdaptorBase	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::EDFilterBase
static const std::string &	baseType ()
static void	fillDescriptions (ConfigurationDescriptions &descriptions)
static void	prevalidate (ConfigurationDescriptions &descriptions)
Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)
EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)
template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)
ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...
template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()
void	consumesMany (const TypeToGet &id)
template<BranchType B>
void	consumesMany (const TypeToGet &id)
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)
template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Detailed Description

Produces a list containing a single vertex selected by some criteria.

Author

Giovanni Petrucciani

Version

Id:

PATSingleVertexSelector.h,v 1.5 2011/06/15 11:47:25 friis Exp

Definition at line 28 of file PATSingleVertexSelector.h.

Member Typedef Documentation

typedef StringCutObjectSelector<reco::Candidate> pat::PATSingleVertexSelector::CandSel

private

Definition at line 40 of file PATSingleVertexSelector.h.

typedef StringCutObjectSelector<reco::Vertex> pat::PATSingleVertexSelector::VtxSel

private

Definition at line 39 of file PATSingleVertexSelector.h.

Member Enumeration Documentation

enum pat::PATSingleVertexSelector::Mode

private

Enumerator
First
NearestToCand
FromCand
FromBeamSpot

Definition at line 38 of file PATSingleVertexSelector.h.

{ First, NearestToCand, FromCand, FromBeamSpot };

Constructor & Destructor Documentation

PATSingleVertexSelector::PATSingleVertexSelector ( const edm::ParameterSet &  iConfig )

explicit

Definition at line 29 of file PATSingleVertexSelector.cc.

References candidatesToken_, edm::EDConsumerBase::consumes(), edm::ParameterSet::exists(), First, FromCand, edm::ParameterSet::getParameter(), hasMode_(), modes_, NearestToCand, parseMode(), AlCaHLTBitMon_QueryRunRegistry::string, GlobalPosition_Frontier_DevDB_cff::tag, edm::vector_transform(), and verticesToken_.

                                                                                : 
  vtxPreselection_( iConfig.existsAs<std::string>("vertexPreselection") ? iConfig.getParameter<std::string>("vertexPreselection") : std::string(" 1 == 1 ") ), 
  candPreselection_( iConfig.existsAs<std::string>("candidatePreselection") ? iConfig.getParameter<std::string>("candidatePreselection") : std::string(" 1 == 1 ") ),
  doFilterEvents_(false)
{
   using namespace std;

   modes_.push_back( parseMode(iConfig.getParameter<std::string>("mode")) );
   if (iConfig.exists("fallbacks")) {
      vector<string> modes = iConfig.getParameter<vector<string> >("fallbacks");
      for (vector<string>::const_iterator it = modes.begin(), ed = modes.end(); it != ed; ++it) {
        modes_.push_back( parseMode(*it) );
      }
   }
   if (hasMode_(First) || hasMode_(NearestToCand)) {
        verticesToken_ = consumes<vector<reco::Vertex> >(iConfig.getParameter<edm::InputTag>("vertices"));        
   }
   if (hasMode_(NearestToCand) || hasMode_(FromCand)) {
        candidatesToken_ = edm::vector_transform(iConfig.getParameter<vector<edm::InputTag> >("candidates"), [this](edm::InputTag const & tag){return consumes<edm::View<reco::Candidate> >(tag);});        
   }
   if (hasMode_(FromBeamSpot)) {
        beamSpotToken_ = consumes<reco::BeamSpot>(iConfig.getParameter<edm::InputTag>("beamSpot"));
   }

   if ( iConfig.exists("filter") ) doFilterEvents_ = iConfig.getParameter<bool>("filter");

   produces<vector<reco::Vertex> >();
}

PATSingleVertexSelector::~PATSingleVertexSelector

(

)

Definition at line 59 of file PATSingleVertexSelector.cc.

{
}

Member Function Documentation

bool PATSingleVertexSelector::filter ( edm::Event &  iEvent, const edm::EventSetup &  iSetup  )

overridevirtual

Implements edm::stream::EDFilterBase.

Definition at line 68 of file PATSingleVertexSelector.cc.

References bestCand_, candidatesToken_, candPreselection_, HLT_25ns10e33_v2_cff::distance, doFilterEvents_, filter_(), First, FromCand, edm::Event::getByToken(), hasMode_(), modes_, eostools::move(), NearestToCand, edm::Event::put(), mps_fire::result, selVtxs_, HLT_25ns10e33_v2_cff::vertices, verticesToken_, and vtxPreselection_.

                                                                               {
  using namespace edm;
  using namespace std;

  // Clear
  selVtxs_.clear(); bestCand_ = reco::CandidatePtr();
  
  // Gather data from the Event
  // -- vertex data --
  if (hasMode_(First) || hasMode_(NearestToCand)) {
    Handle<vector<reco::Vertex> > vertices;
    iEvent.getByToken(verticesToken_, vertices);
    for (vector<reco::Vertex>::const_iterator itv = vertices->begin(), edv = vertices->end(); itv != edv; ++itv) {
      if ( !(vtxPreselection_(*itv)) ) continue;
      selVtxs_.push_back( reco::VertexRef(vertices,std::distance(vertices->begin(),itv) ) );
    }
  }
  // -- candidate data --
  if (hasMode_(NearestToCand) || hasMode_(FromCand)) {
    vector<pair<double, reco::CandidatePtr> > cands;
    for (vector<edm::EDGetTokenT<edm::View<reco::Candidate> > >::const_iterator itt = candidatesToken_.begin(), edt = candidatesToken_.end(); itt != edt; ++itt) {
      Handle<View<reco::Candidate> > theseCands;
      iEvent.getByToken(*itt, theseCands);
      for (View<reco::Candidate>::const_iterator itc = theseCands->begin(), edc = theseCands->end(); itc != edc; ++itc) {
        if ( !(candPreselection_(*itc)) ) continue;
        cands.push_back( pair<double, reco::CandidatePtr>(-itc->pt(), reco::CandidatePtr(theseCands,std::distance(theseCands->begin(),itc) ) ) );
      }
    }
    if (!cands.empty()) bestCand_ = cands.front().second;
  }
  
  bool passes = false;
  std::unique_ptr<vector<reco::Vertex> > result;
  // Run main mode + possible fallback modes
  for (std::vector<Mode>::const_iterator itm = modes_.begin(), endm = modes_.end(); itm != endm; ++itm) {
    result = filter_(*itm, iEvent, iSetup);
    // Check if we got any vertices.  If so, take them.
    if (result->size()) {
      passes = true;
      break;
    }
  }
  iEvent.put(std::move(result));
  // Check if we want to apply the EDFilter
  if (doFilterEvents_)
    return passes;
  else return true;
}

std::unique_ptr< std::vector< reco::Vertex > > PATSingleVertexSelector::filter_ ( Mode  mode, const edm::Event &  iEvent, const edm::EventSetup &  iSetup  )

private

Definition at line 118 of file PATSingleVertexSelector.cc.

References funct::abs(), SiPixelRawToDigiRegional_cfi::beamSpot, beamSpotToken_, bestCand_, First, FromBeamSpot, FromCand, edm::Event::getByToken(), edm::Ref< C, T, F >::isNonnull(), edm::Ptr< T >::isNull(), NearestToCand, mps_fire::result, selVtxs_, and eostools::which().

Referenced by filter().

                                                                                                {
  using namespace edm;
  using namespace std;
  auto result = std::make_unique<std::vector<reco::Vertex>>();
  switch(mode) {
  case First: {
    if (selVtxs_.empty()) return result;
    result->push_back(*selVtxs_.front());
    return result;
  }
  case FromCand: {
    if (bestCand_.isNull()) return result;
    reco::Vertex vtx;
    if (typeid(*bestCand_) == typeid(reco::VertexCompositeCandidate)) {
      vtx = reco::Vertex(bestCand_->vertex(), bestCand_->vertexCovariance(),
                         bestCand_->vertexChi2(), bestCand_->vertexNdof(), bestCand_->numberOfDaughters() );
    } else {
      vtx = reco::Vertex(bestCand_->vertex(), reco::Vertex::Error(), 0, 0, 0);
    }
    result->push_back(vtx);
    return result;
  }
  case NearestToCand: {
    if (selVtxs_.empty() || (bestCand_.isNull())) return result;
    reco::VertexRef which;
    float dzmin = 9999.0;
    for (auto itv = selVtxs_.begin(), edv = selVtxs_.end(); itv != edv; ++itv) {
      float dz = std::abs((*itv)->z() - bestCand_->vz());
      if (dz < dzmin) { dzmin = dz; which = *itv; }
    }
    if (which.isNonnull()) // actually it should not happen, but better safe than sorry
      result->push_back(*which);
    return result;
  }
  case FromBeamSpot: {
    Handle<reco::BeamSpot> beamSpot;
    iEvent.getByToken(beamSpotToken_, beamSpot);
    reco::Vertex bs(beamSpot->position(), beamSpot->covariance3D(), 0, 0, 0);
    result->push_back(bs);
    return result;
  }
  default:
    // Return an empty vector signifying no vertices found.
    return result;
  }
}

bool PATSingleVertexSelector::hasMode_ ( Mode  mode ) const

private

Definition at line 63 of file PATSingleVertexSelector.cc.

References spr::find(), universalConfigTemplate::mode, and modes_.

Referenced by filter(), and PATSingleVertexSelector().

                                                      {
    return (std::find(modes_.begin(), modes_.end(), mode) != modes_.end());
}

PATSingleVertexSelector::Mode PATSingleVertexSelector::parseMode ( const std::string &  name ) const

private

Definition at line 14 of file PATSingleVertexSelector.cc.

References Exception, First, FromBeamSpot, FromCand, and NearestToCand.

Referenced by PATSingleVertexSelector().

                                                              {
    if (mode == "firstVertex") {
        return First;
    } else if (mode == "nearestToCandidate") {
        return NearestToCand;
    } else if (mode == "fromCandidate") {
        return FromCand;
    } else if (mode == "beamSpot") {
        return FromBeamSpot;
    } else {
        throw cms::Exception("Configuration") << "PATSingleVertexSelector: Mode '" << mode << "' not recognized or not supported.\n";
    }
}

Member Data Documentation

edm::EDGetTokenT<reco::BeamSpot> pat::PATSingleVertexSelector::beamSpotToken_

private

Definition at line 53 of file PATSingleVertexSelector.h.

Referenced by filter_().

reco::CandidatePtr pat::PATSingleVertexSelector::bestCand_

private

Definition at line 56 of file PATSingleVertexSelector.h.

Referenced by filter(), and filter_().

std::vector<edm::EDGetTokenT<edm::View<reco::Candidate> > > pat::PATSingleVertexSelector::candidatesToken_

private

Definition at line 50 of file PATSingleVertexSelector.h.

Referenced by filter(), and PATSingleVertexSelector().

const CandSel pat::PATSingleVertexSelector::candPreselection_

private

Definition at line 52 of file PATSingleVertexSelector.h.

Referenced by filter().

bool pat::PATSingleVertexSelector::doFilterEvents_

private

Definition at line 61 of file PATSingleVertexSelector.h.

Referenced by filter().

std::vector<Mode> pat::PATSingleVertexSelector::modes_

private

Definition at line 48 of file PATSingleVertexSelector.h.

Referenced by filter(), hasMode_(), and PATSingleVertexSelector().

std::vector<reco::VertexRef> pat::PATSingleVertexSelector::selVtxs_

private

Definition at line 55 of file PATSingleVertexSelector.h.

Referenced by filter(), and filter_().

edm::EDGetTokenT<std::vector<reco::Vertex> > pat::PATSingleVertexSelector::verticesToken_

private

Definition at line 49 of file PATSingleVertexSelector.h.

Referenced by filter(), and PATSingleVertexSelector().

const VtxSel pat::PATSingleVertexSelector::vtxPreselection_

private

Definition at line 51 of file PATSingleVertexSelector.h.

Referenced by filter().