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 edm::stream::EDAnalyzer< edm::RunSummaryCache< dqmDetails::NoCache >, edm::LuminosityBlockSummaryCache< dqmDetails::NoCache > >
typedef CacheContexts< T... >	CacheTypes
typedef CacheTypes::GlobalCache	GlobalCache
typedef AbilityChecker< T... >	HasAbility
typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache
typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext
typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache
typedef CacheTypes::RunCache	RunCache
typedef RunContextT< RunCache, GlobalCache >	RunContext
typedef CacheTypes::RunSummaryCache	RunSummaryCache
Public Types inherited from edm::stream::EDAnalyzerBase
typedef EDAnalyzerAdaptorBase	ModuleType
Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Public Member Functions
	V0Validator (const edm::ParameterSet &)
	~V0Validator ()
Public Member Functions inherited from DQMEDAnalyzer
void	beginRun (edm::Run const &, edm::EventSetup const &) final
void	beginStream (edm::StreamID id) final
virtual void	dqmBeginRun (edm::Run const &, edm::EventSetup const &)
	DQMEDAnalyzer (void)
void	endLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, dqmDetails::NoCache *) const final
void	endRunSummary (edm::Run const &, edm::EventSetup const &, dqmDetails::NoCache *) const final
uint32_t	streamId () const
Public Member Functions inherited from edm::stream::EDAnalyzer< edm::RunSummaryCache< dqmDetails::NoCache >, edm::LuminosityBlockSummaryCache< dqmDetails::NoCache > >
	EDAnalyzer ()=default
Public Member Functions inherited from edm::stream::EDAnalyzerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)
	EDAnalyzerBase ()
ModuleDescription const &	moduleDescription () 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
ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const
void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const
void	labelsForToken (EDGetToken iToken, Labels &oLabels) const
void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const
EDConsumerBase const &	operator= (EDConsumerBase const &)=delete
EDConsumerBase &	operator= (EDConsumerBase &&)=default
bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const
bool	registeredToConsumeMany (TypeID const &, BranchType) const
void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)
virtual	~EDConsumerBase () noexcept(false)

Private Member Functions
virtual 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 std::shared_ptr< dqmDetails::NoCache >	globalBeginLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, LuminosityBlockContext const *)
static std::shared_ptr< dqmDetails::NoCache >	globalBeginRunSummary (edm::Run const &, edm::EventSetup const &, RunContext const *)
static void	globalEndLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, LuminosityBlockContext const *, dqmDetails::NoCache *)
static void	globalEndRunSummary (edm::Run const &, edm::EventSetup const &, RunContext const *, dqmDetails::NoCache *)
Static Public Member Functions inherited from edm::stream::EDAnalyzerBase
static const std::string &	baseType ()
static void	fillDescriptions (ConfigurationDescriptions &descriptions)
static void	prevalidate (ConfigurationDescriptions &descriptions)
Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)
EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)
template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)
ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...
template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()
void	consumesMany (const TypeToGet &id)
template<BranchType B>
void	consumesMany (const TypeToGet &id)
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)
template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Detailed Description

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 80 of file V0Validator.h.

Member Enumeration Documentation

enum V0Validator::V0Type

Enumerator
KSHORT
LAMBDA

Definition at line 84 of file V0Validator.h.

{ KSHORT, LAMBDA };

Constructor & Destructor Documentation

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

explicit

Definition at line 28 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

(

)

Definition at line 50 of file V0Validator.cc.

{}

Member Function Documentation

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

overrideprivatevirtual

Definition at line 426 of file V0Validator.cc.

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

Referenced by V0Validator::V0Couple::operator==().

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

  // Get event setup info, B-field and tracker geometry
  ESHandle<MagneticField> bFieldHandle;
  iSetup.get<IdealMagneticFieldRecord>().get(bFieldHandle);
  ESHandle<GlobalTrackingGeometry> globTkGeomHandle;
  iSetup.get<GlobalTrackingGeometryRecord>().get(globTkGeomHandle);

  // 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());
  }
}

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

overrideprivatevirtual

Implements DQMEDAnalyzer.

Definition at line 52 of file V0Validator.cc.

References DQMStore::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_, DQMStore::IBooker::cd(), dirName, fakeCandidateMass_, goodCandidateMass, KSHORT, LAMBDA, nCandidates_, DQMStore::IBooker::setCurrentFolder(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by V0Validator::V0Couple::operator==().

                                                       {
  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.c_str());

  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.c_str());

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

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 326 of file V0Validator.cc.

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

