Inheritance diagram for VertexCompositeCandidateCollectionSelector:

Public Member Functions
	VertexCompositeCandidateCollectionSelector (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
edm::EDGetTokenT< reco::BeamSpot >	bsToken_

bool	debug_

std::string	label_

float	lxyCUT_

float	lxyWRTbsCUT_

int	pvNDOF_

edm::EDGetTokenT< reco::VertexCollection >	pvToken_

edm::EDGetTokenT< reco::VertexCompositeCandidateCollection >	v0Token_

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 27 of file VertexCompositeCandidateCollectionSelector.cc.

Constructor & Destructor Documentation

◆ VertexCompositeCandidateCollectionSelector()

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

explicit

Definition at line 63 of file VertexCompositeCandidateCollectionSelector.cc.

     : v0Token_(consumes<reco::VertexCompositeCandidateCollection>(iConfig.getParameter<edm::InputTag>("v0"))),
       bsToken_(consumes<reco::BeamSpot>(iConfig.getParameter<edm::InputTag>("beamSpot"))),
       pvToken_(consumes<reco::VertexCollection>(iConfig.getParameter<edm::InputTag>("primaryVertex"))),
       pvNDOF_(iConfig.getParameter<int>("pvNDOF")),
       label_(iConfig.getParameter<edm::InputTag>("v0").instance()),
       lxyCUT_(iConfig.getParameter<double>("lxyCUT")),
       lxyWRTbsCUT_(iConfig.getParameter<double>("lxyWRTbsCUT")),
       debug_(iConfig.getUntrackedParameter<bool>("debug")) {
   if (debug_)
     std::cout << "VertexCompositeCandidateCollectionSelector::VertexCompositeCandidateCollectionSelector" << std::endl;
   // product
   produces<reco::VertexCompositeCandidateCollection>();
  
   //now do what ever other initialization is needed
 }

References gather_cfg::cout, and debug_.

Member Function Documentation

◆ fillDescriptions()

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

static

Definition at line 151 of file VertexCompositeCandidateCollectionSelector.cc.

                                                                                                             {
   //The following says we do not know what parameters are allowed so do no validation
   // Please change this to state exactly what you do use, even if it is no parameters
   edm::ParameterSetDescription desc;
   desc.add<edm::InputTag>("v0");
   desc.add<edm::InputTag>("beamSpot");
   desc.add<edm::InputTag>("primaryVertex");
   desc.add<int>("pvNDOF");
   desc.add<double>("lxyCUT", 16.);      // cm (2016 pixel layer3:10.2 cm ; 2017 pixel layer4: 16.0 cm)
   desc.add<double>("lxyWRTbsCUT", 0.);  // cm
   desc.addUntracked<bool>("debug", false);
   descriptions.add("VertexCompositeCandidateCollectionSelector", desc);
 }

References edm::ConfigurationDescriptions::add(), and submitPVResolutionJobs::desc.

◆ produce()

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

overrideprivate

Definition at line 85 of file VertexCompositeCandidateCollectionSelector.cc.

                                                                                                       {
   using namespace edm;
  
   if (debug_)
     std::cout << "VertexCompositeCandidateCollectionSelector::produce" << std::endl;
  
   // Create auto_ptr for each collection to be stored in the Event
   auto result = std::make_unique<reco::VertexCompositeCandidateCollection>();
  
   edm::Handle<reco::BeamSpot> beamspotHandle;
   iEvent.getByToken(bsToken_, beamspotHandle);
   reco::BeamSpot const* bs = nullptr;
   if (beamspotHandle.isValid())
     bs = &(*beamspotHandle);
  
   edm::Handle<reco::VertexCollection> pvHandle;
   iEvent.getByToken(pvToken_, pvHandle);
   reco::Vertex const* pv = nullptr;
   if (pvHandle.isValid()) {
     pv = &pvHandle->front();
     //--- pv fake (the pv collection should have size==1 and the pv==beam spot)
     if (pv->isFake() ||
         pv->tracksSize() == 0
         // definition of goodOfflinePrimaryVertex
         || pv->ndof() < pvNDOF_ || pv->z() > 24.)
       pv = nullptr;
   }
  
   edm::Handle<reco::VertexCompositeCandidateCollection> v0Handle;
   iEvent.getByToken(v0Token_, v0Handle);
   int n = (v0Handle.isValid() ? v0Handle->size() : -1);
   if (debug_)
     std::cout << "n: " << n << std::endl;
   if (n > 0) {
     auto const& v0s = *v0Handle.product();
     for (auto const& v0 : v0s) {
       GlobalPoint displacementFromPV2D =
           (pv == nullptr ? dummyGP : GlobalPoint((pv->x() - v0.vx()), (pv->y() - v0.vy()), 0.));
       GlobalPoint displacementFromBS2D =
           (bs == nullptr ? dummyGP : GlobalPoint(v0.vx() - bs->x(v0.vz()), v0.vy() - bs->y(v0.vz()), 0.));
       float abslxy = (pv == nullptr ? dummy : displacementFromPV2D.perp());
       float abslxyWRTbs = (bs == nullptr ? dummy : displacementFromBS2D.perp());
  
       if (debug_)
         std::cout << "abslxy: " << abslxy << " w.r.t. " << lxyCUT_ << " ==> " << (abslxy >= lxyCUT_ ? "OK" : "KO")
                   << std::endl;
       if (debug_)
         std::cout << "abslxyWRTbs: " << abslxyWRTbs << " w.r.t. " << lxyWRTbsCUT_ << " ==> "
                   << (abslxyWRTbs >= lxyWRTbsCUT_ ? "OK" : "KO") << std::endl;
       if (abslxy < lxyCUT_)
         continue;
       if (abslxyWRTbs < lxyWRTbsCUT_)
         continue;
       result->push_back(v0);
     }
   }
  
   if (debug_)
     std::cout << "result: " << result->size() << std::endl;
   // put into the Event
   // Write the collections to the Event
   result->shrink_to_fit();
   iEvent.put(std::move(result));
 }