#include <Alignment/OfflineValidation/plugins/DiMuonVertexValidation.cc>

Inheritance diagram for DiMuonVertexValidation:

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

	~DiMuonVertexValidation () override

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

	EDAnalyzer (const EDAnalyzer &)=delete

SerialTaskQueue *	globalLuminosityBlocksQueue () final

SerialTaskQueue *	globalRunsQueue () final

const EDAnalyzer &	operator= (const EDAnalyzer &)=delete

bool	wantsGlobalLuminosityBlocks () const final

bool	wantsGlobalRuns () const final

bool	wantsInputProcessBlocks () const final

bool	wantsProcessBlocks () const final

Public Member Functions inherited from edm::one::EDAnalyzerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

	EDAnalyzerBase ()

ModuleDescription const &	moduleDescription () const

bool	wantsStreamLuminosityBlocks () const

bool	wantsStreamRuns () const

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Private Member Functions
void	analyze (const edm::Event &, const edm::EventSetup &) override

void	beginJob () override

void	endJob () override

const reco::Vertex *	findClosestVertex (const TransientVertex aTransVtx, const reco::VertexCollection *vertices) const

Private Attributes
edm::EDGetTokenT< reco::TrackCollection >	alcaRecoToken_

const edm::ParameterSet	CosPhi3DConfiguration_

DiLeptonHelp::PlotsVsDiLeptonRegion	CosPhi3DInEtaBins = DiLeptonHelp::PlotsVsDiLeptonRegion(1.5)

DiLeptonHelp::PlotsVsKinematics	CosPhi3DPlots = DiLeptonHelp::PlotsVsKinematics(DiLeptonHelp::MM)

const edm::ParameterSet	CosPhiConfiguration_

DiLeptonHelp::PlotsVsKinematics	CosPhiPlots = DiLeptonHelp::PlotsVsKinematics(DiLeptonHelp::MM)

const edm::ParameterSet	DiMuMassConfiguration_

TH1F *	hCosPhi3D_

TH1F *	hCosPhi3DUnbalance_

TH1F *	hCosPhi_

TH1F *	hCosPhiInv3D_

TH1F *	hCosPhiInv_

TH1F *	hCosPhiUnbalance_

TH1F *	hCutFlow_

TH1F *	hdxy_

TH1F *	hdxyErr_

TH1F *	hdz_

TH1F *	hdzErr_

TH1F *	hInvMass_

TH1F *	hIP2d_

TH1F *	hIP2dsig_

TH1F *	hIP3d_

TH1F *	hIP3dsig_

TH1F *	hSVChi2_

TH1F *	hSVCompatibility3D_

TH1F *	hSVCompatibility_

TH1F *	hSVDist3D_

TH1F *	hSVDist3DErr_

TH1F *	hSVDist3DSig_

TH1F *	hSVDist_

TH1F *	hSVDistErr_

TH1F *	hSVDistSig_

TH1F *	hSVNormChi2_

TH1F *	hSVProb_

TH1F *	hTrackInvMass_

DiLeptonHelp::PlotsVsDiLeptonRegion	InvMassInEtaBins = DiLeptonHelp::PlotsVsDiLeptonRegion(1.5)

std::pair< float, float >	massLimits_

const float	maxSVdist_

const std::string	motherName_

edm::EDGetTokenT< reco::MuonCollection >	muonsToken_

DiLeptonHelp::Counts	myCounts

std::vector< double >	pTthresholds_

edm::EDGetTokenT< reco::TrackCollection >	tracksToken_

const edm::ESGetToken< TransientTrackBuilder, TransientTrackRecord >	ttbESToken_

const bool	useClosestVertex_

const bool	useReco_

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

const edm::ParameterSet	VtxDist3DConfiguration_

DiLeptonHelp::PlotsVsKinematics	VtxDist3DPlots = DiLeptonHelp::PlotsVsKinematics(DiLeptonHelp::MM)

const edm::ParameterSet	VtxDist3DSigConfiguration_

DiLeptonHelp::PlotsVsKinematics	VtxDist3DSigPlots = DiLeptonHelp::PlotsVsKinematics(DiLeptonHelp::MM)

const edm::ParameterSet	VtxDistConfiguration_

DiLeptonHelp::PlotsVsKinematics	VtxDistPlots = DiLeptonHelp::PlotsVsKinematics(DiLeptonHelp::MM)

const edm::ParameterSet	VtxDistSigConfiguration_

DiLeptonHelp::PlotsVsKinematics	VtxDistSigPlots = DiLeptonHelp::PlotsVsKinematics(DiLeptonHelp::MM)

const edm::ParameterSet	VtxProbConfiguration_

DiLeptonHelp::PlotsVsKinematics	VtxProbPlots = DiLeptonHelp::PlotsVsKinematics(DiLeptonHelp::MM)

DiLeptonHelp::PlotsVsKinematics	ZMassPlots = DiLeptonHelp::PlotsVsKinematics(DiLeptonHelp::MM)

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

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)

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: Class to perform validation Tracker Alignment Validations by means of a PV and the SV constructed with a di-muon pair

Definition at line 66 of file DiMuonVertexValidation.cc.

Constructor & Destructor Documentation

◆ DiMuonVertexValidation()

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

explicit

Definition at line 177 of file DiMuonVertexValidation.cc.

References alcaRecoToken_, edm::ParameterSet::getParameter(), TFileService::kSharedResource, massLimits_, maxSVdist_, motherName_, muonsToken_, pTthresholds_, jetUpdater_cfi::sort, tracksToken_, and useReco_.

     : motherName_(iConfig.getParameter<std::string>("decayMotherName")),
       useReco_(iConfig.getParameter<bool>("useReco")),
       useClosestVertex_(iConfig.getParameter<bool>("useClosestVertex")),
       pTthresholds_(iConfig.getParameter<std::vector<double>>("pTThresholds")),
       maxSVdist_(iConfig.getParameter<double>("maxSVdist")),
       CosPhiConfiguration_(iConfig.getParameter<edm::ParameterSet>("CosPhiConfig")),
       CosPhi3DConfiguration_(iConfig.getParameter<edm::ParameterSet>("CosPhi3DConfig")),
       VtxProbConfiguration_(iConfig.getParameter<edm::ParameterSet>("VtxProbConfig")),
       VtxDistConfiguration_(iConfig.getParameter<edm::ParameterSet>("VtxDistConfig")),
       VtxDist3DConfiguration_(iConfig.getParameter<edm::ParameterSet>("VtxDist3DConfig")),
       VtxDistSigConfiguration_(iConfig.getParameter<edm::ParameterSet>("VtxDistSigConfig")),
       VtxDist3DSigConfiguration_(iConfig.getParameter<edm::ParameterSet>("VtxDist3DSigConfig")),
       DiMuMassConfiguration_(iConfig.getParameter<edm::ParameterSet>("DiMuMassConfig")),
       ttbESToken_(esConsumes(edm::ESInputTag("", "TransientTrackBuilder"))),
       vertexToken_(consumes<reco::VertexCollection>(iConfig.getParameter<edm::InputTag>("vertices"))) {
   if (useReco_) {
     tracksToken_ = consumes<reco::TrackCollection>(iConfig.getParameter<edm::InputTag>("tracks"));
     muonsToken_ = consumes<reco::MuonCollection>(iConfig.getParameter<edm::InputTag>("muons"));
   } else {
     alcaRecoToken_ = consumes<reco::TrackCollection>(iConfig.getParameter<edm::InputTag>("muonTracks"));
   }
 
   usesResource(TFileService::kSharedResource);
 
   // sort the vector of thresholds
   std::sort(pTthresholds_.begin(), pTthresholds_.end(), [](const double& lhs, const double& rhs) { return lhs > rhs; });
 
   edm::LogInfo("DiMuonVertexValidation") << __FUNCTION__;
   for (const auto& thr : pTthresholds_) {
     edm::LogInfo("DiMuonVertexValidation") << " Threshold: " << thr << " ";
   }
   edm::LogInfo("DiMuonVertexValidation") << "Max SV distance: " << maxSVdist_ << " ";
 
   // set the limits for the mass plots
   if (motherName_.find('Z') != std::string::npos) {
     massLimits_ = std::make_pair(50., 120);
   } else if (motherName_.find("J/#psi") != std::string::npos) {
     massLimits_ = std::make_pair(2.7, 3.4);
   } else if (motherName_.find("#Upsilon") != std::string::npos) {
     massLimits_ = std::make_pair(8.9, 9.9);
   } else {
     edm::LogError("DiMuonVertexValidation") << " unrecognized decay mother particle: " << motherName_
                                             << " setting the default for the Z->mm (50.,120.)" << std::endl;
     massLimits_ = std::make_pair(50., 120);
   }
 }

