#include <Skimming/DisappearingMuonsSkimming/plugins/DisappearingMuonsSkimming.cc>

Inheritance diagram for DisappearingMuonsSkimming:

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

	~DisappearingMuonsSkimming () override=default

Public Member Functions inherited from edm::one::EDFilter<>
	EDFilter ()=default

	EDFilter (const EDFilter &)=delete

SerialTaskQueue *	globalLuminosityBlocksQueue () final

SerialTaskQueue *	globalRunsQueue () final

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDFilter &	operator= (const EDFilter &)=delete

bool	wantsGlobalLuminosityBlocks () const final

bool	wantsGlobalRuns () const final

bool	wantsInputProcessBlocks () const final

bool	wantsProcessBlocks () const final

Public Member Functions inherited from edm::one::EDFilterBase
	EDFilterBase ()

ModuleDescription const &	moduleDescription () const

bool	wantsStreamLuminosityBlocks () const

bool	wantsStreamRuns () const

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

std::vector< bool > const &	recordProvenanceList () 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)

TypeLabelList const &	typeLabelList () const
	used by the fwk to register the list of products of this module More...

	~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

ESResolverIndex const *	esGetTokenIndices (edm::Transition iTrans) const

std::vector< ESResolverIndex > const &	esGetTokenIndicesVector (edm::Transition iTrans) const

std::vector< ESRecordIndex > const &	esGetTokenRecordIndicesVector (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::array< std::vector< ModuleDescription const > , NumBranchTypes > &modulesAll, std::vector< ModuleProcessName > &modulesInPreviousProcesses, 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

void	selectInputProcessBlocks (ProductRegistry const &productRegistry, ProcessBlockHelperBase const &processBlockHelperBase)

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

void	updateLookup (eventsetup::ESRecordsToProductResolverIndices const &)

virtual	~EDConsumerBase () noexcept(false)

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

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

bool	findTrackInVertices (const reco::TrackRef &tkToMatch, const reco::VertexCollection &vertices, unsigned int &vtxIndex, unsigned int &trackIndex)

double	getECALIsolation (const edm::Event &, const edm::EventSetup &, const reco::TransientTrack &track)

double	getTrackIsolation (const reco::TrackRef &tkToMatch, const reco::VertexCollection &vertices)

bool	passTriggers (const edm::Event &iEvent, const edm::TriggerResults &results, const std::vector< std::string > &m_muonPathsToPass)

Private Attributes
const double	ecalIsoConesize_

const edm::ESGetToken< CaloGeometry, CaloGeometryRecord >	geometryToken_

const bool	keepOffPeak_

const bool	keepPartialRegion_

const bool	keepSameSign_

const bool	keepTotalRegion_

const double	maxEcalIso_

const double	maxInvMass_

const double	maxLongDCA_

const double	maxMuEta_

const double	maxSigInvMass_

const double	maxStandaloneDE_

const double	maxTrackEta_

const double	maxTrackIso_

const double	maxTransDCA_

const double	maxVtxChi_

const double	minEcalHitE_

const double	minInvMass_

const double	minMuPt_

const double	minSigInvMass_

const double	minStandaloneDr_

const double	minTrackEta_

const double	minTrackPt_

const std::vector< std::string >	muonPathsToPass_

const edm::EDGetTokenT< reco::VertexCollection >	primaryVerticesToken_

const edm::EDGetTokenT< reco::MuonCollection >	recoMuonToken_

const edm::EDGetTokenT< EcalRecHitCollection >	reducedBarrelRecHitCollectionToken_

const edm::EDGetTokenT< EcalRecHitCollection >	reducedEndcapRecHitCollectionToken_

const edm::EDGetTokenT< reco::TrackCollection >	standaloneMuonToken_

const edm::EDGetTokenT< reco::TrackCollection >	trackCollectionToken_

const double	trackIsoConesize_

const double	trackIsoInnerCone_

const edm::ESGetToken< TransientTrackBuilder, TransientTrackRecord >	transientTrackToken_

const edm::EDGetTokenT< edm::TriggerResults >	trigResultsToken_

Additional Inherited Members
Public Types inherited from edm::one::EDFilterBase
typedef EDFilterBase	ModuleType

Public Types inherited from edm::ProducerBase
template<typename T >
using	BranchAliasSetterT = ProductRegistryHelper::BranchAliasSetterT< T >

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::ProducerBase
template<Transition Tr = Transition::Event>
auto	produces (std::string instanceName) noexcept
	declare what type of product will make and with which optional label More...

template<Transition B>
BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

template<BranchType B>
BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

template<typename ProductType , Transition B>
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

template<class ProductType >
BranchAliasSetterT< ProductType >	produces ()

template<typename ProductType , BranchType B>
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

template<typename ProductType , BranchType B>
BranchAliasSetterT< ProductType >	produces ()

template<class ProductType >
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

template<typename ProductType , Transition B>
BranchAliasSetterT< ProductType >	produces ()

template<Transition Tr = Transition::Event>
auto	produces () noexcept

ProducesCollector	producesCollector ()

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B >	consumes (edm::InputTag tag) noexcept

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

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

template<Transition Tr = Transition::Event>
constexpr auto	esConsumes ()

template<Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag tag)

