#include <SUSYBSMAnalysis/HSCParticleProducer/interface/HSCParticleProducer.h>

Inheritance diagram for HSCParticleProducer:

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

	~HSCParticleProducer () override

Public Member Functions inherited from edm::EDFilter
	EDFilter ()

SerialTaskQueue *	globalLuminosityBlocksQueue ()

SerialTaskQueue *	globalRunsQueue ()

ModuleDescription const &	moduleDescription () const

	~EDFilter () override

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

std::vector< edm::ProductResolverIndex > const &	putTokenIndexToProductResolverIndex () const

std::vector< bool > const &	recordProvenanceList () const

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, ModuleToResolverIndicies const &iIndicies, std::string const &moduleLabel)

TypeLabelList const &	typeLabelList () const
	used by the fwk to register the list of products of this module More...

	~ProducerBase () noexcept(false) override

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase &&)=default

	EDConsumerBase (EDConsumerBase const &)=delete

ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const

std::vector< ESProxyIndex > const &	esGetTokenIndicesVector (edm::Transition iTrans) const

std::vector< ESRecordIndex > const &	esGetTokenRecordIndicesVector (edm::Transition iTrans) const

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 &	operator= (EDConsumerBase &&)=default

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

Private Member Functions
void	beginJob () override

void	endJob () override

bool	filter (edm::Event &, const edm::EventSetup &) override

std::vector< susybsm::HSCParticle >	getHSCPSeedCollection (edm::Handle< reco::TrackCollection > &trackCollectionHandle, edm::Handle< reco::MuonCollection > &muonCollectionHandle, edm::Handle< reco::MuonCollection > &MTmuonCollectionHandle)

Private Attributes
BetaCalculatorECAL *	beta_calculator_ECAL

BetaCalculatorMUON *	beta_calculator_MUON

BetaCalculatorRPC *	beta_calculator_RPC

BetaCalculatorTK *	beta_calculator_TK

bool	Filter_

edm::EDGetTokenT< reco::MuonCollection >	m_MTmuonsToken

edm::EDGetTokenT< reco::MuonCollection >	m_muonsToken

edm::EDGetTokenT< reco::TrackCollection >	m_trackIsoToken

edm::EDGetTokenT< reco::TrackCollection >	m_trackToken

float	maxInvPtDiff

float	maxTkChi2

float	minDR

float	minMTDR

float	minMTMuPt

float	minMuP

float	minSAMuPt

unsigned int	minTkHits

float	minTkP

std::vector< CandidateSelector * >	Selectors

bool	useBetaFromEcal

bool	useBetaFromMuon

bool	useBetaFromRpc

bool	useBetaFromTk

Additional Inherited Members
Public Types inherited from edm::EDFilter
typedef EDFilter	ModuleType

Public Types inherited from edm::ProducerBase
using	ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const , const char , edm::ProductResolverIndex > >

typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &)

static bool	wantsGlobalLuminosityBlocks ()

static bool	wantsGlobalRuns ()

static bool	wantsInputProcessBlocks ()

static bool	wantsProcessBlocks ()

static bool	wantsStreamLuminosityBlocks ()

static bool	wantsStreamRuns ()

Protected Member Functions inherited from edm::ProducerBase
template<class ProductType >
BranchAliasSetterT< ProductType >	produces ()
	declare what type of product will make and with which optional label More...

template<typename ProductType , BranchType B>
BranchAliasSetterT< ProductType >	produces ()

template<typename ProductType , Transition B>
BranchAliasSetterT< ProductType >	produces ()

BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

template<BranchType B>
BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

template<Transition B>
BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

template<typename ProductType , Transition B>
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

template<class ProductType >
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

template<typename ProductType , BranchType B>
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

ProducesCollector	producesCollector ()

Protected Member Functions inherited from edm::EDConsumerBase
EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B >	consumes (edm::InputTag tag) noexcept

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 ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<Transition Tr = Transition::Event>
constexpr auto	esConsumes () noexcept

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

