HSCParticleProducer Class Reference

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

Inheritance diagram for HSCParticleProducer:

Public Member Functions
	HSCParticleProducer (const edm::ParameterSet &)
	~HSCParticleProducer ()
Public Member Functions inherited from edm::EDFilter
	EDFilter ()
ModuleDescription const &	moduleDescription () const
virtual	~EDFilter ()
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
void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...
	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)

Private Member Functions
virtual void	beginJob ()
virtual void	endJob ()
virtual bool	filter (edm::Event &, const edm::EventSetup &)
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
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 &)
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

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

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

Definition at line 54 of file HSCParticleProducer.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 25 of file HSCParticleProducer.cc.

References edm::ParameterSet::getParameter(), mps_fire::i, HSCParticleProducer_cff::maxInvPtDiff, HSCParticleProducer_cff::maxTkChi2, heepIdVarValueMapProducer_cfi::minDR, HSCParticleProducer_cff::minMTDR, HSCParticleProducer_cff::minMTMuPt, HSCParticleProducer_cff::minMuP, HSCParticleProducer_cff::minSAMuPt, HSCParticleProducer_cff::minTkHits, HSCParticleProducer_cff::minTkP, HSCParticleProducer_cff::SelectionParameters, HSCParticleProducer_cff::useBetaFromEcal, HSCParticleProducer_cff::useBetaFromMuon, HSCParticleProducer_cff::useBetaFromRpc, and HSCParticleProducer_cff::useBetaFromTk.

                                                                       {
  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

(

)

Definition at line 71 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

void HSCParticleProducer::beginJob ( void  )

privatevirtual

Reimplemented from edm::EDFilter.

Definition at line 201 of file HSCParticleProducer.cc.

                              {
}

void HSCParticleProducer::endJob ( void  )

privatevirtual

Reimplemented from edm::EDFilter.

Definition at line 206 of file HSCParticleProducer.cc.

                            {
}

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

privatevirtual

Definition at line 82 of file HSCParticleProducer.cc.

References deltaR(), PFRecoTauDiscriminationAgainstElectronDeadECAL_cfi::dR, allElectronIsolations_cfi::dRMin, runEdmFileComparison::found, edm::Event::getByToken(), mps_fire::i, createfilelist::int, edm::Ref< C, T, F >::isNull(), HSCParticleProducer_cff::maxInvPtDiff, heepIdVarValueMapProducer_cfi::minDR, eostools::move(), edm::Event::put(), mps_fire::result, alignCSCRings::s, lumiQTWidget::t, HiIsolationCommonParameters_cff::track, HSCParticleProducer_cff::useBetaFromEcal, HSCParticleProducer_cff::useBetaFromMuon, HSCParticleProducer_cff::useBetaFromRpc, and HSCParticleProducer_cff::useBetaFromTk.

                                                                         {

  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->size()>=1);




  // 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;
}

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

private

Definition at line 209 of file HSCParticleProducer.cc.

References DEFINE_FWK_MODULE, deltaR(), PFRecoTauDiscriminationAgainstElectronDeadECAL_cfi::dR, allElectronIsolations_cfi::dRMin, runEdmFileComparison::found, mps_fire::i, reco::isMuon(), edm::Ref< C, T, F >::isNonnull(), edm::Ref< C, T, F >::isNull(), funct::m, HSCParticleProducer_cff::maxInvPtDiff, HSCParticleProducer_cff::maxTkChi2, heepIdVarValueMapProducer_cfi::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(), lumiQTWidget::t, HiIsolationCommonParameters_cff::track, and l1t::tracks.

{
   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;
}

Member Data Documentation

BetaCalculatorECAL* HSCParticleProducer::beta_calculator_ECAL

private

Definition at line 92 of file HSCParticleProducer.h.

BetaCalculatorMUON* HSCParticleProducer::beta_calculator_MUON

private

Definition at line 90 of file HSCParticleProducer.h.

BetaCalculatorRPC* HSCParticleProducer::beta_calculator_RPC

private

Definition at line 91 of file HSCParticleProducer.h.

BetaCalculatorTK* HSCParticleProducer::beta_calculator_TK

private

Definition at line 89 of file HSCParticleProducer.h.

bool HSCParticleProducer::Filter_

private

Definition at line 67 of file HSCParticleProducer.h.

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

private

Definition at line 72 of file HSCParticleProducer.h.

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

private

Definition at line 71 of file HSCParticleProducer.h.

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

private

Definition at line 70 of file HSCParticleProducer.h.

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

private

Definition at line 69 of file HSCParticleProducer.h.

float HSCParticleProducer::maxInvPtDiff

private

Definition at line 87 of file HSCParticleProducer.h.

float HSCParticleProducer::maxTkChi2

private

Definition at line 80 of file HSCParticleProducer.h.

float HSCParticleProducer::minDR

private

Definition at line 85 of file HSCParticleProducer.h.

float HSCParticleProducer::minMTDR

private

Definition at line 86 of file HSCParticleProducer.h.

float HSCParticleProducer::minMTMuPt

private

Definition at line 84 of file HSCParticleProducer.h.

float HSCParticleProducer::minMuP

private

Definition at line 82 of file HSCParticleProducer.h.

float HSCParticleProducer::minSAMuPt

private

Definition at line 83 of file HSCParticleProducer.h.

unsigned int HSCParticleProducer::minTkHits

private

Definition at line 81 of file HSCParticleProducer.h.

float HSCParticleProducer::minTkP

private

Definition at line 79 of file HSCParticleProducer.h.

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

private

Definition at line 94 of file HSCParticleProducer.h.

bool HSCParticleProducer::useBetaFromEcal

private

Definition at line 77 of file HSCParticleProducer.h.

bool HSCParticleProducer::useBetaFromMuon

private

Definition at line 75 of file HSCParticleProducer.h.

bool HSCParticleProducer::useBetaFromRpc

private

Definition at line 76 of file HSCParticleProducer.h.

bool HSCParticleProducer::useBetaFromTk

private

Definition at line 74 of file HSCParticleProducer.h.