template<Transition Tr = Transition::Event>
ESGetTokenGeneric	esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
	Used with EventSetupRecord::doGet. More...

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)

void	resetItemsToGetFrom (BranchType iType)

Detailed Description

Description: [one line class summary]

Implementation: [Notes on implementation]

Definition at line 45 of file DisappearingMuonsSkimming.h.

Constructor & Destructor Documentation

◆ DisappearingMuonsSkimming()

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

explicit

Definition at line 36 of file DisappearingMuonsSkimming.cc.

     : recoMuonToken_(consumes<reco::MuonCollection>(iConfig.getParameter<edm::InputTag>("recoMuons"))),
       standaloneMuonToken_(consumes<reco::TrackCollection>(iConfig.getParameter<edm::InputTag>("StandaloneTracks"))),
       trackCollectionToken_(consumes<reco::TrackCollection>(iConfig.getParameter<edm::InputTag>("tracks"))),
       primaryVerticesToken_(consumes<reco::VertexCollection>(iConfig.getParameter<edm::InputTag>("primaryVertices"))),
       reducedEndcapRecHitCollectionToken_(
           consumes<EcalRecHitCollection>(iConfig.getParameter<edm::InputTag>("EERecHits"))),
       reducedBarrelRecHitCollectionToken_(
           consumes<EcalRecHitCollection>(iConfig.getParameter<edm::InputTag>("EBRecHits"))),
       trigResultsToken_(consumes<edm::TriggerResults>(iConfig.getParameter<edm::InputTag>("TriggerResultsTag"))),
       transientTrackToken_(
           esConsumes<TransientTrackBuilder, TransientTrackRecord>(edm::ESInputTag("", "TransientTrackBuilder"))),
       geometryToken_(esConsumes<CaloGeometry, CaloGeometryRecord>(edm::ESInputTag{})),
       muonPathsToPass_(iConfig.getParameter<std::vector<std::string>>("muonPathsToPass")),
       minMuPt_(iConfig.getParameter<double>("minMuPt")),
       maxMuEta_(iConfig.getParameter<double>("maxMuEta")),
       minTrackEta_(iConfig.getParameter<double>("minTrackEta")),
       maxTrackEta_(iConfig.getParameter<double>("maxTrackEta")),
       minTrackPt_(iConfig.getParameter<double>("minTrackPt")),
       maxTransDCA_(iConfig.getParameter<double>("maxTransDCA")),
       maxLongDCA_(iConfig.getParameter<double>("maxLongDCA")),
       maxVtxChi_(iConfig.getParameter<double>("maxVtxChi")),
       minInvMass_(iConfig.getParameter<double>("minInvMass")),
       maxInvMass_(iConfig.getParameter<double>("maxInvMass")),
       trackIsoConesize_(iConfig.getParameter<double>("trackIsoConesize")),
       trackIsoInnerCone_(iConfig.getParameter<double>("trackIsoInnerCone")),
       ecalIsoConesize_(iConfig.getParameter<double>("ecalIsoConesize")),
       minEcalHitE_(iConfig.getParameter<double>("minEcalHitE")),
       maxTrackIso_(iConfig.getParameter<double>("maxTrackIso")),
       maxEcalIso_(iConfig.getParameter<double>("maxEcalIso")),
       minSigInvMass_(iConfig.getParameter<double>("minSigInvMass")),
       maxSigInvMass_(iConfig.getParameter<double>("maxSigInvMass")),
       minStandaloneDr_(iConfig.getParameter<double>("minStandaloneDr")),
       maxStandaloneDE_(iConfig.getParameter<double>("maxStandaloneDE")),
       keepOffPeak_(iConfig.getParameter<bool>("keepOffPeak")),
       keepSameSign_(iConfig.getParameter<bool>("keepSameSign")),
       keepTotalRegion_(iConfig.getParameter<bool>("keepTotalRegion")),
       keepPartialRegion_(iConfig.getParameter<bool>("keepPartialRegion")) {}