template<Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag tag) noexcept

template<Transition Tr = Transition::Event>
ESGetTokenGeneric	esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
	Used with EventSetupRecord::doGet. More...

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

Detailed Description

Description: Producer for HSCP candidates, merging tracker dt information and rpc information

Implementation: <Notes on="" implementation>="">

Definition at line 52 of file HSCParticleProducer.h.

Constructor & Destructor Documentation

◆ HSCParticleProducer()

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

explicit

Definition at line 25 of file HSCParticleProducer.cc.

                                                                        {
   using namespace edm;
   using namespace std;
  
   // the Act as Event filter
   Filter_ = iConfig.getParameter<bool>("filter");
  
   // the input collections
   m_trackToken = consumes<reco::TrackCollection>(iConfig.getParameter<edm::InputTag>("tracks"));
   m_muonsToken = consumes<reco::MuonCollection>(iConfig.getParameter<edm::InputTag>("muons"));
   m_MTmuonsToken = consumes<reco::MuonCollection>(iConfig.getParameter<edm::InputTag>("MTmuons"));
   m_trackIsoToken = consumes<reco::TrackCollection>(iConfig.getParameter<edm::InputTag>("tracksIsolation"));
  
   useBetaFromTk = iConfig.getParameter<bool>("useBetaFromTk");
   useBetaFromMuon = iConfig.getParameter<bool>("useBetaFromMuon");
   useBetaFromRpc = iConfig.getParameter<bool>("useBetaFromRpc");
   useBetaFromEcal = iConfig.getParameter<bool>("useBetaFromEcal");
  
   // the parameters
   minTkP = iConfig.getParameter<double>("minTkP");              // 30
   maxTkChi2 = iConfig.getParameter<double>("maxTkChi2");        // 5
   minTkHits = iConfig.getParameter<uint32_t>("minTkHits");      // 9
   minMuP = iConfig.getParameter<double>("minMuP");              // 30
   minDR = iConfig.getParameter<double>("minDR");                // 0.1
   minSAMuPt = iConfig.getParameter<double>("minSAMuPt");        // 70
   minMTMuPt = iConfig.getParameter<double>("minMTMuPt");        // 70
   minMTDR = iConfig.getParameter<double>("minMTDR");            // 0.3
   maxInvPtDiff = iConfig.getParameter<double>("maxInvPtDiff");  // 0.005
  
   if (useBetaFromTk)
     beta_calculator_TK = new BetaCalculatorTK(iConfig, consumesCollector());
   if (useBetaFromMuon)
     beta_calculator_MUON = new BetaCalculatorMUON(iConfig, consumesCollector());
   if (useBetaFromRpc)
     beta_calculator_RPC = new BetaCalculatorRPC(iConfig, consumesCollector());
   if (useBetaFromEcal)
     beta_calculator_ECAL = new BetaCalculatorECAL(iConfig, consumesCollector());
  
   // Load all the selections
   std::vector<edm::ParameterSet> SelectionParameters =
       iConfig.getParameter<std::vector<edm::ParameterSet> >("SelectionParameters");
   for (unsigned int i = 0; i < SelectionParameters.size(); i++) {
     Selectors.push_back(new CandidateSelector(SelectionParameters[i]));
   }
  
   // what I produce
   produces<susybsm::HSCParticleCollection>();
   if (useBetaFromEcal)
     produces<susybsm::HSCPCaloInfoCollection>();
 }

◆ ~HSCParticleProducer()

HSCParticleProducer::~HSCParticleProducer ( )

override

Definition at line 76 of file HSCParticleProducer.cc.

                                           {
   // do anything here that needs to be done at desctruction time
   // (e.g. close files, deallocate resources etc.)
 }

Member Function Documentation

◆ beginJob()

void HSCParticleProducer::beginJob ( void )

