#include <HLTDisplacedtktktkVtxProducer.h>

Inheritance diagram for HLTDisplacedtktktkVtxProducer:

Public Member Functions
virtual void	beginJob ()

virtual void	endJob ()

	HLTDisplacedtktktkVtxProducer (const edm::ParameterSet &)

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

	~HLTDisplacedtktktkVtxProducer () override

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

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

ModuleDescription const &	moduleDescription () const

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

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

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) 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::stream::EDProducerBase
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
const int	chargeOpt_

double	firstTrackMass

double	firstTrackMass2

double	firstTrackPt

const double	massParticle1_

const double	massParticle2_

const double	massParticle3_

const double	maxEta_

const double	maxInvMass_

const double	maxInvMassRes_

const double	minInvMass_

const double	minInvMassRes_

const double	minPtRes_

const double	minPtTk1_

const double	minPtTk2_

const double	minPtTk3_

const double	minPtTri_

const edm::InputTag	previousCandTag_

const edm::EDGetTokenT< trigger::TriggerFilterObjectWithRefs >	previousCandToken_

const int	resOpt_

double	secondTrackMass

double	secondTrackMass2

double	secondTrackPt

const edm::InputTag	srcTag_

const edm::EDGetTokenT< reco::RecoChargedCandidateCollection >	srcToken_

double	thirdTrackMass

double	thirdTrackMass2

double	thirdTrackPt

const int	triggerTypeDaughters_

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
typedef CacheContexts< T... >	CacheTypes

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T... >	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

Public Types inherited from edm::stream::EDProducerBase
typedef EDProducerAdaptorBase	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

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 35 of file HLTDisplacedtktktkVtxProducer.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 35 of file HLTDisplacedtktktkVtxProducer.cc.

References firstTrackMass, firstTrackMass2, firstTrackPt, massParticle1_, massParticle2_, massParticle3_, minPtTk1_, minPtTk2_, minPtTk3_, resOpt_, secondTrackMass, secondTrackMass2, secondTrackPt, std::swap(), thirdTrackMass, thirdTrackMass2, thirdTrackPt, and ~HLTDisplacedtktktkVtxProducer().

                                                                                           : 
   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>("MaxEtaTk")),
   minPtTk1_ (iConfig.getParameter<double>("MinPtResTk1")),
   minPtTk2_ (iConfig.getParameter<double>("MinPtResTk2")),
   minPtTk3_ (iConfig.getParameter<double>("MinPtThirdTk")),
   minPtRes_ (iConfig.getParameter<double>("MinPtRes")),
   minPtTri_ (iConfig.getParameter<double>("MinPtTri")),
   minInvMassRes_ (iConfig.getParameter<double>("MinInvMassRes")),
   maxInvMassRes_ (iConfig.getParameter<double>("MaxInvMassRes")),
   minInvMass_ (iConfig.getParameter<double>("MinInvMass")),
   maxInvMass_ (iConfig.getParameter<double>("MaxInvMass")),
   massParticle1_ (iConfig.getParameter<double>("massParticleRes1")),
   massParticle2_ (iConfig.getParameter<double>("massParticleRes2")),
   massParticle3_ (iConfig.getParameter<double>("massParticle3")),
   chargeOpt_ (iConfig.getParameter<int>("ChargeOpt")),
   resOpt_ (iConfig.getParameter<int>("ResOpt")),
   triggerTypeDaughters_(iConfig.getParameter<int>("triggerTypeDaughters"))
 
 {
   produces<VertexCollection>();
 
   firstTrackMass = massParticle1_;
   secondTrackMass = massParticle2_;
   thirdTrackMass = massParticle3_;
   firstTrackPt = minPtTk1_;
   secondTrackPt = minPtTk2_;
   thirdTrackPt = minPtTk3_;
   if(resOpt_<=0 && massParticle1_!=massParticle2_)
     {
       if(massParticle1_==massParticle3_) 
         {
           std::swap(secondTrackMass, thirdTrackMass);
           std::swap(secondTrackPt, thirdTrackPt);
         }
       if(massParticle2_==massParticle3_) 
         {
           std::swap(firstTrackMass, thirdTrackMass);
           std::swap(firstTrackPt, thirdTrackPt);
         }
     }
   firstTrackMass2 = firstTrackMass*firstTrackMass;
   secondTrackMass2 = secondTrackMass*secondTrackMass;
   thirdTrackMass2 = thirdTrackMass*thirdTrackMass;
 }