◆ ~DisappearingMuonsSkimming()

DisappearingMuonsSkimming::~DisappearingMuonsSkimming ( )

overridedefault

Member Function Documentation

◆ fillDescriptions()

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

static

Definition at line 390 of file DisappearingMuonsSkimming.cc.

References edm::ConfigurationDescriptions::addWithDefaultLabel(), submitPVResolutionJobs::desc, and ProducerED_cfi::InputTag.

                                                                                            {
   edm::ParameterSetDescription desc;
 
   desc.add<edm::InputTag>("recoMuons", edm::InputTag("muons"));
   desc.add<edm::InputTag>("tracks", edm::InputTag("generalTracks"));
   desc.add<edm::InputTag>("StandaloneTracks", edm::InputTag("standAloneMuons"));
   desc.add<edm::InputTag>("primaryVertices", edm::InputTag("offlinePrimaryVertices"));
   desc.add<edm::InputTag>("EERecHits", edm::InputTag("reducedEcalRecHitsEE"));
   desc.add<edm::InputTag>("EBRecHits", edm::InputTag("reducedEcalRecHitsEB"));
   desc.add<edm::InputTag>("TriggerResultsTag", edm::InputTag("TriggerResults", "", "HLT"));
   desc.add<std::vector<std::string>>("muonPathsToPass",
                                      {
                                          "HLT_IsoMu24_v",
                                          "HLT_IsoMu27_v",
                                      });
   desc.add<double>("minMuPt", 26);
   desc.add<double>("maxMuEta", 2.4);
   desc.add<double>("minTrackEta", 0);
   desc.add<double>("maxTrackEta", 2.4);
   desc.add<double>("minTrackPt", 20);
   desc.add<double>("maxTransDCA", 0.005);
   desc.add<double>("maxLongDCA", 0.05);
   desc.add<double>("maxVtxChi", 3.0);
   desc.add<double>("minInvMass", 50);
   desc.add<double>("maxInvMass", 150);
   desc.add<double>("trackIsoConesize", 0.3);
   desc.add<double>("trackIsoInnerCone", 0.01);
   desc.add<double>("ecalIsoConesize", 0.4);
   desc.add<double>("minEcalHitE", 0.3);
   desc.add<double>("maxTrackIso", 0.05);
   desc.add<double>("maxEcalIso", 10);
   desc.add<double>("minSigInvMass", 76);
   desc.add<double>("maxSigInvMass", 106);
   desc.add<double>("minStandaloneDr", 1.0);
   desc.add<double>("maxStandaloneDE", -0.5);
   desc.add<bool>("keepOffPeak", true);
   desc.add<bool>("keepSameSign", true);
   desc.add<bool>("keepTotalRegion", true);
   desc.add<bool>("keepPartialRegion", true);
   descriptions.addWithDefaultLabel(desc);
 }

◆ filter()

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

overrideprivatevirtual

Implements edm::one::EDFilterBase.

Definition at line 80 of file DisappearingMuonsSkimming.cc.