◆ ~DiMuonVertexValidation()

DiMuonVertexValidation::~DiMuonVertexValidation ( )

overridedefault

Member Function Documentation

◆ analyze()

void DiMuonVertexValidation::analyze	(	const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overrideprivatevirtual

Implements edm::one::EDAnalyzerBase.

Definition at line 232 of file DiMuonVertexValidation.cc.

References alcaRecoToken_, TransientTrackBuilder::build(), ALCARECOTkAlJpsiMuMu_cff::charge, cmToum, VertexDistanceXY::compatibility(), VertexDistance3D::compatibility(), CosPhi3DInEtaBins, CosPhi3DPlots, CosPhiPlots, TransientVertex::degreesOfFreedom(), PbPb_ZMuSkimMuonDPG_cff::deltaR, DeadROC_duringRun::dir, VertexDistanceXY::distance(), VertexDistance3D::distance(), HLT_2024v12_cff::distance, Measurement1D::error(), DiLeptonHelp::Counts::eventsAfterDist, DiLeptonHelp::Counts::eventsAfterEta, DiLeptonHelp::Counts::eventsAfterMult, DiLeptonHelp::Counts::eventsAfterPt, DiLeptonHelp::Counts::eventsAfterVtx, DiLeptonHelp::Counts::eventsTotal, DiLeptonHelp::PlotsVsKinematics::fillPlots(), DiLeptonHelp::PlotsVsDiLeptonRegion::fillTH1Plots(), findClosestVertex(), edm::EventSetup::getData(), hCosPhi3D_, hCosPhi3DUnbalance_, hCosPhi_, hCosPhiUnbalance_, hdxy_, hdxyErr_, hdz_, hdzErr_, reco::TrackBase::highPurity, hInvMass_, hIP2d_, hIP2dsig_, hIP3d_, hIP3dsig_, hSVChi2_, hSVCompatibility3D_, hSVCompatibility_, hSVDist3D_, hSVDist3DErr_, hSVDist3DSig_, hSVDist_, hSVDistErr_, hSVDistSig_, hSVNormChi2_, hSVProb_, hTrackInvMass_, mps_fire::i, iEvent, createfilelist::int, InvMassInEtaBins, electrons_cff::ip3d, edm::HandleBase::isValid(), reco::Vertex::isValid(), TransientVertex::isValid(), LogDebug, LogTrace, maxSVdist_, mumass2, muonsToken_, myCounts, reco::Vertex::position(), TransientVertex::position(), edm::Handle< T >::product(), DiDispStaMuonMonitor_cfi::pt, reco::LeafCandidate::pt(), pTthresholds_, IPTools::signedImpactParameter3D(), IPTools::signedTransverseImpactParameter(), jetUpdater_cfi::sort, mathSSE::sqrt(), submitPVValidationJobs::t, FrontierCondition_GT_autoExpress_cfi::t0, RandomServiceHelper::t1, to_string(), TransientVertex::totalChiSquared(), HLT_2024v12_cff::track, tracksToken_, ttbESToken_, useClosestVertex_, useReco_, Measurement1D::value(), trackerHitRTTI::vector, KalmanVertexFitter::vertex(), vertexToken_, AlignmentTracksFromVertexSelector_cfi::vertices, VtxDist3DPlots, VtxDist3DSigPlots, VtxDistPlots, VtxDistSigPlots, VtxProbPlots, cms::Exception::what(), PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), PV3DBase< T, PVType, FrameType >::z(), and ZMassPlots.

                                                                                         {
   using namespace edm;
 
   myCounts.eventsTotal++;
 
   // the di-muon tracks
   std::vector<const reco::Track*> myTracks;
 
   // if we have to start from scratch from RECO data-tier
   if (useReco_) {
     // select the good muons
     std::vector<const reco::Muon*> myGoodMuonVector;
     for (const auto& muon : iEvent.get(muonsToken_)) {
       const reco::TrackRef t = muon.innerTrack();
       if (!t.isNull()) {
         if (t->quality(reco::TrackBase::highPurity)) {
           if (t->chi2() / t->ndof() <= 2.5 && t->numberOfValidHits() >= 5 &&
               t->hitPattern().numberOfValidPixelHits() >= 2 && t->quality(reco::TrackBase::highPurity))
             myGoodMuonVector.emplace_back(&muon);
         }
       }
     }
 
     LogDebug("DiMuonVertexValidation") << "myGoodMuonVector size: " << myGoodMuonVector.size() << std::endl;
     std::sort(myGoodMuonVector.begin(), myGoodMuonVector.end(), [](const reco::Muon*& lhs, const reco::Muon*& rhs) {
       return lhs->pt() > rhs->pt();
     });
 
     // just check the ordering
     for (const auto& muon : myGoodMuonVector) {
       LogDebug("DiMuonVertexValidation") << "pT: " << muon->pt() << " ";
     }
     LogDebug("DiMuonVertexValidation") << std::endl;
 
     // reject if there's no Z
     if (myGoodMuonVector.size() < 2)
       return;
 
     myCounts.eventsAfterMult++;
 
     if ((myGoodMuonVector[0]->pt()) < pTthresholds_[0] || (myGoodMuonVector[1]->pt() < pTthresholds_[1]))
       return;
 
     myCounts.eventsAfterPt++;
     myCounts.eventsAfterEta++;
 
     if (myGoodMuonVector[0]->charge() * myGoodMuonVector[1]->charge() > 0)
       return;
 
     const auto& m1 = myGoodMuonVector[1]->p4();
     const auto& m0 = myGoodMuonVector[0]->p4();
     const auto& mother = m0 + m1;
 
     float invMass = mother.M();
     hInvMass_->Fill(invMass);
 
     // just copy the top two muons
     std::vector<const reco::Muon*> theZMuonVector;
     theZMuonVector.reserve(2);
     theZMuonVector.emplace_back(myGoodMuonVector[1]);
     theZMuonVector.emplace_back(myGoodMuonVector[0]);
 
     // do the matching of Z muons with inner tracks
     unsigned int i = 0;
     for (const auto& muon : theZMuonVector) {
       i++;
       float minD = 1000.;
       const reco::Track* theMatch = nullptr;
       for (const auto& track : iEvent.get(tracksToken_)) {
         float D = ::deltaR(muon->eta(), muon->phi(), track.eta(), track.phi());
         if (D < minD) {
           minD = D;
           theMatch = &track;
         }
       }
       LogDebug("DiMuonVertexValidation") << "pushing new track: " << i << std::endl;
       myTracks.emplace_back(theMatch);
     }
   } else {
     // we start directly with the pre-selected ALCARECO tracks
     for (const auto& muon : iEvent.get(alcaRecoToken_)) {
       myTracks.emplace_back(&muon);
     }
   }
 
 #ifdef EDM_ML_DEBUG
   for (const auto& track : myTracks) {
     edm::LogVerbatim("DiMuonVertexValidation") << __PRETTY_FUNCTION__ << " pT: " << track->pt() << " GeV"
                                                << " , pT error: " << track->ptError() << " GeV"
                                                << " , eta: " << track->eta() << " , phi: " << track->phi() << std::endl;
   }
 #endif
 
   LogDebug("DiMuonVertexValidation") << "selected tracks: " << myTracks.size() << std::endl;
 
   const TransientTrackBuilder* theB = &iSetup.getData(ttbESToken_);
   TransientVertex aTransientVertex;
   std::vector<reco::TransientTrack> tks;
 
   if (myTracks.size() != 2)
     return;
 
   const auto& t1 = myTracks[1]->momentum();
   const auto& t0 = myTracks[0]->momentum();
   const auto& ditrack = t1 + t0;
 
   const auto& tplus = myTracks[0]->charge() > 0 ? myTracks[0] : myTracks[1];
   const auto& tminus = myTracks[0]->charge() < 0 ? myTracks[0] : myTracks[1];
 
   TLorentzVector p4_tplus(tplus->px(), tplus->py(), tplus->pz(), sqrt((tplus->p() * tplus->p()) + mumass2));
   TLorentzVector p4_tminus(tminus->px(), tminus->py(), tminus->pz(), sqrt((tminus->p() * tminus->p()) + mumass2));
 
 #ifdef EDM_ML_DEBUG
   // Define a lambda function to convert TLorentzVector to a string
   auto tLorentzVectorToString = [](const TLorentzVector& vector) {
     return std::to_string(vector.Px()) + " " + std::to_string(vector.Py()) + " " + std::to_string(vector.Pz()) + " " +
            std::to_string(vector.E());
   };
 
   edm::LogVerbatim("DiMuonVertexValidation") << "mu+" << tLorentzVectorToString(p4_tplus) << std::endl;
   edm::LogVerbatim("DiMuonVertexValidation") << "mu-" << tLorentzVectorToString(p4_tminus) << std::endl;
 #endif
 
   const auto& Zp4 = p4_tplus + p4_tminus;
   float track_invMass = Zp4.M();
   hTrackInvMass_->Fill(track_invMass);
 
   // creat the pair of TLorentVectors used to make the plos
   std::pair<TLorentzVector, TLorentzVector> tktk_p4 = std::make_pair(p4_tplus, p4_tminus);
 
   // fill the z->mm mass plots
   ZMassPlots.fillPlots(track_invMass, tktk_p4);
   InvMassInEtaBins.fillTH1Plots(track_invMass, tktk_p4);
 
   math::XYZPoint ZpT(ditrack.x(), ditrack.y(), 0);
   math::XYZPoint Zp(ditrack.x(), ditrack.y(), ditrack.z());
 
   for (const auto& track : myTracks) {
     reco::TransientTrack trajectory = theB->build(track);
     tks.push_back(trajectory);
   }
 
   KalmanVertexFitter kalman(true);
   aTransientVertex = kalman.vertex(tks);
 
   double SVProb = TMath::Prob(aTransientVertex.totalChiSquared(), (int)aTransientVertex.degreesOfFreedom());
 
   LogDebug("DiMuonVertexValidation") << " vertex prob: " << SVProb << std::endl;
 
   hSVProb_->Fill(SVProb);
   hSVChi2_->Fill(aTransientVertex.totalChiSquared());
   hSVNormChi2_->Fill(aTransientVertex.totalChiSquared() / (int)aTransientVertex.degreesOfFreedom());
 
   LogDebug("DiMuonVertexValidation") << " vertex norm chi2: "
                                      << (aTransientVertex.totalChiSquared() / (int)aTransientVertex.degreesOfFreedom())
                                      << std::endl;
 
   if (!aTransientVertex.isValid())
     return;
 
   myCounts.eventsAfterVtx++;
 
   // fill the VtxProb plots
   VtxProbPlots.fillPlots(SVProb, tktk_p4);
 
   math::XYZPoint mainVtxPos(0, 0, 0);
   const reco::Vertex* theClosestVertex = nullptr;
   // get collection of reconstructed vertices from event
   edm::Handle<reco::VertexCollection> vertexHandle = iEvent.getHandle(vertexToken_);
   if (vertexHandle.isValid()) {
     const reco::VertexCollection* vertices = vertexHandle.product();
     theClosestVertex = this->findClosestVertex(aTransientVertex, vertices);
   } else {
     edm::LogWarning("DiMuonVertexMonitor") << "invalid vertex collection encountered Skipping event!";
     return;
   }
 
   reco::Vertex theMainVertex;
   if (!useClosestVertex_ || theClosestVertex == nullptr) {
     // if the closest vertex is not available, or explicitly not chosen
     theMainVertex = vertexHandle.product()->front();
   } else {
     theMainVertex = *theClosestVertex;
   }
 
   mainVtxPos.SetXYZ(theMainVertex.position().x(), theMainVertex.position().y(), theMainVertex.position().z());
   const math::XYZPoint myVertex(
       aTransientVertex.position().x(), aTransientVertex.position().y(), aTransientVertex.position().z());
   const math::XYZPoint deltaVtx(
       mainVtxPos.x() - myVertex.x(), mainVtxPos.y() - myVertex.y(), mainVtxPos.z() - myVertex.z());
 
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("DiMuonVertexValidation")
       << "mm vertex position:" << aTransientVertex.position().x() << "," << aTransientVertex.position().y() << ","
       << aTransientVertex.position().z();
 
   edm::LogVerbatim("DiMuonVertexValidation") << "main vertex position:" << theMainVertex.position().x() << ","
                                              << theMainVertex.position().y() << "," << theMainVertex.position().z();
 #endif
 
   if (theMainVertex.isValid()) {
     // fill the impact parameter plots
     for (const auto& track : myTracks) {
       hdxy_->Fill(track->dxy(mainVtxPos) * cmToum);
       hdz_->Fill(track->dz(mainVtxPos) * cmToum);
       hdxyErr_->Fill(track->dxyError() * cmToum);
       hdzErr_->Fill(track->dzError() * cmToum);
 
       const auto& ttrk = theB->build(track);
       Global3DVector dir(track->px(), track->py(), track->pz());
       const auto& ip2d = IPTools::signedTransverseImpactParameter(ttrk, dir, theMainVertex);
       const auto& ip3d = IPTools::signedImpactParameter3D(ttrk, dir, theMainVertex);
 
       hIP2d_->Fill(ip2d.second.value() * cmToum);
       hIP3d_->Fill(ip3d.second.value() * cmToum);
       hIP2dsig_->Fill(ip2d.second.significance());
       hIP3dsig_->Fill(ip3d.second.significance());
     }
 
     LogDebug("DiMuonVertexValidation") << " after filling the IP histograms " << std::endl;
 
     // Z Vertex distance in the xy plane
     VertexDistanceXY vertTool;
     double distance = vertTool.distance(aTransientVertex, theMainVertex).value();
     double dist_err = vertTool.distance(aTransientVertex, theMainVertex).error();
     float compatibility = 0.;
 
     try {
       compatibility = vertTool.compatibility(aTransientVertex, theMainVertex);
     } catch (cms::Exception& er) {
       LogTrace("DiMuonVertexValidation") << "caught std::exception " << er.what() << std::endl;
     }
 
     hSVCompatibility_->Fill(compatibility);
     hSVDist_->Fill(distance * cmToum);
     hSVDistErr_->Fill(dist_err * cmToum);
     hSVDistSig_->Fill(distance / dist_err);
 
     // fill the VtxDist plots
     VtxDistPlots.fillPlots(distance * cmToum, tktk_p4);
 
     // fill the VtxDisSig plots
     VtxDistSigPlots.fillPlots(distance / dist_err, tktk_p4);
 
     // Z Vertex distance in 3D
 
     VertexDistance3D vertTool3D;
     double distance3D = vertTool3D.distance(aTransientVertex, theMainVertex).value();
     double dist3D_err = vertTool3D.distance(aTransientVertex, theMainVertex).error();
     float compatibility3D = 0.;
 
     try {
       compatibility3D = vertTool3D.compatibility(aTransientVertex, theMainVertex);
     } catch (cms::Exception& er) {
       LogTrace("DiMuonVertexMonitor") << "caught std::exception " << er.what() << std::endl;
     }
 
     hSVCompatibility3D_->Fill(compatibility3D);
     hSVDist3D_->Fill(distance3D * cmToum);
     hSVDist3DErr_->Fill(dist3D_err * cmToum);
     hSVDist3DSig_->Fill(distance3D / dist3D_err);
 
     // fill the VtxDist3D plots
     VtxDist3DPlots.fillPlots(distance3D * cmToum, tktk_p4);
 
     // fill the VtxDisSig plots
     VtxDist3DSigPlots.fillPlots(distance3D / dist3D_err, tktk_p4);
 
     LogDebug("DiMuonVertexValidation") << "distance: " << distance << "+/-" << dist_err << std::endl;
     // cut on the PV - SV distance
     if (distance * cmToum < maxSVdist_) {
       myCounts.eventsAfterDist++;
 
       double cosphi = (ZpT.x() * deltaVtx.x() + ZpT.y() * deltaVtx.y()) /
                       (sqrt(ZpT.x() * ZpT.x() + ZpT.y() * ZpT.y()) *
                        sqrt(deltaVtx.x() * deltaVtx.x() + deltaVtx.y() * deltaVtx.y()));
 
       double cosphi3D = (Zp.x() * deltaVtx.x() + Zp.y() * deltaVtx.y() + Zp.z() * deltaVtx.z()) /
                         (sqrt(Zp.x() * Zp.x() + Zp.y() * Zp.y() + Zp.z() * Zp.z()) *
                          sqrt(deltaVtx.x() * deltaVtx.x() + deltaVtx.y() * deltaVtx.y() + deltaVtx.z() * deltaVtx.z()));
 
       LogDebug("DiMuonVertexValidation") << "cos(phi) = " << cosphi << std::endl;
 
       hCosPhi_->Fill(cosphi);
       hCosPhi3D_->Fill(cosphi3D);
 
 #ifdef EDM_ML_DEBUG
       edm::LogVerbatim("DiMuonVertexValidation")
           << "distance " << distance * cmToum << " cosphi3D:" << cosphi3D << std::endl;
 #endif
 
       // unbalance
       hCosPhiUnbalance_->Fill(cosphi, 1.);
       hCosPhiUnbalance_->Fill(-cosphi, -1.);
       hCosPhi3DUnbalance_->Fill(cosphi3D, 1.);
       hCosPhi3DUnbalance_->Fill(-cosphi3D, -1.);
 
       // fill the cosphi plots
       CosPhiPlots.fillPlots(cosphi, tktk_p4);
 
       // fill the cosphi3D plots
       CosPhi3DPlots.fillPlots(cosphi3D, tktk_p4);
 
       // fill the cosphi3D plots in eta bins
       CosPhi3DInEtaBins.fillTH1Plots(cosphi3D, tktk_p4);
     }
   }
 }