overrideprivatevirtual

Reimplemented from edm::EDFilter.

Definition at line 216 of file HSCParticleProducer.cc.

216 {}

◆ endJob()

void HSCParticleProducer::endJob ( void )

overrideprivatevirtual

Reimplemented from edm::EDFilter.

Definition at line 219 of file HSCParticleProducer.cc.

219 {}

◆ filter()

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

overrideprivatevirtual

Implements edm::EDFilter.

Definition at line 86 of file HSCParticleProducer.cc.

                                                                               {
   using namespace edm;
   using namespace reco;
   using namespace std;
   using namespace susybsm;
  
   // information from the muons
   edm::Handle<reco::MuonCollection> muonCollectionHandle;
   iEvent.getByToken(m_muonsToken, muonCollectionHandle);
  
   //information from the mean timer muons
   edm::Handle<reco::MuonCollection> MTmuonCollectionHandle;
   iEvent.getByToken(m_MTmuonsToken, MTmuonCollectionHandle);
  
   // information from the tracks
   edm::Handle<reco::TrackCollection> trackCollectionHandle;
   iEvent.getByToken(m_trackToken, trackCollectionHandle);
  
   // information from the tracks iso
   edm::Handle<reco::TrackCollection> trackIsoCollectionHandle;
   iEvent.getByToken(m_trackIsoToken, trackIsoCollectionHandle);
  
   // creates the output collection
   susybsm::HSCParticleCollection* hscp = new susybsm::HSCParticleCollection;
   std::unique_ptr<susybsm::HSCParticleCollection> result(hscp);
  
   susybsm::HSCPCaloInfoCollection* caloInfoColl = new susybsm::HSCPCaloInfoCollection;
   std::unique_ptr<susybsm::HSCPCaloInfoCollection> caloInfoCollaptr(caloInfoColl);
  
   // Fill the output collection with HSCP Candidate (the candiate only contains ref to muon AND/OR track object)
   *hscp = getHSCPSeedCollection(trackCollectionHandle, muonCollectionHandle, MTmuonCollectionHandle);
  
   // find the track ref for isolation purposed (main track is supposed to be the Iso track after refitting)
   for (susybsm::HSCParticleCollection::iterator hscpcandidate = hscp->begin(); hscpcandidate != hscp->end();
        ++hscpcandidate) {
     // Matching is needed because input track collection and muon inner track may lightly differs due to track refit
     reco::TrackRef track = hscpcandidate->trackRef();
     if (track.isNull())
       continue;
     float dRMin = 1000;
     int found = -1;
     for (unsigned int t = 0; t < trackIsoCollectionHandle->size(); t++) {
       reco::TrackRef Isotrack = reco::TrackRef(trackIsoCollectionHandle, t);
       if (fabs((1.0 / track->pt()) - (1.0 / Isotrack->pt())) > maxInvPtDiff)
         continue;
       float dR = deltaR(track->momentum(), Isotrack->momentum());
       if (dR <= minDR && dR < dRMin) {
         dRMin = dR;
         found = t;
       }
     }
     if (found >= 0)
       hscpcandidate->setTrackIso(reco::TrackRef(trackIsoCollectionHandle, found));
   }
  
   // compute the TRACKER contribution
   if (useBetaFromTk) {
     for (susybsm::HSCParticleCollection::iterator hscpcandidate = hscp->begin(); hscpcandidate != hscp->end();
          ++hscpcandidate) {
       beta_calculator_TK->addInfoToCandidate(*hscpcandidate, iEvent, iSetup);
     }
   }
  
   // compute the MUON contribution
   if (useBetaFromMuon) {
     for (susybsm::HSCParticleCollection::iterator hscpcandidate = hscp->begin(); hscpcandidate != hscp->end();
          ++hscpcandidate) {
       beta_calculator_MUON->addInfoToCandidate(*hscpcandidate, iEvent, iSetup);
     }
   }
  
   // compute the RPC contribution
   if (useBetaFromRpc) {
     for (susybsm::HSCParticleCollection::iterator hscpcandidate = hscp->begin(); hscpcandidate != hscp->end();
          ++hscpcandidate) {
       beta_calculator_RPC->addInfoToCandidate(*hscpcandidate, iEvent, iSetup);
     }
   }
  
   // compute the ECAL contribution
   if (useBetaFromEcal) {
     int Index = 0;
     caloInfoColl->resize(hscp->size());
     for (susybsm::HSCParticleCollection::iterator hscpcandidate = hscp->begin(); hscpcandidate != hscp->end();
          ++hscpcandidate, Index++) {
       beta_calculator_ECAL->addInfoToCandidate(
           *hscpcandidate, trackCollectionHandle, iEvent, iSetup, (*caloInfoColl)[Index]);
     }
   }
  
   // cleanup the collection based on the input selection
   for (int i = 0; i < (int)hscp->size(); i++) {
     susybsm::HSCParticleCollection::iterator hscpcandidate = hscp->begin() + i;
     bool decision = false;
     for (unsigned int s = 0; s < Selectors.size(); s++) {
       decision |= Selectors[s]->isSelected(*hscpcandidate);
     }
     if (!decision) {
       hscp->erase(hscpcandidate);
       if (useBetaFromEcal)
         caloInfoColl->erase(caloInfoColl->begin() + i);
       i--;
     }
   }
   bool filterResult = !Filter_ || (Filter_ && !hscp->empty());
  
   // output result
   if (useBetaFromEcal) {
     edm::OrphanHandle<susybsm::HSCPCaloInfoCollection> caloInfoHandle = iEvent.put(std::move(caloInfoCollaptr));
     // adding the reftoCaloInfoObject to the HSCP Object
     for (int i = 0; i < (int)hscp->size(); i++) {
       susybsm::HSCParticleCollection::iterator hscpcandidate = hscp->begin() + i;
       hscpcandidate->setCaloInfo(HSCPCaloInfoRef(caloInfoHandle, i));
     }
   }
  
   // output result
  
   edm::OrphanHandle<susybsm::HSCParticleCollection> putHandle = iEvent.put(std::move(result));
   //  if(useBetaFromEcal){
   //      edm::RefProd<susybsm::HSCParticleCollection> hscpCollectionHandle = iEvent.getRefBeforePut<susybsm::HSCParticleCollection>();
   //    filler.insert(putHandle, CaloInfoColl.begin(), CaloInfoColl.end());
   //    filler.fill();
   //    iEvent.put(std::move(CaloInfoMap));
   //  }
  
   return filterResult;
 }

