#include <HLTPixlMBFilt.h>

Inheritance diagram for HLTPixlMBFilt:

Public Member Functions
virtual bool	hltFilter (edm::Event &, const edm::EventSetup &, trigger::TriggerFilterObjectWithRefs &filterproduct) const override

	HLTPixlMBFilt (const edm::ParameterSet &)

	~HLTPixlMBFilt ()

Public Member Functions inherited from HLTFilter
	HLTFilter (const edm::ParameterSet &config)

int	module (edm::Event const &) const

const std::string *	moduleLabel () const

int	path (edm::Event const &) const

const std::string *	pathName (edm::Event const &) const

std::pair< int, int >	pmid (edm::Event const &) const

bool	saveTags () const

virtual	~HLTFilter ()

Public Member Functions inherited from edm::global::EDFilter<>
	EDFilter ()=default

Public Member Functions inherited from edm::global::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 &	itemsToGetFrom (BranchType iType) 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)

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

Static Public Member Functions inherited from HLTFilter
static void	makeHLTFilterDescription (edm::ParameterSetDescription &desc)

Static Public Member Functions inherited from edm::global::EDFilterBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Private Attributes
double	min_Pt_

float	min_sep_

unsigned int	min_trks_

edm::InputTag	pixlTag_

edm::EDGetTokenT< reco::RecoChargedCandidateCollection >	pixlToken_

Additional Inherited Members
Public Types inherited from edm::global::EDFilterBase
typedef EDFilterBase	ModuleType

Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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

See header file for documentation

Author: Mika Huhtinen

Definition at line 28 of file HLTPixlMBFilt.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 31 of file HLTPixlMBFilt.cc.

References edm::InputTag::encode(), LogDebug, min_Pt_, min_sep_, min_trks_, pixlTag_, pixlToken_, and ~HLTPixlMBFilt().

                                                            : HLTFilter(iConfig),
     pixlTag_ (iConfig.getParameter<edm::InputTag>("pixlTag")),
     min_Pt_  (iConfig.getParameter<double>("MinPt")),
     min_trks_  (iConfig.getParameter<unsigned int>("MinTrks")),
     min_sep_  (iConfig.getParameter<double>("MinSep"))
 
 {
   pixlToken_ = consumes<reco::RecoChargedCandidateCollection>(pixlTag_);
   LogDebug("") << "MinPt cut " << min_Pt_   << "pixl: " << pixlTag_.encode();
   LogDebug("") << "Requesting : " << min_trks_ << " tracks from same vertex ";
   LogDebug("") << "Requesting tracks from same vertex eta-phi separation by " << min_sep_;
 }

HLTPixlMBFilt::~HLTPixlMBFilt ( )

default

Referenced by HLTPixlMBFilt().

Member Function Documentation

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

static

Definition at line 47 of file HLTPixlMBFilt.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), and HLTFilter::makeHLTFilterDescription().

                                                                           {
   edm::ParameterSetDescription desc;
   makeHLTFilterDescription(desc);
   desc.add<edm::InputTag>("pixlTag",edm::InputTag("hltPixelCands"));
   desc.add<double>("MinPt",0.);
   desc.add<unsigned int>("MinTrks",2);
   desc.add<double>("MinSep",1.);
   descriptions.add("hltPixlMBFilt",desc);
 }

bool HLTPixlMBFilt::hltFilter	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup,
		trigger::TriggerFilterObjectWithRefs &	filterproduct
	)		const

overridevirtual

Implements HLTFilter.

Definition at line 62 of file HLTPixlMBFilt.cc.