◆ beginJob()

void DiMuonVertexValidation::beginJob ( )

overrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 542 of file DiMuonVertexValidation.cc.

References DiLeptonHelp::PlotsVsKinematics::bookFromPSet(), DiLeptonHelp::PlotsVsDiLeptonRegion::bookSet(), CosPhi3DConfiguration_, CosPhi3DInEtaBins, CosPhi3DPlots, CosPhiConfiguration_, CosPhiPlots, DiMuMassConfiguration_, compareTotals::fs, hCosPhi3D_, hCosPhi3DUnbalance_, hCosPhi_, hCosPhiInv3D_, hCosPhiInv_, hCosPhiUnbalance_, hCutFlow_, hdxy_, hdxyErr_, hdz_, hdzErr_, hInvMass_, hIP2d_, hIP2dsig_, hIP3d_, hIP3dsig_, hSVChi2_, hSVCompatibility3D_, hSVCompatibility_, hSVDist3D_, hSVDist3DErr_, hSVDist3DSig_, hSVDist_, hSVDistErr_, hSVDistSig_, hSVNormChi2_, hSVProb_, hTrackInvMass_, mps_fire::i, InvMassInEtaBins, SiStripPI::max, SiStripPI::min, motherName_, myCounts, names, AlCaHLTBitMon_QueryRunRegistry::string, VtxDist3DConfiguration_, VtxDist3DPlots, VtxDist3DSigConfiguration_, VtxDist3DSigPlots, VtxDistConfiguration_, VtxDistPlots, VtxDistSigConfiguration_, VtxDistSigPlots, VtxProbConfiguration_, VtxProbPlots, DiLeptonHelp::Counts::zeroAll(), and ZMassPlots.

                                       {
   edm::Service<TFileService> fs;
 
   // clang-format off
   TH1F::SetDefaultSumw2(kTRUE);
   hSVProb_ = fs->make<TH1F>("VtxProb", ";#mu^{+}#mu^{-} vertex probability;N(#mu#mu pairs)", 100, 0., 1.);
 
   auto extractRangeValues = [](const edm::ParameterSet& PSetConfiguration_) -> std::pair<double, double> {
     double min = PSetConfiguration_.getParameter<double>("ymin");
     double max = PSetConfiguration_.getParameter<double>("ymax");
     return {min, max};
   };
 
   std::string ts = fmt::sprintf(";%s vertex probability;N(#mu#mu pairs)", motherName_);
   std::string ps = "N(#mu#mu pairs)";
   ts = fmt::sprintf("#chi^{2} of the %s vertex; #chi^{2} of the %s vertex; %s", motherName_, motherName_, ps);
   hSVChi2_ = fs->make<TH1F>("VtxChi2", ts.c_str(), 200, 0., 200.);
 
   ts = fmt::sprintf("#chi^{2}/ndf of the %s vertex; #chi^{2}/ndf of %s vertex; %s", motherName_, motherName_, ps);
   hSVNormChi2_ = fs->make<TH1F>("VtxNormChi2", ts.c_str(), 100, 0., 20.);
 
   // take the range from the 2D histograms
   const auto& svDistRng = extractRangeValues(VtxDistConfiguration_);
   hSVDist_ = fs->make<TH1F>("VtxDist", ";PV-#mu^{+}#mu^{-} vertex xy distance [#mum];N(#mu#mu pairs)", 100, svDistRng.first, svDistRng.second);
 
   std::string histTit = motherName_ + " #rightarrow #mu^{+}#mu^{-}";
   ts = fmt::sprintf("%s;PV-%sV xy distance error [#mum];%s", histTit, motherName_, ps);
   hSVDistErr_ = fs->make<TH1F>("VtxDistErr", ts.c_str(), 100, 0., 1000.);
 
   // take the range from the 2D histograms
   const auto& svDistSigRng = extractRangeValues(VtxDistSigConfiguration_);
   hSVDistSig_ = fs->make<TH1F>("VtxDistSig", ";PV-#mu^{+}#mu^{-} vertex xy distance signficance;N(#mu#mu pairs)", 100, svDistSigRng.first, svDistSigRng.second);
 
   // take the range from the 2D histograms
   const auto& svDist3DRng = extractRangeValues(VtxDist3DConfiguration_);
   hSVDist3D_ = fs->make<TH1F>("VtxDist3D", ";PV-#mu^{+}#mu^{-} vertex 3D distance [#mum];N(#mu#mu pairs)", 100, svDist3DRng.first, svDist3DRng.second);
 
   ts = fmt::sprintf("%s;PV-%sV 3D distance error [#mum];%s", histTit, motherName_, ps);
   hSVDist3DErr_ = fs->make<TH1F>("VtxDist3DErr", ts.c_str(), 100, 0., 1000.);
 
   // take the range from the 2D histograms
   const auto& svDist3DSigRng = extractRangeValues(VtxDist3DSigConfiguration_);
   hSVDist3DSig_ = fs->make<TH1F>("VtxDist3DSig", ";PV-#mu^{+}#mu^{-} vertex 3D distance signficance;N(#mu#mu pairs)", 100, svDist3DSigRng.first, svDist3DSigRng.second);
 
   ts = fmt::sprintf("compatibility of %s vertex; compatibility of %s vertex; %s", motherName_, motherName_, ps);
   hSVCompatibility_ = fs->make<TH1F>("VtxCompatibility", ts.c_str(), 100, 0., 100.);
 
   ts = fmt::sprintf("3D compatibility of %s vertex;3D compatibility of %s vertex; %s", motherName_, motherName_, ps);
   hSVCompatibility3D_ = fs->make<TH1F>("VtxCompatibility3D", ts.c_str(), 100, 0., 100.);
 
   // take the range from the 2D histograms
   const auto& massRng = extractRangeValues(DiMuMassConfiguration_);
   hInvMass_ = fs->make<TH1F>("InvMass", ";M(#mu#mu) [GeV];N(#mu#mu pairs)", 70., massRng.first, massRng.second);
   hTrackInvMass_ = fs->make<TH1F>("TkTkInvMass", ";M(tk,tk) [GeV];N(tk tk pairs)", 70., massRng.first, massRng.second);
 
   hCosPhi_ = fs->make<TH1F>("CosPhi", ";cos(#phi_{xy});N(#mu#mu pairs)", 50, -1., 1.);
   hCosPhi3D_ = fs->make<TH1F>("CosPhi3D", ";cos(#phi_{3D});N(#mu#mu pairs)", 50, -1., 1.);
 
   hCosPhiInv_ = fs->make<TH1F>("CosPhiInv", ";inverted cos(#phi_{xy});N(#mu#mu pairs)", 50, -1., 1.);
   hCosPhiInv3D_ = fs->make<TH1F>("CosPhiInv3D", ";inverted cos(#phi_{3D});N(#mu#mu pairs)", 50, -1., 1.);
 
   hCosPhiUnbalance_ = fs->make<TH1F>("CosPhiUnbalance", fmt::sprintf("%s;cos(#phi_{xy}) unbalance;#Delta%s", histTit, ps).c_str(), 50, -1.,1.);
   hCosPhi3DUnbalance_ = fs->make<TH1F>("CosPhi3DUnbalance", fmt::sprintf("%s;cos(#phi_{3D}) unbalance;#Delta%s", histTit, ps).c_str(), 50, -1., 1.);
 
   hdxy_ = fs->make<TH1F>("dxy", fmt::sprintf("%s;muon track d_{xy}(PV) [#mum];muon tracks", histTit).c_str(), 150, -300, 300);
   hdz_ = fs->make<TH1F>("dz", fmt::sprintf("%s;muon track d_{z}(PV) [#mum];muon tracks", histTit).c_str(), 150, -300, 300);
   hdxyErr_ = fs->make<TH1F>("dxyErr", fmt::sprintf("%s;muon track err_{dxy} [#mum];muon tracks", histTit).c_str(), 250, 0., 500.);
   hdzErr_ = fs->make<TH1F>("dzErr", fmt::sprintf("%s;muon track err_{dz} [#mum];muon tracks", histTit).c_str(), 250, 0., 500.);
   hIP2d_ = fs->make<TH1F>("IP2d", fmt::sprintf("%s;muon track IP_{2D} [#mum];muon tracks", histTit).c_str(), 150, -300, 300);
   hIP3d_ = fs->make<TH1F>("IP3d", fmt::sprintf("%s;muon track IP_{3D} [#mum];muon tracks", histTit).c_str(), 150, -300, 300);
   hIP2dsig_ = fs->make<TH1F>("IP2Dsig", fmt::sprintf("%s;muon track IP_{2D} significance;muon tracks", histTit).c_str(), 100, 0., 5.);
   hIP3dsig_ = fs->make<TH1F>("IP3Dsig", fmt::sprintf("%s;muon track IP_{3D} significance;muon tracks", histTit).c_str(), 100, 0., 5.);
   // clang-format on
 
   // 2D Maps
 
   TFileDirectory dirCosPhi = fs->mkdir("CosPhiPlots");
   CosPhiPlots.bookFromPSet(dirCosPhi, CosPhiConfiguration_);
 
   TFileDirectory dirCosPhi3D = fs->mkdir("CosPhi3DPlots");
   CosPhi3DPlots.bookFromPSet(dirCosPhi3D, CosPhi3DConfiguration_);
 
   TFileDirectory dirVtxProb = fs->mkdir("VtxProbPlots");
   VtxProbPlots.bookFromPSet(dirVtxProb, VtxProbConfiguration_);
 
   TFileDirectory dirVtxDist = fs->mkdir("VtxDistPlots");
   VtxDistPlots.bookFromPSet(dirVtxDist, VtxDistConfiguration_);
 
   TFileDirectory dirVtxDist3D = fs->mkdir("VtxDist3DPlots");
   VtxDist3DPlots.bookFromPSet(dirVtxDist3D, VtxDist3DConfiguration_);
 
   TFileDirectory dirVtxDistSig = fs->mkdir("VtxDistSigPlots");
   VtxDistSigPlots.bookFromPSet(dirVtxDistSig, VtxDistSigConfiguration_);
 
   TFileDirectory dirVtxDist3DSig = fs->mkdir("VtxDist3DSigPlots");
   VtxDist3DSigPlots.bookFromPSet(dirVtxDist3DSig, VtxDist3DSigConfiguration_);
 
   TFileDirectory dirInvariantMass = fs->mkdir("InvariantMassPlots");
   ZMassPlots.bookFromPSet(dirInvariantMass, DiMuMassConfiguration_);
 
   // CosPhi3D in eta bins
   TFileDirectory dirCosphi3DEta = fs->mkdir("CosPhi3DInEtaBins");
   CosPhi3DInEtaBins.bookSet(dirCosphi3DEta, hCosPhi3D_);
 
   // Z-> mm mass in eta bins
   TFileDirectory dirResMassEta = fs->mkdir("TkTkMassInEtaBins");
   InvMassInEtaBins.bookSet(dirResMassEta, hTrackInvMass_);
 
   // cut flow
 
   hCutFlow_ = fs->make<TH1F>("hCutFlow", "cut flow;cut step;events left", 6, -0.5, 5.5);
   std::string names[6] = {"Total", "Mult.", ">pT", "<eta", "hasVtx", "VtxDist"};
   for (unsigned int i = 0; i < 6; i++) {
     hCutFlow_->GetXaxis()->SetBinLabel(i + 1, names[i].c_str());
   }
 
   myCounts.zeroAll();
 }