References PbPb_ZMuSkimMuonDPG_cff::deltaR, HGC3DClusterGenMatchSelector_cfi::dR, HLT_FULL_cff::dRMin, newFWLiteAna::found, mps_fire::i, iEvent, createfilelist::int, PDWG_EXOHSCP_cff::maxInvPtDiff, PDWG_EXOHSCP_cff::minDR, eostools::move(), mps_fire::result, alignCSCRings::s, submitPVValidationJobs::t, HLT_FULL_cff::track, HSCParticleProducer_cff::useBetaFromEcal, HSCParticleProducer_cff::useBetaFromMuon, HSCParticleProducer_cff::useBetaFromRpc, and HSCParticleProducer_cff::useBetaFromTk.

◆ getHSCPSeedCollection()

std::vector< HSCParticle > HSCParticleProducer::getHSCPSeedCollection	(	edm::Handle< reco::TrackCollection > &	trackCollectionHandle,
		edm::Handle< reco::MuonCollection > &	muonCollectionHandle,
		edm::Handle< reco::MuonCollection > &	MTmuonCollectionHandle
	)

private

Definition at line 221 of file HSCParticleProducer.cc.

                                                            {
   std::vector<HSCParticle> HSCPCollection;
  
   // Store a local vector of track ref (that can be modified if matching)
   std::vector<reco::TrackRef> tracks;
   for (unsigned int i = 0; i < trackCollectionHandle->size(); i++) {
     TrackRef track = reco::TrackRef(trackCollectionHandle, i);
  
     //If track is from muon always keep it
     bool isMuon = false;
     for (unsigned int m = 0; m < muonCollectionHandle->size(); m++) {
       reco::MuonRef muon = reco::MuonRef(muonCollectionHandle, m);
       TrackRef innertrack = muon->innerTrack();
       if (innertrack.isNull())
         continue;
       if (fabs((1.0 / innertrack->pt()) - (1.0 / track->pt())) > maxInvPtDiff)
         continue;
       float dR = deltaR(innertrack->momentum(), track->momentum());
       if (dR <= minDR)
         isMuon = true;
     }
  
     if ((track->p() < minTkP || (track->chi2() / track->ndof()) > maxTkChi2 || track->found() < minTkHits) && !isMuon)
       continue;
     tracks.push_back(track);
   }
  
   // Loop on muons with inner track ref and create Muon HSCP Candidate
   for (unsigned int m = 0; m < muonCollectionHandle->size(); m++) {
     reco::MuonRef muon = reco::MuonRef(muonCollectionHandle, m);
     double SApt = -1;
     if (muon->isStandAloneMuon())
       SApt = muon->standAloneMuon()->pt();
     if (muon->p() < minMuP && SApt < minSAMuPt)
       continue;
     TrackRef innertrack = muon->innerTrack();
     if (innertrack.isNull())
       continue;
  
     // Check if the inner track match any track in order to create a Muon+Track HSCP Candidate
     // Matching is needed because input track collection and muon inner track may lightly differs due to track refit
     float dRMin = 1000;
     int found = -1;
     for (unsigned int t = 0; t < tracks.size(); t++) {
       reco::TrackRef track = tracks[t];
       if (fabs((1.0 / innertrack->pt()) - (1.0 / track->pt())) > maxInvPtDiff)
         continue;
       float dR = deltaR(innertrack->momentum(), track->momentum());
       if (dR <= minDR && dR < dRMin) {
         dRMin = dR;
         found = t;
       }
     }
  
     HSCParticle candidate;
     candidate.setMuon(muon);
     if (found >= 0) {
       //        printf("MUON with Inner Track Matching --> DR = %6.2f (%6.2f %+6.2f %+6.2f):(%6.2f %+6.2f %+6.2f) vs (%6.2f %+6.2f %+6.2f)\n",dRMin,muon->pt(), muon->eta(), muon->phi(), innertrack->pt(), innertrack->eta(), innertrack->phi(), tracks[found]->pt(), tracks[found]->eta(), tracks[found]->phi() );
       candidate.setTrack(tracks[found]);
       tracks.erase(tracks.begin() + found);
     }
     HSCPCollection.push_back(candidate);
   }
  
   // Loop on muons without inner tracks and create Muon HSCP Candidate
   for (unsigned int m = 0; m < muonCollectionHandle->size(); m++) {
     reco::MuonRef muon = reco::MuonRef(muonCollectionHandle, m);
     double SApt = -1;
     if (muon->isStandAloneMuon())
       SApt = muon->standAloneMuon()->pt();
     if (muon->p() < minMuP && SApt < minSAMuPt)
       continue;
     TrackRef innertrack = muon->innerTrack();
     if (innertrack.isNonnull())
       continue;
  
     // Check if the muon match any track in order to create a Muon+Track HSCP Candidate
     float dRMin = 1000;
     int found = -1;
     for (unsigned int t = 0; t < tracks.size(); t++) {
       reco::TrackRef track = tracks[t];
       if (fabs((1.0 / muon->pt()) - (1.0 / track->pt())) > maxInvPtDiff)
         continue;
       float dR = deltaR(muon->momentum(), track->momentum());
       if (dR <= minDR && dR < dRMin) {
         dRMin = dR;
         found = t;
       }
     }
  
     HSCParticle candidate;
     candidate.setMuon(muon);
     if (found >= 0) {
       //        printf("MUON without Inner Track Matching --> DR = %6.2f (%6.2f %+6.2f %+6.2f) vs (%6.2f %+6.2f %+6.2f)\n",dRMin,muon->pt(), muon->eta(), muon->phi(), tracks[found]->pt(), tracks[found]->eta(), tracks[found]->phi() );
       candidate.setTrack(tracks[found]);
       tracks.erase(tracks.begin() + found);
     }
     HSCPCollection.push_back(candidate);
   }
  
   //Loop on MT muons and add to collection
   for (unsigned int m = 0; m < MTmuonCollectionHandle->size(); m++) {
     reco::MuonRef MTmuon = reco::MuonRef(MTmuonCollectionHandle, m);
     if (MTmuon->pt() < minMTMuPt)
       continue;
  
     //Check if matches muon HSCP candidate and add reference
     float dRMin = 1000;
     int found = -1;
     for (unsigned int i = 0; i < HSCPCollection.size(); i++) {
       if (!HSCPCollection[i].hasMuonRef())
         continue;
       reco::MuonRef muon = HSCPCollection[i].muonRef();
       float dR = deltaR(muon->momentum(), MTmuon->momentum());
       if (dR <= minMTDR && dR < dRMin) {
         dRMin = dR;
         found = i;
       }
     }
     if (found > -1)
       HSCPCollection[found].setMTMuon(MTmuon);
     else {
       HSCParticle candidate;
       candidate.setMTMuon(MTmuon);
       HSCPCollection.push_back(candidate);
     }
   }
  
   // Loop on tracks not matching muon and create Track HSCP Candidate
   for (unsigned int i = 0; i < tracks.size(); i++) {
     HSCParticle candidate;
     candidate.setTrack(tracks[i]);
     HSCPCollection.push_back(candidate);
   }
  
   return HSCPCollection;
 }