References funct::abs(), TransientTrackBuilder::build(), reco::Muon::CutBasedIdTight, CachingVertex< N >::degreesOfFreedom(), HLTMuonOfflineAnalyzer_cfi::deltaR2, ALPAKA_ACCELERATOR_NAMESPACE::dR2(), run3scouting_cff::ecalIso, findTrackInVertices(), edm::EventSetup::getData(), getECALIsolation(), getTrackIsolation(), iEvent, CachingVertex< N >::isValid(), keepOffPeak_, keepPartialRegion_, keepSameSign_, keepTotalRegion_, PerigeeTrajectoryParameters::longitudinalImpactParameter(), PV3DBase< T, PVType, FrameType >::mag2(), maxEcalIso_, maxInvMass_, maxLongDCA_, maxMuEta_, maxSigInvMass_, maxStandaloneDE_, maxTrackEta_, maxTrackIso_, maxTransDCA_, maxVtxChi_, minMuPt_, minStandaloneDr_, minTrackEta_, minTrackPt_, TrajectoryStateClosestToPoint::momentum(), muonPathsToPass_, passTriggers(), TrajectoryStateClosestToPoint::perigeeParameters(), reco::Muon::PFIsoTight, CachingVertex< N >::position(), funct::pow(), primaryVerticesToken_, reco::TrackBase::qualityByName(), recoMuonToken_, mathSSE::sqrt(), standaloneMuonToken_, muonTagProbeFilters_cff::staTracks, CachingVertex< N >::totalChiSquared(), HLT_2024v10_cff::track, trackCollectionToken_, run3scouting_cff::trackIso, transientTrackToken_, PerigeeTrajectoryParameters::transverseImpactParameter(), triggerResults, trigResultsToken_, generalV0Candidates_cfi::vertexFitter, AlignmentTracksFromVertexSelector_cfi::vertices, L1BJetProducer_cff::vtx, PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

                                                                                     {
   using namespace edm;
   using namespace std;
   using namespace reco;
 
   bool totalRegion = false;
   bool sameSign = false;
   bool offPeak = false;
   bool partialRegion = false;
 
   const auto& staTracks = iEvent.get(standaloneMuonToken_);
   const auto& vertices = iEvent.get(primaryVerticesToken_);
   const auto& recoMuons = iEvent.get(recoMuonToken_);
   const auto& thePATTracks = iEvent.get(trackCollectionToken_);
   const auto& triggerResults = iEvent.get(trigResultsToken_);
 
   // this wraps tracks with additional methods that are used in vertex-calculation
   const TransientTrackBuilder* transientTrackBuilder = &iSetup.getData(transientTrackToken_);
 
   if (!passTriggers(iEvent, triggerResults, muonPathsToPass_))
     return false;
 
   int nMuonTrackCand = 0;
   float MuonTrackMass = 0.;
 
   //Looping over the reconstructed Muons
   for (const auto& iMuon : recoMuons) {
     if (!(iMuon.isPFMuon() && iMuon.isGlobalMuon()))
       continue;
     if (!(iMuon.passed(reco::Muon::CutBasedIdTight)))
       continue;
     if (!(iMuon.passed(reco::Muon::PFIsoTight)))
       continue;
     if (iMuon.pt() < minMuPt_ || std::abs(iMuon.eta()) > maxMuEta_)
       continue;
 
     //Looping over tracks for any good muon
     int indx(0);
     for (const auto& iTrack : thePATTracks) {
       reco::TrackRef trackRef = reco::TrackRef(&thePATTracks, indx);
       indx++;
 
       if (!iTrack.quality(reco::Track::qualityByName("highPurity")))
         continue;
       if (std::abs(iTrack.eta()) > maxTrackEta_ || std::abs(iTrack.eta()) < minTrackEta_)
         continue;
       if (iTrack.pt() < minTrackPt_)
         continue;
       //Check if the track belongs to a primary vertex for isolation calculation
 
       unsigned int vtxIndex;
       unsigned int tkIndex;
       bool foundtrack = this->findTrackInVertices(trackRef, vertices, vtxIndex, tkIndex);
 
       if (!foundtrack)
         continue;
 
       reco::VertexRef vtx(&vertices, vtxIndex);
       GlobalPoint tkVtx = GlobalPoint(vtx->x(), vtx->y(), vtx->z());
 
       reco::TransientTrack tk = transientTrackBuilder->build(iTrack);
       TrajectoryStateClosestToPoint traj = tk.trajectoryStateClosestToPoint(tkVtx);
       double transDCA = traj.perigeeParameters().transverseImpactParameter();
       double longDCA = traj.perigeeParameters().longitudinalImpactParameter();
       if (std::abs(longDCA) > maxLongDCA_)
         continue;
       if (std::abs(transDCA) > maxTransDCA_)
         continue;
       // make a pair of TransientTracks to feed the vertexer
       std::vector<reco::TransientTrack> tracksToVertex;
       tracksToVertex.push_back(tk);
       tracksToVertex.push_back(transientTrackBuilder->build(iMuon.globalTrack()));
       // try to fit these two tracks to a common vertex
       KalmanVertexFitter vertexFitter;
       CachingVertex<5> fittedVertex = vertexFitter.vertex(tracksToVertex);
       double vtxChi = 0;
       // some poor fits will simply fail to find a common vertex
       if (fittedVertex.isValid() && fittedVertex.totalChiSquared() >= 0. && fittedVertex.degreesOfFreedom() > 0) {
         // others we can exclude by their poor fit
         vtxChi = fittedVertex.totalChiSquared() / fittedVertex.degreesOfFreedom();
 
         if (vtxChi < maxVtxChi_) {
           // important! evaluate momentum vectors AT THE VERTEX
           TrajectoryStateClosestToPoint one_TSCP =
               tracksToVertex[0].trajectoryStateClosestToPoint(fittedVertex.position());
           TrajectoryStateClosestToPoint two_TSCP =
               tracksToVertex[1].trajectoryStateClosestToPoint(fittedVertex.position());
           GlobalVector one_momentum = one_TSCP.momentum();
           GlobalVector two_momentum = two_TSCP.momentum();
 
           double total_energy = sqrt(one_momentum.mag2() + 0.106 * 0.106) + sqrt(two_momentum.mag2() + 0.106 * 0.106);
           double total_px = one_momentum.x() + two_momentum.x();
           double total_py = one_momentum.y() + two_momentum.y();
           double total_pz = one_momentum.z() + two_momentum.z();
           MuonTrackMass = sqrt(pow(total_energy, 2) - pow(total_px, 2) - pow(total_py, 2) - pow(total_pz, 2));
         } else {
           continue;
         }
       } else {
         continue;
       }
       if (MuonTrackMass < minInvMass_ || MuonTrackMass > maxInvMass_)
         continue;
 
       double trackIso = getTrackIsolation(trackRef, vertices);
       //Track iso returns -1 when it fails to find the vertex containing the track (already checked in track selection, but might as well make sure)
       if (trackIso < 0)
         continue;
       double ecalIso = getECALIsolation(iEvent, iSetup, transientTrackBuilder->build(iTrack));
       if (trackIso > maxTrackIso_ || ecalIso > maxEcalIso_)
         continue;
 
       //A good tag/probe pair has been selected, now check for control or signal regions
       if (iMuon.charge() == iTrack.charge()) {
         sameSign = true;
       }
 
       //If not same sign CR, need to check standalone muons for signal regions
       double staMinDr2 = 1000;
       double staMinDEoverE = -10;
       if (!staTracks.empty()) {
         for (const auto& staTrack : staTracks) {
           reco::TransientTrack track = transientTrackBuilder->build(staTrack);
           double dR2 = deltaR2(track.impactPointTSCP().momentum().eta(),
                                track.impactPointTSCP().momentum().phi(),
                                iTrack.eta(),
                                iTrack.phi());
           double staDE = (std::sqrt(track.impactPointTSCP().momentum().mag2()) - iTrack.p()) / iTrack.p();
           if (dR2 < staMinDr2) {
             staMinDr2 = dR2;
           }
           //Pick the largest standalone muon within the cone
           if (dR2 < minStandaloneDr_ * minStandaloneDr_ && staDE > staMinDEoverE) {
             staMinDEoverE = staDE;
           }
         }
       }
       if (staMinDr2 > minStandaloneDr_ * minStandaloneDr_) {
         if (MuonTrackMass < minSigInvMass_ || MuonTrackMass > maxSigInvMass_) {
           offPeak = true;
         } else {
           totalRegion = true;
         }
       } else {
         if (staMinDEoverE < maxStandaloneDE_) {
           if (MuonTrackMass < minSigInvMass_ || MuonTrackMass > maxSigInvMass_) {
             offPeak = true;
           } else {
             partialRegion = true;
           }
         }
       }
       nMuonTrackCand++;
     }
   }
 
   if (nMuonTrackCand == 0)
     return false;
   bool passes = false;
   //Pass all same sign CR events
   if (sameSign && keepSameSign_) {
     passes = true;
   }
   //Pass all total disappearance events
   else if (totalRegion && keepTotalRegion_) {
     passes = true;
   }
   //Pass all partial disappearkance off-peak events
   else if (offPeak && keepOffPeak_) {
     passes = true;
   }
   //Pass partial region events that pass minimum standalone muon DE/E.
   else if (partialRegion && keepPartialRegion_) {
     passes = true;
   }
   return passes;
 }