◆ endJob()

void DiMuonVertexValidation::endJob ( void )

overrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 662 of file DiMuonVertexValidation.cc.

References DiLeptonHelp::Counts::eventsAfterDist, DiLeptonHelp::Counts::eventsAfterEta, DiLeptonHelp::Counts::eventsAfterMult, DiLeptonHelp::Counts::eventsAfterPt, DiLeptonHelp::Counts::eventsAfterVtx, DiLeptonHelp::Counts::eventsTotal, hCosPhi3D_, hCosPhi_, hCosPhiInv3D_, hCosPhiInv_, hCutFlow_, mps_fire::i, myCounts, and DiLeptonHelp::Counts::printCounts().

Referenced by o2olib.O2ORunMgr::executeJob().

                                     {
   myCounts.printCounts();
 
   hCutFlow_->SetBinContent(1, myCounts.eventsTotal);
   hCutFlow_->SetBinContent(2, myCounts.eventsAfterMult);
   hCutFlow_->SetBinContent(3, myCounts.eventsAfterPt);
   hCutFlow_->SetBinContent(4, myCounts.eventsAfterEta);
   hCutFlow_->SetBinContent(5, myCounts.eventsAfterVtx);
   hCutFlow_->SetBinContent(6, myCounts.eventsAfterDist);
 
   TH1F::SetDefaultSumw2(kTRUE);
   const unsigned int nBinsX = hCosPhi_->GetNbinsX();
   for (unsigned int i = 1; i <= nBinsX; i++) {
     //float binContent = hCosPhi_->GetBinContent(i);
     float invertedBinContent = hCosPhi_->GetBinContent(nBinsX + 1 - i);
     float invertedBinError = hCosPhi_->GetBinError(nBinsX + 1 - i);
     hCosPhiInv_->SetBinContent(i, invertedBinContent);
     hCosPhiInv_->SetBinError(i, invertedBinError);
 
     //float binContent3D = hCosPhi3D_->GetBinContent(i);
     float invertedBinContent3D = hCosPhi3D_->GetBinContent(nBinsX + 1 - i);
     float invertedBinError3D = hCosPhi3D_->GetBinError(nBinsX + 1 - i);
     hCosPhiInv3D_->SetBinContent(i, invertedBinContent3D);
     hCosPhiInv3D_->SetBinError(i, invertedBinError3D);
   }
 }

