Inheritance diagram for PixelVertexCollectionTrimmer:

Public Member Functions
	PixelVertexCollectionTrimmer (const edm::ParameterSet &)

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

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

Private Member Functions
void	produce (edm::Event &, const edm::EventSetup &) override

Private Attributes
double const	fractionSumPt2_

uint const	maxVtx_

double const	minSumPt2_

std::unique_ptr < PVClusterComparer >	pvComparer_

edm::EDGetTokenT < reco::VertexCollection > const	vtxToken_

Additional Inherited Members
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

Detailed Description

Definition at line 19 of file PixelVertexCollectionTrimmer.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 36 of file PixelVertexCollectionTrimmer.cc.

References Exception, fractionSumPt2_, edm::ParameterSet::getParameterSet(), pvComparer_, HLT_FULL_cff::track_chi2_max, HLT_FULL_cff::track_prob_min, HLT_FULL_cff::track_pt_max, and HLT_FULL_cff::track_pt_min.

     : vtxToken_(consumes<reco::VertexCollection>(iConfig.getParameter<edm::InputTag>("src"))),
       maxVtx_(iConfig.getParameter<uint>("maxVtx")),
       fractionSumPt2_(iConfig.getParameter<double>("fractionSumPt2")),
       minSumPt2_(iConfig.getParameter<double>("minSumPt2")) {
   if (fractionSumPt2_ > 1)
     throw cms::Exception("PixelVertexConfiguration") << "value of \"fractionSumPt2\" is larger than 1.";
 
   auto const& pvComparerPSet = iConfig.getParameterSet("PVcomparer");
   auto const track_pt_min = pvComparerPSet.getParameter<double>("track_pt_min");
   auto const track_pt_max = pvComparerPSet.getParameter<double>("track_pt_max");
   auto const track_chi2_max = pvComparerPSet.getParameter<double>("track_chi2_max");
   auto const track_prob_min = pvComparerPSet.getParameter<double>("track_prob_min");
 
   if (track_pt_min >= track_pt_max)
     throw cms::Exception("PixelVertexConfiguration")
         << "PVcomparer.track_pt_min (" << track_pt_min << ") >= PVcomparer.track_pt_max (" << track_pt_max
         << ") : PVClusterComparer will use pT=" << track_pt_max << " for all selected tracks.";
 
   pvComparer_ = std::make_unique<PVClusterComparer>(track_pt_min, track_pt_max, track_chi2_max, track_prob_min);
 
   produces<reco::VertexCollection>();
 }

Member Function Documentation

void PixelVertexCollectionTrimmer::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 93 of file PixelVertexCollectionTrimmer.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), submitPVResolutionJobs::desc, HLT_FULL_cff::InputTag, edm::ParameterDescriptionNode::setComment(), and parallelization::uint().

                                                                                               {
   edm::ParameterSetDescription desc;
   desc.add<edm::InputTag>("src", edm::InputTag(""))->setComment("input (pixel) vertex collection");
   desc.add<uint>("maxVtx", 100)->setComment("max output collection size (number of accepted vertices)");
   desc.add<double>("fractionSumPt2", 0.3)->setComment("threshold on sumPt2 fraction of the leading vertex");
   desc.add<double>("minSumPt2", 0.)->setComment("min sumPt2");
   edm::ParameterSetDescription PVcomparerPSet;
   PVcomparerPSet.add<double>("track_pt_min", 1.0)->setComment("min track p_T");
   PVcomparerPSet.add<double>("track_pt_max", 10.0)->setComment("max track p_T");
   PVcomparerPSet.add<double>("track_chi2_max", 99999.)->setComment("max track chi2");
   PVcomparerPSet.add<double>("track_prob_min", -1.)->setComment("min track prob");
   desc.add<edm::ParameterSetDescription>("PVcomparer", PVcomparerPSet)
       ->setComment("from RecoPixelVertexing/PixelVertexFinding/python/PVClusterComparer_cfi.py");
   descriptions.add("hltPixelVertexCollectionTrimmer", desc);
 }

void PixelVertexCollectionTrimmer::produce	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overrideprivate

Definition at line 60 of file PixelVertexCollectionTrimmer.cc.

References fractionSumPt2_, edm::Event::get(), maxVtx_, SiStripPI::min, minSumPt2_, eostools::move(), edm::Event::put(), pvComparer_, and vtxToken_.

                                                                                         {
   auto vtxs_trim = std::make_unique<reco::VertexCollection>();
 
   auto const& vtxs = iEvent.get(vtxToken_);
 
   if (vtxs.empty())
     edm::LogWarning("PixelVertexInput") << "Input collection of vertices is empty. Output collection will be empty.";
   else {
     std::vector<double> foms(vtxs.size());
     for (size_t idx = 0; idx < vtxs.size(); ++idx)
       foms[idx] = pvComparer_->pTSquaredSum(vtxs[idx]);
 
     std::vector<size_t> sortIdxs(vtxs.size());
     std::iota(sortIdxs.begin(), sortIdxs.end(), 0);
     std::sort(sortIdxs.begin(), sortIdxs.end(), [&](size_t const i1, size_t const i2) { return foms[i1] > foms[i2]; });
 
     auto const minFOM_fromFrac = foms[sortIdxs.front()] * fractionSumPt2_;
 
     vtxs_trim->reserve(std::min((size_t)maxVtx_, vtxs.size()));
     for (auto const idx : sortIdxs) {
       if (vtxs_trim->size() >= maxVtx_)
         break;
       if (foms[idx] >= minFOM_fromFrac and foms[idx] > minSumPt2_)
         vtxs_trim->emplace_back(vtxs[idx]);
     }
 
     if (vtxs_trim->empty())
       edm::LogInfo("PixelVertexOutput") << "Output collection is empty.";
   }
 
   iEvent.put(std::move(vtxs_trim));
 }