#include <HLTDisplacedmumumuVtxProducer.h>

Inheritance diagram for HLTDisplacedmumumuVtxProducer:

Public Member Functions
virtual void	beginJob ()

virtual void	endJob ()

	HLTDisplacedmumumuVtxProducer (const edm::ParameterSet &)

virtual void	produce (edm::Event &, const edm::EventSetup &)

	~HLTDisplacedmumumuVtxProducer ()

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

ModuleDescription const &	moduleDescription () const

virtual	~EDProducer ()

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 edm::EDProducer
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Private Member Functions
bool	checkPreviousCand (const reco::TrackRef &trackref, std::vector< reco::RecoChargedCandidateRef > &ref2)

Private Attributes
int	chargeOpt_

double	maxEta_

double	maxInvMass_

double	minInvMass_

double	minPt_

double	minPtTriplet_

edm::InputTag	previousCandTag_

edm::EDGetTokenT< trigger::TriggerFilterObjectWithRefs >	previousCandToken_

edm::InputTag	srcTag_

edm::EDGetTokenT< reco::RecoChargedCandidateCollection >	srcToken_

Additional Inherited Members
Public Types inherited from edm::EDProducer
typedef EDProducer	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

Definition at line 30 of file HLTDisplacedmumumuVtxProducer.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 36 of file HLTDisplacedmumumuVtxProducer.cc.

References ~HLTDisplacedmumumuVtxProducer().

                                                                                           : 
   srcTag_ (iConfig.getParameter<edm::InputTag>("Src")),
   srcToken_(consumes<reco::RecoChargedCandidateCollection>(srcTag_)),
   previousCandTag_(iConfig.getParameter<edm::InputTag>("PreviousCandTag")),
   previousCandToken_(consumes<trigger::TriggerFilterObjectWithRefs>(previousCandTag_)),
   maxEta_ (iConfig.getParameter<double>("MaxEta")),
   minPt_ (iConfig.getParameter<double>("MinPt")),
   minPtTriplet_ (iConfig.getParameter<double>("MinPtTriplet")),
   minInvMass_ (iConfig.getParameter<double>("MinInvMass")),
   maxInvMass_ (iConfig.getParameter<double>("MaxInvMass")),
   chargeOpt_ (iConfig.getParameter<int>("ChargeOpt"))
 {
   produces<VertexCollection>();
 }

HLTDisplacedmumumuVtxProducer::~HLTDisplacedmumumuVtxProducer ( )

default

Referenced by HLTDisplacedmumumuVtxProducer().

Member Function Documentation

void HLTDisplacedmumumuVtxProducer::beginJob ( void )

virtual

Reimplemented from edm::EDProducer.

Definition at line 70 of file HLTDisplacedmumumuVtxProducer.cc.

 {
   
 }

bool HLTDisplacedmumumuVtxProducer::checkPreviousCand	(	const reco::TrackRef &	trackref,
		std::vector< reco::RecoChargedCandidateRef > &	ref2
	)

private

Definition at line 202 of file HLTDisplacedmumumuVtxProducer.cc.

References mps_fire::i, and convertSQLiteXML::ok.

Referenced by produce().

                                                                                                                         {
   bool ok=false;
   for (auto & i : refVect) {
     if ( i->get<TrackRef>() == trackref ) {
       ok=true;
       break;
     }
   }
   return ok;
 }

void HLTDisplacedmumumuVtxProducer::endJob ( void )

virtual

Reimplemented from edm::EDProducer.

Definition at line 76 of file HLTDisplacedmumumuVtxProducer.cc.

 {
   
 }

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

static

Definition at line 55 of file HLTDisplacedmumumuVtxProducer.cc.

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

                                                                                           {
   edm::ParameterSetDescription desc;
   desc.add<edm::InputTag>("Src",edm::InputTag("hltL3MuonCandidates"));
   desc.add<edm::InputTag>("PreviousCandTag",edm::InputTag(""));
   desc.add<double>("MaxEta",2.5);
   desc.add<double>("MinPt",0.0);
   desc.add<double>("MinPtTriplet",0.0);
   desc.add<double>("MinInvMass",1.0);
   desc.add<double>("MaxInvMass",20.0);
   desc.add<int>("ChargeOpt",-1);
   descriptions.add("hltDisplacedmumumuVtxProducer", desc);
 }

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

virtual

Definition at line 82 of file HLTDisplacedmumumuVtxProducer.cc.