◆ fillDescriptions()

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

static

Definition at line 719 of file DiMuonVertexValidation.cc.

References edm::ParameterSetDescription::add(), edm::ConfigurationDescriptions::addWithDefaultLabel(), submitPVResolutionJobs::desc, ProducerED_cfi::InputTag, or, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                         {
   edm::ParameterSetDescription desc;
   desc.ifValue(edm::ParameterDescription<bool>("useReco", true, true),
                true >> edm::ParameterDescription<edm::InputTag>("muons", edm::InputTag("muons"), true) or
                    false >> edm::ParameterDescription<edm::InputTag>(
                                 "muonTracks", edm::InputTag("ALCARECOTkAlDiMuon"), true))
       ->setComment("If useReco is true need to specify the muon tracks, otherwise take the ALCARECO Inner tracks");
   //desc.add<bool>("useReco",true);
   //desc.add<edm::InputTag>("muons", edm::InputTag("muons"));
   //desc.add<edm::InputTag>("muonTracks", edm::InputTag("ALCARECOTkAlDiMuon"));
   desc.add<std::string>("decayMotherName", "Z");
   desc.add<edm::InputTag>("tracks", edm::InputTag("generalTracks"));
   desc.add<edm::InputTag>("vertices", edm::InputTag("offlinePrimaryVertices"));
   desc.add<std::vector<double>>("pTThresholds", {30., 10.});
   desc.add<bool>("useClosestVertex", true);
   desc.add<double>("maxSVdist", 50.);
 
   {
     edm::ParameterSetDescription psDiMuMass;
     psDiMuMass.add<std::string>("name", "DiMuMass");
     psDiMuMass.add<std::string>("title", "M(#mu#mu)");
     psDiMuMass.add<std::string>("yUnits", "[GeV]");
     psDiMuMass.add<int>("NxBins", 24);
     psDiMuMass.add<int>("NyBins", 50);
     psDiMuMass.add<double>("ymin", 70.);
     psDiMuMass.add<double>("ymax", 120.);
     desc.add<edm::ParameterSetDescription>("DiMuMassConfig", psDiMuMass);
   }
   {
     edm::ParameterSetDescription psCosPhi;
     psCosPhi.add<std::string>("name", "CosPhi");
     psCosPhi.add<std::string>("title", "cos(#phi_{xy})");
     psCosPhi.add<std::string>("yUnits", "");
     psCosPhi.add<int>("NxBins", 50);
     psCosPhi.add<int>("NyBins", 50);
     psCosPhi.add<double>("ymin", -1.);
     psCosPhi.add<double>("ymax", 1.);
     desc.add<edm::ParameterSetDescription>("CosPhiConfig", psCosPhi);
   }
   {
     edm::ParameterSetDescription psCosPhi3D;
     psCosPhi3D.add<std::string>("name", "CosPhi3D");
     psCosPhi3D.add<std::string>("title", "cos(#phi_{3D})");
     psCosPhi3D.add<std::string>("yUnits", "");
     psCosPhi3D.add<int>("NxBins", 50);
     psCosPhi3D.add<int>("NyBins", 50);
     psCosPhi3D.add<double>("ymin", -1.);
     psCosPhi3D.add<double>("ymax", 1.);
     desc.add<edm::ParameterSetDescription>("CosPhi3DConfig", psCosPhi3D);
   }
   {
     edm::ParameterSetDescription psVtxProb;
     psVtxProb.add<std::string>("name", "VtxProb");
     psVtxProb.add<std::string>("title", "Prob(#chi^{2}_{SV})");
     psVtxProb.add<std::string>("yUnits", "");
     psVtxProb.add<int>("NxBins", 50);
     psVtxProb.add<int>("NyBins", 50);
     psVtxProb.add<double>("ymin", 0);
     psVtxProb.add<double>("ymax", 1.);
     desc.add<edm::ParameterSetDescription>("VtxProbConfig", psVtxProb);
   }
   {
     edm::ParameterSetDescription psVtxDist;
     psVtxDist.add<std::string>("name", "VtxDist");
     psVtxDist.add<std::string>("title", "d_{xy}(PV,SV)");
     psVtxDist.add<std::string>("yUnits", "[#mum]");
     psVtxDist.add<int>("NxBins", 50);
     psVtxDist.add<int>("NyBins", 100);
     psVtxDist.add<double>("ymin", 0);
     psVtxDist.add<double>("ymax", 300.);
     desc.add<edm::ParameterSetDescription>("VtxDistConfig", psVtxDist);
   }
   {
     edm::ParameterSetDescription psVtxDist3D;
     psVtxDist3D.add<std::string>("name", "VtxDist3D");
     psVtxDist3D.add<std::string>("title", "d_{3D}(PV,SV)");
     psVtxDist3D.add<std::string>("yUnits", "[#mum]");
     psVtxDist3D.add<int>("NxBins", 50);
     psVtxDist3D.add<int>("NyBins", 250);
     psVtxDist3D.add<double>("ymin", 0);
     psVtxDist3D.add<double>("ymax", 500.);
     desc.add<edm::ParameterSetDescription>("VtxDist3DConfig", psVtxDist3D);
   }
   {
     edm::ParameterSetDescription psVtxDistSig;
     psVtxDistSig.add<std::string>("name", "VtxDistSig");
     psVtxDistSig.add<std::string>("title", "d_{xy}(PV,SV)/#sigma_{dxy}(PV,SV)");
     psVtxDistSig.add<std::string>("yUnits", "");
     psVtxDistSig.add<int>("NxBins", 50);
     psVtxDistSig.add<int>("NyBins", 100);
     psVtxDistSig.add<double>("ymin", 0);
     psVtxDistSig.add<double>("ymax", 5.);
     desc.add<edm::ParameterSetDescription>("VtxDistSigConfig", psVtxDistSig);
   }
   {
     edm::ParameterSetDescription psVtxDist3DSig;
     psVtxDist3DSig.add<std::string>("name", "VtxDist3DSig");
     psVtxDist3DSig.add<std::string>("title", "d_{3D}(PV,SV)/#sigma_{d3D}(PV,SV)");
     psVtxDist3DSig.add<std::string>("yUnits", "");
     psVtxDist3DSig.add<int>("NxBins", 50);
     psVtxDist3DSig.add<int>("NyBins", 100);
     psVtxDist3DSig.add<double>("ymin", 0);
     psVtxDist3DSig.add<double>("ymax", 5.);
     desc.add<edm::ParameterSetDescription>("VtxDist3DSigConfig", psVtxDist3DSig);
   }
 
   descriptions.addWithDefaultLabel(desc);
 }