◆ findTrackInVertices()

bool DisappearingMuonsSkimming::findTrackInVertices	(	const reco::TrackRef &	tkToMatch,
		const reco::VertexCollection &	vertices,
		unsigned int &	vtxIndex,
		unsigned int &	trackIndex
	)

private

Definition at line 277 of file DisappearingMuonsSkimming.cc.

References HLT_2024v10_cff::distance, heavyIonCSV_trainingSettings::idx, edm::Ref< C, T, F >::key(), mps_fire::result, AlignmentTracksFromVertexSelector_cfi::vertices, and L1BJetProducer_cff::vtx.

Referenced by filter(), and getTrackIsolation().

                                                                               {
   // initialize indices
   vtxIndex = -1;
   trackIndex = -1;
 
   bool foundtrack{false};
   unsigned int idx = 0;
   for (const auto& vtx : vertices) {
     if (!vtx.isValid()) {
       idx++;
       continue;
     }
 
     const auto& thePVtracks{vtx.tracks()};
     std::vector<unsigned int> thePVkeys;
     thePVkeys.reserve(thePVtracks.size());
     for (const auto& tv : thePVtracks) {
       thePVkeys.push_back(tv.key());
     }
 
     auto result = std::find_if(
         thePVkeys.begin(), thePVkeys.end(), [tkToMatch](const auto& tkRef) { return tkRef == tkToMatch.key(); });
     if (result != thePVkeys.end()) {
       foundtrack = true;
       trackIndex = std::distance(thePVkeys.begin(), result);
       vtxIndex = idx;
     }
     if (foundtrack)
       break;
 
     idx++;
   }
   return foundtrack;
 }