References PbPb_ZMuSkimMuonDPG_cff::deltaR, HGC3DClusterGenMatchSelector_cfi::dR, HLT_FULL_cff::dRMin, newFWLiteAna::found, mps_fire::i, reco::isMuon(), edm::Ref< C, T, F >::isNonnull(), edm::Ref< C, T, F >::isNull(), visualization-live-secondInstance_cfg::m, PDWG_EXOHSCP_cff::maxInvPtDiff, HSCParticleProducer_cff::maxTkChi2, PDWG_EXOHSCP_cff::minDR, HSCParticleProducer_cff::minMTDR, HSCParticleProducer_cff::minMTMuPt, HSCParticleProducer_cff::minMuP, HSCParticleProducer_cff::minSAMuPt, HSCParticleProducer_cff::minTkHits, HSCParticleProducer_cff::minTkP, susybsm::HSCParticle::setMTMuon(), susybsm::HSCParticle::setMuon(), susybsm::HSCParticle::setTrack(), submitPVValidationJobs::t, HLT_FULL_cff::track, and PDWG_EXOHSCP_cff::tracks.

Member Data Documentation

◆ beta_calculator_ECAL

BetaCalculatorECAL* HSCParticleProducer::beta_calculator_ECAL

private

Definition at line 92 of file HSCParticleProducer.h.