◆ findClosestVertex()

const reco::Vertex * DiMuonVertexValidation::findClosestVertex	(	const TransientVertex	aTransVtx,
		const reco::VertexCollection *	vertices
	)		const

private

Definition at line 690 of file DiMuonVertexValidation.cc.

References counter, VertexDistance3D::distance(), TransientVertex::isValid(), Measurement1D::value(), AlignmentTracksFromVertexSelector_cfi::vertices, and L1BJetProducer_cff::vtx.

Referenced by analyze().

                                                                                                           {
   reco::Vertex* defaultVtx = nullptr;
 
   if (!aTransVtx.isValid())
     return defaultVtx;
 
   // find the closest vertex to the secondary vertex in 3D
   VertexDistance3D vertTool3D;
   float minD = 9999.;
   int closestVtxIndex = 0;
   int counter = 0;
   for (const auto& vtx : *vertices) {
     double dist3D = vertTool3D.distance(aTransVtx, vtx).value();
     if (dist3D < minD) {
       minD = dist3D;
       closestVtxIndex = counter;
     }
     counter++;
   }
 
   if ((*vertices).at(closestVtxIndex).isValid()) {
     return &(vertices->at(closestVtxIndex));
   } else {
     return defaultVtx;
   }
 }

Member Data Documentation