◆ getECALIsolation()

double DisappearingMuonsSkimming::getECALIsolation	(	const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup,
		const reco::TransientTrack &	track
	)

private

Definition at line 346 of file DisappearingMuonsSkimming.cc.

References edm::SortedCollection< T, SORT >::begin(), HLTMuonOfflineAnalyzer_cfi::deltaR2, ecalIsoConesize_, edm::SortedCollection< T, SORT >::end(), PV3DBase< T, PVType, FrameType >::eta(), geometryToken_, edm::EventSetup::getData(), CaloSubdetectorGeometry::getGeometry(), CaloGeometry::getSubdetectorGeometry(), iEvent, minEcalHitE_, TrajectoryStateClosestToPoint::position(), reducedBarrelRecHitCollectionToken_, reducedEndcapRecHitCollectionToken_, FrontierCondition_GT_autoExpress_cfi::t0, HLT_2024v10_cff::track, PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by filter().

                                                                                     {
   edm::Handle<EcalRecHitCollection> rechitsEE;
   iEvent.getByToken(reducedEndcapRecHitCollectionToken_, rechitsEE);
 
   edm::Handle<EcalRecHitCollection> rechitsEB;
   iEvent.getByToken(reducedBarrelRecHitCollectionToken_, rechitsEB);
 
   const CaloGeometry& caloGeom = iSetup.getData(geometryToken_);
   TrajectoryStateClosestToPoint t0 = track.impactPointTSCP();
   double eDR = 0;
 
   for (EcalRecHitCollection::const_iterator hit = rechitsEE->begin(); hit != rechitsEE->end(); hit++) {
     const DetId id = (*hit).detid();
     const GlobalPoint hitPos = caloGeom.getSubdetectorGeometry(id)->getGeometry(id)->getPosition();
     //Check if hit and track trajectory ar in the same endcap (transient track projects both ways)
     if ((hitPos.eta() * t0.momentum().eta()) < 0) {
       continue;
     }
     TrajectoryStateClosestToPoint traj = track.trajectoryStateClosestToPoint(hitPos);
     math::XYZVector idPositionRoot(hitPos.x(), hitPos.y(), hitPos.z());
     math::XYZVector trajRoot(traj.position().x(), traj.position().y(), traj.position().z());
     if (deltaR2(idPositionRoot, trajRoot) < ecalIsoConesize_ * ecalIsoConesize_ && (*hit).energy() > minEcalHitE_) {
       eDR += (*hit).energy();
     }
   }
   for (EcalRecHitCollection::const_iterator hit = rechitsEB->begin(); hit != rechitsEB->end(); hit++) {
     const DetId id = (*hit).detid();
     const GlobalPoint hitPos = caloGeom.getSubdetectorGeometry(id)->getGeometry(id)->getPosition();
     if ((hitPos.eta() * t0.momentum().eta()) < 0) {
       continue;
     }
     TrajectoryStateClosestToPoint traj = track.trajectoryStateClosestToPoint(hitPos);
     math::XYZVector idPositionRoot(hitPos.x(), hitPos.y(), hitPos.z());
     math::XYZVector trajRoot(traj.position().x(), traj.position().y(), traj.position().z());
     if (deltaR2(idPositionRoot, trajRoot) < ecalIsoConesize_ * ecalIsoConesize_ && (*hit).energy() > minEcalHitE_) {
       eDR += (*hit).energy();
     }
   }
 
   return eDR;
 }

