DiMuonVertexValidation Class Reference

#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_
edm::ParameterSet	CosPhi3DConfiguration_
DiLeptonHelp::PlotsVsKinematics	CosPhi3DPlots = DiLeptonHelp::PlotsVsKinematics(DiLeptonHelp::MM)
edm::ParameterSet	CosPhiConfiguration_
DiLeptonHelp::PlotsVsKinematics	CosPhiPlots = DiLeptonHelp::PlotsVsKinematics(DiLeptonHelp::MM)
edm::ParameterSet	DiMuMassConfiguration_
TH1F *	hCosPhi3D_
TH1F *	hCosPhi_
TH1F *	hCosPhiInv3D_
TH1F *	hCosPhiInv_
TH1F *	hCutFlow_
TH1F *	hInvMass_
TH1F *	hSVDist3D_
TH1F *	hSVDist3DSig_
TH1F *	hSVDist_
TH1F *	hSVDistSig_
TH1F *	hSVProb_
TH1F *	hTrackInvMass_
float	maxSVdist_
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_
edm::EDGetTokenT< reco::VertexCollection >	vertexToken_
edm::ParameterSet	VtxDist3DConfiguration_
DiLeptonHelp::PlotsVsKinematics	VtxDist3DPlots = DiLeptonHelp::PlotsVsKinematics(DiLeptonHelp::MM)
edm::ParameterSet	VtxDist3DSigConfiguration_
DiLeptonHelp::PlotsVsKinematics	VtxDist3DSigPlots = DiLeptonHelp::PlotsVsKinematics(DiLeptonHelp::MM)
edm::ParameterSet	VtxDistConfiguration_
DiLeptonHelp::PlotsVsKinematics	VtxDistPlots = DiLeptonHelp::PlotsVsKinematics(DiLeptonHelp::MM)
edm::ParameterSet	VtxDistSigConfiguration_
DiLeptonHelp::PlotsVsKinematics	VtxDistSigPlots = DiLeptonHelp::PlotsVsKinematics(DiLeptonHelp::MM)
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 63 of file DiMuonVertexValidation.cc.

Constructor & Destructor Documentation

DiMuonVertexValidation()

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

explicit

Definition at line 149 of file DiMuonVertexValidation.cc.

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

    : 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"))),
      tracksToken_(consumes<reco::TrackCollection>(iConfig.getParameter<edm::InputTag>("tracks"))),
      vertexToken_(consumes<reco::VertexCollection>(iConfig.getParameter<edm::InputTag>("vertices"))) {
  if (useReco_) {
    muonsToken_ = mayConsume<reco::MuonCollection>(iConfig.getParameter<edm::InputTag>("muons"));
  } else {
    alcaRecoToken_ = mayConsume<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_ << " ";
}

~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 190 of file DiMuonVertexValidation.cc.

References alcaRecoToken_, TransientTrackBuilder::build(), ALCARECOTkAlJpsiMuMu_cff::charge, cmToum, CosPhi3DPlots, CosPhiPlots, TransientVertex::degreesOfFreedom(), PbPb_ZMuSkimMuonDPG_cff::deltaR, VertexDistanceXY::distance(), VertexDistance3D::distance(), HLT_2023v12_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(), findClosestVertex(), edm::EventSetup::getData(), hCosPhi3D_, hCosPhi_, reco::TrackBase::highPurity, hInvMass_, hSVDist3D_, hSVDist3DSig_, hSVDist_, hSVDistSig_, hSVProb_, hTrackInvMass_, mps_fire::i, iEvent, createfilelist::int, edm::HandleBase::isValid(), reco::Vertex::isValid(), TransientVertex::isValid(), LogDebug, maxSVdist_, mumass2, muonsToken_, myCounts, reco::Vertex::position(), TransientVertex::position(), edm::Handle< T >::product(), DiDispStaMuonMonitor_cfi::pt, reco::LeafCandidate::pt(), pTthresholds_, jetUpdater_cfi::sort, mathSSE::sqrt(), submitPVValidationJobs::t, FrontierCondition_GT_autoExpress_cfi::t0, RandomServiceHelper::t1, to_string(), TransientVertex::totalChiSquared(), HLT_2023v12_cff::track, tracksToken_, ttbESToken_, useClosestVertex_, useReco_, Measurement1D::value(), trackerHitRTTI::vector, KalmanVertexFitter::vertex(), vertexToken_, AlignmentTracksFromVertexSelector_cfi::vertices, VtxDist3DPlots, VtxDist3DSigPlots, VtxDistPlots, VtxDistSigPlots, VtxProbPlots, 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);

  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);

  if (!aTransientVertex.isValid())
    return;

  myCounts.eventsAfterVtx++;

  // fill the VtxProb plots
  VtxProbPlots.fillPlots(SVProb, tktk_p4);

  math::XYZPoint MainVertex(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;
  }

  MainVertex.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(
      MainVertex.x() - myVertex.x(), MainVertex.y() - myVertex.y(), MainVertex.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()) {
    // Z Vertex distance in the xy plane

    VertexDistanceXY vertTool;
    double distance = vertTool.distance(aTransientVertex, TheMainVertex).value();
    double dist_err = vertTool.distance(aTransientVertex, TheMainVertex).error();

    hSVDist_->Fill(distance * 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();

    hSVDist3D_->Fill(distance3D * 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

      // fill the cosphi plots
      CosPhiPlots.fillPlots(cosphi, tktk_p4);

      // fill the VtxDisSig plots
      CosPhi3DPlots.fillPlots(cosphi3D, tktk_p4);
    }
  }
}