References accept(), trigger::TriggerFilterObjectWithRefs::addCollectionTag(), trigger::TriggerRefsCollections::addObject(), edm::Event::getByToken(), gen::k, LogDebug, min_Pt_, min_sep_, min_trks_, pixlTag_, pixlToken_, HLTFilter::saveTags(), mathSSE::sqrt(), l1t::tracks, and trigger::TriggerTrack.

 {
    using namespace std;
    using namespace edm;
    using namespace reco;
    using namespace trigger;
 
    // All HLT filters must create and fill an HLT filter object,
    // recording any reconstructed physics objects satisfying (or not)
    // this HLT filter, and place it in the Event.
    if (saveTags()) {
        filterproduct.addCollectionTag(pixlTag_);
    }
 
    // Specific filter code
 
    // get hold of products from Event
 
    Handle<RecoChargedCandidateCollection> tracks;
    iEvent.getByToken(pixlToken_,tracks);
 
    // pixel tracks
    int npixl_tot = 0;
    vector<double> etastore;
    vector<double> phistore;
    vector<int> itstore;
    bool accept;
    auto apixl(tracks->begin());
    auto epixl(tracks->end());
    RecoChargedCandidateCollection::const_iterator ipixl, jpixl;
    unsigned int nsame_vtx=0;
    int itrk = -1;
    if (tracks->size() >= min_trks_) {
      for (ipixl=apixl; ipixl!=epixl; ipixl++){
        if (ipixl->pt() < min_Pt_) continue;
        itrk++;
        const double& ztrk1 = ipixl->vz();       
        const double& etatrk1 = ipixl->momentum().eta();
        const double& phitrk1 = ipixl->momentum().phi();
        nsame_vtx=1;
        etastore.clear();
        phistore.clear();
        itstore.clear();
        etastore.push_back(etatrk1);
        phistore.push_back(phitrk1);
        itstore.push_back(itrk);
        if (fabs(ztrk1) < 15.0) {
          //  check this track against all others to see if others start from same point
      int jtrk=-1;
          for (jpixl=apixl; jpixl!=epixl; jpixl++) {
        if (jpixl->pt() < min_Pt_) continue;
        jtrk++;
        if (jpixl==ipixl) continue;
            const double& ztrk2 = jpixl->vz();       
            const double& etatrk2 = jpixl->momentum().eta();
            const double& phitrk2 = jpixl->momentum().phi();
            double eta_dist=etatrk2-etatrk1;
            double phi_dist=phitrk2-phitrk1;
            double etaphi_dist=sqrt(eta_dist*eta_dist + phi_dist*phi_dist);
            if (fabs(ztrk2-ztrk1) < 1.0 && etaphi_dist > min_sep_) {
           if (min_trks_ <= 2 || itstore.size() <= 1) {
             etastore.push_back(etatrk2);
             phistore.push_back(phitrk2);
         itstore.push_back(jtrk);
                 nsame_vtx++;
               } else {
                 // check also separation to already found 'second' tracks
         LogDebug("") << "HLTPixlMBFilt: with mintrks=2 we should not be here...";
         bool isok = true;
         for (unsigned int k=1; k < itstore.size(); k++) {
                   eta_dist=etatrk2-etastore.at(k);
                   phi_dist=phitrk2-phistore.at(k);
                   etaphi_dist=sqrt(eta_dist*eta_dist + phi_dist*phi_dist);
           if (etaphi_dist < min_sep_) {
             isok=false;
             break;
                   }
         }
         if (isok) {
               etastore.push_back(etatrk2);
               phistore.push_back(phitrk2);
                   itstore.push_back(jtrk);
                   nsame_vtx++;
                 }
           }
        }
            if (nsame_vtx >= min_trks_) break;
          }
        }
        npixl_tot++;
 
        if (nsame_vtx >= min_trks_) break;
      }
 
      //   final filter decision:
      //   request at least min_trks_ tracks compatible with vertex-region
      accept = (nsame_vtx >= min_trks_ ) ;
 
    } else {
      accept = false;
    }
 
    // At this point we have the indices of the accepted tracks stored in itstore
    // we now move them to the filterproduct
 
    if (accept) {
      for (int iaddr : itstore) {
        filterproduct.addObject(TriggerTrack,RecoChargedCandidateRef(tracks,iaddr));
      }
    }
 
   LogDebug("") << "Number of pixel-track objects accepted:"
                << " " << npixl_tot;
 
   // return with final filter decision
   return accept;
 
 }