◆ alcaRecoToken_

edm::EDGetTokenT<reco::TrackCollection> DiMuonVertexValidation::alcaRecoToken_

private

Definition at line 160 of file DiMuonVertexValidation.cc.

Referenced by analyze(), and DiMuonVertexValidation().

◆ CosPhi3DConfiguration_

const edm::ParameterSet DiMuonVertexValidation::CosPhi3DConfiguration_

private

Definition at line 91 of file DiMuonVertexValidation.cc.

Referenced by beginJob().

◆ CosPhi3DInEtaBins

DiLeptonHelp::PlotsVsDiLeptonRegion DiMuonVertexValidation::CosPhi3DInEtaBins = DiLeptonHelp::PlotsVsDiLeptonRegion(1.5)

private

Definition at line 148 of file DiMuonVertexValidation.cc.

Referenced by analyze(), and beginJob().

◆ CosPhi3DPlots

DiLeptonHelp::PlotsVsKinematics DiMuonVertexValidation::CosPhi3DPlots = DiLeptonHelp::PlotsVsKinematics(DiLeptonHelp::MM)

private

Definition at line 139 of file DiMuonVertexValidation.cc.

Referenced by analyze(), and beginJob().

◆ CosPhiConfiguration_

const edm::ParameterSet DiMuonVertexValidation::CosPhiConfiguration_

private

Definition at line 90 of file DiMuonVertexValidation.cc.

Referenced by beginJob().

◆ CosPhiPlots

DiLeptonHelp::PlotsVsKinematics DiMuonVertexValidation::CosPhiPlots = DiLeptonHelp::PlotsVsKinematics(DiLeptonHelp::MM)

private

Definition at line 138 of file DiMuonVertexValidation.cc.

Referenced by analyze(), and beginJob().

◆ DiMuMassConfiguration_

const edm::ParameterSet DiMuonVertexValidation::DiMuMassConfiguration_

private

Definition at line 97 of file DiMuonVertexValidation.cc.

Referenced by beginJob().

◆ hCosPhi3D_

TH1F* DiMuonVertexValidation::hCosPhi3D_

private

Definition at line 115 of file DiMuonVertexValidation.cc.

Referenced by analyze(), beginJob(), and endJob().

◆ hCosPhi3DUnbalance_

TH1F* DiMuonVertexValidation::hCosPhi3DUnbalance_

private

Definition at line 119 of file DiMuonVertexValidation.cc.

Referenced by analyze(), and beginJob().

◆ hCosPhi_

TH1F* DiMuonVertexValidation::hCosPhi_

private

Definition at line 114 of file DiMuonVertexValidation.cc.

Referenced by analyze(), beginJob(), and endJob().

◆ hCosPhiInv3D_

TH1F* DiMuonVertexValidation::hCosPhiInv3D_

private

Definition at line 117 of file DiMuonVertexValidation.cc.

Referenced by beginJob(), and endJob().

◆ hCosPhiInv_

TH1F* DiMuonVertexValidation::hCosPhiInv_

private

Definition at line 116 of file DiMuonVertexValidation.cc.

Referenced by beginJob(), and endJob().

◆ hCosPhiUnbalance_

TH1F* DiMuonVertexValidation::hCosPhiUnbalance_

private

Definition at line 118 of file DiMuonVertexValidation.cc.

Referenced by analyze(), and beginJob().

◆ hCutFlow_

TH1F* DiMuonVertexValidation::hCutFlow_

private

Definition at line 124 of file DiMuonVertexValidation.cc.

Referenced by beginJob(), and endJob().

◆ hdxy_

TH1F* DiMuonVertexValidation::hdxy_

private

Definition at line 127 of file DiMuonVertexValidation.cc.

Referenced by analyze(), and beginJob().

◆ hdxyErr_

TH1F* DiMuonVertexValidation::hdxyErr_

private

Definition at line 129 of file DiMuonVertexValidation.cc.

Referenced by analyze(), and beginJob().

◆ hdz_

TH1F* DiMuonVertexValidation::hdz_

private

Definition at line 128 of file DiMuonVertexValidation.cc.

Referenced by analyze(), and beginJob().

◆ hdzErr_

TH1F* DiMuonVertexValidation::hdzErr_

private

Definition at line 130 of file DiMuonVertexValidation.cc.

Referenced by analyze(), and beginJob().

◆ hInvMass_

TH1F* DiMuonVertexValidation::hInvMass_

private

Definition at line 121 of file DiMuonVertexValidation.cc.

Referenced by analyze(), and beginJob().

◆ hIP2d_

TH1F* DiMuonVertexValidation::hIP2d_

private

Definition at line 131 of file DiMuonVertexValidation.cc.

Referenced by analyze(), and beginJob().

◆ hIP2dsig_

TH1F* DiMuonVertexValidation::hIP2dsig_

private

Definition at line 133 of file DiMuonVertexValidation.cc.

Referenced by analyze(), and beginJob().

◆ hIP3d_

TH1F* DiMuonVertexValidation::hIP3d_

private

Definition at line 132 of file DiMuonVertexValidation.cc.

Referenced by analyze(), and beginJob().

◆ hIP3dsig_

TH1F* DiMuonVertexValidation::hIP3dsig_

private

Definition at line 134 of file DiMuonVertexValidation.cc.

Referenced by analyze(), and beginJob().

◆ hSVChi2_

TH1F* DiMuonVertexValidation::hSVChi2_

private

Definition at line 101 of file DiMuonVertexValidation.cc.

Referenced by analyze(), and beginJob().

◆ hSVCompatibility3D_

TH1F* DiMuonVertexValidation::hSVCompatibility3D_

private

Definition at line 112 of file DiMuonVertexValidation.cc.

Referenced by analyze(), and beginJob().

◆ hSVCompatibility_

TH1F* DiMuonVertexValidation::hSVCompatibility_

private

Definition at line 107 of file DiMuonVertexValidation.cc.

Referenced by analyze(), and beginJob().

◆ hSVDist3D_

TH1F* DiMuonVertexValidation::hSVDist3D_

private

Definition at line 109 of file DiMuonVertexValidation.cc.

Referenced by analyze(), and beginJob().

◆ hSVDist3DErr_

TH1F* DiMuonVertexValidation::hSVDist3DErr_

private

Definition at line 110 of file DiMuonVertexValidation.cc.

Referenced by analyze(), and beginJob().

◆ hSVDist3DSig_

TH1F* DiMuonVertexValidation::hSVDist3DSig_

private

Definition at line 111 of file DiMuonVertexValidation.cc.

Referenced by analyze(), and beginJob().

◆ hSVDist_

TH1F* DiMuonVertexValidation::hSVDist_

private

Definition at line 104 of file DiMuonVertexValidation.cc.

Referenced by analyze(), and beginJob().

◆ hSVDistErr_

TH1F* DiMuonVertexValidation::hSVDistErr_

private

Definition at line 105 of file DiMuonVertexValidation.cc.

Referenced by analyze(), and beginJob().

◆ hSVDistSig_

TH1F* DiMuonVertexValidation::hSVDistSig_

private

Definition at line 106 of file DiMuonVertexValidation.cc.

Referenced by analyze(), and beginJob().

◆ hSVNormChi2_

TH1F* DiMuonVertexValidation::hSVNormChi2_

private

Definition at line 102 of file DiMuonVertexValidation.cc.

Referenced by analyze(), and beginJob().

◆ hSVProb_

TH1F* DiMuonVertexValidation::hSVProb_

private

Definition at line 100 of file DiMuonVertexValidation.cc.

Referenced by analyze(), and beginJob().

◆ hTrackInvMass_

TH1F* DiMuonVertexValidation::hTrackInvMass_

private

Definition at line 122 of file DiMuonVertexValidation.cc.