HLTDisplacedtktktkVtxProducer::~HLTDisplacedtktktkVtxProducer ( )

overridedefault

Referenced by HLTDisplacedtktktkVtxProducer().

Member Function Documentation

void HLTDisplacedtktktkVtxProducer::beginJob ( void )

virtual

Definition at line 112 of file HLTDisplacedtktktkVtxProducer.cc.

 {
 
 }

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

private

Definition at line 266 of file HLTDisplacedtktktkVtxProducer.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 HLTDisplacedtktktkVtxProducer::endJob ( void )

virtual

Definition at line 118 of file HLTDisplacedtktktkVtxProducer.cc.

 {
     
 }

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

static

Definition at line 87 of file HLTDisplacedtktktkVtxProducer.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>("MaxEtaTk",2.5);
   desc.add<double>("MinPtResTk1",0.0);
   desc.add<double>("MinPtResTk2",0.0);
   desc.add<double>("MinPtThirdTk",0.0);
   desc.add<double>("MinPtRes",0.0);
   desc.add<double>("MinPtTri",0.0);
   desc.add<double>("MinInvMassRes",1.0);
   desc.add<double>("MaxInvMassRes",20.0);
   desc.add<double>("MinInvMass",1.0);
   desc.add<double>("MaxInvMass",20.0);
   desc.add<double>("massParticleRes1",0.4937);
   desc.add<double>("massParticleRes2",0.4937);
   desc.add<double>("massParticle3",0.1396);
   desc.add<int>("ChargeOpt",-1);
   desc.add<int>("ResOpt",1);
   desc.add<int>("triggerTypeDaughters",0);
 
   descriptions.add("hltDisplacedtktktkVtxProducer", desc);
 }

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

override

Definition at line 124 of file HLTDisplacedtktktkVtxProducer.cc.