Referenced by analyze(), and V0Validator::V0Couple::operator==().

                                                        {
  /* 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.size() > 0) {
    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]]
                        .size() != 0) {
                  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
}

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

private

Definition at line 199 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_, SoftLeptonByDistance_cfi::distance, edm::AssociationMap< Tag >::end(), fakeCandidateMass_, edm::AssociationMap< Tag >::find(), goodCandidateMass, mps_fire::i, edm::Ref< C, T, F >::isNonnull(), ResonanceBuilder::mass, nCandidates_, mathSSE::sqrt(), and HiIsolationCommonParameters_cff::track.

Referenced by analyze(), and V0Validator::V0Couple::operator==().

                                                             {
  using namespace edm;

  int numCandidateFound = 0;
  int realCandidateFound = 0;
  double mass = 0.;
  float CandidatepT = 0.;
  float CandidateEta = 0.;
  float CandidateR = 0.;
  int CandidateStatus = 0;
  const unsigned int NUM_DAUGHTERS = 2;
  if (collection.size() > 0) {
    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.size() != 0) {
            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;
                        realCandidateFound++;
                        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

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

private

Definition at line 140 of file V0Validator.h.

Referenced by bookHistograms(), and doEfficiencies().

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

private

Definition at line 124 of file V0Validator.h.

Referenced by bookHistograms(), and doEfficiencies().

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

private

Definition at line 141 of file V0Validator.h.

Referenced by bookHistograms(), and doEfficiencies().

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

private

Definition at line 125 of file V0Validator.h.

Referenced by bookHistograms(), and doEfficiencies().

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

private

Definition at line 139 of file V0Validator.h.

Referenced by bookHistograms(), and doEfficiencies().

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

private

Definition at line 123 of file V0Validator.h.

Referenced by bookHistograms(), and doEfficiencies().

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

private

Definition at line 146 of file V0Validator.h.

Referenced by bookHistograms(), and doFakeRates().

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

private

Definition at line 137 of file V0Validator.h.

Referenced by bookHistograms(), and doFakeRates().

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

private

Definition at line 130 of file V0Validator.h.

Referenced by bookHistograms(), and doFakeRates().

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

private

Definition at line 138 of file V0Validator.h.

Referenced by bookHistograms(), and doFakeRates().

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

private

Definition at line 131 of file V0Validator.h.

Referenced by bookHistograms(), and doFakeRates().

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

private

Definition at line 136 of file V0Validator.h.

Referenced by bookHistograms(), and doFakeRates().

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

private

Definition at line 129 of file V0Validator.h.

Referenced by bookHistograms(), and doFakeRates().

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

private

Definition at line 147 of file V0Validator.h.

Referenced by bookHistograms(), and doFakeRates().

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

private

Definition at line 144 of file V0Validator.h.

Referenced by bookHistograms(), and doFakeRates().

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

private

Definition at line 127 of file V0Validator.h.

Referenced by bookHistograms().

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

private

Definition at line 128 of file V0Validator.h.

Referenced by bookHistograms().

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

private

Definition at line 126 of file V0Validator.h.

Referenced by bookHistograms().

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

private

Definition at line 133 of file V0Validator.h.

Referenced by bookHistograms(), and doFakeRates().

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

private

Definition at line 134 of file V0Validator.h.

Referenced by bookHistograms(), and doFakeRates().

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

private

Definition at line 132 of file V0Validator.h.

Referenced by bookHistograms(), and doFakeRates().

std::string V0Validator::dirName

private

Definition at line 151 of file V0Validator.h.

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

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

private

Definition at line 145 of file V0Validator.h.

Referenced by bookHistograms(), and doFakeRates().

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

private

Definition at line 148 of file V0Validator.h.

Referenced by bookHistograms(), and doFakeRates().

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

private

Definition at line 143 of file V0Validator.h.

Referenced by bookHistograms(), and doFakeRates().

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

private

Definition at line 152 of file V0Validator.h.

Referenced by analyze().

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

private

Definition at line 153 of file V0Validator.h.

Referenced by analyze().

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

private

Definition at line 157 of file V0Validator.h.

Referenced by analyze().

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

private

Definition at line 157 of file V0Validator.h.

Referenced by analyze().

std::string V0Validator::theDQMRootFileName

private

Definition at line 150 of file V0Validator.h.

edm::EDGetTokenT<TrackingVertexCollection> V0Validator::trackingVertexCollection_Token_

private

Definition at line 154 of file V0Validator.h.

Referenced by analyze().

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

private

Definition at line 155 of file V0Validator.h.

Referenced by analyze().