Referenced by analyze(), and beginJob().

◆ InvMassInEtaBins

DiLeptonHelp::PlotsVsDiLeptonRegion DiMuonVertexValidation::InvMassInEtaBins = DiLeptonHelp::PlotsVsDiLeptonRegion(1.5)

private

Definition at line 149 of file DiMuonVertexValidation.cc.

Referenced by analyze(), and beginJob().

◆ massLimits_

std::pair<float, float> DiMuonVertexValidation::massLimits_

private

Definition at line 85 of file DiMuonVertexValidation.cc.

Referenced by DiMuonVertexValidation().

◆ maxSVdist_

const float DiMuonVertexValidation::maxSVdist_

private

Definition at line 87 of file DiMuonVertexValidation.cc.

Referenced by analyze(), and DiMuonVertexValidation().

◆ motherName_

const std::string DiMuonVertexValidation::motherName_

private

Definition at line 82 of file DiMuonVertexValidation.cc.

Referenced by beginJob(), and DiMuonVertexValidation().

◆ muonsToken_

edm::EDGetTokenT<reco::MuonCollection> DiMuonVertexValidation::muonsToken_

private

Definition at line 159 of file DiMuonVertexValidation.cc.

Referenced by analyze(), and DiMuonVertexValidation().

◆ myCounts

DiLeptonHelp::Counts DiMuonVertexValidation::myCounts

private

Definition at line 80 of file DiMuonVertexValidation.cc.

Referenced by analyze(), beginJob(), and endJob().

◆ pTthresholds_

std::vector<double> DiMuonVertexValidation::pTthresholds_

private

Definition at line 86 of file DiMuonVertexValidation.cc.

Referenced by analyze(), and DiMuonVertexValidation().

◆ tracksToken_

edm::EDGetTokenT<reco::TrackCollection> DiMuonVertexValidation::tracksToken_

private

Definition at line 154 of file DiMuonVertexValidation.cc.

Referenced by analyze(), and DiMuonVertexValidation().

◆ ttbESToken_

const edm::ESGetToken<TransientTrackBuilder, TransientTrackRecord> DiMuonVertexValidation::ttbESToken_

private

Definition at line 151 of file DiMuonVertexValidation.cc.

Referenced by analyze().

◆ useClosestVertex_

const bool DiMuonVertexValidation::useClosestVertex_

private

Definition at line 84 of file DiMuonVertexValidation.cc.

Referenced by analyze().

◆ useReco_

const bool DiMuonVertexValidation::useReco_

private

Definition at line 83 of file DiMuonVertexValidation.cc.

Referenced by analyze(), and DiMuonVertexValidation().

◆ vertexToken_

const edm::EDGetTokenT<reco::VertexCollection> DiMuonVertexValidation::vertexToken_

private

Definition at line 156 of file DiMuonVertexValidation.cc.

Referenced by analyze().

◆ VtxDist3DConfiguration_

const edm::ParameterSet DiMuonVertexValidation::VtxDist3DConfiguration_

private

Definition at line 94 of file DiMuonVertexValidation.cc.

Referenced by beginJob().

◆ VtxDist3DPlots

DiLeptonHelp::PlotsVsKinematics DiMuonVertexValidation::VtxDist3DPlots = DiLeptonHelp::PlotsVsKinematics(DiLeptonHelp::MM)

private

Definition at line 142 of file DiMuonVertexValidation.cc.

Referenced by analyze(), and beginJob().

◆ VtxDist3DSigConfiguration_

const edm::ParameterSet DiMuonVertexValidation::VtxDist3DSigConfiguration_

private

Definition at line 96 of file DiMuonVertexValidation.cc.

Referenced by beginJob().

◆ VtxDist3DSigPlots

DiLeptonHelp::PlotsVsKinematics DiMuonVertexValidation::VtxDist3DSigPlots = DiLeptonHelp::PlotsVsKinematics(DiLeptonHelp::MM)

private

Definition at line 144 of file DiMuonVertexValidation.cc.

Referenced by analyze(), and beginJob().

◆ VtxDistConfiguration_

const edm::ParameterSet DiMuonVertexValidation::VtxDistConfiguration_

private

Definition at line 93 of file DiMuonVertexValidation.cc.

Referenced by beginJob().

◆ VtxDistPlots

DiLeptonHelp::PlotsVsKinematics DiMuonVertexValidation::VtxDistPlots = DiLeptonHelp::PlotsVsKinematics(DiLeptonHelp::MM)

private

Definition at line 141 of file DiMuonVertexValidation.cc.

Referenced by analyze(), and beginJob().

◆ VtxDistSigConfiguration_

const edm::ParameterSet DiMuonVertexValidation::VtxDistSigConfiguration_

private

Definition at line 95 of file DiMuonVertexValidation.cc.

Referenced by beginJob().

◆ VtxDistSigPlots

DiLeptonHelp::PlotsVsKinematics DiMuonVertexValidation::VtxDistSigPlots = DiLeptonHelp::PlotsVsKinematics(DiLeptonHelp::MM)

private

Definition at line 143 of file DiMuonVertexValidation.cc.

Referenced by analyze(), and beginJob().

◆ VtxProbConfiguration_

const edm::ParameterSet DiMuonVertexValidation::VtxProbConfiguration_

private

Definition at line 92 of file DiMuonVertexValidation.cc.

Referenced by beginJob().

◆ VtxProbPlots

DiLeptonHelp::PlotsVsKinematics DiMuonVertexValidation::VtxProbPlots = DiLeptonHelp::PlotsVsKinematics(DiLeptonHelp::MM)

private

Definition at line 140 of file DiMuonVertexValidation.cc.

Referenced by analyze(), and beginJob().

◆ ZMassPlots

DiLeptonHelp::PlotsVsKinematics DiMuonVertexValidation::ZMassPlots = DiLeptonHelp::PlotsVsKinematics(DiLeptonHelp::MM)

private

Definition at line 145 of file DiMuonVertexValidation.cc.

Referenced by analyze(), and beginJob().

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ DiMuonVertexValidation()

◆ ~DiMuonVertexValidation()

Member Function Documentation

◆ analyze()

◆ beginJob()

◆ endJob()

◆ fillDescriptions()

◆ findClosestVertex()

Member Data Documentation

◆ alcaRecoToken_

◆ CosPhi3DConfiguration_

◆ CosPhi3DInEtaBins

◆ CosPhi3DPlots

◆ CosPhiConfiguration_

◆ CosPhiPlots

◆ DiMuMassConfiguration_

◆ hCosPhi3D_

◆ hCosPhi3DUnbalance_

◆ hCosPhi_

◆ hCosPhiInv3D_

◆ hCosPhiInv_

◆ hCosPhiUnbalance_

◆ hCutFlow_

◆ hdxy_

◆ hdxyErr_

◆ hdz_

◆ hdzErr_

◆ hInvMass_

◆ hIP2d_

◆ hIP2dsig_

◆ hIP3d_

◆ hIP3dsig_

◆ hSVChi2_

◆ hSVCompatibility3D_

◆ hSVCompatibility_

◆ hSVDist3D_

◆ hSVDist3DErr_

◆ hSVDist3DSig_

◆ hSVDist_

◆ hSVDistErr_

◆ hSVDistSig_

◆ hSVNormChi2_

◆ hSVProb_

◆ hTrackInvMass_

◆ InvMassInEtaBins

◆ massLimits_

◆ maxSVdist_

◆ motherName_

◆ muonsToken_

◆ myCounts

◆ pTthresholds_

◆ tracksToken_

◆ ttbESToken_

◆ useClosestVertex_

◆ useReco_

◆ vertexToken_

◆ VtxDist3DConfiguration_

◆ VtxDist3DPlots

◆ VtxDist3DSigConfiguration_

◆ VtxDist3DSigPlots

◆ VtxDistConfiguration_

◆ VtxDistPlots

◆ VtxDistSigConfiguration_

◆ VtxDistSigPlots

◆ VtxProbConfiguration_

◆ VtxProbPlots

◆ ZMassPlots