#include <QuarkoniaTrackSelector.h>

Inheritance diagram for QuarkoniaTrackSelector:

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

	~QuarkoniaTrackSelector ()

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

Public Member Functions inherited from edm::global::EDProducerBase
	EDProducerBase ()

ModuleDescription const &	moduleDescription () const

virtual	~EDProducerBase ()

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

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

virtual	~ProducerBase ()

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

	EDConsumerBase ()

ProductHolderIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesDependentUpon (const std::string &iProcessName, std::vector< const char * > &oModuleLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

Private Member Functions
virtual void	produce (edm::StreamID, edm::Event &, const edm::EventSetup &) const override

Private Attributes
bool	checkCharge_
	check opposite charge? More...

std::vector< double >	maxMasses_
	upper mass limits More...

double	maxTrackEta_
	track \|eta\| cut More...

std::vector< double >	minMasses_
	lower mass limits More...

double	minTrackP_
	track p cut More...

double	minTrackPt_
	track pt cut More...

edm::InputTag	muonTag_
	tag for RecoChargedCandidateCollection More...

edm::EDGetTokenT < reco::RecoChargedCandidateCollection >	muonToken_

edm::InputTag	trackTag_
	tag for TrackCollection More...

edm::EDGetTokenT < reco::TrackCollection >	trackToken_

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

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

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Protected Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

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

Creates a filtered TrackCollection based on the mass of a combination of a track and a RecoChargedCandidate (typically a muon)

Definition at line 18 of file QuarkoniaTrackSelector.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 19 of file QuarkoniaTrackSelector.cc.

References checkCharge_, i, LogDebug, maxMasses_, maxTrackEta_, minMasses_, minTrackP_, minTrackPt_, muonTag_, muonToken_, edmStreamStallGrapher::stream, trackTag_, and trackToken_.

                                                                              :
   muonTag_(iConfig.getParameter<edm::InputTag>("muonCandidates")),
   trackTag_(iConfig.getParameter<edm::InputTag>("tracks")),
   minMasses_(iConfig.getParameter< std::vector<double> >("MinMasses")),
   maxMasses_(iConfig.getParameter< std::vector<double> >("MaxMasses")),
   checkCharge_(iConfig.getParameter<bool>("checkCharge")),
   minTrackPt_(iConfig.getParameter<double>("MinTrackPt")),
   minTrackP_(iConfig.getParameter<double>("MinTrackP")),
   maxTrackEta_(iConfig.getParameter<double>("MaxTrackEta"))
 {
 
 
   muonToken_ = consumes<reco::RecoChargedCandidateCollection>(muonTag_);
   trackToken_ = consumes<reco::TrackCollection>(trackTag_);
 
 
   //register your products
   produces<reco::TrackCollection>();
   //
   // verify mass windows
   //
   bool massesValid = minMasses_.size()==maxMasses_.size();
   if ( massesValid ) {
     for ( size_t i=0; i<minMasses_.size(); ++i ) {
       if ( minMasses_[i]<0 || maxMasses_[i]<0 || 
        minMasses_[i]>maxMasses_[i] )  massesValid = false;
     }
   }
   if ( !massesValid ) {
     edm::LogError("QuarkoniaTrackSelector") << "Inconsistency in definition of mass windows, "
                         << "no track will be selected";
     minMasses_.clear();
     maxMasses_.clear();
   }
 
   std::ostringstream stream;
   stream << "instantiated with parameters\n"
      << "  muonTag  = " << muonTag_ << "\n"
      << "  trackTag = " << trackTag_ << "\n";
   stream << "  mass windows =";
   for ( size_t i=0; i<minMasses_.size(); ++i )  
     stream << " (" << minMasses_[i] << "," << maxMasses_[i] << ")";
   stream << "\n";
   stream << "  checkCharge  = " << checkCharge_ << "\n";
   stream << "  MinTrackPt = " << minTrackPt_ << "\n";
   stream << "  MinTrackP = " << minTrackP_ << "\n";
   stream << "  MaxTrackEta = " << maxTrackEta_;
   LogDebug("QuarkoniaTrackSelector") << stream.str();
 }

QuarkoniaTrackSelector::~QuarkoniaTrackSelector ( )

inline

Definition at line 21 of file QuarkoniaTrackSelector.h.

21 {}

Member Function Documentation

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

overrideprivatevirtual

Implements edm::global::EDProducerBase.

Definition at line 71 of file QuarkoniaTrackSelector.cc.

References reco::LeafCandidate::charge(), reco::TrackBase::charge(), checkCharge_, reco::LeafCandidate::eta(), reco::TrackBase::eta(), spr::find(), edm::Event::getByToken(), i, edm::isDebugEnabled(), edm::HandleBase::isValid(), j, LogDebug, maxMasses_, maxTrackEta_, minMasses_, minTrackP_, minTrackPt_, digitizers_cfi::muon, muonToken_, reco::LeafCandidate::p(), reco::TrackBase::p(), reco::LeafCandidate::p4(), reco::LeafCandidate::pt(), reco::TrackBase::pt(), edm::Event::put(), reco::TrackBase::px(), reco::TrackBase::py(), reco::TrackBase::pz(), mathSSE::sqrt(), edmStreamStallGrapher::stream, and trackToken_.

 {
   //
   // the product
   //
   std::auto_ptr<reco::TrackCollection> product(new reco::TrackCollection);
   //
   // Muons
   //
   edm::Handle<reco::RecoChargedCandidateCollection> muonHandle;
   iEvent.getByToken(muonToken_,muonHandle);
   //
   // Tracks
   //
   edm::Handle<reco::TrackCollection> trackHandle;
   iEvent.getByToken(trackToken_,trackHandle);
   //
   // Verification
   //
   if ( !muonHandle.isValid() || !trackHandle.isValid() || minMasses_.empty() ) {
     iEvent.put(product);
     return;
   }
   //
   // Debug output
   //
   if ( edm::isDebugEnabled() ) {
     std::ostringstream stream;
     stream << "\nInput muons: # / q / pt / p / eta\n";
     for ( size_t im=0; im<muonHandle->size(); ++im ) {
       const reco::RecoChargedCandidate& muon = (*muonHandle)[im];
       stream << "   " << im << " "
          << muon.charge() << " " << muon.pt() << " "
          << muon.p() << " " << muon.eta() << "\n";
     }
     stream << "Input tracks: # / q / pt / p / eta\n";
     for ( size_t it=0; it<trackHandle->size(); ++it ) {
       const reco::Track& track = (*trackHandle)[it];
       stream << "   " << it << " "
          << track.charge() << " " << track.pt() << " "
          << track.p() << " " << track.eta() << "\n";
     }
     LogDebug("QuarkoniaTrackSelector") << stream.str();
   }
   //
   // combinations
   //
 //   std::ostringstream stream;
   unsigned int nQ(0);
   unsigned int nComb(0);
   std::vector<size_t> selectedTrackIndices;
   selectedTrackIndices.reserve(muonHandle->size());
   reco::Particle::LorentzVector p4Muon;
   reco::Particle::LorentzVector p4JPsi;
   // muons
   for ( size_t im=0; im<muonHandle->size(); ++im ) {
     const reco::RecoChargedCandidate& muon = (*muonHandle)[im];
     int qMuon = muon.charge();
     p4Muon = muon.p4();
     // tracks
     for ( size_t it=0; it<trackHandle->size(); ++it ) {
       const reco::Track& track = (*trackHandle)[it];
       if ( track.pt()<minTrackPt_ || track.p()<minTrackP_ ||
        fabs(track.eta())>maxTrackEta_ )  continue;
       if ( checkCharge_ && track.charge()!=-qMuon )  continue;
       ++nQ;
       reco::Particle::LorentzVector p4Track(track.px(),track.py(),track.pz(),
                         sqrt(track.p()*track.p()+0.0111636));
       // mass windows
       double mass = (p4Muon+p4Track).mass();
 //       stream << "Combined mass = " << im << " " << it 
 //       << " " << mass 
 //       << " phi " << track.phi() << "\n";
       for ( size_t j=0; j<minMasses_.size(); ++j ) {
     if ( mass>minMasses_[j] && mass<maxMasses_[j] ) {
       ++nComb;
       if ( find(selectedTrackIndices.begin(),selectedTrackIndices.end(),it)==
            selectedTrackIndices.end() )  selectedTrackIndices.push_back(it);
 //    stream << "... adding " << "\n"; 
       break;
     }
       }
     }
   }
 //   LogDebug("QuarkoniaTrackSelector") << stream.str();
   //
   // filling of output collection
   //
   for ( size_t i=0; i<selectedTrackIndices.size(); ++i ) 
     product->push_back((*trackHandle)[selectedTrackIndices[i]]);
   //
   // debug output
   //
   if ( edm::isDebugEnabled() ) {
     std::ostringstream stream;
     stream << "Total number of combinations = " << muonHandle->size()*trackHandle->size()
        << " , after charge " << nQ << " , after mass " << nComb << std::endl;
     stream << "Selected " << product->size() << " tracks with # / q / pt / eta\n";
     for ( size_t i=0; i<product->size(); ++i ) {
       const reco::Track& track = (*product)[i];
       stream << "  " << i << " " << track.charge() << " "
          << track.pt() << " " << track.eta() << "\n";
     }
     LogDebug("QuarkoniaTrackSelector") << stream.str();
   }
   //
   iEvent.put(product);
 }