◆ beta_calculator_MUON

BetaCalculatorMUON* HSCParticleProducer::beta_calculator_MUON

private

Definition at line 90 of file HSCParticleProducer.h.

◆ beta_calculator_RPC

BetaCalculatorRPC* HSCParticleProducer::beta_calculator_RPC

private

Definition at line 91 of file HSCParticleProducer.h.

◆ beta_calculator_TK

BetaCalculatorTK* HSCParticleProducer::beta_calculator_TK

private

Definition at line 89 of file HSCParticleProducer.h.

◆ Filter_

bool HSCParticleProducer::Filter_

private

Definition at line 67 of file HSCParticleProducer.h.

◆ m_MTmuonsToken

edm::EDGetTokenT<reco::MuonCollection> HSCParticleProducer::m_MTmuonsToken

private

Definition at line 72 of file HSCParticleProducer.h.

◆ m_muonsToken

edm::EDGetTokenT<reco::MuonCollection> HSCParticleProducer::m_muonsToken

private

Definition at line 71 of file HSCParticleProducer.h.

◆ m_trackIsoToken

edm::EDGetTokenT<reco::TrackCollection> HSCParticleProducer::m_trackIsoToken

private

Definition at line 70 of file HSCParticleProducer.h.

◆ m_trackToken

edm::EDGetTokenT<reco::TrackCollection> HSCParticleProducer::m_trackToken

