Inheritance diagram for VertexCompositeCandidateCollectionSelector:

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

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

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

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(), edm::ParameterSetDescription::add(), and edm::ParameterSetDescription::addUntracked().

◆ 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));
 }