V0Validator Class Reference

#include <Validation/RecoVertex/src/V0Validator.cc>

Inheritance diagram for V0Validator:

Classes
struct	V0Couple

Public Types
enum	V0Type { KSHORT, LAMBDA }
Public Types inherited from DQMEDAnalyzer
typedef dqm::reco::DQMStore	DQMStore
typedef dqm::reco::MonitorElement	MonitorElement
Public Types inherited from edm::stream::EDProducer< edm::GlobalCache< DQMEDAnalyzerGlobalCache >, edm::EndRunProducer, edm::EndLuminosityBlockProducer, edm::Accumulator >
using	CacheTypes = CacheContexts< T... >
using	GlobalCache = typename CacheTypes::GlobalCache
using	HasAbility = AbilityChecker< T... >
using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache
using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache
using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >
using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache
using	RunCache = typename CacheTypes::RunCache
using	RunContext = RunContextT< RunCache, GlobalCache >
using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Public Member Functions
	V0Validator (const edm::ParameterSet &)
	~V0Validator () override
Public Member Functions inherited from DQMEDAnalyzer
void	accumulate (edm::Event const &event, edm::EventSetup const &setup) final
void	beginLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup) final
void	beginRun (edm::Run const &run, edm::EventSetup const &setup) final
void	beginStream (edm::StreamID id) final
virtual void	dqmBeginRun (edm::Run const &, edm::EventSetup const &)
	DQMEDAnalyzer ()
void	endLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup) final
void	endRun (edm::Run const &run, edm::EventSetup const &setup) final
virtual bool	getCanSaveByLumi ()
Public Member Functions inherited from edm::stream::EDProducer< edm::GlobalCache< DQMEDAnalyzerGlobalCache >, edm::EndRunProducer, edm::EndLuminosityBlockProducer, edm::Accumulator >
	EDProducer ()=default
	EDProducer (const EDProducer &)=delete
bool	hasAbilityToProduceInBeginLumis () const final
bool	hasAbilityToProduceInBeginProcessBlocks () const final
bool	hasAbilityToProduceInBeginRuns () const final
bool	hasAbilityToProduceInEndLumis () const final
bool	hasAbilityToProduceInEndProcessBlocks () const final
bool	hasAbilityToProduceInEndRuns () const final
const EDProducer &	operator= (const EDProducer &)=delete