◆ getTrackIsolation()

double DisappearingMuonsSkimming::getTrackIsolation	(	const reco::TrackRef &	tkToMatch,
		const reco::VertexCollection &	vertices
	)

private

Definition at line 315 of file DisappearingMuonsSkimming.cc.

References HLTMuonOfflineAnalyzer_cfi::deltaR2, reco::TrackBase::eta(), findTrackInVertices(), edm::Ref< C, T, F >::get(), mps_fire::i, LogDebug, reco::TrackBase::phi(), reco::TrackBase::pt(), trackIsoConesize_, trackIsoInnerCone_, and AlignmentTracksFromVertexSelector_cfi::vertices.

Referenced by filter().

                                                                                           {
   unsigned int vtxindex;
   unsigned int trackIndex;
   bool foundtrack = this->findTrackInVertices(tkToMatch, vertices, vtxindex, trackIndex);
 
   LogDebug("DisappearingMuonsSkimming") << "getTrackIsolation vtx Index: " << vtxindex
                                         << " track Index: " << trackIndex;
 
   if (!foundtrack) {
     return -1.;
   }
 
   reco::VertexRef primaryVtx(&vertices, vtxindex);
 
   double Isolation = 0;
   for (unsigned int i = 0; i < primaryVtx->tracksSize(); i++) {
     if (i == trackIndex)
       continue;
     reco::TrackBaseRef secondarytrack = primaryVtx->trackRefAt(i);
     if (deltaR2(tkToMatch.get()->eta(), tkToMatch.get()->phi(), secondarytrack->eta(), secondarytrack->phi()) >
             trackIsoConesize_ * trackIsoConesize_ ||
         deltaR2(tkToMatch.get()->eta(), tkToMatch.get()->phi(), secondarytrack->eta(), secondarytrack->phi()) <
             trackIsoInnerCone_ * trackIsoInnerCone_)
       continue;
     Isolation += secondarytrack->pt();
   }
 
   return Isolation / tkToMatch.get()->pt();
 }

◆ passTriggers()

bool DisappearingMuonsSkimming::passTriggers	(	const edm::Event &	iEvent,
		const edm::TriggerResults &	results,
		const std::vector< std::string > &	m_muonPathsToPass
	)

private

Definition at line 258 of file DisappearingMuonsSkimming.cc.

References mps_fire::i, iEvent, Skims_PA_cff::name, hltMonBTagIPClient_cfi::pathName, AlCaHLTBitMon_QueryRunRegistry::string, triggerResults, and trigNames.

Referenced by filter().

                                                                                             {
   bool passTriggers = false;
   const edm::TriggerNames& trigNames = iEvent.triggerNames(triggerResults);
   for (size_t i = 0; i < trigNames.size(); ++i) {
     const std::string& name = trigNames.triggerName(i);
     for (auto& pathName : m_muonPathsToPass) {
       if ((name.find(pathName) != std::string::npos)) {
         if (triggerResults.accept(i)) {
           passTriggers = true;
           break;
         }
       }
     }
   }
   return passTriggers;
 }