Inheritance diagram for MuScleFitFilter:

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

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

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)

	~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 const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ESProxyIndex const *	esGetTokenIndices (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 const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

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

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

Private Attributes
bool	debug

int	eventsRead

int	eventsWritten

int	maxWrite

unsigned int	minimumMuonsNumber

std::vector< double >	Mmax

std::vector< double >	Mmin

edm::EDGetTokenT< reco::MuonCollection >	theGlbMuonsToken

edm::InputTag	theMuonLabel

int	theMuonType

edm::EDGetTokenT< reco::TrackCollection >	theSaMuonsToken

edm::EDGetTokenT< reco::TrackCollection >	theTracksToken

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

static bool	wantsStreamRuns ()

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

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

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

Definition at line 36 of file MuScleFitFilter.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 71 of file MuScleFitFilter.cc.

References gather_cfg::cout, debug, eventsRead, eventsWritten, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), maxWrite, minimumMuonsNumber, Mmax, Mmin, theGlbMuonsToken, theMuonLabel, theMuonType, theSaMuonsToken, and theTracksToken.

 {
   debug = iConfig.getUntrackedParameter<bool>("debug",false);
 
   if (debug)
     std::cout << "Constructor" << std::endl;
 
   // Parameters
   // ----------
   //ParameterSet serviceParameters = iConfig.getParameter<ParameterSet>("ServiceParameters");
   //theService = new MuonServiceProxy(serviceParameters);
   theMuonLabel = iConfig.getParameter<edm::InputTag>("MuonLabel");
   theGlbMuonsToken = mayConsume<reco::MuonCollection>(theMuonLabel);
   theSaMuonsToken = mayConsume<reco::TrackCollection>(theMuonLabel);
   theTracksToken = mayConsume<reco::TrackCollection>(theMuonLabel);
   theMuonType = iConfig.getParameter<int>("muonType");
 
   Mmin = iConfig.getUntrackedParameter<std::vector<double> >("Mmin");
   Mmax = iConfig.getUntrackedParameter<std::vector<double> >("Mmax");
   maxWrite = iConfig.getUntrackedParameter<int>("maxWrite",100000);
 
   minimumMuonsNumber = iConfig.getUntrackedParameter<unsigned int>("minimumMuonsNumber", 2);
 
   // The must have the same size and they must not be empty, otherwise abort.
   if ( !(Mmin.size() == Mmax.size() && !Mmin.empty()) ) abort();
 
   // Count the total number of analyzed and written events
   // -----------------------------------------------------
   eventsRead = 0;
   eventsWritten = 0;
 
 }

MuScleFitFilter::~MuScleFitFilter ( )

override

Definition at line 107 of file MuScleFitFilter.cc.

References gather_cfg::cout, eventsRead, and eventsWritten.

                                   {
   std::cout << "Total number of events read    = " << eventsRead << std::endl;
   std::cout << "Total number of events written = " << eventsWritten << std::endl;
 }

Member Function Documentation

void MuScleFitFilter::endJob ( void )

inlineoverrideprivatevirtual

Reimplemented from edm::EDFilter.

Definition at line 43 of file MuScleFitFilter.cc.

43 {};

bool MuScleFitFilter::filter	(	edm::Event &	event,
		const edm::EventSetup &	iSetup
	)

overrideprivate

Definition at line 117 of file MuScleFitFilter.cc.

