TrackingMonitor Class Reference

#include <DQM/TrackerMonitorTrack/src/TrackingMonitor.cc>

Inheritance diagram for TrackingMonitor:

Public Types
using	MVACollection = std::vector< float >
using	QualityMaskCollection = std::vector< unsigned char >
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
void	analyze (const edm::Event &, const edm::EventSetup &) override
void	bookHistograms (DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override
virtual void	setMaxMinBin (std::vector< double > &, std::vector< double > &, std::vector< int > &, double, double, int, double, double, int)
virtual void	setNclus (const edm::Event &, std::vector< int > &)
	TrackingMonitor (const edm::ParameterSet &)
	~TrackingMonitor () 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	doProfileX (TH2 *th2, MonitorElement *me)
void	doProfileX (MonitorElement *th2m, MonitorElement *me)

Private Attributes
std::string	AlgoName_
edm::EDGetTokenT< edm::View< reco::Track > >	allTrackToken_
edm::InputTag	bsSrc_
edm::EDGetTokenT< reco::BeamSpot >	bsSrcToken_
std::string	builderName
std::vector< std::string >	ClusterLabels
edm::ParameterSetID	confID_
StringCutObjectSelector< reco::Track, true >	denSelection_
bool	doAllPlots
bool	doAllSeedPlots
bool	doDCAPlots_
bool	doFractionPlot_
bool	doGeneralPropertiesPlots_
bool	doHitPropertiesPlots_
bool	doLumiAnalysis
bool	doMVAPlots
bool	doPlotsVsBX_
bool	doPlotsVsBXlumi_
bool	doPlotsVsGoodPVtx_
bool	doPlotsVsLUMI_
bool	doProfilesVsLS_
bool	doPUmonitoring_
bool	doRegionCandidatePlots
bool	doRegionPlots
bool	doSeedLumiAnalysis_
bool	doSeedNumberPlot
bool	doSeedVsClusterPlot
bool	doTkCandPlots
bool	doTrackerSpecific_
const bool	forceSCAL_
MonitorElement *	FractionCandidatesOverSeeds
MonitorElement *	FractionOfGoodTracks
GenericTriggerEventFlag *	genTriggerEventFlag_
MonitorElement *	GoodTracksFractionVsBX
MonitorElement *	GoodTracksFractionVsGoodPVtx
MonitorElement *	GoodTracksFractionVsLS
MonitorElement *	GoodTracksFractionVsLUMI
std::string	histname
edm::EDGetTokenT< LumiScalersCollection >	lumiscalersToken_
edm::ESGetToken< MagneticField, IdealMagneticFieldRecord >	magneticFieldToken_
std::string	MEFolderName
edm::EDGetTokenT< OnlineLuminosityRecord >	metaDataToken_
std::vector< std::tuple< edm::EDGetTokenT< MVACollection >, edm::EDGetTokenT< QualityMaskCollection > > >	mvaQualityTokens_
edm::EDGetTokenT< edm::View< reco::Track > >	mvaTrackToken_
MonitorElement *	NumberEventsOfVsBX
MonitorElement *	NumberEventsOfVsGoodPVtx
MonitorElement *	NumberEventsOfVsLS
MonitorElement *	NumberEventsOfVsLUMI
MonitorElement *	NumberOfGoodPVtxVsBX
MonitorElement *	NumberOfGoodPVtxVsLS
MonitorElement *	NumberOfGoodPVtxVsLUMI
MonitorElement *	NumberOfGoodPVtxWO0VsBX
MonitorElement *	NumberOfGoodPVtxWO0VsLS
MonitorElement *	NumberOfGoodPVtxWO0VsLUMI
MonitorElement *	NumberOfMeanLayersPerTrack
MonitorElement *	NumberOfMeanRecHitsPerTrack
MonitorElement *	NumberOfPixelClustersVsGoodPVtx
MonitorElement *	NumberOfPixelClustersVsLUMI
MonitorElement *	NumberOfPVtxVsGoodPVtx
MonitorElement *	NumberOfRecHitsPerTrackVsBX
MonitorElement *	NumberOfRecHitsPerTrackVsGoodPVtx
MonitorElement *	NumberOfRecHitsPerTrackVsLS
MonitorElement *	NumberOfRecHitsPerTrackVsLUMI
MonitorElement *	NumberOfSeeds
MonitorElement *	NumberOfSeeds_lumiFlag
MonitorElement *	NumberOfStripClustersVsGoodPVtx
MonitorElement *	NumberOfStripClustersVsLUMI
MonitorElement *	NumberOfTrackCandidates
MonitorElement *	NumberOfTrackingRegions
MonitorElement *	NumberOfTracks
MonitorElement *	NumberofTracks_Hardvtx
MonitorElement *	NumberofTracks_Hardvtx_PUvtx
MonitorElement *	NumberOfTracks_lumiFlag
MonitorElement *	NumberOfTracks_PUvtx
MonitorElement *	NumberOfTracksVsBX
MonitorElement *	NumberOfTracksVsBXlumi
MonitorElement *	NumberOfTracksVsGoodPVtx
MonitorElement *	NumberOfTracksVsLS
MonitorElement *	NumberOfTracksVsLUMI
MonitorElement *	NumberOfTracksVsPUPVtx
MonitorElement *	NumberOfTrkVsClus
std::vector< MonitorElement * >	NumberOfTrkVsClusters
MonitorElement *	NumberOfTrkVsPixelClus
MonitorElement *	NumberOfTrkVsStripClus
StringCutObjectSelector< reco::Track, true >	numSelection_
edm::InputTag	pixelClusterInputTag_
edm::EDGetTokenT< edmNew::DetSetVector< SiPixelCluster > >	pixelClustersToken_
int	pvNDOF_
edm::InputTag	pvSrc_
edm::EDGetTokenT< reco::VertexCollection >	pvSrcToken_
std::string	Quality_
edm::EDGetTokenT< reco::CandidateView >	regionCandidateToken_
edm::EDGetTokenT< TrackingRegionsSeedingLayerSets >	regionLayerSetsToken_
edm::EDGetTokenT< edm::OwnVector< TrackingRegion > >	regionToken_
bool	runTrackBuildingAnalyzerForSeed
edm::EDGetTokenT< std::vector< SeedStopInfo > >	seedStopInfoToken_
std::vector< MonitorElement * >	SeedsVsClusters
edm::EDGetTokenT< edm::View< TrajectorySeed > >	seedToken_
edm::InputTag	stripClusterInputTag_
edm::EDGetTokenT< edmNew::DetSetVector< SiStripCluster > >	stripClustersToken_
GetLumi *	theLumiDetails_
tadqm::TrackAnalyzer *	theTrackAnalyzer
TrackBuildingAnalyzer *	theTrackBuildingAnalyzer
std::vector< VertexMonitor * >	theVertexMonitor
edm::EDGetTokenT< TrackCandidateCollection >	trackCandidateToken_
edm::EDGetTokenT< edm::View< reco::Track > >	trackToken_
edm::ESGetToken< TransientTrackingRecHitBuilder, TransientRecHitRecord >	transientTrackingRecHitBuilderToken_

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

Monitoring source for general quantities related to tracks.

Definition at line 63 of file TrackingMonitor.h.

Member Typedef Documentation

MVACollection

using TrackingMonitor::MVACollection = std::vector<float>

Definition at line 65 of file TrackingMonitor.h.

QualityMaskCollection

using TrackingMonitor::QualityMaskCollection = std::vector<unsigned char>

Definition at line 66 of file TrackingMonitor.h.

Constructor & Destructor Documentation

TrackingMonitor()

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

explicit

Definition at line 47 of file TrackingMonitor.cc.

References AlgoName_, allTrackToken_, bsSrc_, bsSrcToken_, builderName, c, doAllSeedPlots, doFractionPlot_, doMVAPlots, doPlotsVsBX_, doPlotsVsBXlumi_, doPlotsVsGoodPVtx_, doPlotsVsLUMI_, doPUmonitoring_, doRegionCandidatePlots, doRegionPlots, doTkCandPlots, Exception, edm::ParameterSet::getParameter(), mps_fire::i, edm::EDGetTokenT< T >::isUninitialized(), edm::InputTag::label(), lumiscalersToken_, magneticFieldToken_, metaDataToken_, mvaQualityTokens_, mvaTrackToken_, pixelClusterInputTag_, pixelClustersToken_, TrackerCollisionTrackingMonitor_cfi::primaryVertexInputTags, TrackerCollisionTrackingMonitor_cfi::pvLabels, pvSrc_, pvSrcToken_, Quality_, regionCandidateToken_, regionLayerSetsToken_, ValL1Emulator_cff::regionTag, regionToken_, runTrackBuildingAnalyzerForSeed, seedStopInfoToken_, seedToken_, TrackerCollisionTrackingMonitor_cfi::selPrimaryVertexInputTags, AlCaHLTBitMon_QueryRunRegistry::string, stripClusterInputTag_, stripClustersToken_, makeGlobalPositionRcd_cfg::tag, theLumiDetails_, theTrackAnalyzer, theVertexMonitor, trackCandidateToken_, L1TCSCTF_cfi::trackProducer, trackToken_, transientTrackingRecHitBuilderToken_, and edm::vector_transform().

    : confID_(iConfig.id()),
      theTrackBuildingAnalyzer(new TrackBuildingAnalyzer(iConfig)),
      NumberOfTracks(nullptr),
      NumberOfMeanRecHitsPerTrack(nullptr),
      NumberOfMeanLayersPerTrack(nullptr)
      //    , NumberOfGoodTracks(NULL)
      ,
      FractionOfGoodTracks(nullptr),
      NumberOfTrackingRegions(nullptr),
      NumberOfSeeds(nullptr),
      NumberOfSeeds_lumiFlag(nullptr),
      NumberOfTrackCandidates(nullptr),
      FractionCandidatesOverSeeds(nullptr)
      //    , NumberOfGoodTrkVsClus(NULL)
      ,
      NumberEventsOfVsLS(nullptr),
      NumberOfTracksVsLS(nullptr)
      //    , NumberOfGoodTracksVsLS(NULL)
      ,
      GoodTracksFractionVsLS(nullptr)
      //    , GoodTracksNumberOfRecHitsPerTrackVsLS(NULL)
      // ADD by Mia for PU monitoring
      // vertex plots to be moved in ad hoc class
      ,
      NumberOfGoodPVtxVsLS(nullptr),
      NumberOfGoodPVtxWO0VsLS(nullptr),
      NumberEventsOfVsBX(nullptr),
      NumberOfTracksVsBX(nullptr),
      GoodTracksFractionVsBX(nullptr),
      NumberOfRecHitsPerTrackVsBX(nullptr),
      NumberOfGoodPVtxVsBX(nullptr),
      NumberOfGoodPVtxWO0VsBX(nullptr),
      NumberOfTracksVsBXlumi(nullptr),
      NumberOfTracksVsGoodPVtx(nullptr),
      NumberOfTracksVsPUPVtx(nullptr),
      NumberEventsOfVsGoodPVtx(nullptr),
      GoodTracksFractionVsGoodPVtx(nullptr),
      NumberOfRecHitsPerTrackVsGoodPVtx(nullptr),
      NumberOfPVtxVsGoodPVtx(nullptr),
      NumberOfPixelClustersVsGoodPVtx(nullptr),
      NumberOfStripClustersVsGoodPVtx(nullptr),
      NumberEventsOfVsLUMI(nullptr),
      NumberOfTracksVsLUMI(nullptr),
      GoodTracksFractionVsLUMI(nullptr),
      NumberOfRecHitsPerTrackVsLUMI(nullptr),
      NumberOfGoodPVtxVsLUMI(nullptr),
      NumberOfGoodPVtxWO0VsLUMI(nullptr),
      NumberOfPixelClustersVsLUMI(nullptr),
      NumberOfStripClustersVsLUMI(nullptr),
      NumberOfTracks_lumiFlag(nullptr)
      //    , NumberOfGoodTracks_lumiFlag(NULL)

      ,
      builderName(iConfig.getParameter<std::string>("TTRHBuilder")),
      doTrackerSpecific_(iConfig.getParameter<bool>("doTrackerSpecific")),
      doLumiAnalysis(iConfig.getParameter<bool>("doLumiAnalysis")),
      doProfilesVsLS_(iConfig.getParameter<bool>("doProfilesVsLS")),
      doAllSeedPlots(iConfig.getParameter<bool>("doSeedParameterHistos")),
      doAllPlots(iConfig.getParameter<bool>("doAllPlots")),
      doGeneralPropertiesPlots_(iConfig.getParameter<bool>("doGeneralPropertiesPlots")),
      doHitPropertiesPlots_(iConfig.getParameter<bool>("doHitPropertiesPlots")),
      doTkCandPlots(iConfig.getParameter<bool>("doTrackCandHistos")),
      doPUmonitoring_(iConfig.getParameter<bool>("doPUmonitoring")),
      genTriggerEventFlag_(new GenericTriggerEventFlag(
          iConfig.getParameter<edm::ParameterSet>("genericTriggerEventPSet"), consumesCollector(), *this)),
      numSelection_(iConfig.getParameter<std::string>("numCut")),
      denSelection_(iConfig.getParameter<std::string>("denCut")),
      pvNDOF_(iConfig.getParameter<int>("pvNDOF")),
      forceSCAL_(iConfig.getParameter<bool>("forceSCAL")) {
  edm::ConsumesCollector c{consumesCollector()};
  theTrackAnalyzer = new tadqm::TrackAnalyzer(iConfig, c);

  // input tags for collections from the configuration
  bsSrc_ = iConfig.getParameter<edm::InputTag>("beamSpot");
  pvSrc_ = iConfig.getParameter<edm::InputTag>("primaryVertex");
  bsSrcToken_ = consumes<reco::BeamSpot>(bsSrc_);
  pvSrcToken_ = mayConsume<reco::VertexCollection>(pvSrc_);

  lumiscalersToken_ = consumes<LumiScalersCollection>(iConfig.getParameter<edm::InputTag>("scal"));
  metaDataToken_ = consumes<OnlineLuminosityRecord>(iConfig.getParameter<edm::InputTag>("metadata"));

  edm::InputTag alltrackProducer = iConfig.getParameter<edm::InputTag>("allTrackProducer");
  edm::InputTag trackProducer = iConfig.getParameter<edm::InputTag>("TrackProducer");
  edm::InputTag tcProducer = iConfig.getParameter<edm::InputTag>("TCProducer");
  edm::InputTag seedProducer = iConfig.getParameter<edm::InputTag>("SeedProducer");
  allTrackToken_ = consumes<edm::View<reco::Track> >(alltrackProducer);
  trackToken_ = consumes<edm::View<reco::Track> >(trackProducer);
  trackCandidateToken_ = consumes<TrackCandidateCollection>(tcProducer);
  seedToken_ = consumes<edm::View<TrajectorySeed> >(seedProducer);
  seedStopInfoToken_ = consumes<std::vector<SeedStopInfo> >(tcProducer);

  doMVAPlots = iConfig.getParameter<bool>("doMVAPlots");
  if (doMVAPlots) {
    mvaQualityTokens_ = edm::vector_transform(
        iConfig.getParameter<std::vector<std::string> >("MVAProducers"), [&](const std::string& tag) {
          return std::make_tuple(consumes<MVACollection>(edm::InputTag(tag, "MVAValues")),
                                 consumes<QualityMaskCollection>(edm::InputTag(tag, "QualityMasks")));
        });
    mvaTrackToken_ = consumes<edm::View<reco::Track> >(iConfig.getParameter<edm::InputTag>("TrackProducerForMVA"));
  }

  doRegionPlots = iConfig.getParameter<bool>("doRegionPlots");
  doRegionCandidatePlots = iConfig.getParameter<bool>("doRegionCandidatePlots");
  if (doRegionPlots) {
    const auto& regionTag = iConfig.getParameter<edm::InputTag>("RegionProducer");
    if (!regionTag.label().empty()) {
      regionToken_ = consumes<edm::OwnVector<TrackingRegion> >(regionTag);
    }
    const auto& regionLayersTag = iConfig.getParameter<edm::InputTag>("RegionSeedingLayersProducer");
    if (!regionLayersTag.label().empty()) {
      if (!regionToken_.isUninitialized()) {
        throw cms::Exception("Configuration")
            << "Only one of 'RegionProducer' and 'RegionSeedingLayersProducer' can be non-empty, now both are.";
      }
      regionLayerSetsToken_ = consumes<TrackingRegionsSeedingLayerSets>(regionLayersTag);
    } else if (regionToken_.isUninitialized()) {
      throw cms::Exception("Configuration") << "With doRegionPlots=True either 'RegionProducer' or "
                                               "'RegionSeedingLayersProducer' must be non-empty, now both are empty.";
    }

    if (doRegionCandidatePlots) {
      regionCandidateToken_ = consumes<reco::CandidateView>(iConfig.getParameter<edm::InputTag>("RegionCandidates"));
    }
  }

  edm::InputTag stripClusterInputTag_ = iConfig.getParameter<edm::InputTag>("stripCluster");
  edm::InputTag pixelClusterInputTag_ = iConfig.getParameter<edm::InputTag>("pixelCluster");
  stripClustersToken_ = mayConsume<edmNew::DetSetVector<SiStripCluster> >(stripClusterInputTag_);
  pixelClustersToken_ = mayConsume<edmNew::DetSetVector<SiPixelCluster> >(pixelClusterInputTag_);

  runTrackBuildingAnalyzerForSeed =
      (doAllSeedPlots || iConfig.getParameter<bool>("doSeedPTHisto") || iConfig.getParameter<bool>("doSeedETAHisto") ||
       iConfig.getParameter<bool>("doSeedPHIHisto") || iConfig.getParameter<bool>("doSeedPHIVsETAHisto") ||
       iConfig.getParameter<bool>("doSeedThetaHisto") || iConfig.getParameter<bool>("doSeedQHisto") ||
       iConfig.getParameter<bool>("doSeedDxyHisto") || iConfig.getParameter<bool>("doSeedDzHisto") ||
       iConfig.getParameter<bool>("doSeedNRecHitsHisto") || iConfig.getParameter<bool>("doSeedNVsPhiProf") ||
       iConfig.getParameter<bool>("doSeedNVsEtaProf"));

  if (doTkCandPlots || doAllSeedPlots || runTrackBuildingAnalyzerForSeed) {
    magneticFieldToken_ = esConsumes<MagneticField, IdealMagneticFieldRecord>();
    transientTrackingRecHitBuilderToken_ =
        esConsumes<TransientTrackingRecHitBuilder, TransientRecHitRecord>(edm::ESInputTag("", builderName));
  }

  doFractionPlot_ = true;
  if (alltrackProducer.label() == trackProducer.label())
    doFractionPlot_ = false;

  Quality_ = iConfig.getParameter<std::string>("Quality");
  AlgoName_ = iConfig.getParameter<std::string>("AlgoName");

  // get flag from the configuration
  doPlotsVsBXlumi_ = iConfig.getParameter<bool>("doPlotsVsBXlumi");
  if (doPlotsVsBXlumi_)
    theLumiDetails_ = new GetLumi(iConfig.getParameter<edm::ParameterSet>("BXlumiSetup"), c);
  doPlotsVsGoodPVtx_ = iConfig.getParameter<bool>("doPlotsVsGoodPVtx");
  doPlotsVsLUMI_ = iConfig.getParameter<bool>("doPlotsVsLUMI");
  doPlotsVsBX_ = iConfig.getParameter<bool>("doPlotsVsBX");

  if (doPUmonitoring_) {
    std::vector<edm::InputTag> primaryVertexInputTags =
        iConfig.getParameter<std::vector<edm::InputTag> >("primaryVertexInputTags");
    std::vector<edm::InputTag> selPrimaryVertexInputTags =
        iConfig.getParameter<std::vector<edm::InputTag> >("selPrimaryVertexInputTags");
    std::vector<std::string> pvLabels = iConfig.getParameter<std::vector<std::string> >("pvLabels");

    if (primaryVertexInputTags.size() == pvLabels.size() and
        primaryVertexInputTags.size() == selPrimaryVertexInputTags.size()) {
      for (size_t i = 0; i < primaryVertexInputTags.size(); i++) {
        edm::InputTag iPVinputTag = primaryVertexInputTags[i];
        edm::InputTag iSelPVinputTag = selPrimaryVertexInputTags[i];
        std::string iPVlabel = pvLabels[i];

        theVertexMonitor.push_back(new VertexMonitor(iConfig, iPVinputTag, iSelPVinputTag, iPVlabel, c));
      }
    }
  }
}

~TrackingMonitor()

TrackingMonitor::~TrackingMonitor ( )

override

Definition at line 227 of file TrackingMonitor.cc.

References doPUmonitoring_, genTriggerEventFlag_, mps_fire::i, theTrackAnalyzer, theTrackBuildingAnalyzer, and theVertexMonitor.

                                  {
  if (theTrackAnalyzer)
    delete theTrackAnalyzer;
  if (theTrackBuildingAnalyzer)
    delete theTrackBuildingAnalyzer;
  if (doPUmonitoring_)
    for (size_t i = 0; i < theVertexMonitor.size(); i++)
      if (theVertexMonitor[i])
        delete theVertexMonitor[i];
  if (genTriggerEventFlag_)
    delete genTriggerEventFlag_;
}

Member Function Documentation

analyze()

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

overridevirtual

Reimplemented from DQMEDAnalyzer.

Definition at line 741 of file TrackingMonitor.cc.

References funct::abs(), GenericTriggerEventFlag::accept(), allTrackToken_, TrackBuildingAnalyzer::analyze(), tadqm::TrackAnalyzer::analyze(), cms::cuda::bs, bsSrcToken_, simKBmtfDigis_cfi::bx, ClusterLabels, confID_, COUT, denSelection_, doAllPlots, doAllSeedPlots, doFractionPlot_, doGeneralPropertiesPlots_, doLumiAnalysis, doMVAPlots, doPlotsVsBX_, doPlotsVsBXlumi_, doPlotsVsGoodPVtx_, doPlotsVsLUMI_, doProfilesVsLS_, doPUmonitoring_, doRegionCandidatePlots, doRegionPlots, doSeedLumiAnalysis_, doSeedNumberPlot, doSeedVsClusterPlot, doTkCandPlots, doTrackerSpecific_, dqm::impl::MonitorElement::Fill(), forceSCAL_, DivergingColor::frac, FractionCandidatesOverSeeds, FractionOfGoodTracks, genTriggerEventFlag_, edm::EventSetup::getData(), edm::pset::Registry::getMapped(), GetLumi::getValue(), GoodTracksFractionVsBX, GoodTracksFractionVsGoodPVtx, GoodTracksFractionVsLS, GoodTracksFractionVsLUMI, mps_fire::i, iEvent, edm::pset::Registry::instance(), OnlineLuminosityRecord::instLumi(), reco::Vertex::isFake(), edm::EDGetTokenT< T >::isUninitialized(), edm::HandleBase::isValid(), V0Monitor_cfi::lumiScalers, lumiscalersToken_, magneticFieldToken_, MEFolderName, metaDataToken_, mvaQualityTokens_, mvaTrackToken_, reco::Vertex::ndof(), NumberEventsOfVsBX, NumberEventsOfVsGoodPVtx, NumberEventsOfVsLS, NumberEventsOfVsLUMI, NumberOfGoodPVtxVsBX, NumberOfGoodPVtxVsLS, NumberOfGoodPVtxVsLUMI, NumberOfGoodPVtxWO0VsBX, NumberOfGoodPVtxWO0VsLS, NumberOfGoodPVtxWO0VsLUMI, NumberOfMeanLayersPerTrack, NumberOfMeanRecHitsPerTrack, NumberOfPixelClustersVsGoodPVtx, NumberOfPixelClustersVsLUMI, NumberOfPVtxVsGoodPVtx, NumberOfRecHitsPerTrackVsBX, NumberOfRecHitsPerTrackVsGoodPVtx, NumberOfRecHitsPerTrackVsLS, NumberOfRecHitsPerTrackVsLUMI, NumberOfSeeds, NumberOfSeeds_lumiFlag, NumberOfStripClustersVsGoodPVtx, NumberOfStripClustersVsLUMI, NumberOfTrackCandidates, NumberOfTrackingRegions, NumberOfTracks, NumberofTracks_Hardvtx, NumberofTracks_Hardvtx_PUvtx, NumberOfTracks_lumiFlag, NumberOfTracks_PUvtx, NumberOfTracksVsBX, NumberOfTracksVsBXlumi, NumberOfTracksVsGoodPVtx, NumberOfTracksVsLS, NumberOfTracksVsLUMI, NumberOfTracksVsPUPVtx, NumberOfTrkVsClusters, numSelection_, GenericTriggerEventFlag::on(), reco::Vertex::position(), edm::Handle< T >::product(), MetAnalyzer::pv(), pvNDOF_, pvSrcToken_, regionCandidateToken_, regionLayerSetsToken_, regionToken_, runTrackBuildingAnalyzerForSeed, ElectronSeedTrackRefFix_cfi::seedCollection, seedStopInfoToken_, SeedsVsClusters, seedToken_, tadqm::TrackAnalyzer::setBX(), tadqm::TrackAnalyzer::setLumi(), setNclus(), tadqm::TrackAnalyzer::setNumberOfGoodVertices(), contentValuesCheck::ss, AlCaHLTBitMon_QueryRunRegistry::string, theLumiDetails_, theTrackAnalyzer, theTrackBuildingAnalyzer, theVertexMonitor, HLT_2022v14_cff::track, trackCandidateToken_, duplicaterechits_cfi::trackCollection, reco::Vertex::tracksSize(), trackToken_, transientTrackingRecHitBuilderToken_, parallelization::uint, and reco::Vertex::z().

                                                                                 {
  // Filter out events if Trigger Filtering is requested
  if (genTriggerEventFlag_->on() && !genTriggerEventFlag_->accept(iEvent, iSetup))
    return;
  auto const* conf = edm::pset::Registry::instance()->getMapped(confID_);
  MEFolderName = conf->getParameter<std::string>("FolderName");
  std::string Folder = MEFolderName.substr(0, 2);
  float lumi = -1.;
  if (forceSCAL_) {
    edm::Handle<LumiScalersCollection> lumiScalers = iEvent.getHandle(lumiscalersToken_);
    if (lumiScalers.isValid() && !lumiScalers->empty()) {
      LumiScalersCollection::const_iterator scalit = lumiScalers->begin();
      lumi = scalit->instantLumi();
    }
  } else {
    edm::Handle<OnlineLuminosityRecord> metaData = iEvent.getHandle(metaDataToken_);
    if (metaData.isValid())
      lumi = metaData->instLumi();
  }

  if (doPlotsVsLUMI_ || doAllPlots)
    NumberEventsOfVsLUMI->Fill(lumi);

  //  Analyse the tracks
  //  if the collection is empty, do not fill anything
  // ---------------------------------------------------------------------------------//

  size_t bx = iEvent.bunchCrossing();
  if (doPlotsVsBX_ || doAllPlots)
    NumberEventsOfVsBX->Fill(bx);

  // get the track collection
  edm::Handle<edm::View<reco::Track> > trackHandle = iEvent.getHandle(trackToken_);

  int numberOfTracks_den = 0;
  edm::Handle<edm::View<reco::Track> > allTrackHandle = iEvent.getHandle(allTrackToken_);
  if (allTrackHandle.isValid()) {
    for (edm::View<reco::Track>::const_iterator track = allTrackHandle->begin(); track != allTrackHandle->end();
         ++track) {
      if (denSelection_(*track))
        numberOfTracks_den++;
    }
  }

  edm::Handle<reco::VertexCollection> pvHandle = iEvent.getHandle(pvSrcToken_);
  reco::Vertex const* pv0 = nullptr;
  if (pvHandle.isValid()) {
    pv0 = &pvHandle->front();
    //--- pv fake (the pv collection should have size==1 and the pv==beam spot)
    if (pv0->isFake() ||
        pv0->tracksSize() == 0
        // definition of goodOfflinePrimaryVertex
        || pv0->ndof() < pvNDOF_ || pv0->z() > 24.)
      pv0 = nullptr;
  }

  if (trackHandle.isValid()) {
    int numberOfTracks = trackHandle->size();
    int numberOfTracks_num = 0;
    int numberOfTracks_pv0 = 0;

    const edm::View<reco::Track>& trackCollection = *trackHandle;
    // calculate the mean # rechits and layers
    int totalRecHits = 0, totalLayers = 0;

    theTrackAnalyzer->setNumberOfGoodVertices(iEvent);
    theTrackAnalyzer->setBX(iEvent);
    theTrackAnalyzer->setLumi(iEvent, iSetup);
    for (edm::View<reco::Track>::const_iterator track = trackCollection.begin(); track != trackCollection.end();
         ++track) {
      if (doPlotsVsBX_ || doAllPlots)
        NumberOfRecHitsPerTrackVsBX->Fill(bx, track->numberOfValidHits());
      if (numSelection_(*track)) {
        numberOfTracks_num++;
        if (pv0 && std::abs(track->dz(pv0->position())) < 0.15)
          ++numberOfTracks_pv0;
      }

      if (doProfilesVsLS_ || doAllPlots)
        NumberOfRecHitsPerTrackVsLS->Fill(static_cast<double>(iEvent.id().luminosityBlock()),
                                          track->numberOfValidHits());

      if (doPlotsVsLUMI_ || doAllPlots)
        NumberOfRecHitsPerTrackVsLUMI->Fill(lumi, track->numberOfValidHits());

      totalRecHits += track->numberOfValidHits();
      totalLayers += track->hitPattern().trackerLayersWithMeasurement();

      // do analysis per track
      theTrackAnalyzer->analyze(iEvent, iSetup, *track);
    }

    double frac = -1.;
    //      if (numberOfAllTracks > 0) frac = static_cast<double>(numberOfTracks)/static_cast<double>(numberOfAllTracks);
    if (numberOfTracks_den > 0)
      frac = static_cast<double>(numberOfTracks_num) / static_cast<double>(numberOfTracks_den);

    if (doGeneralPropertiesPlots_ || doAllPlots) {
      NumberOfTracks->Fill(double(numberOfTracks));

      if (Folder == "Tr") {
        NumberofTracks_Hardvtx->Fill(double(numberOfTracks_pv0));
        NumberOfTracks_PUvtx->Fill(double(numberOfTracks - numberOfTracks_pv0));
        NumberofTracks_Hardvtx_PUvtx->Fill(0.5, double(numberOfTracks_pv0));
        NumberofTracks_Hardvtx_PUvtx->Fill(1.5, double(numberOfTracks - numberOfTracks_pv0));
      }

      if (doPlotsVsBX_ || doAllPlots)
        NumberOfTracksVsBX->Fill(bx, numberOfTracks);
      if (doPlotsVsLUMI_ || doAllPlots)
        NumberOfTracksVsLUMI->Fill(lumi, numberOfTracks);
      if (doFractionPlot_) {
        FractionOfGoodTracks->Fill(frac);

        if (doFractionPlot_) {
          if (doPlotsVsBX_ || doAllPlots)
            GoodTracksFractionVsBX->Fill(bx, frac);
          if (doPlotsVsLUMI_ || doAllPlots)
            GoodTracksFractionVsLUMI->Fill(lumi, frac);
        }
      }
      if (numberOfTracks > 0) {
        double meanRecHits = static_cast<double>(totalRecHits) / static_cast<double>(numberOfTracks);
        double meanLayers = static_cast<double>(totalLayers) / static_cast<double>(numberOfTracks);
        NumberOfMeanRecHitsPerTrack->Fill(meanRecHits);
        NumberOfMeanLayersPerTrack->Fill(meanLayers);
      }
    }

    if (doProfilesVsLS_ || doAllPlots) {
      float nLS = static_cast<double>(iEvent.id().luminosityBlock());
      NumberEventsOfVsLS->Fill(nLS);
      NumberOfTracksVsLS->Fill(nLS, numberOfTracks);
      if (doFractionPlot_)
        GoodTracksFractionVsLS->Fill(nLS, frac);
    }

    if (doLumiAnalysis) {
      NumberOfTracks_lumiFlag->Fill(numberOfTracks);
    }

    //  Analyse the Track Building variables
    //  if the collection is empty, do not fill anything
    // ---------------------------------------------------------------------------------//

    // fill the TrackCandidate info
    if (doTkCandPlots) {
      // magnetic field
      MagneticField const& theMF = iSetup.getData(magneticFieldToken_);

      // get the candidate collection
      edm::Handle<TrackCandidateCollection> theTCHandle = iEvent.getHandle(trackCandidateToken_);
      const TrackCandidateCollection& theTCCollection = *theTCHandle;

      if (theTCHandle.isValid()) {
        // get the beam spot
        edm::Handle<reco::BeamSpot> recoBeamSpotHandle = iEvent.getHandle(bsSrcToken_);
        const reco::BeamSpot& bs = *recoBeamSpotHandle;

        NumberOfTrackCandidates->Fill(theTCCollection.size());

        // get the seed collection
        edm::Handle<edm::View<TrajectorySeed> > seedHandle = iEvent.getHandle(seedToken_);
        const edm::View<TrajectorySeed>& seedCollection = *seedHandle;
        if (seedHandle.isValid() && !seedCollection.empty())
          FractionCandidatesOverSeeds->Fill(double(theTCCollection.size()) / double(seedCollection.size()));

        TransientTrackingRecHitBuilder const& theTTRHBuilder = iSetup.getData(transientTrackingRecHitBuilderToken_);
        for (TrackCandidateCollection::const_iterator cand = theTCCollection.begin(); cand != theTCCollection.end();
             ++cand) {
          theTrackBuildingAnalyzer->analyze(iEvent, iSetup, *cand, bs, theMF, theTTRHBuilder);
        }
      } else {
        edm::LogWarning("TrackingMonitor") << "No Track Candidates in the event.  Not filling associated histograms";
      }

      if (doMVAPlots) {
        // Get MVA and quality mask collections
        std::vector<const MVACollection*> mvaCollections;
        std::vector<const QualityMaskCollection*> qualityMaskCollections;

        edm::Handle<edm::View<reco::Track> > htracks = iEvent.getHandle(mvaTrackToken_);

        edm::Handle<MVACollection> hmva;
        edm::Handle<QualityMaskCollection> hqual;
        for (const auto& tokenTpl : mvaQualityTokens_) {
          hmva = iEvent.getHandle(std::get<0>(tokenTpl));
          hqual = iEvent.getHandle(std::get<1>(tokenTpl));
          mvaCollections.push_back(hmva.product());
          qualityMaskCollections.push_back(hqual.product());
        }
        theTrackBuildingAnalyzer->analyze(*htracks, mvaCollections, qualityMaskCollections);
      }
    }

    //plots for trajectory seeds

    if (doAllSeedPlots || doSeedNumberPlot || doSeedVsClusterPlot || runTrackBuildingAnalyzerForSeed) {
      // get the seed collection
      edm::Handle<edm::View<TrajectorySeed> > seedHandle = iEvent.getHandle(seedToken_);

      // fill the seed info
      if (seedHandle.isValid()) {
        const auto& seedCollection = *seedHandle;

        if (doAllSeedPlots || doSeedNumberPlot) {
          NumberOfSeeds->Fill(seedCollection.size());
          if (doSeedLumiAnalysis_)
            NumberOfSeeds_lumiFlag->Fill(seedCollection.size());
        }

        if (doAllSeedPlots || doSeedVsClusterPlot) {
          std::vector<int> NClus;
          setNclus(iEvent, NClus);
          for (uint i = 0; i < ClusterLabels.size(); i++) {
            SeedsVsClusters[i]->Fill(NClus[i], seedCollection.size());
          }
        }

        if (doAllSeedPlots || runTrackBuildingAnalyzerForSeed) {
          edm::Handle<std::vector<SeedStopInfo> > stopHandle = iEvent.getHandle(seedStopInfoToken_);
          const auto& seedStopInfo = *stopHandle;

          if (seedStopInfo.size() == seedCollection.size()) {
            //here duplication of mag field and be informations is needed to allow seed and track cand histos to be independent
            // magnetic field
            MagneticField const& theMF = iSetup.getData(magneticFieldToken_);

            // get the beam spot
            edm::Handle<reco::BeamSpot> recoBeamSpotHandle = iEvent.getHandle(bsSrcToken_);
            const reco::BeamSpot& bs = *recoBeamSpotHandle;

            TransientTrackingRecHitBuilder const& theTTRHBuilder = iSetup.getData(transientTrackingRecHitBuilderToken_);
            for (size_t i = 0; i < seedCollection.size(); ++i) {
              theTrackBuildingAnalyzer->analyze(
                  iEvent, iSetup, seedCollection[i], seedStopInfo[i], bs, theMF, theTTRHBuilder);
            }
          } else {
            edm::LogWarning("TrackingMonitor")
                << "Seed collection size (" << seedCollection.size()
                << ") differs from seed stop info collection size (" << seedStopInfo.size()
                << "). This is a sign of inconsistency in the configuration. Not filling associated histograms.";
          }
        }

      } else {
        edm::LogWarning("TrackingMonitor") << "No Trajectory seeds in the event.  Not filling associated histograms";
      }
    }

    // plots for tracking regions
    if (doRegionPlots) {
      if (!regionToken_.isUninitialized()) {
        edm::Handle<edm::OwnVector<TrackingRegion> > hregions = iEvent.getHandle(regionToken_);
        const auto& regions = *hregions;
        NumberOfTrackingRegions->Fill(regions.size());

        theTrackBuildingAnalyzer->analyze(regions);
      } else if (!regionLayerSetsToken_.isUninitialized()) {
        edm::Handle<TrackingRegionsSeedingLayerSets> hregions = iEvent.getHandle(regionLayerSetsToken_);
        const auto& regions = *hregions;
        NumberOfTrackingRegions->Fill(regions.regionsSize());

        theTrackBuildingAnalyzer->analyze(regions);
      }

      if (doRegionCandidatePlots) {
        edm::Handle<reco::CandidateView> hcandidates = iEvent.getHandle(regionCandidateToken_);
        theTrackBuildingAnalyzer->analyze(*hcandidates);
      }
    }

    if (doTrackerSpecific_ || doAllPlots) {
      std::vector<int> NClus;
      setNclus(iEvent, NClus);
      for (uint i = 0; i < ClusterLabels.size(); i++) {
        NumberOfTrkVsClusters[i]->Fill(NClus[i], numberOfTracks);
      }
    }

    if (doPUmonitoring_) {
      // do vertex monitoring
      for (size_t i = 0; i < theVertexMonitor.size(); i++)
        theVertexMonitor[i]->analyze(iEvent, iSetup);
    }
    if (doPlotsVsGoodPVtx_) {
      size_t totalNumGoodPV = 0;
      if (pvHandle.isValid()) {
        for (reco::VertexCollection::const_iterator pv = pvHandle->begin(); pv != pvHandle->end(); ++pv) {
          //--- pv fake (the pv collection should have size==1 and the pv==beam spot)
          if (pv->isFake() || pv->tracksSize() == 0)
            continue;

          // definition of goodOfflinePrimaryVertex
          if (pv->ndof() < pvNDOF_ || pv->z() > 24.)
            continue;
          totalNumGoodPV++;
        }

        NumberEventsOfVsGoodPVtx->Fill(float(totalNumGoodPV));
        NumberOfTracksVsGoodPVtx->Fill(float(totalNumGoodPV), numberOfTracks);
        if (totalNumGoodPV > 1)
          NumberOfTracksVsPUPVtx->Fill(totalNumGoodPV - 1,
                                       double(numberOfTracks - numberOfTracks_pv0) / double(totalNumGoodPV - 1));
        NumberOfPVtxVsGoodPVtx->Fill(float(totalNumGoodPV), pvHandle->size());

        for (edm::View<reco::Track>::const_iterator track = trackCollection.begin(); track != trackCollection.end();
             ++track) {
          NumberOfRecHitsPerTrackVsGoodPVtx->Fill(float(totalNumGoodPV), track->numberOfValidHits());
        }

        if (doProfilesVsLS_ || doAllPlots)
          NumberOfGoodPVtxVsLS->Fill(static_cast<double>(iEvent.id().luminosityBlock()), totalNumGoodPV);
        if (doPlotsVsBX_ || doAllPlots)
          NumberOfGoodPVtxVsBX->Fill(bx, float(totalNumGoodPV));

        if (doFractionPlot_)
          GoodTracksFractionVsGoodPVtx->Fill(float(totalNumGoodPV), frac);

        if (doPlotsVsLUMI_ || doAllPlots)
          NumberOfGoodPVtxVsLUMI->Fill(lumi, float(totalNumGoodPV));
      }

      std::vector<int> NClus;
      setNclus(iEvent, NClus);
      std::ostringstream ss;
      ss << "VI stat " << totalNumGoodPV << ' ' << numberOfTracks;
      for (uint i = 0; i < ClusterLabels.size(); i++) {
        ss << ' ' << NClus[i];
        if (doPlotsVsLUMI_ || doAllPlots) {
          if (ClusterLabels[i] == "Pix")
            NumberOfPixelClustersVsLUMI->Fill(lumi, NClus[i]);
          if (ClusterLabels[i] == "Strip")
            NumberOfStripClustersVsLUMI->Fill(lumi, NClus[i]);
        }
        if (ClusterLabels[i] == "Pix")
          NumberOfPixelClustersVsGoodPVtx->Fill(float(totalNumGoodPV), NClus[i]);
        if (ClusterLabels[i] == "Strip")
          NumberOfStripClustersVsGoodPVtx->Fill(float(totalNumGoodPV), NClus[i]);
      }
      COUT(MEFolderName) << ss.str() << std::endl;
      if (doPlotsVsBXlumi_) {
        double bxlumi = theLumiDetails_->getValue(iEvent);
        NumberOfTracksVsBXlumi->Fill(bxlumi, numberOfTracks);
      }

      if (doProfilesVsLS_ || doAllPlots)
        if (totalNumGoodPV != 0)
          NumberOfGoodPVtxWO0VsLS->Fill(static_cast<double>(iEvent.id().luminosityBlock()), float(totalNumGoodPV));
      if (doPlotsVsBX_ || doAllPlots)
        if (totalNumGoodPV != 0)
          NumberOfGoodPVtxWO0VsBX->Fill(bx, float(totalNumGoodPV));
      if (doPlotsVsLUMI_ || doAllPlots)
        if (totalNumGoodPV != 0)
          NumberOfGoodPVtxWO0VsLUMI->Fill(lumi, float(totalNumGoodPV));

    }  // PU monitoring

  }  // trackHandle is valid
}

bookHistograms()

void TrackingMonitor::bookHistograms ( DQMStore::IBooker &  ibooker, edm::Run const &  iRun, edm::EventSetup const &  iSetup  )

overridevirtual

Implements DQMEDAnalyzer.

Definition at line 240 of file TrackingMonitor.cc.

References HLTSiStripMonitoring_cff::AlgoName, AlgoName_, cms::cuda::assert(), dqm::implementation::IBooker::book1D(), dqm::implementation::IBooker::book2D(), dqm::implementation::IBooker::bookProfile(), BXlumiParameters_cfi::BXlumiBin, BXlumiParameters_cfi::BXlumiMax, BXlumiParameters_cfi::BXlumiMin, ClusterLabels, confID_, doAllPlots, doAllSeedPlots, doFractionPlot_, doGeneralPropertiesPlots_, doLumiAnalysis, doPlotsVsBX_, doPlotsVsBXlumi_, doPlotsVsGoodPVtx_, doPlotsVsLUMI_, doProfilesVsLS_, doPUmonitoring_, doRegionPlots, doSeedLumiAnalysis_, doSeedNumberPlot, doSeedVsClusterPlot, doTkCandPlots, doTrackerSpecific_, FractionCandidatesOverSeeds, FractionOfGoodTracks, genTriggerEventFlag_, edm::pset::Registry::getMapped(), edm::ParameterSet::getParameter(), dqm::impl::MonitorElement::getTH1(), TrackerCollisionTrackingMonitor_cfi::GoodPVtxMax, TrackerCollisionTrackingMonitor_cfi::GoodPVtxMin, GoodTracksFractionVsBX, GoodTracksFractionVsGoodPVtx, GoodTracksFractionVsLS, GoodTracksFractionVsLUMI, histname, mps_fire::i, TrackBuildingAnalyzer::initHisto(), tadqm::TrackAnalyzer::initHisto(), GenericTriggerEventFlag::initRun(), edm::pset::Registry::instance(), edm::InputTag::label(), siStripFEDCheck_cfi::LSBin, siStripFEDCheck_cfi::LSMax, siStripFEDCheck_cfi::LSMin, TrackingMonitor_cfi::LUMIBin, TrackingMonitor_cfi::LUMIMax, TrackingMonitor_cfi::LUMIMin, MonitorTrackSTAMuons_cfi::MeanHitBin, MonitorTrackSTAMuons_cfi::MeanHitMax, MonitorTrackSTAMuons_cfi::MeanHitMin, MonitorTrackSTAMuons_cfi::MeanLayBin, MonitorTrackSTAMuons_cfi::MeanLayMax, MonitorTrackSTAMuons_cfi::MeanLayMin, MEFolderName, MonitorTrackSTAMuons_cfi::NClusPxBin, MonitorTrackSTAMuons_cfi::NClusPxMax, MonitorTrackSTAMuons_cfi::NClusPxMin, MonitorTrackSTAMuons_cfi::NClusStrBin, MonitorTrackSTAMuons_cfi::NClusStrMax, MonitorTrackSTAMuons_cfi::NClusStrMin, MonitorTrackSTAMuons_cfi::NTrk2DBin, MonitorTrackSTAMuons_cfi::NTrk2DMax, MonitorTrackSTAMuons_cfi::NTrk2DMin, NumberEventsOfVsBX, NumberEventsOfVsGoodPVtx, NumberEventsOfVsLS, NumberEventsOfVsLUMI, NumberOfGoodPVtxVsBX, NumberOfGoodPVtxVsLS, NumberOfGoodPVtxVsLUMI, NumberOfGoodPVtxWO0VsBX, NumberOfGoodPVtxWO0VsLS, NumberOfGoodPVtxWO0VsLUMI, NumberOfMeanLayersPerTrack, NumberOfMeanRecHitsPerTrack, NumberOfPixelClustersVsGoodPVtx, NumberOfPixelClustersVsLUMI, NumberOfPVtxVsGoodPVtx, NumberOfRecHitsPerTrackVsBX, NumberOfRecHitsPerTrackVsGoodPVtx, NumberOfRecHitsPerTrackVsLS, NumberOfRecHitsPerTrackVsLUMI, NumberOfSeeds, NumberOfSeeds_lumiFlag, NumberOfStripClustersVsGoodPVtx, NumberOfStripClustersVsLUMI, NumberOfTrackCandidates, NumberOfTrackingRegions, NumberOfTracks, NumberofTracks_Hardvtx, NumberofTracks_Hardvtx_PUvtx, NumberOfTracks_lumiFlag, NumberOfTracks_PUvtx, NumberOfTracksVsBX, NumberOfTracksVsBXlumi, NumberOfTracksVsGoodPVtx, NumberOfTracksVsLS, NumberOfTracksVsLUMI, NumberOfTracksVsPUPVtx, NumberOfTrkVsClusters, GenericTriggerEventFlag::on(), MonitorTrackInnerTrackMuons_cff::PVBin, MonitorTrackInnerTrackMuons_cff::PVMax, MonitorTrackInnerTrackMuons_cff::PVMin, Quality_, MonitorTrackSTAMuons_cfi::RecHitMax, MonitorTrackSTAMuons_cfi::RecHitMin, SeedsVsClusters, dqm::impl::MonitorElement::setAxisTitle(), dqm::impl::MonitorElement::setBinLabel(), dqm::implementation::NavigatorBase::setCurrentFolder(), setMaxMinBin(), AlCaHLTBitMon_QueryRunRegistry::string, theTrackAnalyzer, theTrackBuildingAnalyzer, theVertexMonitor, runGCPTkAlMap::title, and parallelization::uint.

                                                                                                              {
  // parameters from the configuration
  auto const* conf = edm::pset::Registry::instance()->getMapped(confID_);
  assert(conf != nullptr);
  std::string Quality = conf->getParameter<std::string>("Quality");
  std::string AlgoName = conf->getParameter<std::string>("AlgoName");
  MEFolderName = conf->getParameter<std::string>("FolderName");
  std::string Folder = MEFolderName.substr(0, 2);

  // test for the Quality veriable validity
  if (!Quality_.empty()) {
    if (Quality_ != "highPurity" && Quality_ != "tight" && Quality_ != "loose") {
      edm::LogWarning("TrackingMonitor") << "Qualty Name is invalid, using no quality criterea by default";
      Quality_ = "";
    }
  }

  // use the AlgoName and Quality Name
  std::string CategoryName = !Quality_.empty() ? AlgoName_ + "_" + Quality_ : AlgoName_;

  // get binning from the configuration
  int TKNoBin = conf->getParameter<int>("TkSizeBin");
  double TKNoMin = conf->getParameter<double>("TkSizeMin");
  double TKNoMax = conf->getParameter<double>("TkSizeMax");

  int TCNoBin = conf->getParameter<int>("TCSizeBin");
  double TCNoMin = conf->getParameter<double>("TCSizeMin");
  double TCNoMax = conf->getParameter<double>("TCSizeMax");

  int TKNoSeedBin = conf->getParameter<int>("TkSeedSizeBin");
  double TKNoSeedMin = conf->getParameter<double>("TkSeedSizeMin");
  double TKNoSeedMax = conf->getParameter<double>("TkSeedSizeMax");

  //int RecHitBin = conf->getParameter<int>("RecHitBin");
  double RecHitMin = conf->getParameter<double>("RecHitMin");
  double RecHitMax = conf->getParameter<double>("RecHitMax");

  int MeanHitBin = conf->getParameter<int>("MeanHitBin");
  double MeanHitMin = conf->getParameter<double>("MeanHitMin");
  double MeanHitMax = conf->getParameter<double>("MeanHitMax");

  int MeanLayBin = conf->getParameter<int>("MeanLayBin");
  double MeanLayMin = conf->getParameter<double>("MeanLayMin");
  double MeanLayMax = conf->getParameter<double>("MeanLayMax");

  int LSBin = conf->getParameter<int>("LSBin");
  int LSMin = conf->getParameter<double>("LSMin");
  int LSMax = conf->getParameter<double>("LSMax");

  std::string StateName = conf->getParameter<std::string>("MeasurementState");
  if (StateName != "OuterSurface" && StateName != "InnerSurface" && StateName != "ImpactPoint" &&
      StateName != "default" && StateName != "All") {
    // print warning
    edm::LogWarning("TrackingMonitor") << "State Name is invalid, using 'ImpactPoint' by default";
  }

  ibooker.setCurrentFolder(MEFolderName);

  // book the General Property histograms
  // ---------------------------------------------------------------------------------//

  if (doGeneralPropertiesPlots_ || doAllPlots) {
    ibooker.setCurrentFolder(MEFolderName + "/GeneralProperties");

    histname = "NumberOfTracks_" + CategoryName;
    // MODIFY by Mia in order to cope w/ high multiplicity
    NumberOfTracks = ibooker.book1D(histname, histname, TKNoBin, TKNoMin, TKNoMax);
    NumberOfTracks->setAxisTitle("Number of Tracks per Event", 1);
    NumberOfTracks->setAxisTitle("Number of Events", 2);

    if (Folder == "Tr") {
      histname = "NumberOfTracks_PUvtx_" + CategoryName;
      NumberOfTracks_PUvtx = ibooker.book1D(histname, histname, TKNoBin, TKNoMin, TKNoMax);
      NumberOfTracks_PUvtx->setAxisTitle("Number of Tracks per Event (matched a PU vertex)", 1);
      NumberOfTracks_PUvtx->setAxisTitle("Number of Events", 2);

      histname = "NumberofTracks_Hardvtx_" + CategoryName;
      NumberofTracks_Hardvtx =
          ibooker.book1D(histname, histname, TKNoBin / 10, TKNoMin, ((TKNoMax - TKNoMin) / 10) - 0.5);
      NumberofTracks_Hardvtx->setAxisTitle("Number of Tracks per Event (matched main vertex)", 1);
      NumberofTracks_Hardvtx->setAxisTitle("Number of Events", 2);

      histname = "NumberofTracks_Hardvtx_PUvtx_" + CategoryName;
      NumberofTracks_Hardvtx_PUvtx = ibooker.book1D(histname, histname, 2, 0., 2.);
      NumberofTracks_Hardvtx_PUvtx->setAxisTitle("Number of Tracks per PU/Hard vertex", 1);
      NumberofTracks_Hardvtx_PUvtx->setAxisTitle("Number of Tracks", 2);
      NumberofTracks_Hardvtx_PUvtx->setBinLabel(1, "PU_Vertex");
      NumberofTracks_Hardvtx_PUvtx->setBinLabel(2, "Hard_Vertex");
    }

    histname = "NumberOfMeanRecHitsPerTrack_" + CategoryName;
    NumberOfMeanRecHitsPerTrack = ibooker.book1D(histname, histname, MeanHitBin, MeanHitMin, MeanHitMax);
    NumberOfMeanRecHitsPerTrack->setAxisTitle("Mean number of valid RecHits per Track", 1);
    NumberOfMeanRecHitsPerTrack->setAxisTitle("Entries", 2);

    histname = "NumberOfMeanLayersPerTrack_" + CategoryName;
    NumberOfMeanLayersPerTrack = ibooker.book1D(histname, histname, MeanLayBin, MeanLayMin, MeanLayMax);
    NumberOfMeanLayersPerTrack->setAxisTitle("Mean number of Layers per Track", 1);
    NumberOfMeanLayersPerTrack->setAxisTitle("Entries", 2);

    if (doFractionPlot_) {
      histname = "FractionOfGoodTracks_" + CategoryName;
      FractionOfGoodTracks = ibooker.book1D(histname, histname, 101, -0.005, 1.005);
      FractionOfGoodTracks->setAxisTitle("Fraction of Tracks (w.r.t. generalTracks)", 1);
      FractionOfGoodTracks->setAxisTitle("Entries", 2);
    }
  }

  if (doLumiAnalysis) {
    // add by Mia in order to deal with LS transitions
    ibooker.setCurrentFolder(MEFolderName + "/LSanalysis");
    auto scope = DQMStore::IBooker::UseLumiScope(ibooker);

    histname = "NumberOfTracks_lumiFlag_" + CategoryName;
    NumberOfTracks_lumiFlag = ibooker.book1D(histname, histname, TKNoBin, TKNoMin, TKNoMax);
    NumberOfTracks_lumiFlag->setAxisTitle("Number of Tracks per Event", 1);
    NumberOfTracks_lumiFlag->setAxisTitle("Number of Events", 2);
  }

  // book profile plots vs LS :
  //---------------------------

  if (doProfilesVsLS_ || doAllPlots) {
    ibooker.setCurrentFolder(MEFolderName + "/GeneralProperties");

    histname = "NumberOfTracksVsLS_" + CategoryName;
    NumberOfTracksVsLS = ibooker.bookProfile(histname, histname, LSBin, LSMin, LSMax, TKNoMin, TKNoMax, "");
    NumberOfTracksVsLS->getTH1()->SetCanExtend(TH1::kAllAxes);
    NumberOfTracksVsLS->setAxisTitle("#Lumi section", 1);
    NumberOfTracksVsLS->setAxisTitle("Number of  Tracks", 2);

    histname = "NumberOfRecHitsPerTrackVsLS_" + CategoryName;
    NumberOfRecHitsPerTrackVsLS =
        ibooker.bookProfile(histname, histname, LSBin, LSMin, LSMax, RecHitMin, RecHitMax * 5, "");
    NumberOfRecHitsPerTrackVsLS->getTH1()->SetCanExtend(TH1::kAllAxes);
    NumberOfRecHitsPerTrackVsLS->setAxisTitle("#Lumi section", 1);
    NumberOfRecHitsPerTrackVsLS->setAxisTitle("Mean number of Valid RecHits per track", 2);

    histname = "NumberEventsVsLS_" + CategoryName;
    NumberEventsOfVsLS = ibooker.book1D(histname, histname, LSBin, LSMin, LSMax);
    NumberEventsOfVsLS->getTH1()->SetCanExtend(TH1::kAllAxes);
    NumberEventsOfVsLS->setAxisTitle("#Lumi section", 1);
    NumberEventsOfVsLS->setAxisTitle("Number of events", 2);

    edm::ParameterSet ParametersGoodPVtx = conf->getParameter<edm::ParameterSet>("GoodPVtx");

    double GoodPVtxMin = ParametersGoodPVtx.getParameter<double>("GoodPVtxMin");
    double GoodPVtxMax = ParametersGoodPVtx.getParameter<double>("GoodPVtxMax");

    histname = "NumberOfGoodPVtxVsLS_" + CategoryName;
    NumberOfGoodPVtxVsLS =
        ibooker.bookProfile(histname, histname, LSBin, LSMin, LSMax, GoodPVtxMin, 3. * GoodPVtxMax, "");
    NumberOfGoodPVtxVsLS->getTH1()->SetCanExtend(TH1::kAllAxes);
    NumberOfGoodPVtxVsLS->setAxisTitle("#Lumi section", 1);
    NumberOfGoodPVtxVsLS->setAxisTitle("Mean number of good PV", 2);

    histname = "NumberOfGoodPVtxWO0VsLS_" + CategoryName;
    NumberOfGoodPVtxWO0VsLS =
        ibooker.bookProfile(histname, histname, LSBin, LSMin, LSMax, GoodPVtxMin, 3. * GoodPVtxMax, "");
    NumberOfGoodPVtxWO0VsLS->setAxisTitle("#Lumi section", 1);
    NumberOfGoodPVtxWO0VsLS->setAxisTitle("Mean number of good PV", 2);

    if (doFractionPlot_) {
      histname = "GoodTracksFractionVsLS_" + CategoryName;
      GoodTracksFractionVsLS = ibooker.bookProfile(histname, histname, LSBin, LSMin, LSMax, 0, 1.1, "");
      GoodTracksFractionVsLS->getTH1()->SetCanExtend(TH1::kAllAxes);
      GoodTracksFractionVsLS->setAxisTitle("#Lumi section", 1);
      GoodTracksFractionVsLS->setAxisTitle("Fraction of Good Tracks", 2);
    }

    if (doPlotsVsBX_ || doAllPlots) {
      ibooker.setCurrentFolder(MEFolderName + "/BXanalysis");
      int BXBin = 3564;
      double BXMin = 0.5;
      double BXMax = 3564.5;

      histname = "NumberEventsVsBX_" + CategoryName;
      NumberEventsOfVsBX = ibooker.book1D(histname, histname, BXBin, BXMin, BXMax);
      NumberEventsOfVsBX->setAxisTitle("BX", 1);
      NumberEventsOfVsBX->setAxisTitle("Number of events", 2);

      histname = "NumberOfTracksVsBX_" + CategoryName;
      NumberOfTracksVsBX = ibooker.bookProfile(histname, histname, BXBin, BXMin, BXMax, TKNoMin, TKNoMax * 3., "");
      NumberOfTracksVsBX->setAxisTitle("BX", 1);
      NumberOfTracksVsBX->setAxisTitle("Number of  Tracks", 2);

      histname = "NumberOfRecHitsPerTrackVsBX_" + CategoryName;
      NumberOfRecHitsPerTrackVsBX =
          ibooker.bookProfile(histname, histname, BXBin, BXMin, BXMax, RecHitMin, RecHitMax * 5, "");
      NumberOfRecHitsPerTrackVsBX->setAxisTitle("BX", 1);
      NumberOfRecHitsPerTrackVsBX->setAxisTitle("Mean number of Valid RecHits per track", 2);

      histname = "NumberOfGoodPVtxVsBX_" + CategoryName;
      NumberOfGoodPVtxVsBX =
          ibooker.bookProfile(histname, histname, BXBin, BXMin, BXMax, GoodPVtxMin, 3. * GoodPVtxMax, "");
      NumberOfGoodPVtxVsBX->setAxisTitle("BX", 1);
      NumberOfGoodPVtxVsBX->setAxisTitle("Mean number of good PV", 2);

      histname = "NumberOfGoodPVtxWO0VsBX_" + CategoryName;
      NumberOfGoodPVtxWO0VsBX =
          ibooker.bookProfile(histname, histname, BXBin, BXMin, BXMax, GoodPVtxMin, 3. * GoodPVtxMax, "");
      NumberOfGoodPVtxWO0VsBX->setAxisTitle("BX", 1);
      NumberOfGoodPVtxWO0VsBX->setAxisTitle("Mean number of good PV", 2);

      if (doFractionPlot_) {
        histname = "GoodTracksFractionVsBX_" + CategoryName;
        GoodTracksFractionVsBX = ibooker.bookProfile(histname, histname, BXBin, BXMin, BXMax, 0, 1.1, "");
        GoodTracksFractionVsBX->setAxisTitle("BX", 1);
        GoodTracksFractionVsBX->setAxisTitle("Fraction of Good Tracks", 2);
      }
    }
  }

  // book PU monitoring plots :
  //---------------------------

  if (doPUmonitoring_) {
    for (size_t i = 0; i < theVertexMonitor.size(); i++)
      theVertexMonitor[i]->initHisto(ibooker);
  }

  if (doPlotsVsGoodPVtx_) {
    ibooker.setCurrentFolder(MEFolderName + "/PUmonitoring");
    // get binning from the configuration
    int PVBin = conf->getParameter<int>("PVBin");
    float PVMin = conf->getParameter<double>("PVMin");
    float PVMax = conf->getParameter<double>("PVMax");

    histname = "NumberOfTracksVsGoodPVtx";
    NumberOfTracksVsGoodPVtx = ibooker.bookProfile(histname, histname, PVBin, PVMin, PVMax, TKNoMin, TKNoMax * 5., "");
    NumberOfTracksVsGoodPVtx->setAxisTitle("Number of PV", 1);
    NumberOfTracksVsGoodPVtx->setAxisTitle("Mean number of Tracks per Event", 2);

    histname = "NumberOfTracksVsPUPVtx";
    NumberOfTracksVsPUPVtx = ibooker.bookProfile(histname, histname, PVBin, PVMin, PVMax, 0., TKNoMax * 5., "");
    NumberOfTracksVsPUPVtx->setAxisTitle("Number of PU", 1);
    NumberOfTracksVsPUPVtx->setAxisTitle("Mean number of Tracks per PUvtx", 2);

    histname = "NumberEventsVsGoodPVtx";
    NumberEventsOfVsGoodPVtx = ibooker.book1D(histname, histname, PVBin, PVMin, PVMax);
    NumberEventsOfVsGoodPVtx->setAxisTitle("Number of good PV (PU)", 1);
    NumberEventsOfVsGoodPVtx->setAxisTitle("Number of events", 2);

    if (doFractionPlot_) {
      histname = "GoodTracksFractionVsGoodPVtx";
      GoodTracksFractionVsGoodPVtx = ibooker.bookProfile(histname, histname, PVBin, PVMin, PVMax, 0., 1.1, "");
      GoodTracksFractionVsGoodPVtx->setAxisTitle("Number of good PV (PU)", 1);
      GoodTracksFractionVsGoodPVtx->setAxisTitle("Mean fraction of good tracks", 2);
    }

    histname = "NumberOfRecHitsPerTrackVsGoodPVtx";
    NumberOfRecHitsPerTrackVsGoodPVtx = ibooker.bookProfile(histname, histname, PVBin, PVMin, PVMax, 0., 200., "");
    NumberOfRecHitsPerTrackVsGoodPVtx->setAxisTitle("Number of good PV (PU)", 1);
    NumberOfRecHitsPerTrackVsGoodPVtx->setAxisTitle("Mean number of valid rechits per Tracks", 2);

    histname = "NumberOfPVtxVsGoodPVtx";
    NumberOfPVtxVsGoodPVtx = ibooker.bookProfile(histname, histname, PVBin, PVMin, PVMax, 0., 3. * PVMax, "");
    NumberOfPVtxVsGoodPVtx->setAxisTitle("Number of good PV (PU)", 1);
    NumberOfPVtxVsGoodPVtx->setAxisTitle("Mean number of vertices", 2);

    double NClusPxMin = conf->getParameter<double>("NClusPxMin");
    double NClusPxMax = conf->getParameter<double>("NClusPxMax");
    histname = "NumberOfPixelClustersVsGoodPVtx";
    NumberOfPixelClustersVsGoodPVtx =
        ibooker.bookProfile(histname, histname, PVBin, PVMin, PVMax, NClusPxMin, 3. * NClusPxMax, "");
    NumberOfPixelClustersVsGoodPVtx->setAxisTitle("Number of good PV (PU)", 1);
    NumberOfPixelClustersVsGoodPVtx->setAxisTitle("Mean number of pixel clusters", 2);

    double NClusStrMin = conf->getParameter<double>("NClusStrMin");
    double NClusStrMax = conf->getParameter<double>("NClusStrMax");
    histname = "NumberOfStripClustersVsGoodPVtx";
    NumberOfStripClustersVsGoodPVtx =
        ibooker.bookProfile(histname, histname, PVBin, PVMin, PVMax, NClusStrMin, 3. * NClusStrMax, "");
    NumberOfStripClustersVsGoodPVtx->setAxisTitle("Number of good PV (PU)", 1);
    NumberOfStripClustersVsGoodPVtx->setAxisTitle("Mean number of strip clusters", 2);
  }

  if (doPlotsVsLUMI_ || doAllPlots) {
    ibooker.setCurrentFolder(MEFolderName + "/LUMIanalysis");
    int LUMIBin = conf->getParameter<int>("LUMIBin");
    float LUMIMin = conf->getParameter<double>("LUMIMin");
    float LUMIMax = conf->getParameter<double>("LUMIMax");

    histname = "NumberEventsVsLUMI";
    NumberEventsOfVsLUMI = ibooker.book1D(histname, histname, LUMIBin, LUMIMin, LUMIMax);
    NumberEventsOfVsLUMI->setAxisTitle("scal lumi [10e30 Hz cm^{-2}]", 1);
    NumberEventsOfVsLUMI->setAxisTitle("Number of events", 2);

    histname = "NumberOfTracksVsLUMI";
    NumberOfTracksVsLUMI = ibooker.bookProfile(histname, histname, LUMIBin, LUMIMin, LUMIMax, TKNoMin, TKNoMax * 3, "");
    NumberOfTracksVsLUMI->setAxisTitle("scal lumi [10e30 Hz cm^{-2}]", 1);
    NumberOfTracksVsLUMI->setAxisTitle("Mean number of vertices", 2);

    if (doFractionPlot_) {
      histname = "GoodTracksFractionVsLUMI";
      GoodTracksFractionVsLUMI = ibooker.bookProfile(histname, histname, LUMIBin, LUMIMin, LUMIMax, 0., 1.1, "");
      GoodTracksFractionVsLUMI->setAxisTitle("scal lumi [10e30 Hz cm^{-2}]", 1);
      GoodTracksFractionVsLUMI->setAxisTitle("Mean number of vertices", 2);
    }

    histname = "NumberOfRecHitsPerTrackVsLUMI";
    NumberOfRecHitsPerTrackVsLUMI =
        ibooker.bookProfile(histname, histname, LUMIBin, LUMIMin, LUMIMax, RecHitMin, RecHitMax * 5, "");
    NumberOfRecHitsPerTrackVsLUMI->setAxisTitle("scal lumi [10e30 Hz cm^{-2}]", 1);
    NumberOfRecHitsPerTrackVsLUMI->setAxisTitle("Mean number of vertices", 2);

    double PVMin = conf->getParameter<double>("PVMin");
    double PVMax = conf->getParameter<double>("PVMax");

    histname = "NumberOfGoodPVtxVsLUMI";
    NumberOfGoodPVtxVsLUMI = ibooker.bookProfile(histname, histname, LUMIBin, LUMIMin, LUMIMax, PVMin, 3. * PVMax, "");
    NumberOfGoodPVtxVsLUMI->setAxisTitle("scal lumi [10e30 Hz cm^{-2}]", 1);
    NumberOfGoodPVtxVsLUMI->setAxisTitle("Mean number of vertices", 2);

    histname = "NumberOfGoodPVtxWO0VsLUMI";
    NumberOfGoodPVtxWO0VsLUMI =
        ibooker.bookProfile(histname, histname, LUMIBin, LUMIMin, LUMIMax, PVMin, 3. * PVMax, "");
    NumberOfGoodPVtxWO0VsLUMI->setAxisTitle("scal lumi [10e30 Hz cm^{-2}]", 1);
    NumberOfGoodPVtxWO0VsLUMI->setAxisTitle("Mean number of vertices", 2);

    double NClusPxMin = conf->getParameter<double>("NClusPxMin");
    double NClusPxMax = conf->getParameter<double>("NClusPxMax");
    histname = "NumberOfPixelClustersVsGoodPVtx";
    NumberOfPixelClustersVsLUMI =
        ibooker.bookProfile(histname, histname, LUMIBin, LUMIMin, LUMIMax, NClusPxMin, 3. * NClusPxMax, "");
    NumberOfPixelClustersVsLUMI->setAxisTitle("scal lumi [10e30 Hz cm^{-2}]", 1);
    NumberOfPixelClustersVsLUMI->setAxisTitle("Mean number of pixel clusters", 2);

    double NClusStrMin = conf->getParameter<double>("NClusStrMin");
    double NClusStrMax = conf->getParameter<double>("NClusStrMax");
    histname = "NumberOfStripClustersVsLUMI";
    NumberOfStripClustersVsLUMI =
        ibooker.bookProfile(histname, histname, LUMIBin, LUMIMin, LUMIMax, NClusStrMin, 3. * NClusStrMax, "");
    NumberOfStripClustersVsLUMI->setAxisTitle("scal lumi [10e30 Hz cm^{-2}]", 1);
    NumberOfStripClustersVsLUMI->setAxisTitle("Mean number of strip clusters", 2);
  }

  if (doPlotsVsBXlumi_) {
    ibooker.setCurrentFolder(MEFolderName + "/PUmonitoring");
    // get binning from the configuration
    edm::ParameterSet BXlumiParameters = conf->getParameter<edm::ParameterSet>("BXlumiSetup");
    int BXlumiBin = BXlumiParameters.getParameter<int>("BXlumiBin");
    double BXlumiMin = BXlumiParameters.getParameter<double>("BXlumiMin");
    double BXlumiMax = BXlumiParameters.getParameter<double>("BXlumiMax");

    histname = "NumberOfTracksVsBXlumi_" + CategoryName;
    NumberOfTracksVsBXlumi =
        ibooker.bookProfile(histname, histname, BXlumiBin, BXlumiMin, BXlumiMax, TKNoMin, 3. * TKNoMax, "");
    NumberOfTracksVsBXlumi->setAxisTitle("lumi BX [10^{30}Hzcm^{-2}]", 1);
    NumberOfTracksVsBXlumi->setAxisTitle("Mean number of Tracks", 2);
  }

  if (doLumiAnalysis) {
    auto scope = DQMStore::IBooker::UseLumiScope(ibooker);
    theTrackAnalyzer->initHisto(ibooker, iSetup, *conf);
  } else {
    theTrackAnalyzer->initHisto(ibooker, iSetup, *conf);
  }

  // book the Seed Property histograms
  // ---------------------------------------------------------------------------------//

  ibooker.setCurrentFolder(MEFolderName + "/TrackBuilding");

  doSeedNumberPlot = conf->getParameter<bool>("doSeedNumberHisto");
  doSeedLumiAnalysis_ = conf->getParameter<bool>("doSeedLumiAnalysis");
  doSeedVsClusterPlot = conf->getParameter<bool>("doSeedVsClusterHisto");

  edm::InputTag seedProducer = conf->getParameter<edm::InputTag>("SeedProducer");

  if (doAllSeedPlots || doSeedNumberPlot) {
    ibooker.setCurrentFolder(MEFolderName + "/TrackBuilding");
    histname = "NumberOfSeeds_" + seedProducer.label() + "_" + CategoryName;
    NumberOfSeeds = ibooker.book1D(histname, histname, TKNoSeedBin, TKNoSeedMin, TKNoSeedMax);
    NumberOfSeeds->setAxisTitle("Number of Seeds per Event", 1);
    NumberOfSeeds->setAxisTitle("Number of Events", 2);

    if (doSeedLumiAnalysis_) {
      ibooker.setCurrentFolder(MEFolderName + "/LSanalysis");
      auto scope = DQMStore::IBooker::UseLumiScope(ibooker);
      histname = "NumberOfSeeds_lumiFlag_" + seedProducer.label() + "_" + CategoryName;
      NumberOfSeeds_lumiFlag = ibooker.book1D(histname, histname, TKNoSeedBin, TKNoSeedMin, TKNoSeedMax);
      NumberOfSeeds_lumiFlag->setAxisTitle("Number of Seeds per Event", 1);
      NumberOfSeeds_lumiFlag->setAxisTitle("Number of Events", 2);
    }
  }

  if (doAllSeedPlots || doSeedVsClusterPlot) {
    ibooker.setCurrentFolder(MEFolderName + "/TrackBuilding");

    ClusterLabels = conf->getParameter<std::vector<std::string> >("ClusterLabels");

    std::vector<double> histoMin, histoMax;
    std::vector<int> histoBin;  //these vectors are for max min and nbins in histograms

    int NClusPxBin = conf->getParameter<int>("NClusPxBin");
    double NClusPxMin = conf->getParameter<double>("NClusPxMin");
    double NClusPxMax = conf->getParameter<double>("NClusPxMax");

    int NClusStrBin = conf->getParameter<int>("NClusStrBin");
    double NClusStrMin = conf->getParameter<double>("NClusStrMin");
    double NClusStrMax = conf->getParameter<double>("NClusStrMax");

    setMaxMinBin(
        histoMin, histoMax, histoBin, NClusStrMin, NClusStrMax, NClusStrBin, NClusPxMin, NClusPxMax, NClusPxBin);

    for (uint i = 0; i < ClusterLabels.size(); i++) {
      histname = "SeedsVsClusters_" + seedProducer.label() + "_Vs_" + ClusterLabels[i] + "_" + CategoryName;
      SeedsVsClusters.push_back(dynamic_cast<MonitorElement*>(ibooker.book2D(
          histname, histname, histoBin[i], histoMin[i], histoMax[i], TKNoSeedBin, TKNoSeedMin, TKNoSeedMax)));
      SeedsVsClusters[i]->setAxisTitle("Number of Clusters", 1);
      SeedsVsClusters[i]->setAxisTitle("Number of Seeds", 2);
      SeedsVsClusters[i]->getTH2F()->SetCanExtend(TH1::kAllAxes);
    }
  }

  if (doRegionPlots) {
    ibooker.setCurrentFolder(MEFolderName + "/TrackBuilding");

    int regionBin = conf->getParameter<int>("RegionSizeBin");
    double regionMin = conf->getParameter<double>("RegionSizeMin");
    double regionMax = conf->getParameter<double>("RegionSizeMax");

    histname = "TrackingRegionsNumberOf_" + seedProducer.label() + "_" + CategoryName;
    NumberOfTrackingRegions = ibooker.book1D(histname, histname, regionBin, regionMin, regionMax);
    NumberOfTrackingRegions->setAxisTitle("Number of TrackingRegions per Event", 1);
    NumberOfTrackingRegions->setAxisTitle("Number of Events", 2);
  }

  if (doTkCandPlots) {
    ibooker.setCurrentFolder(MEFolderName + "/TrackBuilding");

    edm::InputTag tcProducer = conf->getParameter<edm::InputTag>("TCProducer");

    histname = "NumberOfTrackCandidates_" + tcProducer.label() + "_" + CategoryName;
    NumberOfTrackCandidates = ibooker.book1D(histname, histname, TCNoBin, TCNoMin, TCNoMax);
    NumberOfTrackCandidates->setAxisTitle("Number of Track Candidates per Event", 1);
    NumberOfTrackCandidates->setAxisTitle("Number of Event", 2);

    histname = "FractionOfCandOverSeeds_" + tcProducer.label() + "_" + CategoryName;
    FractionCandidatesOverSeeds = ibooker.book1D(histname, histname, 101, 0., 1.01);
    FractionCandidatesOverSeeds->setAxisTitle("Number of Track Candidates / Number of Seeds per Event", 1);
    FractionCandidatesOverSeeds->setAxisTitle("Number of Event", 2);
  }

  theTrackBuildingAnalyzer->initHisto(ibooker, *conf);

  if (doTrackerSpecific_ || doAllPlots) {
    ClusterLabels = conf->getParameter<std::vector<std::string> >("ClusterLabels");

    std::vector<double> histoMin, histoMax;
    std::vector<int> histoBin;  //these vectors are for max min and nbins in histograms

    int NClusStrBin = conf->getParameter<int>("NClusStrBin");
    double NClusStrMin = conf->getParameter<double>("NClusStrMin");
    double NClusStrMax = conf->getParameter<double>("NClusStrMax");

    int NClusPxBin = conf->getParameter<int>("NClusPxBin");
    double NClusPxMin = conf->getParameter<double>("NClusPxMin");
    double NClusPxMax = conf->getParameter<double>("NClusPxMax");

    edm::ParameterSet ParametersNTrk2D = conf->getParameter<edm::ParameterSet>("NTrk2D");
    int NTrk2DBin = ParametersNTrk2D.getParameter<int>("NTrk2DBin");
    double NTrk2DMin = ParametersNTrk2D.getParameter<double>("NTrk2DMin");
    double NTrk2DMax = ParametersNTrk2D.getParameter<double>("NTrk2DMax");

    setMaxMinBin(
        histoMin, histoMax, histoBin, NClusStrMin, NClusStrMax, NClusStrBin, NClusPxMin, NClusPxMax, NClusPxBin);

    ibooker.setCurrentFolder(MEFolderName + "/HitProperties");

    for (uint i = 0; i < ClusterLabels.size(); i++) {
      ibooker.setCurrentFolder(MEFolderName + "/HitProperties");
      histname = "TracksVs" + ClusterLabels[i] + "Cluster_" + CategoryName;
      NumberOfTrkVsClusters.push_back(dynamic_cast<MonitorElement*>(
          ibooker.book2D(histname, histname, histoBin[i], histoMin[i], histoMax[i], NTrk2DBin, NTrk2DMin, NTrk2DMax)));
      std::string title = "Number of " + ClusterLabels[i] + " Clusters";
      if (ClusterLabels[i] == "Tot")
        title = "# of Clusters in (Pixel+Strip) Detectors";
      NumberOfTrkVsClusters[i]->setAxisTitle(title, 1);
      NumberOfTrkVsClusters[i]->setAxisTitle("Number of Tracks", 2);
      NumberOfTrkVsClusters[i]->getTH1()->SetCanExtend(TH1::kXaxis);
    }
  }

  // Initialize the GenericTriggerEventFlag
  if (genTriggerEventFlag_->on())
    genTriggerEventFlag_->initRun(iRun, iSetup);
}

doProfileX() [1/2]

void TrackingMonitor::doProfileX ( TH2 *  th2, MonitorElement *  me  )

private

doProfileX() [2/2]

void TrackingMonitor::doProfileX ( MonitorElement *  th2m, MonitorElement *  me  )

private

setMaxMinBin()

void TrackingMonitor::setMaxMinBin ( std::vector< double > &  arrayMin, std::vector< double > &  arrayMax, std::vector< int > &  arrayBin, double  smin, double  smax, int  sbin, double  pmin, double  pmax, int  pbin  )

virtual

Definition at line 1102 of file TrackingMonitor.cc.

References ClusterLabels, mps_fire::i, trackingParticleMuon_cfi::pmin, and parallelization::uint.

Referenced by bookHistograms().

                                             {
  arrayMin.resize(ClusterLabels.size());
  arrayMax.resize(ClusterLabels.size());
  arrayBin.resize(ClusterLabels.size());

  for (uint i = 0; i < ClusterLabels.size(); ++i) {
    if (ClusterLabels[i] == "Pix") {
      arrayMin[i] = pmin;
      arrayMax[i] = pmax;
      arrayBin[i] = pbin;
    } else if (ClusterLabels[i] == "Strip") {
      arrayMin[i] = smin;
      arrayMax[i] = smax;
      arrayBin[i] = sbin;
    } else if (ClusterLabels[i] == "Tot") {
      arrayMin[i] = smin;
      arrayMax[i] = smax + pmax;
      arrayBin[i] = sbin;
    } else {
      edm::LogWarning("TrackingMonitor") << "Cluster Label " << ClusterLabels[i]
                                         << " not defined, using strip parameters ";
      arrayMin[i] = smin;
      arrayMax[i] = smax;
      arrayBin[i] = sbin;
    }
  }
}

setNclus()

void TrackingMonitor::setNclus ( const edm::Event &  iEvent, std::vector< int > &  arrayNclus  )

virtual

Definition at line 1138 of file TrackingMonitor.cc.

References ClusterLabels, mps_fire::i, iEvent, edm::HandleBase::isValid(), pixelClustersToken_, stripClustersToken_, and parallelization::uint.

Referenced by analyze().

                                                                                 {
  int ncluster_pix = -1;
  int ncluster_strip = -1;

  edm::Handle<edmNew::DetSetVector<SiStripCluster> > strip_clusters = iEvent.getHandle(stripClustersToken_);
  edm::Handle<edmNew::DetSetVector<SiPixelCluster> > pixel_clusters = iEvent.getHandle(pixelClustersToken_);

  if (strip_clusters.isValid() && pixel_clusters.isValid()) {
    ncluster_pix = (*pixel_clusters).dataSize();
    ncluster_strip = (*strip_clusters).dataSize();
  }

  arrayNclus.resize(ClusterLabels.size());
  for (uint i = 0; i < ClusterLabels.size(); ++i) {
    if (ClusterLabels[i] == "Pix")
      arrayNclus[i] = ncluster_pix;
    else if (ClusterLabels[i] == "Strip")
      arrayNclus[i] = ncluster_strip;
    else if (ClusterLabels[i] == "Tot")
      arrayNclus[i] = ncluster_pix + ncluster_strip;
    else {
      edm::LogWarning("TrackingMonitor") << "Cluster Label " << ClusterLabels[i]
                                         << " not defined using stri parametrs ";
      arrayNclus[i] = ncluster_strip;
    }
  }
}

Member Data Documentation

AlgoName_

std::string TrackingMonitor::AlgoName_

private

Definition at line 121 of file TrackingMonitor.h.

Referenced by bookHistograms(), and TrackingMonitor().

allTrackToken_

edm::EDGetTokenT<edm::View<reco::Track> > TrackingMonitor::allTrackToken_

private

Definition at line 97 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().

bsSrc_

edm::InputTag TrackingMonitor::bsSrc_

private

Definition at line 92 of file TrackingMonitor.h.

Referenced by TrackingMonitor().

bsSrcToken_

edm::EDGetTokenT<reco::BeamSpot> TrackingMonitor::bsSrcToken_

private

Definition at line 94 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().

builderName

std::string TrackingMonitor::builderName

private

Definition at line 199 of file TrackingMonitor.h.

Referenced by TrackingMonitor().

ClusterLabels

std::vector<std::string> TrackingMonitor::ClusterLabels

private

Definition at line 146 of file TrackingMonitor.h.

Referenced by analyze(), bookHistograms(), setMaxMinBin(), and setNclus().

confID_

edm::ParameterSetID TrackingMonitor::confID_

private

Definition at line 89 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

denSelection_

StringCutObjectSelector<reco::Track, true> TrackingMonitor::denSelection_

private

Definition at line 228 of file TrackingMonitor.h.

Referenced by analyze().

doAllPlots

bool TrackingMonitor::doAllPlots

private

Definition at line 205 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

doAllSeedPlots

bool TrackingMonitor::doAllSeedPlots

private

Definition at line 204 of file TrackingMonitor.h.

Referenced by analyze(), bookHistograms(), and TrackingMonitor().

doDCAPlots_

bool TrackingMonitor::doDCAPlots_

private

Definition at line 206 of file TrackingMonitor.h.

doFractionPlot_

bool TrackingMonitor::doFractionPlot_

private

Definition at line 223 of file TrackingMonitor.h.

Referenced by analyze(), bookHistograms(), and TrackingMonitor().

doGeneralPropertiesPlots_

bool TrackingMonitor::doGeneralPropertiesPlots_

private

Definition at line 207 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

doHitPropertiesPlots_

bool TrackingMonitor::doHitPropertiesPlots_

private

Definition at line 208 of file TrackingMonitor.h.

doLumiAnalysis

bool TrackingMonitor::doLumiAnalysis

private

Definition at line 202 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

doMVAPlots

bool TrackingMonitor::doMVAPlots

private

Definition at line 210 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().

doPlotsVsBX_

bool TrackingMonitor::doPlotsVsBX_

private

Definition at line 222 of file TrackingMonitor.h.

Referenced by analyze(), bookHistograms(), and TrackingMonitor().

doPlotsVsBXlumi_

bool TrackingMonitor::doPlotsVsBXlumi_

private

Definition at line 219 of file TrackingMonitor.h.

Referenced by analyze(), bookHistograms(), and TrackingMonitor().

doPlotsVsGoodPVtx_

bool TrackingMonitor::doPlotsVsGoodPVtx_

private

Definition at line 220 of file TrackingMonitor.h.

Referenced by analyze(), bookHistograms(), and TrackingMonitor().

doPlotsVsLUMI_

bool TrackingMonitor::doPlotsVsLUMI_

private

Definition at line 221 of file TrackingMonitor.h.

Referenced by analyze(), bookHistograms(), and TrackingMonitor().

doProfilesVsLS_

bool TrackingMonitor::doProfilesVsLS_

private

Definition at line 203 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

doPUmonitoring_

bool TrackingMonitor::doPUmonitoring_

private

Definition at line 218 of file TrackingMonitor.h.

Referenced by analyze(), bookHistograms(), TrackingMonitor(), and ~TrackingMonitor().

doRegionCandidatePlots

bool TrackingMonitor::doRegionCandidatePlots

private

Definition at line 212 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().

doRegionPlots

bool TrackingMonitor::doRegionPlots

private

Definition at line 211 of file TrackingMonitor.h.

Referenced by analyze(), bookHistograms(), and TrackingMonitor().

doSeedLumiAnalysis_

bool TrackingMonitor::doSeedLumiAnalysis_

private

Definition at line 214 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

doSeedNumberPlot

bool TrackingMonitor::doSeedNumberPlot

private

Definition at line 213 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

doSeedVsClusterPlot

bool TrackingMonitor::doSeedVsClusterPlot

private

Definition at line 215 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

doTkCandPlots

bool TrackingMonitor::doTkCandPlots

private

Definition at line 209 of file TrackingMonitor.h.

Referenced by analyze(), bookHistograms(), and TrackingMonitor().

doTrackerSpecific_

bool TrackingMonitor::doTrackerSpecific_

private

Definition at line 201 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

forceSCAL_

const bool TrackingMonitor::forceSCAL_

private

Definition at line 230 of file TrackingMonitor.h.

Referenced by analyze().

FractionCandidatesOverSeeds

MonitorElement* TrackingMonitor::FractionCandidatesOverSeeds

private

Definition at line 150 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

FractionOfGoodTracks

MonitorElement* TrackingMonitor::FractionOfGoodTracks

private

Definition at line 137 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

genTriggerEventFlag_

GenericTriggerEventFlag* TrackingMonitor::genTriggerEventFlag_

private

Definition at line 225 of file TrackingMonitor.h.

Referenced by analyze(), bookHistograms(), and ~TrackingMonitor().

GoodTracksFractionVsBX

MonitorElement* TrackingMonitor::GoodTracksFractionVsBX

private

Definition at line 169 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

GoodTracksFractionVsGoodPVtx

MonitorElement* TrackingMonitor::GoodTracksFractionVsGoodPVtx

private

Definition at line 180 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

GoodTracksFractionVsLS

MonitorElement* TrackingMonitor::GoodTracksFractionVsLS

private

Definition at line 161 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

GoodTracksFractionVsLUMI

MonitorElement* TrackingMonitor::GoodTracksFractionVsLUMI

private

Definition at line 189 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

histname

std::string TrackingMonitor::histname

private

Definition at line 85 of file TrackingMonitor.h.

Referenced by bookHistograms().

lumiscalersToken_

edm::EDGetTokenT<LumiScalersCollection> TrackingMonitor::lumiscalersToken_

private

Definition at line 106 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().

magneticFieldToken_

edm::ESGetToken<MagneticField, IdealMagneticFieldRecord> TrackingMonitor::magneticFieldToken_

private

Definition at line 117 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().

MEFolderName

std::string TrackingMonitor::MEFolderName

private

Definition at line 84 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

metaDataToken_

edm::EDGetTokenT<OnlineLuminosityRecord> TrackingMonitor::metaDataToken_

private

Definition at line 107 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().

mvaQualityTokens_

std::vector<std::tuple<edm::EDGetTokenT<MVACollection>, edm::EDGetTokenT<QualityMaskCollection> > > TrackingMonitor::mvaQualityTokens_

private

Definition at line 114 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().

mvaTrackToken_

edm::EDGetTokenT<edm::View<reco::Track> > TrackingMonitor::mvaTrackToken_

private

Definition at line 115 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().

NumberEventsOfVsBX

MonitorElement* TrackingMonitor::NumberEventsOfVsBX

private

Definition at line 167 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

NumberEventsOfVsGoodPVtx

MonitorElement* TrackingMonitor::NumberEventsOfVsGoodPVtx

private

Definition at line 179 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

NumberEventsOfVsLS

MonitorElement* TrackingMonitor::NumberEventsOfVsLS

private

Definition at line 159 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

NumberEventsOfVsLUMI

MonitorElement* TrackingMonitor::NumberEventsOfVsLUMI

private

Definition at line 187 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

NumberOfGoodPVtxVsBX

MonitorElement* TrackingMonitor::NumberOfGoodPVtxVsBX

private

Definition at line 171 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

NumberOfGoodPVtxVsLS

MonitorElement* TrackingMonitor::NumberOfGoodPVtxVsLS

private

Definition at line 163 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

NumberOfGoodPVtxVsLUMI

MonitorElement* TrackingMonitor::NumberOfGoodPVtxVsLUMI

private

Definition at line 191 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

NumberOfGoodPVtxWO0VsBX

MonitorElement* TrackingMonitor::NumberOfGoodPVtxWO0VsBX

private

Definition at line 172 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

NumberOfGoodPVtxWO0VsLS

MonitorElement* TrackingMonitor::NumberOfGoodPVtxWO0VsLS

private

Definition at line 164 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

NumberOfGoodPVtxWO0VsLUMI

MonitorElement* TrackingMonitor::NumberOfGoodPVtxWO0VsLUMI

private

Definition at line 192 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

NumberOfMeanLayersPerTrack

MonitorElement* TrackingMonitor::NumberOfMeanLayersPerTrack

private

Definition at line 134 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

NumberOfMeanRecHitsPerTrack

MonitorElement* TrackingMonitor::NumberOfMeanRecHitsPerTrack

private

Definition at line 133 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

NumberOfPixelClustersVsGoodPVtx

MonitorElement* TrackingMonitor::NumberOfPixelClustersVsGoodPVtx

private

Definition at line 183 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

NumberOfPixelClustersVsLUMI

MonitorElement* TrackingMonitor::NumberOfPixelClustersVsLUMI

private

Definition at line 193 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

NumberOfPVtxVsGoodPVtx

MonitorElement* TrackingMonitor::NumberOfPVtxVsGoodPVtx

private

Definition at line 182 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

NumberOfRecHitsPerTrackVsBX

MonitorElement* TrackingMonitor::NumberOfRecHitsPerTrackVsBX

private

Definition at line 170 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

NumberOfRecHitsPerTrackVsGoodPVtx

MonitorElement* TrackingMonitor::NumberOfRecHitsPerTrackVsGoodPVtx

private

Definition at line 181 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

NumberOfRecHitsPerTrackVsLS

MonitorElement* TrackingMonitor::NumberOfRecHitsPerTrackVsLS

private

Definition at line 162 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

NumberOfRecHitsPerTrackVsLUMI

MonitorElement* TrackingMonitor::NumberOfRecHitsPerTrackVsLUMI

private

Definition at line 190 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

NumberOfSeeds

MonitorElement* TrackingMonitor::NumberOfSeeds

private

Definition at line 143 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

NumberOfSeeds_lumiFlag

MonitorElement* TrackingMonitor::NumberOfSeeds_lumiFlag

private

Definition at line 144 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

NumberOfStripClustersVsGoodPVtx

MonitorElement* TrackingMonitor::NumberOfStripClustersVsGoodPVtx

private

Definition at line 184 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

NumberOfStripClustersVsLUMI

MonitorElement* TrackingMonitor::NumberOfStripClustersVsLUMI

private

Definition at line 194 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

NumberOfTrackCandidates

MonitorElement* TrackingMonitor::NumberOfTrackCandidates

private

Definition at line 149 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

NumberOfTrackingRegions

MonitorElement* TrackingMonitor::NumberOfTrackingRegions

private

Definition at line 140 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

NumberOfTracks

MonitorElement* TrackingMonitor::NumberOfTracks

private

Definition at line 129 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

NumberofTracks_Hardvtx

MonitorElement* TrackingMonitor::NumberofTracks_Hardvtx

private

Definition at line 131 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

NumberofTracks_Hardvtx_PUvtx

MonitorElement* TrackingMonitor::NumberofTracks_Hardvtx_PUvtx

private

Definition at line 132 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

NumberOfTracks_lumiFlag

MonitorElement* TrackingMonitor::NumberOfTracks_lumiFlag

private

Definition at line 197 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

NumberOfTracks_PUvtx

MonitorElement* TrackingMonitor::NumberOfTracks_PUvtx

private

Definition at line 130 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

NumberOfTracksVsBX

MonitorElement* TrackingMonitor::NumberOfTracksVsBX

private

Definition at line 168 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

NumberOfTracksVsBXlumi

MonitorElement* TrackingMonitor::NumberOfTracksVsBXlumi

private

Definition at line 174 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

NumberOfTracksVsGoodPVtx

MonitorElement* TrackingMonitor::NumberOfTracksVsGoodPVtx

private

Definition at line 177 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

NumberOfTracksVsLS

MonitorElement* TrackingMonitor::NumberOfTracksVsLS

private

Definition at line 160 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

NumberOfTracksVsLUMI

MonitorElement* TrackingMonitor::NumberOfTracksVsLUMI

private

Definition at line 188 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

NumberOfTracksVsPUPVtx

MonitorElement* TrackingMonitor::NumberOfTracksVsPUPVtx

private

Definition at line 178 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

NumberOfTrkVsClus

MonitorElement* TrackingMonitor::NumberOfTrkVsClus

private

Definition at line 154 of file TrackingMonitor.h.

NumberOfTrkVsClusters

std::vector<MonitorElement*> TrackingMonitor::NumberOfTrkVsClusters

private

Definition at line 153 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

NumberOfTrkVsPixelClus

MonitorElement* TrackingMonitor::NumberOfTrkVsPixelClus

private

Definition at line 156 of file TrackingMonitor.h.

NumberOfTrkVsStripClus

MonitorElement* TrackingMonitor::NumberOfTrkVsStripClus

private

Definition at line 155 of file TrackingMonitor.h.

numSelection_

StringCutObjectSelector<reco::Track, true> TrackingMonitor::numSelection_

private

Definition at line 227 of file TrackingMonitor.h.

Referenced by analyze().

pixelClusterInputTag_

edm::InputTag TrackingMonitor::pixelClusterInputTag_

private

Definition at line 110 of file TrackingMonitor.h.

Referenced by TrackingMonitor().

pixelClustersToken_

edm::EDGetTokenT<edmNew::DetSetVector<SiPixelCluster> > TrackingMonitor::pixelClustersToken_

private

Definition at line 112 of file TrackingMonitor.h.

Referenced by setNclus(), and TrackingMonitor().

pvNDOF_

int TrackingMonitor::pvNDOF_

private

Definition at line 229 of file TrackingMonitor.h.

Referenced by analyze().

pvSrc_

edm::InputTag TrackingMonitor::pvSrc_

private

Definition at line 93 of file TrackingMonitor.h.

Referenced by TrackingMonitor().

pvSrcToken_

edm::EDGetTokenT<reco::VertexCollection> TrackingMonitor::pvSrcToken_

private

Definition at line 95 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().

Quality_

std::string TrackingMonitor::Quality_

private

Definition at line 120 of file TrackingMonitor.h.

Referenced by bookHistograms(), and TrackingMonitor().

regionCandidateToken_

edm::EDGetTokenT<reco::CandidateView> TrackingMonitor::regionCandidateToken_

private

Definition at line 104 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().

regionLayerSetsToken_

edm::EDGetTokenT<TrackingRegionsSeedingLayerSets> TrackingMonitor::regionLayerSetsToken_

private

Definition at line 103 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().

regionToken_

edm::EDGetTokenT<edm::OwnVector<TrackingRegion> > TrackingMonitor::regionToken_

private

Definition at line 102 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().

runTrackBuildingAnalyzerForSeed

bool TrackingMonitor::runTrackBuildingAnalyzerForSeed

private

Definition at line 216 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().

seedStopInfoToken_

edm::EDGetTokenT<std::vector<SeedStopInfo> > TrackingMonitor::seedStopInfoToken_

private

Definition at line 101 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().

SeedsVsClusters

std::vector<MonitorElement*> TrackingMonitor::SeedsVsClusters

private

Definition at line 145 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

seedToken_

edm::EDGetTokenT<edm::View<TrajectorySeed> > TrackingMonitor::seedToken_

private

Definition at line 100 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().

stripClusterInputTag_

edm::InputTag TrackingMonitor::stripClusterInputTag_

private

Definition at line 109 of file TrackingMonitor.h.

Referenced by TrackingMonitor().

stripClustersToken_

edm::EDGetTokenT<edmNew::DetSetVector<SiStripCluster> > TrackingMonitor::stripClustersToken_

private

Definition at line 111 of file TrackingMonitor.h.

Referenced by setNclus(), and TrackingMonitor().

theLumiDetails_

GetLumi* TrackingMonitor::theLumiDetails_

private

Definition at line 126 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().

theTrackAnalyzer

tadqm::TrackAnalyzer* TrackingMonitor::theTrackAnalyzer

private

Definition at line 123 of file TrackingMonitor.h.

Referenced by analyze(), bookHistograms(), TrackingMonitor(), and ~TrackingMonitor().

theTrackBuildingAnalyzer

TrackBuildingAnalyzer* TrackingMonitor::theTrackBuildingAnalyzer

private

Definition at line 124 of file TrackingMonitor.h.

Referenced by analyze(), bookHistograms(), and ~TrackingMonitor().

theVertexMonitor

std::vector<VertexMonitor*> TrackingMonitor::theVertexMonitor

private

Definition at line 125 of file TrackingMonitor.h.

Referenced by analyze(), bookHistograms(), TrackingMonitor(), and ~TrackingMonitor().

trackCandidateToken_

edm::EDGetTokenT<TrackCandidateCollection> TrackingMonitor::trackCandidateToken_

private

Definition at line 99 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().

trackToken_

edm::EDGetTokenT<edm::View<reco::Track> > TrackingMonitor::trackToken_

private

Definition at line 98 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().

transientTrackingRecHitBuilderToken_

edm::ESGetToken<TransientTrackingRecHitBuilder, TransientRecHitRecord> TrackingMonitor::transientTrackingRecHitBuilderToken_

private

Definition at line 118 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().