beginJob()

void DiMuonVertexValidation::beginJob ( )

overrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 447 of file DiMuonVertexValidation.cc.

References DiLeptonHelp::PlotsVsKinematics::bookFromPSet(), CosPhi3DConfiguration_, CosPhi3DPlots, CosPhiConfiguration_, CosPhiPlots, DiMuMassConfiguration_, compareTotals::fs, hCosPhi3D_, hCosPhi_, hCosPhiInv3D_, hCosPhiInv_, hCutFlow_, hInvMass_, hSVDist3D_, hSVDist3DSig_, hSVDist_, hSVDistSig_, hSVProb_, hTrackInvMass_, mps_fire::i, 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", ";ZV vertex probability;N(#mu#mu pairs)", 100, 0., 1.);

  hSVDist_ = fs->make<TH1F>("VtxDist", ";PV-ZV xy distance [#mum];N(#mu#mu pairs)", 100, 0., 300.);
  hSVDistSig_ = fs->make<TH1F>("VtxDistSig", ";PV-ZV xy distance signficance;N(#mu#mu pairs)", 100, 0., 5.);

  hSVDist3D_ = fs->make<TH1F>("VtxDist3D", ";PV-ZV 3D distance [#mum];N(#mu#mu pairs)", 100, 0., 300.);
  hSVDist3DSig_ = fs->make<TH1F>("VtxDist3DSig", ";PV-ZV 3D distance signficance;N(#mu#mu pairs)", 100, 0., 5.);

  hInvMass_ = fs->make<TH1F>("InvMass", ";M(#mu#mu) [GeV];N(#mu#mu pairs)", 70., 50., 120.);
  hTrackInvMass_ = fs->make<TH1F>("TkTkInvMass", ";M(tk,tk) [GeV];N(tk tk pairs)", 70., 50., 120.);

  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.);
  // 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_);

  // 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 508 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 565 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<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 536 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 132 of file DiMuonVertexValidation.cc.

Referenced by analyze(), and DiMuonVertexValidation().

CosPhi3DConfiguration_

edm::ParameterSet DiMuonVertexValidation::CosPhi3DConfiguration_

private

Definition at line 87 of file DiMuonVertexValidation.cc.

Referenced by beginJob().

CosPhi3DPlots

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

private

Definition at line 116 of file DiMuonVertexValidation.cc.

Referenced by analyze(), and beginJob().

CosPhiConfiguration_

edm::ParameterSet DiMuonVertexValidation::CosPhiConfiguration_

private

Definition at line 86 of file DiMuonVertexValidation.cc.

Referenced by beginJob().

CosPhiPlots

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

private

Definition at line 115 of file DiMuonVertexValidation.cc.

Referenced by analyze(), and beginJob().

DiMuMassConfiguration_

edm::ParameterSet DiMuonVertexValidation::DiMuMassConfiguration_

private

Definition at line 93 of file DiMuonVertexValidation.cc.

Referenced by beginJob().

hCosPhi3D_

TH1F* DiMuonVertexValidation::hCosPhi3D_

private

Definition at line 104 of file DiMuonVertexValidation.cc.

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

hCosPhi_

TH1F* DiMuonVertexValidation::hCosPhi_

private

Definition at line 103 of file DiMuonVertexValidation.cc.

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

hCosPhiInv3D_

TH1F* DiMuonVertexValidation::hCosPhiInv3D_

private

Definition at line 106 of file DiMuonVertexValidation.cc.

Referenced by beginJob(), and endJob().

hCosPhiInv_

TH1F* DiMuonVertexValidation::hCosPhiInv_

private

Definition at line 105 of file DiMuonVertexValidation.cc.

Referenced by beginJob(), and endJob().

hCutFlow_

TH1F* DiMuonVertexValidation::hCutFlow_

private

Definition at line 111 of file DiMuonVertexValidation.cc.

Referenced by beginJob(), and endJob().

hInvMass_

TH1F* DiMuonVertexValidation::hInvMass_