References funct::abs(), chargeOpt_, checkPreviousCand(), reco::e1, reco::e2, edm::EventSetup::get(), edm::Ref< C, T, F >::get(), edm::Event::getByToken(), trigger::TriggerRefsCollections::getObjects(), TransientVertex::isValid(), LogDebug, maxEta_, maxInvMass_, minInvMass_, minPt_, minPtTriplet_, eostools::move(), AlCaHLTBitMon_ParallelJobs::p, p1, p2, p3, previousCandToken_, edm::Event::put(), mathSSE::sqrt(), srcToken_, trigger::TriggerMuon, KalmanVertexFitter::vertex(), and particleFlowSuperClusterECAL_cfi::vertexCollection.

 {
   double const MuMass = 0.106;
   double const MuMass2 = MuMass*MuMass;
   
   
   // get hold of muon trks
   Handle<RecoChargedCandidateCollection> mucands;
   iEvent.getByToken(srcToken_,mucands);
   
   //get the transient track builder:
   edm::ESHandle<TransientTrackBuilder> theB;
   iSetup.get<TransientTrackRecord>().get("TransientTrackBuilder",theB);
   
   std::unique_ptr<VertexCollection> vertexCollection(new VertexCollection());
   
   // look at all mucands,  check cuts and make vertices
   double e1,e2,e3;
   Particle::LorentzVector p,p1,p2,p3;
   
   RecoChargedCandidateCollection::const_iterator cand1;
   RecoChargedCandidateCollection::const_iterator cand2;
   RecoChargedCandidateCollection::const_iterator cand3;
   
   // get the objects passing the previous filter
   Handle<TriggerFilterObjectWithRefs> previousCands;
   iEvent.getByToken(previousCandToken_,previousCands);
   
   vector<RecoChargedCandidateRef> vPrevCands;
   previousCands->getObjects(TriggerMuon,vPrevCands);
   
   for (cand1=mucands->begin(); cand1!=mucands->end(); cand1++) {
     TrackRef tk1 = cand1->get<TrackRef>();
     LogDebug("HLTDisplacedMumumuFilter") << " 1st muon in loop: q*pt= " << cand1->charge()*cand1->pt() << ", eta= " << cand1->eta() << ", hits= " << tk1->numberOfValidHits();
     
     //first check if this muon passed the previous filter
     if( ! checkPreviousCand( tk1, vPrevCands) ) continue;
     
     // cuts
     if (fabs(cand1->eta())>maxEta_) continue;
     if (cand1->pt() < minPt_) continue;
     
     cand2 = cand1; cand2++;
     for (; cand2!=mucands->end(); cand2++) {
       TrackRef tk2 = cand2->get<TrackRef>();
       
       // eta cut
       LogDebug("HLTMuonDimuonFilter") << " 2nd muon in loop: q*pt= " << cand2->charge()*cand2->pt() << ", eta= " << cand2->eta() << ", hits= " << tk2->numberOfValidHits() << ", d0= " << tk2->d0();
       //first check if this muon passed the previous filter
       if( ! checkPreviousCand( tk2, vPrevCands) ) continue;
       
       // cuts
       if (fabs(cand2->eta())>maxEta_) continue;
       if (cand2->pt() < minPt_) continue;
       
       cand3 = cand2; cand3++;
       for (; cand3!=mucands->end(); cand3++) {
     TrackRef tk3 = cand3->get<TrackRef>();
     
     // eta cut
     LogDebug("HLTMuonDimuonFilter") << " 3rd muon in loop: q*pt= " << cand3->charge()*cand3->pt() << ", eta= " << cand3->eta() << ", hits= " << tk3->numberOfValidHits() << ", d0= " << tk3->d0();
     //first check if this muon passed the previous filter
     if( ! checkPreviousCand( tk3, vPrevCands) ) continue;
     
     // cuts
     if (fabs(cand3->eta())>maxEta_) continue;
     if (cand3->pt() < minPt_) continue;
     
     // opposite sign or same sign
     if (chargeOpt_>0) {
       if (fabs (cand1->charge() + cand2->charge() + cand3->charge()) != chargeOpt_) continue;
     }
     
     // Combined dimuon system
     e1 = sqrt(cand1->momentum().Mag2()+MuMass2);
     e2 = sqrt(cand2->momentum().Mag2()+MuMass2);
     e3 = sqrt(cand3->momentum().Mag2()+MuMass2);
     p1 = Particle::LorentzVector(cand1->px(),cand1->py(),cand1->pz(),e1);
     p2 = Particle::LorentzVector(cand2->px(),cand2->py(),cand2->pz(),e2);
     p3 = Particle::LorentzVector(cand3->px(),cand3->py(),cand3->pz(),e3);
     p = p1+p2+p3;
     
     
     if (p.pt()<minPtTriplet_) continue;
     
     double invmass = abs(p.mass());
     LogDebug("HLTDisplacedMumumuFilter") << " ... 1-2 invmass= " << invmass;
     
     if (invmass<minInvMass_) continue;
     if (invmass>maxInvMass_) continue;
     
     // do the vertex fit
     vector<TransientTrack> t_tks;
     TransientTrack ttkp1 = (*theB).build(&tk1);
     TransientTrack ttkp2 = (*theB).build(&tk2);
     TransientTrack ttkp3 = (*theB).build(&tk3);
     t_tks.push_back(ttkp1);
     t_tks.push_back(ttkp2);
     t_tks.push_back(ttkp3);
     
     
     if (t_tks.size()!=3) continue;
     
     KalmanVertexFitter kvf;
     TransientVertex tv = kvf.vertex(t_tks);
     
     if (!tv.isValid()) continue;
     
     Vertex vertex = tv;
     
     // put vertex in the event
     vertexCollection->push_back(vertex);
       }
     }
   }
   iEvent.put(std::move(vertexCollection));
 }