References gather_cfg::cout, debug, DEFINE_FWK_MODULE, eventsRead, eventsWritten, maxWrite, minimumMuonsNumber, Mmax, Mmin, Mmu2, metsig::muon, extraflags_cff::muons, p4, reco::LeafCandidate::setCharge(), reco::LeafCandidate::setP4(), mathSSE::sqrt(), theGlbMuonsToken, theMuonType, theSaMuonsToken, theTracksToken, HiIsolationCommonParameters_cff::track, l1t::tracks, TriggerAnalyzer::write(), and DOFs::Z.

                                                                          {
 
   // Cut the crap if we have stored enough stuff
   // -------------------------------------------
   if ( maxWrite != -1 && eventsWritten>=maxWrite ) return false;
 
   // Get the RecTrack and the RecMuon collection from the event
   // ----------------------------------------------------------
   std::unique_ptr<reco::MuonCollection> muons(new reco::MuonCollection());
 
   if (debug) std::cout << "Looking for muons of the right kind" << std::endl;
 
   if (theMuonType==1) { // GlobalMuons
 
     // Global muons:
     // -------------
     edm::Handle<reco::MuonCollection> glbMuons;
     if (debug) std::cout << "Handle defined" << std::endl;
     event.getByToken(theGlbMuonsToken, glbMuons);
     if (debug)
       std::cout << "Global muons: " << glbMuons->size() << std::endl;
 
     // Store the muon
     // --------------
     reco::MuonCollection::const_iterator glbMuon;
     for (glbMuon=glbMuons->begin(); glbMuon!=glbMuons->end(); ++glbMuon) {
       muons->push_back(*glbMuon);
       if (debug) {
     std::cout << "  Reconstructed muon: pT = " << glbMuon->p4().Pt()
          << "  Eta = " << glbMuon->p4().Eta() << std::endl;
       }
     }
   } else if (theMuonType==2) { // StandaloneMuons
 
     // Standalone muons:
     // -----------------
     edm::Handle<reco::TrackCollection> saMuons;
     event.getByToken(theSaMuonsToken, saMuons);
     if (debug)
       std::cout << "Standalone muons: " << saMuons->size() << std::endl;
 
     // Store the muon
     // --------------
     reco::TrackCollection::const_iterator saMuon;
     for (saMuon=saMuons->begin(); saMuon!=saMuons->end(); ++saMuon) {
       reco::Muon muon;
       double energy = sqrt(saMuon->p()*saMuon->p()+Mmu2);
       math::XYZTLorentzVector p4(saMuon->px(), saMuon->py(), saMuon->pz(), energy);
       muon.setP4(p4);
       muon.setCharge(saMuon->charge());
       muons->push_back(muon);
     }
   } else if (theMuonType==3) { // Tracker tracks
 
     // Tracks:
     // -------
     edm::Handle<reco::TrackCollection> tracks;
     event.getByToken(theTracksToken, tracks);
     if (debug)
       std::cout << "Tracker tracks: " << tracks->size() << std::endl;
 
     // Store the muon
     // -------------
     reco::TrackCollection::const_iterator track;
     for (track=tracks->begin(); track!=tracks->end(); ++track) {
       reco::Muon muon;
       double energy = sqrt(track->p()*track->p()+Mmu2);
       math::XYZTLorentzVector p4(track->px(), track->py(), track->pz(), energy);
       muon.setP4(p4);
       muon.setCharge(track->charge());
       muons->push_back(muon);
     }
   } else {
     std::cout << "Wrong muon type! Aborting." << std::endl;
     abort();
   }
 
   // Loop on RecMuon and reconstruct the resonance
   // ---------------------------------------------
   reco::MuonCollection::const_iterator muon1;
   reco::MuonCollection::const_iterator muon2;
 
   bool resfound = false;
 
   // Require at least N muons of the selected type.
   if( muons->size() >= minimumMuonsNumber ) {
 
     for (muon1=muons->begin(); muon1!=muons->end(); ++muon1) {
 
       if (debug) {
         std::cout << "  Reconstructed muon: pT = " << muon1->p4().Pt()
              << "  Eta = " << muon1->p4().Eta() << std::endl;
       }
 
       // Recombine all the possible Z from reconstructed muons
       // -----------------------------------------------------
       if (muons->size()>1) {
         for (muon2 = muon1+1; muon2!=muons->end(); ++muon2) {
           if ( ((*muon1).charge()*(*muon2).charge())<0 ) { // This also gets rid of muon1==muon2
             //    reco::Particle::LorentzVector Z (muonCorr1 + muonCorr2);
             reco::Particle::LorentzVector Z (muon1->p4()+muon2->p4());
             // Loop on all the cuts on invariant mass.
             // If it passes at least one of the cuts, the event will be accepted.
             // ------------------------------------------------------------------
             std::vector<double>::const_iterator mMinCut = Mmin.begin();
             std::vector<double>::const_iterator mMaxCut = Mmax.begin();
             for( ; mMinCut != Mmin.end(); ++mMinCut, ++mMaxCut ) {
               // When the two borders are -1 do not cut.
               if( *mMinCut == *mMaxCut && *mMaxCut == -1) {
                 resfound = true;
                 if (debug) {
                   std::cout << "Acceptiong event because mMinCut = " << *mMinCut << " = mMaxCut = " << *mMaxCut << std::endl;
                 }
               }
               else if (Z.mass()>*mMinCut && Z.mass()<*mMaxCut) {
                 resfound = true;
                 if (debug) {
                   std::cout << "One particle found with mass = " << Z.mass() << std::endl;
                 }
               }
             }
           }
         }
       } else if (debug) {
         std::cout << "Not enough reconstructed muons to make a resonance" << std::endl;
       }
     }
   }
   else if (debug) {
     std::cout << "Skipping event because muons = " << muons->size() << " < " << "minimumMuonsNumber("<<minimumMuonsNumber<<")" << std::endl;
   }
 
   // Store the event if it has a dimuon pair with mass within defined boundaries
   // ---------------------------------------------------------------------------
   bool write = false;
   eventsRead++;
   if ( resfound ) {
     write = true;
     eventsWritten++;
   }
   return write;
 
 }