private

Definition at line 108 of file DiMuonVertexValidation.cc.

Referenced by analyze(), and beginJob().

hSVDist3D_

TH1F* DiMuonVertexValidation::hSVDist3D_

private

Definition at line 100 of file DiMuonVertexValidation.cc.

Referenced by analyze(), and beginJob().

hSVDist3DSig_

TH1F* DiMuonVertexValidation::hSVDist3DSig_

private

Definition at line 101 of file DiMuonVertexValidation.cc.

Referenced by analyze(), and beginJob().

hSVDist_

TH1F* DiMuonVertexValidation::hSVDist_

private

Definition at line 98 of file DiMuonVertexValidation.cc.

Referenced by analyze(), and beginJob().

hSVDistSig_

TH1F* DiMuonVertexValidation::hSVDistSig_

private

Definition at line 99 of file DiMuonVertexValidation.cc.

Referenced by analyze(), and beginJob().

hSVProb_

TH1F* DiMuonVertexValidation::hSVProb_

private

Definition at line 97 of file DiMuonVertexValidation.cc.

Referenced by analyze(), and beginJob().

hTrackInvMass_

TH1F* DiMuonVertexValidation::hTrackInvMass_

private

Definition at line 109 of file DiMuonVertexValidation.cc.

Referenced by analyze(), and beginJob().

maxSVdist_

float DiMuonVertexValidation::maxSVdist_

private

Definition at line 82 of file DiMuonVertexValidation.cc.

Referenced by analyze(), and DiMuonVertexValidation().

muonsToken_

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

private

Definition at line 130 of file DiMuonVertexValidation.cc.

Referenced by analyze(), and DiMuonVertexValidation().

myCounts

DiLeptonHelp::Counts DiMuonVertexValidation::myCounts

private

Definition at line 77 of file DiMuonVertexValidation.cc.

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

pTthresholds_

std::vector<double> DiMuonVertexValidation::pTthresholds_

private

Definition at line 81 of file DiMuonVertexValidation.cc.

Referenced by analyze(), and DiMuonVertexValidation().

tracksToken_

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

private

Definition at line 126 of file DiMuonVertexValidation.cc.

Referenced by analyze().

ttbESToken_

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

private

Definition at line 124 of file DiMuonVertexValidation.cc.

Referenced by analyze().

useClosestVertex_

const bool DiMuonVertexValidation::useClosestVertex_

private

Definition at line 80 of file DiMuonVertexValidation.cc.

Referenced by analyze().

useReco_

const bool DiMuonVertexValidation::useReco_

private

Definition at line 79 of file DiMuonVertexValidation.cc.

Referenced by analyze(), and DiMuonVertexValidation().

vertexToken_

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

private

Definition at line 127 of file DiMuonVertexValidation.cc.

Referenced by analyze().

VtxDist3DConfiguration_

edm::ParameterSet DiMuonVertexValidation::VtxDist3DConfiguration_

private

Definition at line 90 of file DiMuonVertexValidation.cc.

Referenced by beginJob().

VtxDist3DPlots

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

private

Definition at line 119 of file DiMuonVertexValidation.cc.

Referenced by analyze(), and beginJob().

VtxDist3DSigConfiguration_

edm::ParameterSet DiMuonVertexValidation::VtxDist3DSigConfiguration_

private

Definition at line 92 of file DiMuonVertexValidation.cc.

Referenced by beginJob().

VtxDist3DSigPlots

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

private

Definition at line 121 of file DiMuonVertexValidation.cc.

Referenced by analyze(), and beginJob().

VtxDistConfiguration_

edm::ParameterSet DiMuonVertexValidation::VtxDistConfiguration_

private

Definition at line 89 of file DiMuonVertexValidation.cc.

Referenced by beginJob().

VtxDistPlots

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

private

Definition at line 118 of file DiMuonVertexValidation.cc.

Referenced by analyze(), and beginJob().

VtxDistSigConfiguration_

edm::ParameterSet DiMuonVertexValidation::VtxDistSigConfiguration_

private

Definition at line 91 of file DiMuonVertexValidation.cc.

Referenced by beginJob().

VtxDistSigPlots

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

private

Definition at line 120 of file DiMuonVertexValidation.cc.

Referenced by analyze(), and beginJob().

VtxProbConfiguration_

edm::ParameterSet DiMuonVertexValidation::VtxProbConfiguration_

private

Definition at line 88 of file DiMuonVertexValidation.cc.

Referenced by beginJob().

VtxProbPlots

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

private

Definition at line 117 of file DiMuonVertexValidation.cc.

Referenced by analyze(), and beginJob().

ZMassPlots

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

private

Definition at line 122 of file DiMuonVertexValidation.cc.

Referenced by analyze(), and beginJob().