Private Member Functions
void	analyze (const edm::Event &, const edm::EventSetup &) override
void	bookHistograms (DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override
void	doEfficiencies (const TrackingVertexCollection &gen_vertices, V0Type t, int parent_particle_id, int first_daughter_id, int second_daughter_id, const reco::VertexCompositeCandidateCollection &collection, const reco::SimToRecoCollection &simtorecoCollection)
void	doFakeRates (const reco::VertexCompositeCandidateCollection &collection, const reco::RecoToSimCollection &recotosimCollection, V0Type t, int particle_pdgid, int misreconstructed_particle_pdgid)

Private Attributes
std::array< MonitorElement *, 2 >	candidateEffVsEta_denom_
std::array< MonitorElement *, 2 >	candidateEffVsEta_num_
std::array< MonitorElement *, 2 >	candidateEffVsPt_denom_
std::array< MonitorElement *, 2 >	candidateEffVsPt_num_
std::array< MonitorElement *, 2 >	candidateEffVsR_denom_
std::array< MonitorElement *, 2 >	candidateEffVsR_num_
std::array< MonitorElement *, 2 >	candidateFakeDauRadDist_
std::array< MonitorElement *, 2 >	candidateFakeVsEta_denom_
std::array< MonitorElement *, 2 >	candidateFakeVsEta_num_
std::array< MonitorElement *, 2 >	candidateFakeVsPt_denom_
std::array< MonitorElement *, 2 >	candidateFakeVsPt_num_
std::array< MonitorElement *, 2 >	candidateFakeVsR_denom_
std::array< MonitorElement *, 2 >	candidateFakeVsR_num_
std::array< MonitorElement *, 2 >	candidateMassAll
std::array< MonitorElement *, 2 >	candidateStatus_
std::array< MonitorElement *, 2 >	candidateTkEffVsEta_num_
std::array< MonitorElement *, 2 >	candidateTkEffVsPt_num_
std::array< MonitorElement *, 2 >	candidateTkEffVsR_num_
std::array< MonitorElement *, 2 >	candidateTkFakeVsEta_num_
std::array< MonitorElement *, 2 >	candidateTkFakeVsPt_num_
std::array< MonitorElement *, 2 >	candidateTkFakeVsR_num_
std::string	dirName
std::array< MonitorElement *, 2 >	fakeCandidateMass_
std::array< MonitorElement *, 2 >	goodCandidateMass
std::array< MonitorElement *, 2 >	nCandidates_
edm::EDGetTokenT< reco::RecoToSimCollection >	recoRecoToSimCollectionToken_
edm::EDGetTokenT< reco::SimToRecoCollection >	recoSimToRecoCollectionToken_
edm::EDGetTokenT< reco::VertexCompositeCandidateCollection >	recoVertexCompositeCandidateCollection_k0s_Token_
edm::EDGetTokenT< reco::VertexCompositeCandidateCollection >	recoVertexCompositeCandidateCollection_lambda_Token_
std::string	theDQMRootFileName
edm::EDGetTokenT< TrackingVertexCollection >	trackingVertexCollection_Token_
edm::EDGetTokenT< std::vector< reco::Vertex > >	vec_recoVertex_Token_

Additional Inherited Members
Static Public Member Functions inherited from DQMEDAnalyzer
static void	globalEndJob (DQMEDAnalyzerGlobalCache const *)
static void	globalEndLuminosityBlockProduce (edm::LuminosityBlock &lumi, edm::EventSetup const &setup, LuminosityBlockContext const *context)
static void	globalEndRunProduce (edm::Run &run, edm::EventSetup const &setup, RunContext const *context)
static std::unique_ptr< DQMEDAnalyzerGlobalCache >	initializeGlobalCache (edm::ParameterSet const &)
Protected Member Functions inherited from DQMEDAnalyzer
uint64_t	meId () const
Protected Attributes inherited from DQMEDAnalyzer
edm::EDPutTokenT< DQMToken >	lumiToken_
edm::EDPutTokenT< DQMToken >	runToken_
unsigned int	streamId_

Detailed Description

Validation/RecoVertex/interface/V0Validator.h

Description: Creates validation histograms for RecoVertex/V0Producer

Implementation: <Notes on="" implementation>="">

Description: Creates validation histograms for RecoVertex/V0Producer

Implementation: <Notes on="" implementation>="">

Definition at line 79 of file V0Validator.h.

Member Enumeration Documentation

V0Type

enum V0Validator::V0Type

Enumerator
KSHORT
LAMBDA

Definition at line 83 of file V0Validator.h.

{ KSHORT, LAMBDA };

Constructor & Destructor Documentation

V0Validator()

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

explicit

Definition at line 27 of file V0Validator.cc.

    : theDQMRootFileName(iConfig.getUntrackedParameter<std::string>("DQMRootFileName")),
      dirName(iConfig.getUntrackedParameter<std::string>("dirName")),
      recoRecoToSimCollectionToken_(
          consumes<reco::RecoToSimCollection>(iConfig.getUntrackedParameter<edm::InputTag>("trackAssociatorMap"))),
      recoSimToRecoCollectionToken_(
          consumes<reco::SimToRecoCollection>(iConfig.getUntrackedParameter<edm::InputTag>("trackAssociatorMap"))),
      trackingVertexCollection_Token_(
          consumes<TrackingVertexCollection>(iConfig.getUntrackedParameter<edm::InputTag>("trackingVertexCollection"))),
      vec_recoVertex_Token_(
          consumes<std::vector<reco::Vertex> >(iConfig.getUntrackedParameter<edm::InputTag>("vertexCollection"))),
      recoVertexCompositeCandidateCollection_k0s_Token_(consumes<reco::VertexCompositeCandidateCollection>(
          iConfig.getUntrackedParameter<edm::InputTag>("kShortCollection"))),
      recoVertexCompositeCandidateCollection_lambda_Token_(consumes<reco::VertexCompositeCandidateCollection>(
          iConfig.getUntrackedParameter<edm::InputTag>("lambdaCollection"))) {}

~V0Validator()

V0Validator::~V0Validator ( )

override

Definition at line 43 of file V0Validator.cc.

{}

Member Function Documentation

analyze()

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

overrideprivatevirtual

Reimplemented from DQMEDAnalyzer.

Definition at line 380 of file V0Validator.cc.

References gather_cfg::cout, doEfficiencies(), doFakeRates(), iEvent, edm::HandleBase::isValid(), v0validator_cfi::lambdaCollection, edm::Handle< T >::product(), recoRecoToSimCollectionToken_, recoSimToRecoCollectionToken_, recoVertexCompositeCandidateCollection_k0s_Token_, recoVertexCompositeCandidateCollection_lambda_Token_, trackingVertexCollection_Token_, and vec_recoVertex_Token_.

                                                                             {
  using std::cout;
  using std::endl;
  using namespace edm;
  using namespace std;

  // Make matching collections
  Handle<reco::RecoToSimCollection> recotosimCollectionH;
  iEvent.getByToken(recoRecoToSimCollectionToken_, recotosimCollectionH);

  Handle<reco::SimToRecoCollection> simtorecoCollectionH;
  iEvent.getByToken(recoSimToRecoCollectionToken_, simtorecoCollectionH);

  // Get Monte Carlo information
  edm::Handle<TrackingVertexCollection> TVCollectionH;
  iEvent.getByToken(trackingVertexCollection_Token_, TVCollectionH);

  // Select the primary vertex, create a new reco::Vertex to hold it
  edm::Handle<std::vector<reco::Vertex> > primaryVtxCollectionH;
  iEvent.getByToken(vec_recoVertex_Token_, primaryVtxCollectionH);

  std::vector<reco::Vertex>::const_iterator iVtxPH = primaryVtxCollectionH->begin();
  for (std::vector<reco::Vertex>::const_iterator iVtx = primaryVtxCollectionH->begin();
       iVtx < primaryVtxCollectionH->end();
       iVtx++) {
    if (primaryVtxCollectionH->size() > 1) {
      if (iVtx->tracksSize() > iVtxPH->tracksSize()) {
        iVtxPH = iVtx;
      }
    } else
      iVtxPH = iVtx;
  }

  // get the V0s;
  edm::Handle<reco::VertexCompositeCandidateCollection> k0sCollection;
  edm::Handle<reco::VertexCompositeCandidateCollection> lambdaCollection;
  iEvent.getByToken(recoVertexCompositeCandidateCollection_k0s_Token_, k0sCollection);
  iEvent.getByToken(recoVertexCompositeCandidateCollection_lambda_Token_, lambdaCollection);

  // Do fake rate and efficiency calculation

  // Get gen vertex collection out of the event, as done in the Vertex
  // validation package!!!
  if (k0sCollection.isValid()) {
    doFakeRates(*k0sCollection.product(), *recotosimCollectionH.product(), V0Type::KSHORT, 310, 3122);
    doEfficiencies(*TVCollectionH.product(),
                   V0Type::KSHORT,
                   310,
                   211,
                   211,
                   *k0sCollection.product(),
                   *simtorecoCollectionH.product());
  }
  if (lambdaCollection.isValid()) {
    doFakeRates(*lambdaCollection.product(), *recotosimCollectionH.product(), V0Type::LAMBDA, 3122, 310);
    doEfficiencies(*TVCollectionH.product(),
                   V0Type::LAMBDA,
                   3122,
                   211,
                   2212,
                   *lambdaCollection.product(),
                   *simtorecoCollectionH.product());
  }
}

bookHistograms()

void V0Validator::bookHistograms ( DQMStore::IBooker &  ibooker, edm::Run const &  , edm::EventSetup const &    )

overrideprivatevirtual

Implements DQMEDAnalyzer.

Definition at line 45 of file V0Validator.cc.

References dqm::implementation::IBooker::book1D(), candidateEffVsEta_denom_, candidateEffVsEta_num_, candidateEffVsPt_denom_, candidateEffVsPt_num_, candidateEffVsR_denom_, candidateEffVsR_num_, candidateFakeDauRadDist_, candidateFakeVsEta_denom_, candidateFakeVsEta_num_, candidateFakeVsPt_denom_, candidateFakeVsPt_num_, candidateFakeVsR_denom_, candidateFakeVsR_num_, candidateMassAll, candidateStatus_, candidateTkEffVsEta_num_, candidateTkEffVsPt_num_, candidateTkEffVsR_num_, candidateTkFakeVsEta_num_, candidateTkFakeVsPt_num_, candidateTkFakeVsR_num_, dqm::implementation::NavigatorBase::cd(), dirName, fakeCandidateMass_, goodCandidateMass, KSHORT, LAMBDA, nCandidates_, dqm::implementation::NavigatorBase::setCurrentFolder(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                              {
  double minKsMass = 0.49767 - 0.07;
  double maxKsMass = 0.49767 + 0.07;
  double minLamMass = 1.1156 - 0.05;
  double maxLamMass = 1.1156 + 0.05;
  int ksMassNbins = 100;
  double ksMassXmin = minKsMass;
  double ksMassXmax = maxKsMass;
  int lamMassNbins = 100;
  double lamMassXmin = minLamMass;
  double lamMassXmax = maxLamMass;

  ibooker.cd();
  std::string subDirName = V0Validator::dirName + "/K0";
  ibooker.setCurrentFolder(subDirName);

  candidateEffVsR_num_[V0Validator::KSHORT] =
      ibooker.book1D("K0sEffVsR_num", "K^{0}_{S} Efficiency vs #rho", 80, 0., 40.);
  candidateEffVsEta_num_[V0Validator::KSHORT] =
      ibooker.book1D("K0sEffVsEta_num", "K^{0}_{S} Efficiency vs #eta", 40, -2.5, 2.5);
  candidateEffVsPt_num_[V0Validator::KSHORT] =
      ibooker.book1D("K0sEffVsPt_num", "K^{0}_{S} Efficiency vs p_{T}", 70, 0., 20.);

  candidateTkEffVsR_num_[V0Validator::KSHORT] =
      ibooker.book1D("K0sTkEffVsR_num", "K^{0}_{S} Tracking Efficiency vs #rho", 80, 0., 40.);
  candidateTkEffVsEta_num_[V0Validator::KSHORT] =
      ibooker.book1D("K0sTkEffVsEta_num", "K^{0}_{S} Tracking Efficiency vs #eta", 40, -2.5, 2.5);
  candidateTkEffVsPt_num_[V0Validator::KSHORT] =
      ibooker.book1D("K0sTkEffVsPt_num", "K^{0}_{S} Tracking Efficiency vs p_{T}", 70, 0., 20.);

  candidateEffVsR_denom_[V0Validator::KSHORT] =
      ibooker.book1D("K0sEffVsR_denom", "K^{0}_{S} Efficiency vs #rho", 80, 0., 40.);
  candidateEffVsEta_denom_[V0Validator::KSHORT] =
      ibooker.book1D("K0sEffVsEta_denom", "K^{0}_{S} Efficiency vs #eta", 40, -2.5, 2.5);
  candidateEffVsPt_denom_[V0Validator::KSHORT] =
      ibooker.book1D("K0sEffVsPt_denom", "K^{0}_{S} Efficiency vs p_{T}", 70, 0., 20.);

  candidateFakeVsR_num_[V0Validator::KSHORT] =
      ibooker.book1D("K0sFakeVsR_num", "K^{0}_{S} Fake Rate vs #rho", 80, 0., 40.);
  candidateFakeVsEta_num_[V0Validator::KSHORT] =
      ibooker.book1D("K0sFakeVsEta_num", "K^{0}_{S} Fake Rate vs #eta", 40, -2.5, 2.5);
  candidateFakeVsPt_num_[V0Validator::KSHORT] =
      ibooker.book1D("K0sFakeVsPt_num", "K^{0}_{S} Fake Rate vs p_{T}", 70, 0., 20.);
  candidateTkFakeVsR_num_[V0Validator::KSHORT] =
      ibooker.book1D("K0sTkFakeVsR_num", "K^{0}_{S} Tracking Fake Rate vs #rho", 80, 0., 80.);
  candidateTkFakeVsEta_num_[V0Validator::KSHORT] =
      ibooker.book1D("K0sTkFakeVsEta_num", "K^{0}_{S} Tracking Fake Rate vs #eta", 40, -2.5, 2.5);
  candidateTkFakeVsPt_num_[V0Validator::KSHORT] =
      ibooker.book1D("K0sTkFakeVsPt_num", "K^{0}_{S} Tracking Fake Rate vs p_{T}", 70, 0., 20.);

  candidateFakeVsR_denom_[V0Validator::KSHORT] =
      ibooker.book1D("K0sFakeVsR_denom", "K^{0}_{S} Fake Rate vs #rho", 80, 0., 40.);
  candidateFakeVsEta_denom_[V0Validator::KSHORT] =
      ibooker.book1D("K0sFakeVsEta_denom", "K^{0}_{S} Fake Rate vs #eta", 40, -2.5, 2.5);
  candidateFakeVsPt_denom_[V0Validator::KSHORT] =
      ibooker.book1D("K0sFakeVsPt_denom", "K^{0}_{S} Fake Rate vs p_{T}", 70, 0., 20.);
  nCandidates_[V0Validator::KSHORT] = ibooker.book1D("nK0s", "Number of K^{0}_{S} found per event", 60, 0., 60.);
  fakeCandidateMass_[V0Validator::KSHORT] =
      ibooker.book1D("ksMassFake", "Mass of fake K0S", ksMassNbins, minKsMass, maxKsMass);
  goodCandidateMass[V0Validator::KSHORT] =
      ibooker.book1D("ksMassGood", "Mass of good reco K0S", ksMassNbins, minKsMass, maxKsMass);
  candidateMassAll[V0Validator::KSHORT] =
      ibooker.book1D("ksMassAll", "Invariant mass of all K0S", ksMassNbins, ksMassXmin, ksMassXmax);
  candidateFakeDauRadDist_[V0Validator::KSHORT] =
      ibooker.book1D("radDistFakeKs", "Production radius of daughter particle of Ks fake", 100, 0., 15.);
  candidateStatus_[V0Validator::KSHORT] = ibooker.book1D("ksCandStatus", "Fake type by cand status", 10, 0., 10.);

  // Lambda Plots follow

  subDirName = V0Validator::dirName + "/Lambda";
  ibooker.setCurrentFolder(subDirName);

  candidateEffVsR_num_[V0Validator::LAMBDA] =
      ibooker.book1D("LamEffVsR_num", "#Lambda^{0} Efficiency vs #rho", 80, 0., 40.);
  candidateEffVsEta_num_[V0Validator::LAMBDA] =
      ibooker.book1D("LamEffVsEta_num", "#Lambda^{0} Efficiency vs #eta", 40, -2.5, 2.5);
  candidateEffVsPt_num_[V0Validator::LAMBDA] =
      ibooker.book1D("LamEffVsPt_num", "#Lambda^{0} Efficiency vs p_{T}", 70, 0., 20.);

  candidateTkEffVsR_num_[V0Validator::LAMBDA] =
      ibooker.book1D("LamTkEffVsR_num", "#Lambda^{0} TrackingEfficiency vs #rho", 80, 0., 40.);
  candidateTkEffVsEta_num_[V0Validator::LAMBDA] =
      ibooker.book1D("LamTkEffVsEta_num", "#Lambda^{0} Tracking Efficiency vs #eta", 40, -2.5, 2.5);
  candidateTkEffVsPt_num_[V0Validator::LAMBDA] =
      ibooker.book1D("LamTkEffVsPt_num", "#Lambda^{0} Tracking Efficiency vs p_{T}", 70, 0., 20.);

  candidateEffVsR_denom_[V0Validator::LAMBDA] =
      ibooker.book1D("LamEffVsR_denom", "#Lambda^{0} Efficiency vs #rho", 80, 0., 40.);
  candidateEffVsEta_denom_[V0Validator::LAMBDA] =
      ibooker.book1D("LamEffVsEta_denom", "#Lambda^{0} Efficiency vs #eta", 40, -2.5, 2.5);
  candidateEffVsPt_denom_[V0Validator::LAMBDA] =
      ibooker.book1D("LamEffVsPt_denom", "#Lambda^{0} Efficiency vs p_{T}", 70, 0., 20.);

  candidateFakeVsR_num_[V0Validator::LAMBDA] =
      ibooker.book1D("LamFakeVsR_num", "#Lambda^{0} Fake Rate vs #rho", 80, 0., 40.);
  candidateFakeVsEta_num_[V0Validator::LAMBDA] =
      ibooker.book1D("LamFakeVsEta_num", "#Lambda^{0} Fake Rate vs #eta", 40, -2.5, 2.5);
  candidateFakeVsPt_num_[V0Validator::LAMBDA] =
      ibooker.book1D("LamFakeVsPt_num", "#Lambda^{0} Fake Rate vs p_{T}", 70, 0., 20.);
  candidateTkFakeVsR_num_[V0Validator::LAMBDA] =
      ibooker.book1D("LamTkFakeVsR_num", "#Lambda^{0} Tracking Fake Rate vs #rho", 80, 0., 40.);
  candidateTkFakeVsEta_num_[V0Validator::LAMBDA] =
      ibooker.book1D("LamTkFakeVsEta_num", "#Lambda^{0} Tracking Fake Rate vs #eta", 40, -2.5, 2.5);
  candidateTkFakeVsPt_num_[V0Validator::LAMBDA] =
      ibooker.book1D("LamTkFakeVsPt_num", "#Lambda^{0} Tracking Fake Rate vs p_{T}", 70, 0., 20.);

  candidateFakeVsR_denom_[V0Validator::LAMBDA] =
      ibooker.book1D("LamFakeVsR_denom", "#Lambda^{0} Fake Rate vs #rho", 80, 0., 40.);
  candidateFakeVsEta_denom_[V0Validator::LAMBDA] =
      ibooker.book1D("LamFakeVsEta_denom", "#Lambda^{0} Fake Rate vs #eta", 40, -2.5, 2.5);
  candidateFakeVsPt_denom_[V0Validator::LAMBDA] =
      ibooker.book1D("LamFakeVsPt_denom", "#Lambda^{0} Fake Rate vs p_{T}", 70, 0., 20.);

  nCandidates_[V0Validator::LAMBDA] = ibooker.book1D("nLam", "Number of #Lambda^{0} found per event", 60, 0., 60.);
  fakeCandidateMass_[V0Validator::LAMBDA] =
      ibooker.book1D("lamMassFake", "Mass of fake Lambda", lamMassNbins, minLamMass, maxLamMass);
  goodCandidateMass[V0Validator::LAMBDA] =
      ibooker.book1D("lamMassGood", "Mass of good Lambda", lamMassNbins, minLamMass, maxLamMass);

  candidateMassAll[V0Validator::LAMBDA] =
      ibooker.book1D("lamMassAll", "Invariant mass of all #Lambda^{0}", lamMassNbins, lamMassXmin, lamMassXmax);
  candidateFakeDauRadDist_[V0Validator::LAMBDA] =
      ibooker.book1D("radDistFakeLam", "Production radius of daughter particle of Lam fake", 100, 0., 15.);

  candidateStatus_[V0Validator::LAMBDA] = ibooker.book1D("ksCandStatus", "Fake type by cand status", 10, 0., 10.);
}

doEfficiencies()

void V0Validator::doEfficiencies ( const TrackingVertexCollection &  gen_vertices, V0Type  t, int  parent_particle_id, int  first_daughter_id, int  second_daughter_id, const reco::VertexCompositeCandidateCollection &  collection, const reco::SimToRecoCollection &  simtorecoCollection  )

private

Definition at line 294 of file V0Validator.cc.

References funct::abs(), edm::AssociationMap< Tag >::begin(), candidateEffVsEta_denom_, candidateEffVsEta_num_, candidateEffVsPt_denom_, candidateEffVsPt_num_, candidateEffVsR_denom_, candidateEffVsR_num_, universalConfigTemplate::collection, edm::AssociationMap< Tag >::empty(), edm::AssociationMap< Tag >::end(), edm::AssociationMap< Tag >::find(), EgammaValidation_cff::pdgId, source, and mathSSE::sqrt().

Referenced by analyze().

                                                                                     {
  /* We store the TrackRef of the tracks that have been used to
   * produce the V0 under consideration here. This is used later to
   * check if a specific V0 has been really reconstructed or not. The
   * ordering is based on the key_index of the reference, since it
   * indeed does not matter that much. */

  std::set<V0Couple> reconstructed_V0_couples;
  if (!collection.empty()) {
    for (reco::VertexCompositeCandidateCollection::const_iterator iCandidate = collection.begin();
         iCandidate != collection.end();
         iCandidate++) {
      reconstructed_V0_couples.insert(
          V0Couple((dynamic_cast<const reco::RecoChargedCandidate*>(iCandidate->daughter(0)))->track(),
                   (dynamic_cast<const reco::RecoChargedCandidate*>(iCandidate->daughter(1)))->track()));
    }
  }

  /* PSEUDO CODE
     for v in gen_vertices
       if v.eventId().BX() !=0 continue
       if v.nDaughterTracks != 2 continue
       for source in v.sourceTracks_begin
         if source is parent_particle_id
          for daughter in v.daughterTracks_begin
           if daughter in region_and_kine_cuts
             decay_found
   */
  unsigned int candidateEff[2] = {0, 0};
  for (auto const& gen_vertex : gen_vertices) {
    if (gen_vertex.eventId().bunchCrossing() != 0)
      continue;  // Consider only in-time events
    if (gen_vertex.nDaughterTracks() != 2)
      continue;  // Keep only V0 vertices
    for (TrackingVertex::tp_iterator source = gen_vertex.sourceTracks_begin(); source != gen_vertex.sourceTracks_end();
         ++source) {
      if (std::abs((*source)->pdgId()) == parent_particle_id) {
        if ((std::abs((gen_vertex.daughterTracks().at(0))->pdgId()) == first_daughter_id &&
             std::abs((gen_vertex.daughterTracks().at(1))->pdgId()) == second_daughter_id) ||
            (std::abs((gen_vertex.daughterTracks().at(0))->pdgId()) == second_daughter_id &&
             std::abs((gen_vertex.daughterTracks().at(1))->pdgId()) == first_daughter_id)) {
          if ((std::abs((gen_vertex.daughterTracks().at(0))->momentum().eta()) < 2.4 &&
               gen_vertex.daughterTracks().at(0)->pt() > 0.9) &&
              (std::abs((gen_vertex.daughterTracks().at(1))->momentum().eta()) < 2.4 &&
               gen_vertex.daughterTracks().at(1)->pt() > 0.9)) {
            // found desired generated Candidate
            float candidateGenpT = sqrt((*source)->momentum().perp2());
            float candidateGenEta = (*source)->momentum().eta();
            float candidateGenR = sqrt((*source)->vertex().perp2());
            candidateEffVsPt_denom_[v0_type]->Fill(candidateGenpT);
            candidateEffVsEta_denom_[v0_type]->Fill(candidateGenEta);
            candidateEffVsR_denom_[v0_type]->Fill(candidateGenR);

            std::array<reco::TrackRef, 2> reco_daughter;

            for (unsigned int daughter = 0; daughter < 2; ++daughter) {
              if (simtorecoCollection.find(gen_vertex.daughterTracks()[daughter]) != simtorecoCollection.end()) {
                if (!simtorecoCollection[gen_vertex.daughterTracks()[daughter]].empty()) {
                  candidateEff[daughter] = 1;  // Found a daughter track
                  reco_daughter[daughter] =
                      simtorecoCollection[gen_vertex.daughterTracks()[daughter]].begin()->first.castTo<reco::TrackRef>();
                }
              } else {
                candidateEff[daughter] = 2;  // First daughter not found
              }
            }
            if ((candidateEff[0] == 1 && candidateEff[1] == 1) && (reco_daughter[0].key() != reco_daughter[1].key()) &&
                (reconstructed_V0_couples.find(V0Couple(reco_daughter[0], reco_daughter[1])) !=
                 reconstructed_V0_couples.end())) {
              candidateEffVsPt_num_[v0_type]->Fill(candidateGenpT);
              candidateEffVsEta_num_[v0_type]->Fill(candidateGenEta);
              candidateEffVsR_num_[v0_type]->Fill(candidateGenR);
            }
          }  // Check that daughters are inside the desired kinematic region
        }    // Check decay products of the current generatex vertex
      }      // Check pdgId of the source of the current generated vertex
    }        // Loop over all sources of the current generated vertex
  }          // Loop over all generated vertices
}

doFakeRates()

void V0Validator::doFakeRates ( const reco::VertexCompositeCandidateCollection &  collection, const reco::RecoToSimCollection &  recotosimCollection, V0Type  t, int  particle_pdgid, int  misreconstructed_particle_pdgid  )

private

Definition at line 172 of file V0Validator.cc.

References funct::abs(), candidateFakeDauRadDist_, candidateFakeVsEta_denom_, candidateFakeVsEta_num_, candidateFakeVsPt_denom_, candidateFakeVsPt_num_, candidateFakeVsR_denom_, candidateFakeVsR_num_, candidateMassAll, candidateStatus_, candidateTkFakeVsEta_num_, candidateTkFakeVsPt_num_, candidateTkFakeVsR_num_, universalConfigTemplate::collection, HLT_2024v12_cff::distance, edm::AssociationMap< Tag >::end(), fakeCandidateMass_, edm::AssociationMap< Tag >::find(), goodCandidateMass, mps_fire::i, edm::Ref< C, T, F >::isNonnull(), EgHLTOffHistBins_cfi::mass, nCandidates_, mathSSE::sqrt(), cmsswSequenceInfo::tp, and HLT_2024v12_cff::track.

Referenced by analyze().

                                                                   {
  using namespace edm;

  int numCandidateFound = 0;
  double mass = 0.;
  float CandidatepT = 0.;
  float CandidateEta = 0.;
  float CandidateR = 0.;
  int CandidateStatus = 0;
  const unsigned int NUM_DAUGHTERS = 2;
  if (!collection.empty()) {
    for (reco::VertexCompositeCandidateCollection::const_iterator iCandidate = collection.begin();
         iCandidate != collection.end();
         iCandidate++) {
      // Fill values to be histogrammed
      mass = iCandidate->mass();
      CandidatepT = (sqrt(iCandidate->momentum().perp2()));
      CandidateEta = iCandidate->momentum().eta();
      CandidateR = (sqrt(iCandidate->vertex().perp2()));
      candidateMassAll[v0_type]->Fill(mass);
      CandidateStatus = 0;

      std::array<reco::TrackRef, NUM_DAUGHTERS> theDaughterTracks = {
          {(*(dynamic_cast<const reco::RecoChargedCandidate*>(iCandidate->daughter(0)))).track(),
           (*(dynamic_cast<const reco::RecoChargedCandidate*>(iCandidate->daughter(1)))).track()}};

      TrackingParticleRef tpref;
      TrackingParticleRef firstDauTP;
      TrackingVertexRef candidateVtx;

      std::array<double, NUM_DAUGHTERS> radDist;
      // Loop through candidate's daugher tracks
      for (View<reco::Track>::size_type i = 0; i < theDaughterTracks.size(); ++i) {
        radDist = {{-1., -1.}};
        // Found track from theDaughterTracks
        RefToBase<reco::Track> track(theDaughterTracks.at(i));

        if (recotosimCollection.find(track) != recotosimCollection.end()) {
          const std::vector<std::pair<TrackingParticleRef, double> >& tp = recotosimCollection[track];
          if (!tp.empty()) {
            tpref = tp.begin()->first;

            TrackingVertexRef parentVertex = tpref->parentVertex();
            if (parentVertex.isNonnull()) {
              radDist[i] = parentVertex->position().R();
              if (candidateVtx.isNonnull()) {
                if (candidateVtx->position() == parentVertex->position()) {
                  if (parentVertex->nDaughterTracks() == 2) {
                    if (parentVertex->nSourceTracks() == 0) {
                      // No source tracks found for candidate's
                      // vertex: it shouldn't happen, but does for
                      // evtGen events
                      CandidateStatus = 6;
                    }

                    for (TrackingVertex::tp_iterator iTP = parentVertex->sourceTracks_begin();
                         iTP != parentVertex->sourceTracks_end();
                         iTP++) {
                      if (abs((*iTP)->pdgId()) == particle_pdgid) {
                        CandidateStatus = 1;
                        numCandidateFound += 1.;
                        goodCandidateMass[v0_type]->Fill(mass);
                      } else {
                        CandidateStatus = 2;
                        if (abs((*iTP)->pdgId()) == misreconstructed_particle_pdgid) {
                          CandidateStatus = 7;
                        }
                      }
                    }
                  } else {
                    // Found a bad match because the mother has too
                    // many daughters
                    CandidateStatus = 3;
                  }
                } else {
                  // Found a bad match because the parent vertices
                  // from the two tracks are different
                  CandidateStatus = 4;
                }
              } else {
                // if candidateVtx is null, fill it with parentVertex
                // to compare to the parentVertex from the second
                // track
                candidateVtx = parentVertex;
                firstDauTP = tpref;
              }
            }  // parent vertex is null
          }    // check on associated tp size zero
        } else {
          CandidateStatus = 5;
        }
      }  // Loop on candidate's daughter tracks

      // fill the fake rate histograms
      if (CandidateStatus > 1) {
        candidateFakeVsR_num_[v0_type]->Fill(CandidateR);
        candidateFakeVsEta_num_[v0_type]->Fill(CandidateEta);
        candidateFakeVsPt_num_[v0_type]->Fill(CandidatepT);
        candidateStatus_[v0_type]->Fill((float)CandidateStatus);
        fakeCandidateMass_[v0_type]->Fill(mass);
        for (auto distance : radDist) {
          if (distance > 0)
            candidateFakeDauRadDist_[v0_type]->Fill(distance);
        }
      }
      if (CandidateStatus == 5) {
        candidateTkFakeVsR_num_[v0_type]->Fill(CandidateR);
        candidateTkFakeVsEta_num_[v0_type]->Fill(CandidateEta);
        candidateTkFakeVsPt_num_[v0_type]->Fill(CandidatepT);
      }
      candidateFakeVsR_denom_[v0_type]->Fill(CandidateR);
      candidateFakeVsEta_denom_[v0_type]->Fill(CandidateEta);
      candidateFakeVsPt_denom_[v0_type]->Fill(CandidatepT);
    }  // Loop on candidates
  }    // check on presence of candidate's collection in the event
  nCandidates_[v0_type]->Fill((float)numCandidateFound);
}

Member Data Documentation

candidateEffVsEta_denom_

std::array<MonitorElement *, 2> V0Validator::candidateEffVsEta_denom_

private

Definition at line 132 of file V0Validator.h.

Referenced by bookHistograms(), and doEfficiencies().

candidateEffVsEta_num_

std::array<MonitorElement *, 2> V0Validator::candidateEffVsEta_num_

private

Definition at line 116 of file V0Validator.h.

Referenced by bookHistograms(), and doEfficiencies().

candidateEffVsPt_denom_

std::array<MonitorElement *, 2> V0Validator::candidateEffVsPt_denom_

private

Definition at line 133 of file V0Validator.h.

Referenced by bookHistograms(), and doEfficiencies().

candidateEffVsPt_num_

std::array<MonitorElement *, 2> V0Validator::candidateEffVsPt_num_

private

Definition at line 117 of file V0Validator.h.

Referenced by bookHistograms(), and doEfficiencies().

candidateEffVsR_denom_

std::array<MonitorElement *, 2> V0Validator::candidateEffVsR_denom_

private

Definition at line 131 of file V0Validator.h.

Referenced by bookHistograms(), and doEfficiencies().

candidateEffVsR_num_

std::array<MonitorElement *, 2> V0Validator::candidateEffVsR_num_

private

Definition at line 115 of file V0Validator.h.

Referenced by bookHistograms(), and doEfficiencies().

candidateFakeDauRadDist_

std::array<MonitorElement *, 2> V0Validator::candidateFakeDauRadDist_

private

Definition at line 138 of file V0Validator.h.

Referenced by bookHistograms(), and doFakeRates().

candidateFakeVsEta_denom_

std::array<MonitorElement *, 2> V0Validator::candidateFakeVsEta_denom_

private

Definition at line 129 of file V0Validator.h.

Referenced by bookHistograms(), and doFakeRates().

candidateFakeVsEta_num_

std::array<MonitorElement *, 2> V0Validator::candidateFakeVsEta_num_

private

Definition at line 122 of file V0Validator.h.

Referenced by bookHistograms(), and doFakeRates().

candidateFakeVsPt_denom_

std::array<MonitorElement *, 2> V0Validator::candidateFakeVsPt_denom_

private

Definition at line 130 of file V0Validator.h.

Referenced by bookHistograms(), and doFakeRates().

candidateFakeVsPt_num_

std::array<MonitorElement *, 2> V0Validator::candidateFakeVsPt_num_

private

Definition at line 123 of file V0Validator.h.

Referenced by bookHistograms(), and doFakeRates().

candidateFakeVsR_denom_

std::array<MonitorElement *, 2> V0Validator::candidateFakeVsR_denom_

private

Definition at line 128 of file V0Validator.h.

Referenced by bookHistograms(), and doFakeRates().

candidateFakeVsR_num_

std::array<MonitorElement *, 2> V0Validator::candidateFakeVsR_num_

private

Definition at line 121 of file V0Validator.h.

Referenced by bookHistograms(), and doFakeRates().

candidateMassAll

std::array<MonitorElement *, 2> V0Validator::candidateMassAll

private

Definition at line 139 of file V0Validator.h.

Referenced by bookHistograms(), and doFakeRates().

candidateStatus_

std::array<MonitorElement *, 2> V0Validator::candidateStatus_

private

Definition at line 136 of file V0Validator.h.

Referenced by bookHistograms(), and doFakeRates().

candidateTkEffVsEta_num_

std::array<MonitorElement *, 2> V0Validator::candidateTkEffVsEta_num_

private

Definition at line 119 of file V0Validator.h.

Referenced by bookHistograms().

candidateTkEffVsPt_num_

std::array<MonitorElement *, 2> V0Validator::candidateTkEffVsPt_num_

private

Definition at line 120 of file V0Validator.h.

Referenced by bookHistograms().

candidateTkEffVsR_num_

std::array<MonitorElement *, 2> V0Validator::candidateTkEffVsR_num_

private

Definition at line 118 of file V0Validator.h.

Referenced by bookHistograms().

candidateTkFakeVsEta_num_

std::array<MonitorElement *, 2> V0Validator::candidateTkFakeVsEta_num_

private

Definition at line 125 of file V0Validator.h.

Referenced by bookHistograms(), and doFakeRates().

candidateTkFakeVsPt_num_

std::array<MonitorElement *, 2> V0Validator::candidateTkFakeVsPt_num_

private

Definition at line 126 of file V0Validator.h.

Referenced by bookHistograms(), and doFakeRates().

candidateTkFakeVsR_num_

std::array<MonitorElement *, 2> V0Validator::candidateTkFakeVsR_num_

private

Definition at line 124 of file V0Validator.h.

Referenced by bookHistograms(), and doFakeRates().

dirName

std::string V0Validator::dirName

private

Definition at line 143 of file V0Validator.h.

Referenced by bookHistograms(), and core.JSONAnalyzer.JSONAnalyzer::write().

fakeCandidateMass_

std::array<MonitorElement *, 2> V0Validator::fakeCandidateMass_

private

Definition at line 137 of file V0Validator.h.

Referenced by bookHistograms(), and doFakeRates().

goodCandidateMass

std::array<MonitorElement *, 2> V0Validator::goodCandidateMass

private

Definition at line 140 of file V0Validator.h.

Referenced by bookHistograms(), and doFakeRates().

nCandidates_

std::array<MonitorElement *, 2> V0Validator::nCandidates_

private

Definition at line 135 of file V0Validator.h.

Referenced by bookHistograms(), and doFakeRates().

recoRecoToSimCollectionToken_

edm::EDGetTokenT<reco::RecoToSimCollection> V0Validator::recoRecoToSimCollectionToken_

private

Definition at line 144 of file V0Validator.h.

Referenced by analyze().

recoSimToRecoCollectionToken_

edm::EDGetTokenT<reco::SimToRecoCollection> V0Validator::recoSimToRecoCollectionToken_

private

Definition at line 145 of file V0Validator.h.

Referenced by analyze().

recoVertexCompositeCandidateCollection_k0s_Token_

edm::EDGetTokenT<reco::VertexCompositeCandidateCollection> V0Validator::recoVertexCompositeCandidateCollection_k0s_Token_

private

Definition at line 148 of file V0Validator.h.

Referenced by analyze().

recoVertexCompositeCandidateCollection_lambda_Token_

edm::EDGetTokenT<reco::VertexCompositeCandidateCollection> V0Validator::recoVertexCompositeCandidateCollection_lambda_Token_

private

Definition at line 148 of file V0Validator.h.

Referenced by analyze().

theDQMRootFileName

std::string V0Validator::theDQMRootFileName

private

Definition at line 142 of file V0Validator.h.

trackingVertexCollection_Token_

edm::EDGetTokenT<TrackingVertexCollection> V0Validator::trackingVertexCollection_Token_

private

Definition at line 146 of file V0Validator.h.

Referenced by analyze().

vec_recoVertex_Token_

edm::EDGetTokenT<std::vector<reco::Vertex> > V0Validator::vec_recoVertex_Token_

private

Definition at line 147 of file V0Validator.h.

Referenced by analyze().