References funct::abs(), chargeOpt_, checkPreviousCand(), reco::e1, reco::e2, SiPixelPhase1TrackClustersV_cfi::e3, firstTrackMass, firstTrackMass2, firstTrackPt, edm::EventSetup::get(), edm::Ref< C, T, F >::get(), edm::Event::getByToken(), trigger::TriggerRefsCollections::getObjects(), TransientVertex::isValid(), LogDebug, maxEta_, maxInvMass_, maxInvMassRes_, minInvMass_, minInvMassRes_, minPtRes_, minPtTri_, eostools::move(), AlCaHLTBitMon_ParallelJobs::p, previousCandToken_, edm::Event::put(), resOpt_, secondTrackMass, secondTrackMass2, secondTrackPt, mathSSE::sqrt(), srcToken_, thirdTrackMass, thirdTrackMass2, thirdTrackPt, triggerTypeDaughters_, KalmanVertexFitter::vertex(), and particleFlowSuperClusterECAL_cfi::vertexCollection.

 {
   // get hold of track trks
   Handle<RecoChargedCandidateCollection> trackcands;
   iEvent.getByToken(srcToken_,trackcands);
   if ( trackcands->size()  < 3 )   return;
     
   //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 trackcands,  check cuts and make vertices
   double e1,e2,e3;
   Particle::LorentzVector p,pres;
 
   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(triggerTypeDaughters_,vPrevCands);
 
   std::vector<bool> candComp;
   for (cand1=trackcands->begin(); cand1!=trackcands->end(); cand1++)
     candComp.push_back(checkPreviousCand( cand1->get<TrackRef>(), vPrevCands)); 
   
   for (cand1=trackcands->begin(); cand1!=trackcands->end(); cand1++) {
 
     TrackRef tk1 = cand1->get<TrackRef>();
     LogDebug("HLTDisplacedtktktkVtxProducer") << " 1st track in loop: q*pt= " << cand1->charge()*cand1->pt() << ", eta= " << cand1->eta() << ", hits= " << tk1->numberOfValidHits();
          
     //first check if this track passed the previous filter
     if (!candComp[cand1-trackcands->begin()]) continue;
     // if( ! checkPreviousCand( tk1, vPrevCands) ) continue;
     
     // cuts
     if (std::abs(cand1->eta())>maxEta_) continue;
     if (cand1->pt() < firstTrackPt) continue;
     
     cand2=trackcands->begin();
     if(firstTrackMass==secondTrackMass){cand2 = cand1+1;}
 
     for (; cand2!=trackcands->end(); cand2++) {
              
       TrackRef tk2 = cand2->get<TrackRef>();
       if(tk1==tk2) continue;         
       LogDebug("HLTDisplacedtktktkVtxProducer") << " 2nd track in loop: q*pt= " << cand2->charge()*cand2->pt() << ", eta= " << cand2->eta() << ", hits= " << tk2->numberOfValidHits() << ", d0= " << tk2->d0();
 
       //first check if this track passed the previous filter
       if (!candComp[cand2-trackcands->begin()]) continue;
       // if( ! checkPreviousCand( tk2, vPrevCands) ) continue;
              
       // cuts
       if (std::abs(cand2->eta()) > maxEta_) continue;
       if (cand2->pt() < secondTrackPt) continue;
 
       // opposite sign or same sign for resonance
       if(resOpt_>0)
         {
           if (chargeOpt_<0) {
             if (cand1->charge()*cand2->charge()>0) continue;
           } else if (chargeOpt_>0) {
             if (cand1->charge()*cand2->charge()<0) continue;
           }
         }
 
       //                
       // Combined ditrack system
       e1 = sqrt(cand1->momentum().Mag2()+firstTrackMass2);
       e2 = sqrt(cand2->momentum().Mag2()+secondTrackMass2);
       pres = Particle::LorentzVector(cand1->px(),cand1->py(),cand1->pz(),e1)+Particle::LorentzVector(cand2->px(),cand2->py(),cand2->pz(),e2);
                 
       if(resOpt_>0)
         {
           if (pres.pt()<minPtRes_) continue;
           double invmassRes = std::abs(pres.mass());
           LogDebug("HLTDisplacedtktktkVtxProducer") << " ... 1-2 invmass= " << invmassRes;
           if (invmassRes<minInvMassRes_) continue;
           if (invmassRes>maxInvMassRes_) continue;
         }
 
       cand3=trackcands->begin();
       if(firstTrackMass==secondTrackMass && firstTrackMass==thirdTrackMass && resOpt_<=0){cand3 = cand2+1;}
 
       for (; cand3!=trackcands->end(); cand3++) {
 
         TrackRef tk3 = cand3->get<TrackRef>();
         if(tk1==tk3 || tk2==tk3) continue;
         LogDebug("HLTDisplacedtktktkVtxProducer") << " 3rd track in loop: q*pt= " << cand3->charge()*cand3->pt() << ", eta= " << cand3->eta() << ", hits= " << tk3->numberOfValidHits();
     
         //first check if this track passed the previous filter
         if (!candComp[cand3-trackcands->begin()]) continue;
         // if( ! checkPreviousCand( tk3, vPrevCands) ) continue;
     
         // cuts
         if (std::abs(cand3->eta())>maxEta_) continue;
         if (cand3->pt() < thirdTrackPt) continue;
 
         e3 = sqrt(cand3->momentum().Mag2()+thirdTrackMass2);
         p = Particle::LorentzVector(cand1->px(),cand1->py(),cand1->pz(),e1)+Particle::LorentzVector(cand2->px(),cand2->py(),cand2->pz(),e2)+Particle::LorentzVector(cand3->px(),cand3->py(),cand3->pz(),e3);
              
         if (p.pt()<minPtTri_) continue;
         double invmass = std::abs(p.mass());
         LogDebug("HLTDisplacedtktktkVtxProducer") << " ... 1-2-3 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));
 }