private

Definition at line 69 of file HSCParticleProducer.h.

◆ maxInvPtDiff

float HSCParticleProducer::maxInvPtDiff

private

Definition at line 87 of file HSCParticleProducer.h.

◆ maxTkChi2

float HSCParticleProducer::maxTkChi2

private

Definition at line 80 of file HSCParticleProducer.h.

◆ minDR

float HSCParticleProducer::minDR

private

Definition at line 85 of file HSCParticleProducer.h.

◆ minMTDR

float HSCParticleProducer::minMTDR

private

Definition at line 86 of file HSCParticleProducer.h.

◆ minMTMuPt

float HSCParticleProducer::minMTMuPt

private

Definition at line 84 of file HSCParticleProducer.h.

◆ minMuP

float HSCParticleProducer::minMuP

private

Definition at line 82 of file HSCParticleProducer.h.

◆ minSAMuPt

float HSCParticleProducer::minSAMuPt

private

Definition at line 83 of file HSCParticleProducer.h.

◆ minTkHits

unsigned int HSCParticleProducer::minTkHits

private

Definition at line 81 of file HSCParticleProducer.h.

◆ minTkP

float HSCParticleProducer::minTkP

private

Definition at line 79 of file HSCParticleProducer.h.

◆ Selectors

std::vector<CandidateSelector*> HSCParticleProducer::Selectors

private

Definition at line 94 of file HSCParticleProducer.h.

◆ useBetaFromEcal

bool HSCParticleProducer::useBetaFromEcal

private

Definition at line 77 of file HSCParticleProducer.h.

◆ useBetaFromMuon

bool HSCParticleProducer::useBetaFromMuon

private

Definition at line 75 of file HSCParticleProducer.h.

◆ useBetaFromRpc

bool HSCParticleProducer::useBetaFromRpc

private

Definition at line 76 of file HSCParticleProducer.h.

◆ useBetaFromTk

bool HSCParticleProducer::useBetaFromTk

private

Definition at line 74 of file HSCParticleProducer.h.

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ HSCParticleProducer()

◆ ~HSCParticleProducer()

Member Function Documentation

◆ beginJob()

◆ endJob()

◆ filter()

◆ getHSCPSeedCollection()

Member Data Documentation

◆ beta_calculator_ECAL

◆ beta_calculator_MUON

◆ beta_calculator_RPC

◆ beta_calculator_TK

◆ Filter_

◆ m_MTmuonsToken

◆ m_muonsToken

◆ m_trackIsoToken

◆ m_trackToken

◆ maxInvPtDiff

◆ maxTkChi2

◆ minDR

◆ minMTDR

◆ minMTMuPt

◆ minMuP

◆ minSAMuPt

◆ minTkHits

◆ minTkP

◆ Selectors

◆ useBetaFromEcal

◆ useBetaFromMuon

◆ useBetaFromRpc

◆ useBetaFromTk