CMS 3D CMS Logo
List of all members | Public Types | Public Member Functions | Private Member Functions | Private Attributes
TrackingMonitor Class Reference

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

Inheritance diagram for TrackingMonitor:
DQMEDAnalyzer edm::stream::EDProducer< edm::GlobalCache< DQMEDAnalyzerGlobalCache >, edm::EndRunProducer, edm::EndLuminosityBlockProducer, edm::Accumulator >

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 (MonitorElement *th2m, MonitorElement *me)
 
void doProfileX (TH2 *th2, 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.

48  : confID_(iConfig.id()),
49  theTrackBuildingAnalyzer(new TrackBuildingAnalyzer(iConfig)),
50  NumberOfTracks(nullptr),
51  NumberOfMeanRecHitsPerTrack(nullptr),
52  NumberOfMeanLayersPerTrack(nullptr)
53  // , NumberOfGoodTracks(NULL)
54  ,
55  FractionOfGoodTracks(nullptr),
56  NumberOfTrackingRegions(nullptr),
57  NumberOfSeeds(nullptr),
58  NumberOfSeeds_lumiFlag(nullptr),
59  NumberOfTrackCandidates(nullptr),
60  FractionCandidatesOverSeeds(nullptr)
61  // , NumberOfGoodTrkVsClus(NULL)
62  ,
63  NumberEventsOfVsLS(nullptr),
64  NumberOfTracksVsLS(nullptr)
65  // , NumberOfGoodTracksVsLS(NULL)
66  ,
67  GoodTracksFractionVsLS(nullptr)
68  // , GoodTracksNumberOfRecHitsPerTrackVsLS(NULL)
69  // ADD by Mia for PU monitoring
70  // vertex plots to be moved in ad hoc class
71  ,
72  NumberOfGoodPVtxVsLS(nullptr),
73  NumberOfGoodPVtxWO0VsLS(nullptr),
74  NumberEventsOfVsBX(nullptr),
75  NumberOfTracksVsBX(nullptr),
76  GoodTracksFractionVsBX(nullptr),
77  NumberOfRecHitsPerTrackVsBX(nullptr),
78  NumberOfGoodPVtxVsBX(nullptr),
79  NumberOfGoodPVtxWO0VsBX(nullptr),
80  NumberOfTracksVsBXlumi(nullptr),
81  NumberOfTracksVsGoodPVtx(nullptr),
82  NumberOfTracksVsPUPVtx(nullptr),
83  NumberEventsOfVsGoodPVtx(nullptr),
84  GoodTracksFractionVsGoodPVtx(nullptr),
85  NumberOfRecHitsPerTrackVsGoodPVtx(nullptr),
86  NumberOfPVtxVsGoodPVtx(nullptr),
87  NumberOfPixelClustersVsGoodPVtx(nullptr),
88  NumberOfStripClustersVsGoodPVtx(nullptr),
89  NumberEventsOfVsLUMI(nullptr),
90  NumberOfTracksVsLUMI(nullptr),
91  GoodTracksFractionVsLUMI(nullptr),
92  NumberOfRecHitsPerTrackVsLUMI(nullptr),
93  NumberOfGoodPVtxVsLUMI(nullptr),
94  NumberOfGoodPVtxWO0VsLUMI(nullptr),
95  NumberOfPixelClustersVsLUMI(nullptr),
96  NumberOfStripClustersVsLUMI(nullptr),
97  NumberOfTracks_lumiFlag(nullptr)
98  // , NumberOfGoodTracks_lumiFlag(NULL)
99 
100  ,
101  builderName(iConfig.getParameter<std::string>("TTRHBuilder")),
102  doTrackerSpecific_(iConfig.getParameter<bool>("doTrackerSpecific")),
103  doLumiAnalysis(iConfig.getParameter<bool>("doLumiAnalysis")),
104  doProfilesVsLS_(iConfig.getParameter<bool>("doProfilesVsLS")),
105  doAllSeedPlots(iConfig.getParameter<bool>("doSeedParameterHistos")),
106  doAllPlots(iConfig.getParameter<bool>("doAllPlots")),
107  doGeneralPropertiesPlots_(iConfig.getParameter<bool>("doGeneralPropertiesPlots")),
108  doHitPropertiesPlots_(iConfig.getParameter<bool>("doHitPropertiesPlots")),
109  doTkCandPlots(iConfig.getParameter<bool>("doTrackCandHistos")),
110  doPUmonitoring_(iConfig.getParameter<bool>("doPUmonitoring")),
111  genTriggerEventFlag_(new GenericTriggerEventFlag(
112  iConfig.getParameter<edm::ParameterSet>("genericTriggerEventPSet"), consumesCollector(), *this)),
113  numSelection_(iConfig.getParameter<std::string>("numCut")),
114  denSelection_(iConfig.getParameter<std::string>("denCut")),
115  pvNDOF_(iConfig.getParameter<int>("pvNDOF")),
116  forceSCAL_(iConfig.getParameter<bool>("forceSCAL")) {
117  edm::ConsumesCollector c{consumesCollector()};
118  theTrackAnalyzer = new tadqm::TrackAnalyzer(iConfig, c);
119 
120  // input tags for collections from the configuration
121  bsSrc_ = iConfig.getParameter<edm::InputTag>("beamSpot");
122  pvSrc_ = iConfig.getParameter<edm::InputTag>("primaryVertex");
123  bsSrcToken_ = consumes<reco::BeamSpot>(bsSrc_);
124  pvSrcToken_ = mayConsume<reco::VertexCollection>(pvSrc_);
125 
126  lumiscalersToken_ = consumes<LumiScalersCollection>(iConfig.getParameter<edm::InputTag>("scal"));
127  metaDataToken_ = consumes<OnlineLuminosityRecord>(iConfig.getParameter<edm::InputTag>("metadata"));
128 
129  edm::InputTag alltrackProducer = iConfig.getParameter<edm::InputTag>("allTrackProducer");
130  edm::InputTag trackProducer = iConfig.getParameter<edm::InputTag>("TrackProducer");
131  edm::InputTag tcProducer = iConfig.getParameter<edm::InputTag>("TCProducer");
132  edm::InputTag seedProducer = iConfig.getParameter<edm::InputTag>("SeedProducer");
133  allTrackToken_ = consumes<edm::View<reco::Track> >(alltrackProducer);
134  trackToken_ = consumes<edm::View<reco::Track> >(trackProducer);
135  trackCandidateToken_ = consumes<TrackCandidateCollection>(tcProducer);
136  seedToken_ = consumes<edm::View<TrajectorySeed> >(seedProducer);
137  seedStopInfoToken_ = consumes<std::vector<SeedStopInfo> >(tcProducer);
138 
139  doMVAPlots = iConfig.getParameter<bool>("doMVAPlots");
140  if (doMVAPlots) {
141  mvaQualityTokens_ = edm::vector_transform(
142  iConfig.getParameter<std::vector<std::string> >("MVAProducers"), [&](const std::string& tag) {
143  return std::make_tuple(consumes<MVACollection>(edm::InputTag(tag, "MVAValues")),
144  consumes<QualityMaskCollection>(edm::InputTag(tag, "QualityMasks")));
145  });
146  mvaTrackToken_ = consumes<edm::View<reco::Track> >(iConfig.getParameter<edm::InputTag>("TrackProducerForMVA"));
147  }
148 
149  doRegionPlots = iConfig.getParameter<bool>("doRegionPlots");
150  doRegionCandidatePlots = iConfig.getParameter<bool>("doRegionCandidatePlots");
151  if (doRegionPlots) {
152  const auto& regionTag = iConfig.getParameter<edm::InputTag>("RegionProducer");
153  if (!regionTag.label().empty()) {
154  regionToken_ = consumes<edm::OwnVector<TrackingRegion> >(regionTag);
155  }
156  const auto& regionLayersTag = iConfig.getParameter<edm::InputTag>("RegionSeedingLayersProducer");
157  if (!regionLayersTag.label().empty()) {
158  if (!regionToken_.isUninitialized()) {
159  throw cms::Exception("Configuration")
160  << "Only one of 'RegionProducer' and 'RegionSeedingLayersProducer' can be non-empty, now both are.";
161  }
162  regionLayerSetsToken_ = consumes<TrackingRegionsSeedingLayerSets>(regionLayersTag);
163  } else if (regionToken_.isUninitialized()) {
164  throw cms::Exception("Configuration") << "With doRegionPlots=True either 'RegionProducer' or "
165  "'RegionSeedingLayersProducer' must be non-empty, now both are empty.";
166  }
167 
168  if (doRegionCandidatePlots) {
169  regionCandidateToken_ = consumes<reco::CandidateView>(iConfig.getParameter<edm::InputTag>("RegionCandidates"));
170  }
171  }
172 
173  edm::InputTag stripClusterInputTag_ = iConfig.getParameter<edm::InputTag>("stripCluster");
174  edm::InputTag pixelClusterInputTag_ = iConfig.getParameter<edm::InputTag>("pixelCluster");
175  stripClustersToken_ = mayConsume<edmNew::DetSetVector<SiStripCluster> >(stripClusterInputTag_);
176  pixelClustersToken_ = mayConsume<edmNew::DetSetVector<SiPixelCluster> >(pixelClusterInputTag_);
177 
178  runTrackBuildingAnalyzerForSeed =
179  (doAllSeedPlots || iConfig.getParameter<bool>("doSeedPTHisto") || iConfig.getParameter<bool>("doSeedETAHisto") ||
180  iConfig.getParameter<bool>("doSeedPHIHisto") || iConfig.getParameter<bool>("doSeedPHIVsETAHisto") ||
181  iConfig.getParameter<bool>("doSeedThetaHisto") || iConfig.getParameter<bool>("doSeedQHisto") ||
182  iConfig.getParameter<bool>("doSeedDxyHisto") || iConfig.getParameter<bool>("doSeedDzHisto") ||
183  iConfig.getParameter<bool>("doSeedNRecHitsHisto") || iConfig.getParameter<bool>("doSeedNVsPhiProf") ||
184  iConfig.getParameter<bool>("doSeedNVsEtaProf"));
185 
186  if (doTkCandPlots || doAllSeedPlots || runTrackBuildingAnalyzerForSeed) {
187  magneticFieldToken_ = esConsumes<MagneticField, IdealMagneticFieldRecord>();
188  transientTrackingRecHitBuilderToken_ =
189  esConsumes<TransientTrackingRecHitBuilder, TransientRecHitRecord>(edm::ESInputTag("", builderName));
190  }
191 
192  doFractionPlot_ = true;
193  if (alltrackProducer.label() == trackProducer.label())
194  doFractionPlot_ = false;
195 
196  Quality_ = iConfig.getParameter<std::string>("Quality");
197  AlgoName_ = iConfig.getParameter<std::string>("AlgoName");
198 
199  // get flag from the configuration
200  doPlotsVsBXlumi_ = iConfig.getParameter<bool>("doPlotsVsBXlumi");
201  if (doPlotsVsBXlumi_)
202  theLumiDetails_ = new GetLumi(iConfig.getParameter<edm::ParameterSet>("BXlumiSetup"), c);
203  doPlotsVsGoodPVtx_ = iConfig.getParameter<bool>("doPlotsVsGoodPVtx");
204  doPlotsVsLUMI_ = iConfig.getParameter<bool>("doPlotsVsLUMI");
205  doPlotsVsBX_ = iConfig.getParameter<bool>("doPlotsVsBX");
206 
207  if (doPUmonitoring_) {
208  std::vector<edm::InputTag> primaryVertexInputTags =
209  iConfig.getParameter<std::vector<edm::InputTag> >("primaryVertexInputTags");
210  std::vector<edm::InputTag> selPrimaryVertexInputTags =
211  iConfig.getParameter<std::vector<edm::InputTag> >("selPrimaryVertexInputTags");
212  std::vector<std::string> pvLabels = iConfig.getParameter<std::vector<std::string> >("pvLabels");
213 
214  if (primaryVertexInputTags.size() == pvLabels.size() and
215  primaryVertexInputTags.size() == selPrimaryVertexInputTags.size()) {
216  for (size_t i = 0; i < primaryVertexInputTags.size(); i++) {
217  edm::InputTag iPVinputTag = primaryVertexInputTags[i];
218  edm::InputTag iSelPVinputTag = selPrimaryVertexInputTags[i];
219  std::string iPVlabel = pvLabels[i];
220 
221  theVertexMonitor.push_back(new VertexMonitor(iConfig, iPVinputTag, iSelPVinputTag, iPVlabel, c));
222  }
223  }
224  }
225 }

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

◆ ~TrackingMonitor()

TrackingMonitor::~TrackingMonitor ( )
override

Definition at line 227 of file TrackingMonitor.cc.

227  {
228  if (theTrackAnalyzer)
229  delete theTrackAnalyzer;
230  if (theTrackBuildingAnalyzer)
231  delete theTrackBuildingAnalyzer;
232  if (doPUmonitoring_)
233  for (size_t i = 0; i < theVertexMonitor.size(); i++)
234  if (theVertexMonitor[i])
235  delete theVertexMonitor[i];
236  if (genTriggerEventFlag_)
237  delete genTriggerEventFlag_;
238 }

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

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.

741  {
742  // Filter out events if Trigger Filtering is requested
743  if (genTriggerEventFlag_->on() && !genTriggerEventFlag_->accept(iEvent, iSetup))
744  return;
745  auto const* conf = edm::pset::Registry::instance()->getMapped(confID_);
746  MEFolderName = conf->getParameter<std::string>("FolderName");
747  std::string Folder = MEFolderName.substr(0, 2);
748  float lumi = -1.;
749  if (forceSCAL_) {
750  edm::Handle<LumiScalersCollection> lumiScalers = iEvent.getHandle(lumiscalersToken_);
751  if (lumiScalers.isValid() && !lumiScalers->empty()) {
752  LumiScalersCollection::const_iterator scalit = lumiScalers->begin();
753  lumi = scalit->instantLumi();
754  }
755  } else {
756  edm::Handle<OnlineLuminosityRecord> metaData = iEvent.getHandle(metaDataToken_);
757  if (metaData.isValid())
758  lumi = metaData->instLumi();
759  }
760 
761  if (doPlotsVsLUMI_ || doAllPlots)
762  NumberEventsOfVsLUMI->Fill(lumi);
763 
764  // Analyse the tracks
765  // if the collection is empty, do not fill anything
766  // ---------------------------------------------------------------------------------//
767 
768  size_t bx = iEvent.bunchCrossing();
769  if (doPlotsVsBX_ || doAllPlots)
770  NumberEventsOfVsBX->Fill(bx);
771 
772  // get the track collection
773  edm::Handle<edm::View<reco::Track> > trackHandle = iEvent.getHandle(trackToken_);
774 
775  int numberOfTracks_den = 0;
776  edm::Handle<edm::View<reco::Track> > allTrackHandle = iEvent.getHandle(allTrackToken_);
777  if (allTrackHandle.isValid()) {
778  for (edm::View<reco::Track>::const_iterator track = allTrackHandle->begin(); track != allTrackHandle->end();
779  ++track) {
780  if (denSelection_(*track))
781  numberOfTracks_den++;
782  }
783  }
784 
785  edm::Handle<reco::VertexCollection> pvHandle = iEvent.getHandle(pvSrcToken_);
786  reco::Vertex const* pv0 = nullptr;
787  if (pvHandle.isValid()) {
788  pv0 = &pvHandle->front();
789  //--- pv fake (the pv collection should have size==1 and the pv==beam spot)
790  if (pv0->isFake() ||
791  pv0->tracksSize() == 0
792  // definition of goodOfflinePrimaryVertex
793  || pv0->ndof() < pvNDOF_ || pv0->z() > 24.)
794  pv0 = nullptr;
795  }
796 
797  if (trackHandle.isValid()) {
798  int numberOfTracks = trackHandle->size();
799  int numberOfTracks_num = 0;
800  int numberOfTracks_pv0 = 0;
801 
802  const edm::View<reco::Track>& trackCollection = *trackHandle;
803  // calculate the mean # rechits and layers
804  int totalRecHits = 0, totalLayers = 0;
805 
806  theTrackAnalyzer->setNumberOfGoodVertices(iEvent);
807  theTrackAnalyzer->setBX(iEvent);
808  theTrackAnalyzer->setLumi(iEvent, iSetup);
809  for (edm::View<reco::Track>::const_iterator track = trackCollection.begin(); track != trackCollection.end();
810  ++track) {
811  if (doPlotsVsBX_ || doAllPlots)
812  NumberOfRecHitsPerTrackVsBX->Fill(bx, track->numberOfValidHits());
813  if (numSelection_(*track)) {
814  numberOfTracks_num++;
815  if (pv0 && std::abs(track->dz(pv0->position())) < 0.15)
816  ++numberOfTracks_pv0;
817  }
818 
819  if (doProfilesVsLS_ || doAllPlots)
820  NumberOfRecHitsPerTrackVsLS->Fill(static_cast<double>(iEvent.id().luminosityBlock()),
821  track->numberOfValidHits());
822 
823  if (doPlotsVsLUMI_ || doAllPlots)
824  NumberOfRecHitsPerTrackVsLUMI->Fill(lumi, track->numberOfValidHits());
825 
826  totalRecHits += track->numberOfValidHits();
827  totalLayers += track->hitPattern().trackerLayersWithMeasurement();
828 
829  // do analysis per track
830  theTrackAnalyzer->analyze(iEvent, iSetup, *track);
831  }
832 
833  double frac = -1.;
834  // if (numberOfAllTracks > 0) frac = static_cast<double>(numberOfTracks)/static_cast<double>(numberOfAllTracks);
835  if (numberOfTracks_den > 0)
836  frac = static_cast<double>(numberOfTracks_num) / static_cast<double>(numberOfTracks_den);
837 
838  if (doGeneralPropertiesPlots_ || doAllPlots) {
839  NumberOfTracks->Fill(double(numberOfTracks));
840 
841  if (Folder == "Tr") {
842  NumberofTracks_Hardvtx->Fill(double(numberOfTracks_pv0));
843  NumberOfTracks_PUvtx->Fill(double(numberOfTracks - numberOfTracks_pv0));
844  NumberofTracks_Hardvtx_PUvtx->Fill(0.5, double(numberOfTracks_pv0));
845  NumberofTracks_Hardvtx_PUvtx->Fill(1.5, double(numberOfTracks - numberOfTracks_pv0));
846  }
847 
848  if (doPlotsVsBX_ || doAllPlots)
849  NumberOfTracksVsBX->Fill(bx, numberOfTracks);
850  if (doPlotsVsLUMI_ || doAllPlots)
851  NumberOfTracksVsLUMI->Fill(lumi, numberOfTracks);
852  if (doFractionPlot_) {
853  FractionOfGoodTracks->Fill(frac);
854 
855  if (doFractionPlot_) {
856  if (doPlotsVsBX_ || doAllPlots)
857  GoodTracksFractionVsBX->Fill(bx, frac);
858  if (doPlotsVsLUMI_ || doAllPlots)
859  GoodTracksFractionVsLUMI->Fill(lumi, frac);
860  }
861  }
862  if (numberOfTracks > 0) {
863  double meanRecHits = static_cast<double>(totalRecHits) / static_cast<double>(numberOfTracks);
864  double meanLayers = static_cast<double>(totalLayers) / static_cast<double>(numberOfTracks);
865  NumberOfMeanRecHitsPerTrack->Fill(meanRecHits);
866  NumberOfMeanLayersPerTrack->Fill(meanLayers);
867  }
868  }
869 
870  if (doProfilesVsLS_ || doAllPlots) {
871  float nLS = static_cast<double>(iEvent.id().luminosityBlock());
872  NumberEventsOfVsLS->Fill(nLS);
873  NumberOfTracksVsLS->Fill(nLS, numberOfTracks);
874  if (doFractionPlot_)
875  GoodTracksFractionVsLS->Fill(nLS, frac);
876  }
877 
878  if (doLumiAnalysis) {
879  NumberOfTracks_lumiFlag->Fill(numberOfTracks);
880  }
881 
882  // Analyse the Track Building variables
883  // if the collection is empty, do not fill anything
884  // ---------------------------------------------------------------------------------//
885 
886  // fill the TrackCandidate info
887  if (doTkCandPlots) {
888  // magnetic field
889  MagneticField const& theMF = iSetup.getData(magneticFieldToken_);
890 
891  // get the candidate collection
892  edm::Handle<TrackCandidateCollection> theTCHandle = iEvent.getHandle(trackCandidateToken_);
893  const TrackCandidateCollection& theTCCollection = *theTCHandle;
894 
895  if (theTCHandle.isValid()) {
896  // get the beam spot
897  edm::Handle<reco::BeamSpot> recoBeamSpotHandle = iEvent.getHandle(bsSrcToken_);
898  const reco::BeamSpot& bs = *recoBeamSpotHandle;
899 
900  NumberOfTrackCandidates->Fill(theTCCollection.size());
901 
902  // get the seed collection
903  edm::Handle<edm::View<TrajectorySeed> > seedHandle = iEvent.getHandle(seedToken_);
904  const edm::View<TrajectorySeed>& seedCollection = *seedHandle;
905  if (seedHandle.isValid() && !seedCollection.empty())
906  FractionCandidatesOverSeeds->Fill(double(theTCCollection.size()) / double(seedCollection.size()));
907 
908  TransientTrackingRecHitBuilder const& theTTRHBuilder = iSetup.getData(transientTrackingRecHitBuilderToken_);
909  for (TrackCandidateCollection::const_iterator cand = theTCCollection.begin(); cand != theTCCollection.end();
910  ++cand) {
911  theTrackBuildingAnalyzer->analyze(iEvent, iSetup, *cand, bs, theMF, theTTRHBuilder);
912  }
913  } else {
914  edm::LogWarning("TrackingMonitor") << "No Track Candidates in the event. Not filling associated histograms";
915  }
916 
917  if (doMVAPlots) {
918  // Get MVA and quality mask collections
919  std::vector<const MVACollection*> mvaCollections;
920  std::vector<const QualityMaskCollection*> qualityMaskCollections;
921 
922  edm::Handle<edm::View<reco::Track> > htracks = iEvent.getHandle(mvaTrackToken_);
923 
924  edm::Handle<MVACollection> hmva;
925  edm::Handle<QualityMaskCollection> hqual;
926  for (const auto& tokenTpl : mvaQualityTokens_) {
927  hmva = iEvent.getHandle(std::get<0>(tokenTpl));
928  hqual = iEvent.getHandle(std::get<1>(tokenTpl));
929  mvaCollections.push_back(hmva.product());
930  qualityMaskCollections.push_back(hqual.product());
931  }
932  theTrackBuildingAnalyzer->analyze(*htracks, mvaCollections, qualityMaskCollections);
933  }
934  }
935 
936  //plots for trajectory seeds
937 
938  if (doAllSeedPlots || doSeedNumberPlot || doSeedVsClusterPlot || runTrackBuildingAnalyzerForSeed) {
939  // get the seed collection
940  edm::Handle<edm::View<TrajectorySeed> > seedHandle = iEvent.getHandle(seedToken_);
941 
942  // fill the seed info
943  if (seedHandle.isValid()) {
944  const auto& seedCollection = *seedHandle;
945 
946  if (doAllSeedPlots || doSeedNumberPlot) {
947  NumberOfSeeds->Fill(seedCollection.size());
948  if (doSeedLumiAnalysis_)
949  NumberOfSeeds_lumiFlag->Fill(seedCollection.size());
950  }
951 
952  if (doAllSeedPlots || doSeedVsClusterPlot) {
953  std::vector<int> NClus;
954  setNclus(iEvent, NClus);
955  for (uint i = 0; i < ClusterLabels.size(); i++) {
956  SeedsVsClusters[i]->Fill(NClus[i], seedCollection.size());
957  }
958  }
959 
960  if (doAllSeedPlots || runTrackBuildingAnalyzerForSeed) {
961  edm::Handle<std::vector<SeedStopInfo> > stopHandle = iEvent.getHandle(seedStopInfoToken_);
962  const auto& seedStopInfo = *stopHandle;
963 
964  if (seedStopInfo.size() == seedCollection.size()) {
965  //here duplication of mag field and be informations is needed to allow seed and track cand histos to be independent
966  // magnetic field
967  MagneticField const& theMF = iSetup.getData(magneticFieldToken_);
968 
969  // get the beam spot
970  edm::Handle<reco::BeamSpot> recoBeamSpotHandle = iEvent.getHandle(bsSrcToken_);
971  const reco::BeamSpot& bs = *recoBeamSpotHandle;
972 
973  TransientTrackingRecHitBuilder const& theTTRHBuilder = iSetup.getData(transientTrackingRecHitBuilderToken_);
974  for (size_t i = 0; i < seedCollection.size(); ++i) {
975  theTrackBuildingAnalyzer->analyze(
976  iEvent, iSetup, seedCollection[i], seedStopInfo[i], bs, theMF, theTTRHBuilder);
977  }
978  } else {
979  edm::LogWarning("TrackingMonitor")
980  << "Seed collection size (" << seedCollection.size()
981  << ") differs from seed stop info collection size (" << seedStopInfo.size()
982  << "). This is a sign of inconsistency in the configuration. Not filling associated histograms.";
983  }
984  }
985 
986  } else {
987  edm::LogWarning("TrackingMonitor") << "No Trajectory seeds in the event. Not filling associated histograms";
988  }
989  }
990 
991  // plots for tracking regions
992  if (doRegionPlots) {
993  if (!regionToken_.isUninitialized()) {
994  edm::Handle<edm::OwnVector<TrackingRegion> > hregions = iEvent.getHandle(regionToken_);
995  const auto& regions = *hregions;
996  NumberOfTrackingRegions->Fill(regions.size());
997 
998  theTrackBuildingAnalyzer->analyze(regions);
999  } else if (!regionLayerSetsToken_.isUninitialized()) {
1000  edm::Handle<TrackingRegionsSeedingLayerSets> hregions = iEvent.getHandle(regionLayerSetsToken_);
1001  const auto& regions = *hregions;
1002  NumberOfTrackingRegions->Fill(regions.regionsSize());
1003 
1004  theTrackBuildingAnalyzer->analyze(regions);
1005  }
1006 
1007  if (doRegionCandidatePlots) {
1008  edm::Handle<reco::CandidateView> hcandidates = iEvent.getHandle(regionCandidateToken_);
1009  theTrackBuildingAnalyzer->analyze(*hcandidates);
1010  }
1011  }
1012 
1013  if (doTrackerSpecific_ || doAllPlots) {
1014  std::vector<int> NClus;
1015  setNclus(iEvent, NClus);
1016  for (uint i = 0; i < ClusterLabels.size(); i++) {
1017  NumberOfTrkVsClusters[i]->Fill(NClus[i], numberOfTracks);
1018  }
1019  }
1020 
1021  if (doPUmonitoring_) {
1022  // do vertex monitoring
1023  for (size_t i = 0; i < theVertexMonitor.size(); i++)
1024  theVertexMonitor[i]->analyze(iEvent, iSetup);
1025  }
1026  if (doPlotsVsGoodPVtx_) {
1027  size_t totalNumGoodPV = 0;
1028  if (pvHandle.isValid()) {
1029  for (reco::VertexCollection::const_iterator pv = pvHandle->begin(); pv != pvHandle->end(); ++pv) {
1030  //--- pv fake (the pv collection should have size==1 and the pv==beam spot)
1031  if (pv->isFake() || pv->tracksSize() == 0)
1032  continue;
1033 
1034  // definition of goodOfflinePrimaryVertex
1035  if (pv->ndof() < pvNDOF_ || pv->z() > 24.)
1036  continue;
1037  totalNumGoodPV++;
1038  }
1039 
1040  NumberEventsOfVsGoodPVtx->Fill(float(totalNumGoodPV));
1041  NumberOfTracksVsGoodPVtx->Fill(float(totalNumGoodPV), numberOfTracks);
1042  if (totalNumGoodPV > 1)
1043  NumberOfTracksVsPUPVtx->Fill(totalNumGoodPV - 1,
1044  double(numberOfTracks - numberOfTracks_pv0) / double(totalNumGoodPV - 1));
1045  NumberOfPVtxVsGoodPVtx->Fill(float(totalNumGoodPV), pvHandle->size());
1046 
1047  for (edm::View<reco::Track>::const_iterator track = trackCollection.begin(); track != trackCollection.end();
1048  ++track) {
1049  NumberOfRecHitsPerTrackVsGoodPVtx->Fill(float(totalNumGoodPV), track->numberOfValidHits());
1050  }
1051 
1052  if (doProfilesVsLS_ || doAllPlots)
1053  NumberOfGoodPVtxVsLS->Fill(static_cast<double>(iEvent.id().luminosityBlock()), totalNumGoodPV);
1054  if (doPlotsVsBX_ || doAllPlots)
1055  NumberOfGoodPVtxVsBX->Fill(bx, float(totalNumGoodPV));
1056 
1057  if (doFractionPlot_)
1058  GoodTracksFractionVsGoodPVtx->Fill(float(totalNumGoodPV), frac);
1059 
1060  if (doPlotsVsLUMI_ || doAllPlots)
1061  NumberOfGoodPVtxVsLUMI->Fill(lumi, float(totalNumGoodPV));
1062  }
1063 
1064  std::vector<int> NClus;
1065  setNclus(iEvent, NClus);
1066  std::ostringstream ss;
1067  ss << "VI stat " << totalNumGoodPV << ' ' << numberOfTracks;
1068  for (uint i = 0; i < ClusterLabels.size(); i++) {
1069  ss << ' ' << NClus[i];
1070  if (doPlotsVsLUMI_ || doAllPlots) {
1071  if (ClusterLabels[i] == "Pix")
1072  NumberOfPixelClustersVsLUMI->Fill(lumi, NClus[i]);
1073  if (ClusterLabels[i] == "Strip")
1074  NumberOfStripClustersVsLUMI->Fill(lumi, NClus[i]);
1075  }
1076  if (ClusterLabels[i] == "Pix")
1077  NumberOfPixelClustersVsGoodPVtx->Fill(float(totalNumGoodPV), NClus[i]);
1078  if (ClusterLabels[i] == "Strip")
1079  NumberOfStripClustersVsGoodPVtx->Fill(float(totalNumGoodPV), NClus[i]);
1080  }
1081  COUT(MEFolderName) << ss.str() << std::endl;
1082  if (doPlotsVsBXlumi_) {
1083  double bxlumi = theLumiDetails_->getValue(iEvent);
1084  NumberOfTracksVsBXlumi->Fill(bxlumi, numberOfTracks);
1085  }
1086 
1087  if (doProfilesVsLS_ || doAllPlots)
1088  if (totalNumGoodPV != 0)
1089  NumberOfGoodPVtxWO0VsLS->Fill(static_cast<double>(iEvent.id().luminosityBlock()), float(totalNumGoodPV));
1090  if (doPlotsVsBX_ || doAllPlots)
1091  if (totalNumGoodPV != 0)
1092  NumberOfGoodPVtxWO0VsBX->Fill(bx, float(totalNumGoodPV));
1093  if (doPlotsVsLUMI_ || doAllPlots)
1094  if (totalNumGoodPV != 0)
1095  NumberOfGoodPVtxWO0VsLUMI->Fill(lumi, float(totalNumGoodPV));
1096 
1097  } // PU monitoring
1098 
1099  } // trackHandle is valid
1100 }

References funct::abs(), GenericTriggerEventFlag::accept(), allTrackToken_, TrackBuildingAnalyzer::analyze(), tadqm::TrackAnalyzer::analyze(), cms::cuda::bs, bsSrcToken_, l1GtPatternGenerator_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_FULL_cff::track, trackCandidateToken_, duplicaterechits_cfi::trackCollection, reco::Vertex::tracksSize(), trackToken_, transientTrackingRecHitBuilderToken_, parallelization::uint, and reco::Vertex::z().

◆ 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.

240  {
241  // parameters from the configuration
242  auto const* conf = edm::pset::Registry::instance()->getMapped(confID_);
243  assert(conf != nullptr);
244  std::string Quality = conf->getParameter<std::string>("Quality");
245  std::string AlgoName = conf->getParameter<std::string>("AlgoName");
246  MEFolderName = conf->getParameter<std::string>("FolderName");
247  std::string Folder = MEFolderName.substr(0, 2);
248 
249  // test for the Quality veriable validity
250  if (!Quality_.empty()) {
251  if (Quality_ != "highPurity" && Quality_ != "tight" && Quality_ != "loose") {
252  edm::LogWarning("TrackingMonitor") << "Qualty Name is invalid, using no quality criterea by default";
253  Quality_ = "";
254  }
255  }
256 
257  // use the AlgoName and Quality Name
258  std::string CategoryName = !Quality_.empty() ? AlgoName_ + "_" + Quality_ : AlgoName_;
259 
260  // get binning from the configuration
261  int TKNoBin = conf->getParameter<int>("TkSizeBin");
262  double TKNoMin = conf->getParameter<double>("TkSizeMin");
263  double TKNoMax = conf->getParameter<double>("TkSizeMax");
264 
265  int TCNoBin = conf->getParameter<int>("TCSizeBin");
266  double TCNoMin = conf->getParameter<double>("TCSizeMin");
267  double TCNoMax = conf->getParameter<double>("TCSizeMax");
268 
269  int TKNoSeedBin = conf->getParameter<int>("TkSeedSizeBin");
270  double TKNoSeedMin = conf->getParameter<double>("TkSeedSizeMin");
271  double TKNoSeedMax = conf->getParameter<double>("TkSeedSizeMax");
272 
273  //int RecHitBin = conf->getParameter<int>("RecHitBin");
274  double RecHitMin = conf->getParameter<double>("RecHitMin");
275  double RecHitMax = conf->getParameter<double>("RecHitMax");
276 
277  int MeanHitBin = conf->getParameter<int>("MeanHitBin");
278  double MeanHitMin = conf->getParameter<double>("MeanHitMin");
279  double MeanHitMax = conf->getParameter<double>("MeanHitMax");
280 
281  int MeanLayBin = conf->getParameter<int>("MeanLayBin");
282  double MeanLayMin = conf->getParameter<double>("MeanLayMin");
283  double MeanLayMax = conf->getParameter<double>("MeanLayMax");
284 
285  int LSBin = conf->getParameter<int>("LSBin");
286  int LSMin = conf->getParameter<double>("LSMin");
287  int LSMax = conf->getParameter<double>("LSMax");
288 
289  std::string StateName = conf->getParameter<std::string>("MeasurementState");
290  if (StateName != "OuterSurface" && StateName != "InnerSurface" && StateName != "ImpactPoint" &&
291  StateName != "default" && StateName != "All") {
292  // print warning
293  edm::LogWarning("TrackingMonitor") << "State Name is invalid, using 'ImpactPoint' by default";
294  }
295 
296  ibooker.setCurrentFolder(MEFolderName);
297 
298  // book the General Property histograms
299  // ---------------------------------------------------------------------------------//
300 
301  if (doGeneralPropertiesPlots_ || doAllPlots) {
302  ibooker.setCurrentFolder(MEFolderName + "/GeneralProperties");
303 
304  histname = "NumberOfTracks_" + CategoryName;
305  // MODIFY by Mia in order to cope w/ high multiplicity
306  NumberOfTracks = ibooker.book1D(histname, histname, TKNoBin, TKNoMin, TKNoMax);
307  NumberOfTracks->setAxisTitle("Number of Tracks per Event", 1);
308  NumberOfTracks->setAxisTitle("Number of Events", 2);
309 
310  if (Folder == "Tr") {
311  histname = "NumberOfTracks_PUvtx_" + CategoryName;
312  NumberOfTracks_PUvtx = ibooker.book1D(histname, histname, TKNoBin, TKNoMin, TKNoMax);
313  NumberOfTracks_PUvtx->setAxisTitle("Number of Tracks per Event (matched a PU vertex)", 1);
314  NumberOfTracks_PUvtx->setAxisTitle("Number of Events", 2);
315 
316  histname = "NumberofTracks_Hardvtx_" + CategoryName;
317  NumberofTracks_Hardvtx =
318  ibooker.book1D(histname, histname, TKNoBin / 10, TKNoMin, ((TKNoMax - TKNoMin) / 10) - 0.5);
319  NumberofTracks_Hardvtx->setAxisTitle("Number of Tracks per Event (matched main vertex)", 1);
320  NumberofTracks_Hardvtx->setAxisTitle("Number of Events", 2);
321 
322  histname = "NumberofTracks_Hardvtx_PUvtx_" + CategoryName;
323  NumberofTracks_Hardvtx_PUvtx = ibooker.book1D(histname, histname, 2, 0., 2.);
324  NumberofTracks_Hardvtx_PUvtx->setAxisTitle("Number of Tracks per PU/Hard vertex", 1);
325  NumberofTracks_Hardvtx_PUvtx->setAxisTitle("Number of Tracks", 2);
326  NumberofTracks_Hardvtx_PUvtx->setBinLabel(1, "PU_Vertex");
327  NumberofTracks_Hardvtx_PUvtx->setBinLabel(2, "Hard_Vertex");
328  }
329 
330  histname = "NumberOfMeanRecHitsPerTrack_" + CategoryName;
331  NumberOfMeanRecHitsPerTrack = ibooker.book1D(histname, histname, MeanHitBin, MeanHitMin, MeanHitMax);
332  NumberOfMeanRecHitsPerTrack->setAxisTitle("Mean number of valid RecHits per Track", 1);
333  NumberOfMeanRecHitsPerTrack->setAxisTitle("Entries", 2);
334 
335  histname = "NumberOfMeanLayersPerTrack_" + CategoryName;
336  NumberOfMeanLayersPerTrack = ibooker.book1D(histname, histname, MeanLayBin, MeanLayMin, MeanLayMax);
337  NumberOfMeanLayersPerTrack->setAxisTitle("Mean number of Layers per Track", 1);
338  NumberOfMeanLayersPerTrack->setAxisTitle("Entries", 2);
339 
340  if (doFractionPlot_) {
341  histname = "FractionOfGoodTracks_" + CategoryName;
342  FractionOfGoodTracks = ibooker.book1D(histname, histname, 101, -0.005, 1.005);
343  FractionOfGoodTracks->setAxisTitle("Fraction of Tracks (w.r.t. generalTracks)", 1);
344  FractionOfGoodTracks->setAxisTitle("Entries", 2);
345  }
346  }
347 
348  if (doLumiAnalysis) {
349  // add by Mia in order to deal with LS transitions
350  ibooker.setCurrentFolder(MEFolderName + "/LSanalysis");
351  auto scope = DQMStore::IBooker::UseLumiScope(ibooker);
352 
353  histname = "NumberOfTracks_lumiFlag_" + CategoryName;
354  NumberOfTracks_lumiFlag = ibooker.book1D(histname, histname, TKNoBin, TKNoMin, TKNoMax);
355  NumberOfTracks_lumiFlag->setAxisTitle("Number of Tracks per Event", 1);
356  NumberOfTracks_lumiFlag->setAxisTitle("Number of Events", 2);
357  }
358 
359  // book profile plots vs LS :
360  //---------------------------
361 
362  if (doProfilesVsLS_ || doAllPlots) {
363  ibooker.setCurrentFolder(MEFolderName + "/GeneralProperties");
364 
365  histname = "NumberOfTracksVsLS_" + CategoryName;
366  NumberOfTracksVsLS = ibooker.bookProfile(histname, histname, LSBin, LSMin, LSMax, TKNoMin, TKNoMax, "");
367  NumberOfTracksVsLS->getTH1()->SetCanExtend(TH1::kAllAxes);
368  NumberOfTracksVsLS->setAxisTitle("#Lumi section", 1);
369  NumberOfTracksVsLS->setAxisTitle("Number of Tracks", 2);
370 
371  histname = "NumberOfRecHitsPerTrackVsLS_" + CategoryName;
372  NumberOfRecHitsPerTrackVsLS =
373  ibooker.bookProfile(histname, histname, LSBin, LSMin, LSMax, RecHitMin, RecHitMax * 5, "");
374  NumberOfRecHitsPerTrackVsLS->getTH1()->SetCanExtend(TH1::kAllAxes);
375  NumberOfRecHitsPerTrackVsLS->setAxisTitle("#Lumi section", 1);
376  NumberOfRecHitsPerTrackVsLS->setAxisTitle("Mean number of Valid RecHits per track", 2);
377 
378  histname = "NumberEventsVsLS_" + CategoryName;
379  NumberEventsOfVsLS = ibooker.book1D(histname, histname, LSBin, LSMin, LSMax);
380  NumberEventsOfVsLS->getTH1()->SetCanExtend(TH1::kAllAxes);
381  NumberEventsOfVsLS->setAxisTitle("#Lumi section", 1);
382  NumberEventsOfVsLS->setAxisTitle("Number of events", 2);
383 
384  edm::ParameterSet ParametersGoodPVtx = conf->getParameter<edm::ParameterSet>("GoodPVtx");
385 
386  double GoodPVtxMin = ParametersGoodPVtx.getParameter<double>("GoodPVtxMin");
387  double GoodPVtxMax = ParametersGoodPVtx.getParameter<double>("GoodPVtxMax");
388 
389  histname = "NumberOfGoodPVtxVsLS_" + CategoryName;
390  NumberOfGoodPVtxVsLS =
391  ibooker.bookProfile(histname, histname, LSBin, LSMin, LSMax, GoodPVtxMin, 3. * GoodPVtxMax, "");
392  NumberOfGoodPVtxVsLS->getTH1()->SetCanExtend(TH1::kAllAxes);
393  NumberOfGoodPVtxVsLS->setAxisTitle("#Lumi section", 1);
394  NumberOfGoodPVtxVsLS->setAxisTitle("Mean number of good PV", 2);
395 
396  histname = "NumberOfGoodPVtxWO0VsLS_" + CategoryName;
397  NumberOfGoodPVtxWO0VsLS =
398  ibooker.bookProfile(histname, histname, LSBin, LSMin, LSMax, GoodPVtxMin, 3. * GoodPVtxMax, "");
399  NumberOfGoodPVtxWO0VsLS->setAxisTitle("#Lumi section", 1);
400  NumberOfGoodPVtxWO0VsLS->setAxisTitle("Mean number of good PV", 2);
401 
402  if (doFractionPlot_) {
403  histname = "GoodTracksFractionVsLS_" + CategoryName;
404  GoodTracksFractionVsLS = ibooker.bookProfile(histname, histname, LSBin, LSMin, LSMax, 0, 1.1, "");
405  GoodTracksFractionVsLS->getTH1()->SetCanExtend(TH1::kAllAxes);
406  GoodTracksFractionVsLS->setAxisTitle("#Lumi section", 1);
407  GoodTracksFractionVsLS->setAxisTitle("Fraction of Good Tracks", 2);
408  }
409 
410  if (doPlotsVsBX_ || doAllPlots) {
411  ibooker.setCurrentFolder(MEFolderName + "/BXanalysis");
412  int BXBin = 3564;
413  double BXMin = 0.5;
414  double BXMax = 3564.5;
415 
416  histname = "NumberEventsVsBX_" + CategoryName;
417  NumberEventsOfVsBX = ibooker.book1D(histname, histname, BXBin, BXMin, BXMax);
418  NumberEventsOfVsBX->setAxisTitle("BX", 1);
419  NumberEventsOfVsBX->setAxisTitle("Number of events", 2);
420 
421  histname = "NumberOfTracksVsBX_" + CategoryName;
422  NumberOfTracksVsBX = ibooker.bookProfile(histname, histname, BXBin, BXMin, BXMax, TKNoMin, TKNoMax * 3., "");
423  NumberOfTracksVsBX->setAxisTitle("BX", 1);
424  NumberOfTracksVsBX->setAxisTitle("Number of Tracks", 2);
425 
426  histname = "NumberOfRecHitsPerTrackVsBX_" + CategoryName;
427  NumberOfRecHitsPerTrackVsBX =
428  ibooker.bookProfile(histname, histname, BXBin, BXMin, BXMax, RecHitMin, RecHitMax * 5, "");
429  NumberOfRecHitsPerTrackVsBX->setAxisTitle("BX", 1);
430  NumberOfRecHitsPerTrackVsBX->setAxisTitle("Mean number of Valid RecHits per track", 2);
431 
432  histname = "NumberOfGoodPVtxVsBX_" + CategoryName;
433  NumberOfGoodPVtxVsBX =
434  ibooker.bookProfile(histname, histname, BXBin, BXMin, BXMax, GoodPVtxMin, 3. * GoodPVtxMax, "");
435  NumberOfGoodPVtxVsBX->setAxisTitle("BX", 1);
436  NumberOfGoodPVtxVsBX->setAxisTitle("Mean number of good PV", 2);
437 
438  histname = "NumberOfGoodPVtxWO0VsBX_" + CategoryName;
439  NumberOfGoodPVtxWO0VsBX =
440  ibooker.bookProfile(histname, histname, BXBin, BXMin, BXMax, GoodPVtxMin, 3. * GoodPVtxMax, "");
441  NumberOfGoodPVtxWO0VsBX->setAxisTitle("BX", 1);
442  NumberOfGoodPVtxWO0VsBX->setAxisTitle("Mean number of good PV", 2);
443 
444  if (doFractionPlot_) {
445  histname = "GoodTracksFractionVsBX_" + CategoryName;
446  GoodTracksFractionVsBX = ibooker.bookProfile(histname, histname, BXBin, BXMin, BXMax, 0, 1.1, "");
447  GoodTracksFractionVsBX->setAxisTitle("BX", 1);
448  GoodTracksFractionVsBX->setAxisTitle("Fraction of Good Tracks", 2);
449  }
450  }
451  }
452 
453  // book PU monitoring plots :
454  //---------------------------
455 
456  if (doPUmonitoring_) {
457  for (size_t i = 0; i < theVertexMonitor.size(); i++)
458  theVertexMonitor[i]->initHisto(ibooker);
459  }
460 
461  if (doPlotsVsGoodPVtx_) {
462  ibooker.setCurrentFolder(MEFolderName + "/PUmonitoring");
463  // get binning from the configuration
464  int PVBin = conf->getParameter<int>("PVBin");
465  float PVMin = conf->getParameter<double>("PVMin");
466  float PVMax = conf->getParameter<double>("PVMax");
467 
468  histname = "NumberOfTracksVsGoodPVtx";
469  NumberOfTracksVsGoodPVtx = ibooker.bookProfile(histname, histname, PVBin, PVMin, PVMax, TKNoMin, TKNoMax * 5., "");
470  NumberOfTracksVsGoodPVtx->setAxisTitle("Number of PV", 1);
471  NumberOfTracksVsGoodPVtx->setAxisTitle("Mean number of Tracks per Event", 2);
472 
473  histname = "NumberOfTracksVsPUPVtx";
474  NumberOfTracksVsPUPVtx = ibooker.bookProfile(histname, histname, PVBin, PVMin, PVMax, 0., TKNoMax * 5., "");
475  NumberOfTracksVsPUPVtx->setAxisTitle("Number of PU", 1);
476  NumberOfTracksVsPUPVtx->setAxisTitle("Mean number of Tracks per PUvtx", 2);
477 
478  histname = "NumberEventsVsGoodPVtx";
479  NumberEventsOfVsGoodPVtx = ibooker.book1D(histname, histname, PVBin, PVMin, PVMax);
480  NumberEventsOfVsGoodPVtx->setAxisTitle("Number of good PV (PU)", 1);
481  NumberEventsOfVsGoodPVtx->setAxisTitle("Number of events", 2);
482 
483  if (doFractionPlot_) {
484  histname = "GoodTracksFractionVsGoodPVtx";
485  GoodTracksFractionVsGoodPVtx = ibooker.bookProfile(histname, histname, PVBin, PVMin, PVMax, 0., 1.1, "");
486  GoodTracksFractionVsGoodPVtx->setAxisTitle("Number of good PV (PU)", 1);
487  GoodTracksFractionVsGoodPVtx->setAxisTitle("Mean fraction of good tracks", 2);
488  }
489 
490  histname = "NumberOfRecHitsPerTrackVsGoodPVtx";
491  NumberOfRecHitsPerTrackVsGoodPVtx = ibooker.bookProfile(histname, histname, PVBin, PVMin, PVMax, 0., 200., "");
492  NumberOfRecHitsPerTrackVsGoodPVtx->setAxisTitle("Number of good PV (PU)", 1);
493  NumberOfRecHitsPerTrackVsGoodPVtx->setAxisTitle("Mean number of valid rechits per Tracks", 2);
494 
495  histname = "NumberOfPVtxVsGoodPVtx";
496  NumberOfPVtxVsGoodPVtx = ibooker.bookProfile(histname, histname, PVBin, PVMin, PVMax, 0., 3. * PVMax, "");
497  NumberOfPVtxVsGoodPVtx->setAxisTitle("Number of good PV (PU)", 1);
498  NumberOfPVtxVsGoodPVtx->setAxisTitle("Mean number of vertices", 2);
499 
500  double NClusPxMin = conf->getParameter<double>("NClusPxMin");
501  double NClusPxMax = conf->getParameter<double>("NClusPxMax");
502  histname = "NumberOfPixelClustersVsGoodPVtx";
503  NumberOfPixelClustersVsGoodPVtx =
504  ibooker.bookProfile(histname, histname, PVBin, PVMin, PVMax, NClusPxMin, 3. * NClusPxMax, "");
505  NumberOfPixelClustersVsGoodPVtx->setAxisTitle("Number of good PV (PU)", 1);
506  NumberOfPixelClustersVsGoodPVtx->setAxisTitle("Mean number of pixel clusters", 2);
507 
508  double NClusStrMin = conf->getParameter<double>("NClusStrMin");
509  double NClusStrMax = conf->getParameter<double>("NClusStrMax");
510  histname = "NumberOfStripClustersVsGoodPVtx";
511  NumberOfStripClustersVsGoodPVtx =
512  ibooker.bookProfile(histname, histname, PVBin, PVMin, PVMax, NClusStrMin, 3. * NClusStrMax, "");
513  NumberOfStripClustersVsGoodPVtx->setAxisTitle("Number of good PV (PU)", 1);
514  NumberOfStripClustersVsGoodPVtx->setAxisTitle("Mean number of strip clusters", 2);
515  }
516 
517  if (doPlotsVsLUMI_ || doAllPlots) {
518  ibooker.setCurrentFolder(MEFolderName + "/LUMIanalysis");
519  int LUMIBin = conf->getParameter<int>("LUMIBin");
520  float LUMIMin = conf->getParameter<double>("LUMIMin");
521  float LUMIMax = conf->getParameter<double>("LUMIMax");
522 
523  histname = "NumberEventsVsLUMI";
524  NumberEventsOfVsLUMI = ibooker.book1D(histname, histname, LUMIBin, LUMIMin, LUMIMax);
525  NumberEventsOfVsLUMI->setAxisTitle("scal lumi [10e30 Hz cm^{-2}]", 1);
526  NumberEventsOfVsLUMI->setAxisTitle("Number of events", 2);
527 
528  histname = "NumberOfTracksVsLUMI";
529  NumberOfTracksVsLUMI = ibooker.bookProfile(histname, histname, LUMIBin, LUMIMin, LUMIMax, TKNoMin, TKNoMax * 3, "");
530  NumberOfTracksVsLUMI->setAxisTitle("scal lumi [10e30 Hz cm^{-2}]", 1);
531  NumberOfTracksVsLUMI->setAxisTitle("Mean number of vertices", 2);
532 
533  if (doFractionPlot_) {
534  histname = "GoodTracksFractionVsLUMI";
535  GoodTracksFractionVsLUMI = ibooker.bookProfile(histname, histname, LUMIBin, LUMIMin, LUMIMax, 0., 1.1, "");
536  GoodTracksFractionVsLUMI->setAxisTitle("scal lumi [10e30 Hz cm^{-2}]", 1);
537  GoodTracksFractionVsLUMI->setAxisTitle("Mean number of vertices", 2);
538  }
539 
540  histname = "NumberOfRecHitsPerTrackVsLUMI";
541  NumberOfRecHitsPerTrackVsLUMI =
542  ibooker.bookProfile(histname, histname, LUMIBin, LUMIMin, LUMIMax, RecHitMin, RecHitMax * 5, "");
543  NumberOfRecHitsPerTrackVsLUMI->setAxisTitle("scal lumi [10e30 Hz cm^{-2}]", 1);
544  NumberOfRecHitsPerTrackVsLUMI->setAxisTitle("Mean number of vertices", 2);
545 
546  double PVMin = conf->getParameter<double>("PVMin");
547  double PVMax = conf->getParameter<double>("PVMax");
548 
549  histname = "NumberOfGoodPVtxVsLUMI";
550  NumberOfGoodPVtxVsLUMI = ibooker.bookProfile(histname, histname, LUMIBin, LUMIMin, LUMIMax, PVMin, 3. * PVMax, "");
551  NumberOfGoodPVtxVsLUMI->setAxisTitle("scal lumi [10e30 Hz cm^{-2}]", 1);
552  NumberOfGoodPVtxVsLUMI->setAxisTitle("Mean number of vertices", 2);
553 
554  histname = "NumberOfGoodPVtxWO0VsLUMI";
555  NumberOfGoodPVtxWO0VsLUMI =
556  ibooker.bookProfile(histname, histname, LUMIBin, LUMIMin, LUMIMax, PVMin, 3. * PVMax, "");
557  NumberOfGoodPVtxWO0VsLUMI->setAxisTitle("scal lumi [10e30 Hz cm^{-2}]", 1);
558  NumberOfGoodPVtxWO0VsLUMI->setAxisTitle("Mean number of vertices", 2);
559 
560  double NClusPxMin = conf->getParameter<double>("NClusPxMin");
561  double NClusPxMax = conf->getParameter<double>("NClusPxMax");
562  histname = "NumberOfPixelClustersVsGoodPVtx";
563  NumberOfPixelClustersVsLUMI =
564  ibooker.bookProfile(histname, histname, LUMIBin, LUMIMin, LUMIMax, NClusPxMin, 3. * NClusPxMax, "");
565  NumberOfPixelClustersVsLUMI->setAxisTitle("scal lumi [10e30 Hz cm^{-2}]", 1);
566  NumberOfPixelClustersVsLUMI->setAxisTitle("Mean number of pixel clusters", 2);
567 
568  double NClusStrMin = conf->getParameter<double>("NClusStrMin");
569  double NClusStrMax = conf->getParameter<double>("NClusStrMax");
570  histname = "NumberOfStripClustersVsLUMI";
571  NumberOfStripClustersVsLUMI =
572  ibooker.bookProfile(histname, histname, LUMIBin, LUMIMin, LUMIMax, NClusStrMin, 3. * NClusStrMax, "");
573  NumberOfStripClustersVsLUMI->setAxisTitle("scal lumi [10e30 Hz cm^{-2}]", 1);
574  NumberOfStripClustersVsLUMI->setAxisTitle("Mean number of strip clusters", 2);
575  }
576 
577  if (doPlotsVsBXlumi_) {
578  ibooker.setCurrentFolder(MEFolderName + "/PUmonitoring");
579  // get binning from the configuration
580  edm::ParameterSet BXlumiParameters = conf->getParameter<edm::ParameterSet>("BXlumiSetup");
581  int BXlumiBin = BXlumiParameters.getParameter<int>("BXlumiBin");
582  double BXlumiMin = BXlumiParameters.getParameter<double>("BXlumiMin");
583  double BXlumiMax = BXlumiParameters.getParameter<double>("BXlumiMax");
584 
585  histname = "NumberOfTracksVsBXlumi_" + CategoryName;
586  NumberOfTracksVsBXlumi =
587  ibooker.bookProfile(histname, histname, BXlumiBin, BXlumiMin, BXlumiMax, TKNoMin, 3. * TKNoMax, "");
588  NumberOfTracksVsBXlumi->setAxisTitle("lumi BX [10^{30}Hzcm^{-2}]", 1);
589  NumberOfTracksVsBXlumi->setAxisTitle("Mean number of Tracks", 2);
590  }
591 
592  if (doLumiAnalysis) {
593  auto scope = DQMStore::IBooker::UseLumiScope(ibooker);
594  theTrackAnalyzer->initHisto(ibooker, iSetup, *conf);
595  } else {
596  theTrackAnalyzer->initHisto(ibooker, iSetup, *conf);
597  }
598 
599  // book the Seed Property histograms
600  // ---------------------------------------------------------------------------------//
601 
602  ibooker.setCurrentFolder(MEFolderName + "/TrackBuilding");
603 
604  doSeedNumberPlot = conf->getParameter<bool>("doSeedNumberHisto");
605  doSeedLumiAnalysis_ = conf->getParameter<bool>("doSeedLumiAnalysis");
606  doSeedVsClusterPlot = conf->getParameter<bool>("doSeedVsClusterHisto");
607 
608  edm::InputTag seedProducer = conf->getParameter<edm::InputTag>("SeedProducer");
609 
610  if (doAllSeedPlots || doSeedNumberPlot) {
611  ibooker.setCurrentFolder(MEFolderName + "/TrackBuilding");
612  histname = "NumberOfSeeds_" + seedProducer.label() + "_" + CategoryName;
613  NumberOfSeeds = ibooker.book1D(histname, histname, TKNoSeedBin, TKNoSeedMin, TKNoSeedMax);
614  NumberOfSeeds->setAxisTitle("Number of Seeds per Event", 1);
615  NumberOfSeeds->setAxisTitle("Number of Events", 2);
616 
617  if (doSeedLumiAnalysis_) {
618  ibooker.setCurrentFolder(MEFolderName + "/LSanalysis");
619  auto scope = DQMStore::IBooker::UseLumiScope(ibooker);
620  histname = "NumberOfSeeds_lumiFlag_" + seedProducer.label() + "_" + CategoryName;
621  NumberOfSeeds_lumiFlag = ibooker.book1D(histname, histname, TKNoSeedBin, TKNoSeedMin, TKNoSeedMax);
622  NumberOfSeeds_lumiFlag->setAxisTitle("Number of Seeds per Event", 1);
623  NumberOfSeeds_lumiFlag->setAxisTitle("Number of Events", 2);
624  }
625  }
626 
627  if (doAllSeedPlots || doSeedVsClusterPlot) {
628  ibooker.setCurrentFolder(MEFolderName + "/TrackBuilding");
629 
630  ClusterLabels = conf->getParameter<std::vector<std::string> >("ClusterLabels");
631 
632  std::vector<double> histoMin, histoMax;
633  std::vector<int> histoBin; //these vectors are for max min and nbins in histograms
634 
635  int NClusPxBin = conf->getParameter<int>("NClusPxBin");
636  double NClusPxMin = conf->getParameter<double>("NClusPxMin");
637  double NClusPxMax = conf->getParameter<double>("NClusPxMax");
638 
639  int NClusStrBin = conf->getParameter<int>("NClusStrBin");
640  double NClusStrMin = conf->getParameter<double>("NClusStrMin");
641  double NClusStrMax = conf->getParameter<double>("NClusStrMax");
642 
643  setMaxMinBin(
644  histoMin, histoMax, histoBin, NClusStrMin, NClusStrMax, NClusStrBin, NClusPxMin, NClusPxMax, NClusPxBin);
645 
646  for (uint i = 0; i < ClusterLabels.size(); i++) {
647  histname = "SeedsVsClusters_" + seedProducer.label() + "_Vs_" + ClusterLabels[i] + "_" + CategoryName;
648  SeedsVsClusters.push_back(dynamic_cast<MonitorElement*>(ibooker.book2D(
649  histname, histname, histoBin[i], histoMin[i], histoMax[i], TKNoSeedBin, TKNoSeedMin, TKNoSeedMax)));
650  SeedsVsClusters[i]->setAxisTitle("Number of Clusters", 1);
651  SeedsVsClusters[i]->setAxisTitle("Number of Seeds", 2);
652  SeedsVsClusters[i]->getTH2F()->SetCanExtend(TH1::kAllAxes);
653  }
654  }
655 
656  if (doRegionPlots) {
657  ibooker.setCurrentFolder(MEFolderName + "/TrackBuilding");
658 
659  int regionBin = conf->getParameter<int>("RegionSizeBin");
660  double regionMin = conf->getParameter<double>("RegionSizeMin");
661  double regionMax = conf->getParameter<double>("RegionSizeMax");
662 
663  histname = "TrackingRegionsNumberOf_" + seedProducer.label() + "_" + CategoryName;
664  NumberOfTrackingRegions = ibooker.book1D(histname, histname, regionBin, regionMin, regionMax);
665  NumberOfTrackingRegions->setAxisTitle("Number of TrackingRegions per Event", 1);
666  NumberOfTrackingRegions->setAxisTitle("Number of Events", 2);
667  }
668 
669  if (doTkCandPlots) {
670  ibooker.setCurrentFolder(MEFolderName + "/TrackBuilding");
671 
672  edm::InputTag tcProducer = conf->getParameter<edm::InputTag>("TCProducer");
673 
674  histname = "NumberOfTrackCandidates_" + tcProducer.label() + "_" + CategoryName;
675  NumberOfTrackCandidates = ibooker.book1D(histname, histname, TCNoBin, TCNoMin, TCNoMax);
676  NumberOfTrackCandidates->setAxisTitle("Number of Track Candidates per Event", 1);
677  NumberOfTrackCandidates->setAxisTitle("Number of Event", 2);
678 
679  histname = "FractionOfCandOverSeeds_" + tcProducer.label() + "_" + CategoryName;
680  FractionCandidatesOverSeeds = ibooker.book1D(histname, histname, 101, 0., 1.01);
681  FractionCandidatesOverSeeds->setAxisTitle("Number of Track Candidates / Number of Seeds per Event", 1);
682  FractionCandidatesOverSeeds->setAxisTitle("Number of Event", 2);
683  }
684 
685  theTrackBuildingAnalyzer->initHisto(ibooker, *conf);
686 
687  if (doTrackerSpecific_ || doAllPlots) {
688  ClusterLabels = conf->getParameter<std::vector<std::string> >("ClusterLabels");
689 
690  std::vector<double> histoMin, histoMax;
691  std::vector<int> histoBin; //these vectors are for max min and nbins in histograms
692 
693  int NClusStrBin = conf->getParameter<int>("NClusStrBin");
694  double NClusStrMin = conf->getParameter<double>("NClusStrMin");
695  double NClusStrMax = conf->getParameter<double>("NClusStrMax");
696 
697  int NClusPxBin = conf->getParameter<int>("NClusPxBin");
698  double NClusPxMin = conf->getParameter<double>("NClusPxMin");
699  double NClusPxMax = conf->getParameter<double>("NClusPxMax");
700 
701  edm::ParameterSet ParametersNTrk2D = conf->getParameter<edm::ParameterSet>("NTrk2D");
702  int NTrk2DBin = ParametersNTrk2D.getParameter<int>("NTrk2DBin");
703  double NTrk2DMin = ParametersNTrk2D.getParameter<double>("NTrk2DMin");
704  double NTrk2DMax = ParametersNTrk2D.getParameter<double>("NTrk2DMax");
705 
706  setMaxMinBin(
707  histoMin, histoMax, histoBin, NClusStrMin, NClusStrMax, NClusStrBin, NClusPxMin, NClusPxMax, NClusPxBin);
708 
709  ibooker.setCurrentFolder(MEFolderName + "/HitProperties");
710 
711  for (uint i = 0; i < ClusterLabels.size(); i++) {
712  ibooker.setCurrentFolder(MEFolderName + "/HitProperties");
713  histname = "TracksVs" + ClusterLabels[i] + "Cluster_" + CategoryName;
714  NumberOfTrkVsClusters.push_back(dynamic_cast<MonitorElement*>(
715  ibooker.book2D(histname, histname, histoBin[i], histoMin[i], histoMax[i], NTrk2DBin, NTrk2DMin, NTrk2DMax)));
716  std::string title = "Number of " + ClusterLabels[i] + " Clusters";
717  if (ClusterLabels[i] == "Tot")
718  title = "# of Clusters in (Pixel+Strip) Detectors";
719  NumberOfTrkVsClusters[i]->setAxisTitle(title, 1);
720  NumberOfTrkVsClusters[i]->setAxisTitle("Number of Tracks", 2);
721  NumberOfTrkVsClusters[i]->getTH1()->SetCanExtend(TH1::kXaxis);
722  }
723  }
724 
725  // Initialize the GenericTriggerEventFlag
726  if (genTriggerEventFlag_->on())
727  genTriggerEventFlag_->initRun(iRun, iSetup);
728 }

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.

◆ doProfileX() [1/2]

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

◆ doProfileX() [2/2]

void TrackingMonitor::doProfileX ( TH2 *  th2,
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.

1110  {
1111  arrayMin.resize(ClusterLabels.size());
1112  arrayMax.resize(ClusterLabels.size());
1113  arrayBin.resize(ClusterLabels.size());
1114 
1115  for (uint i = 0; i < ClusterLabels.size(); ++i) {
1116  if (ClusterLabels[i] == "Pix") {
1117  arrayMin[i] = pmin;
1118  arrayMax[i] = pmax;
1119  arrayBin[i] = pbin;
1120  } else if (ClusterLabels[i] == "Strip") {
1121  arrayMin[i] = smin;
1122  arrayMax[i] = smax;
1123  arrayBin[i] = sbin;
1124  } else if (ClusterLabels[i] == "Tot") {
1125  arrayMin[i] = smin;
1126  arrayMax[i] = smax + pmax;
1127  arrayBin[i] = sbin;
1128  } else {
1129  edm::LogWarning("TrackingMonitor") << "Cluster Label " << ClusterLabels[i]
1130  << " not defined, using strip parameters ";
1131  arrayMin[i] = smin;
1132  arrayMax[i] = smax;
1133  arrayBin[i] = sbin;
1134  }
1135  }
1136 }

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

Referenced by bookHistograms().

◆ setNclus()

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

Definition at line 1138 of file TrackingMonitor.cc.

1138  {
1139  int ncluster_pix = -1;
1140  int ncluster_strip = -1;
1141 
1142  edm::Handle<edmNew::DetSetVector<SiStripCluster> > strip_clusters = iEvent.getHandle(stripClustersToken_);
1143  edm::Handle<edmNew::DetSetVector<SiPixelCluster> > pixel_clusters = iEvent.getHandle(pixelClustersToken_);
1144 
1145  if (strip_clusters.isValid() && pixel_clusters.isValid()) {
1146  ncluster_pix = (*pixel_clusters).dataSize();
1147  ncluster_strip = (*strip_clusters).dataSize();
1148  }
1149 
1150  arrayNclus.resize(ClusterLabels.size());
1151  for (uint i = 0; i < ClusterLabels.size(); ++i) {
1152  if (ClusterLabels[i] == "Pix")
1153  arrayNclus[i] = ncluster_pix;
1154  else if (ClusterLabels[i] == "Strip")
1155  arrayNclus[i] = ncluster_strip;
1156  else if (ClusterLabels[i] == "Tot")
1157  arrayNclus[i] = ncluster_pix + ncluster_strip;
1158  else {
1159  edm::LogWarning("TrackingMonitor") << "Cluster Label " << ClusterLabels[i]
1160  << " not defined using stri parametrs ";
1161  arrayNclus[i] = ncluster_strip;
1162  }
1163  }
1164 }

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

Referenced by analyze().

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

TrackingMonitor::builderName
std::string builderName
Definition: TrackingMonitor.h:199
edm::pset::Registry::instance
static Registry * instance()
Definition: Registry.cc:12
TrackingMonitor::NumberOfTrkVsClusters
std::vector< MonitorElement * > NumberOfTrkVsClusters
Definition: TrackingMonitor.h:153
TrackingMonitor::doAllPlots
bool doAllPlots
Definition: TrackingMonitor.h:205
runGCPTkAlMap.title
string title
Definition: runGCPTkAlMap.py:94
mps_fire.i
i
Definition: mps_fire.py:428
TrackingMonitor::FractionOfGoodTracks
MonitorElement * FractionOfGoodTracks
Definition: TrackingMonitor.h:137
TrackingMonitor::doAllSeedPlots
bool doAllSeedPlots
Definition: TrackingMonitor.h:204
edm::ESInputTag
Definition: ESInputTag.h:87
TrackingMonitor::regionToken_
edm::EDGetTokenT< edm::OwnVector< TrackingRegion > > regionToken_
Definition: TrackingMonitor.h:102
MonitorTrackSTAMuons_cfi.RecHitMax
RecHitMax
Definition: MonitorTrackSTAMuons_cfi.py:110
TrackingMonitor::GoodTracksFractionVsGoodPVtx
MonitorElement * GoodTracksFractionVsGoodPVtx
Definition: TrackingMonitor.h:180
HLT_FULL_cff.track
track
Definition: HLT_FULL_cff.py:11724
MonitorTrackSTAMuons_cfi.MeanHitBin
MeanHitBin
Definition: MonitorTrackSTAMuons_cfi.py:114
edm::Handle::product
T const * product() const
Definition: Handle.h:70
TrackingMonitor::doPlotsVsBX_
bool doPlotsVsBX_
Definition: TrackingMonitor.h:222
MonitorTrackSTAMuons_cfi.NClusStrMin
NClusStrMin
Definition: MonitorTrackSTAMuons_cfi.py:331
TrackingMonitor::NumberOfRecHitsPerTrackVsBX
MonitorElement * NumberOfRecHitsPerTrackVsBX
Definition: TrackingMonitor.h:170
TrackingMonitor::stripClustersToken_
edm::EDGetTokenT< edmNew::DetSetVector< SiStripCluster > > stripClustersToken_
Definition: TrackingMonitor.h:111
TrackingMonitor::NumberofTracks_Hardvtx_PUvtx
MonitorElement * NumberofTracks_Hardvtx_PUvtx
Definition: TrackingMonitor.h:132
L1TCSCTF_cfi.trackProducer
trackProducer
Run2: False; Run1: True.
Definition: L1TCSCTF_cfi.py:12
reco::Vertex::z
double z() const
z coordinate
Definition: Vertex.h:133
tadqm::TrackAnalyzer
Definition: TrackAnalyzer.h:40
MonitorTrackSTAMuons_cfi.MeanHitMax
MeanHitMax
Definition: MonitorTrackSTAMuons_cfi.py:115
TrackingMonitor::NumberEventsOfVsBX
MonitorElement * NumberEventsOfVsBX
Definition: TrackingMonitor.h:167
V0Monitor_cfi.lumiScalers
lumiScalers
Definition: V0Monitor_cfi.py:9
TrackingMonitor::histname
std::string histname
Definition: TrackingMonitor.h:85
tadqm::TrackAnalyzer::initHisto
void initHisto(DQMStore::IBooker &ibooker, const edm::EventSetup &, const edm::ParameterSet &)
Definition: TrackAnalyzer.cc:194
TrackingMonitor::confID_
edm::ParameterSetID confID_
Definition: TrackingMonitor.h:89
MonitorTrackSTAMuons_cfi.NClusPxMin
NClusPxMin
Definition: MonitorTrackSTAMuons_cfi.py:326
l1GtPatternGenerator_cfi.bx
bx
Definition: l1GtPatternGenerator_cfi.py:18
TrackingMonitor::NumberEventsOfVsLS
MonitorElement * NumberEventsOfVsLS
Definition: TrackingMonitor.h:159
TrackingMonitor::doFractionPlot_
bool doFractionPlot_
Definition: TrackingMonitor.h:223
dqm::implementation::NavigatorBase::setCurrentFolder
virtual void setCurrentFolder(std::string const &fullpath)
Definition: DQMStore.cc:32
TrackingMonitor::doRegionCandidatePlots
bool doRegionCandidatePlots
Definition: TrackingMonitor.h:212
TrackingMonitor::pvSrcToken_
edm::EDGetTokenT< reco::VertexCollection > pvSrcToken_
Definition: TrackingMonitor.h:95
TrackingMonitor::NumberOfSeeds_lumiFlag
MonitorElement * NumberOfSeeds_lumiFlag
Definition: TrackingMonitor.h:144
TrackerCollisionTrackingMonitor_cfi.selPrimaryVertexInputTags
selPrimaryVertexInputTags
Definition: TrackerCollisionTrackingMonitor_cfi.py:18
TrackingMonitor::NumberOfTrackCandidates
MonitorElement * NumberOfTrackCandidates
Definition: TrackingMonitor.h:149
cms::cuda::assert
assert(be >=bs)
edm::EDGetTokenT::isUninitialized
constexpr bool isUninitialized() const noexcept
Definition: EDGetToken.h:99
TrackingMonitor::doPlotsVsBXlumi_
bool doPlotsVsBXlumi_
Definition: TrackingMonitor.h:219
TrackingMonitor::NumberOfGoodPVtxWO0VsBX
MonitorElement * NumberOfGoodPVtxWO0VsBX
Definition: TrackingMonitor.h:172
TrackingMonitor::NumberOfGoodPVtxVsLS
MonitorElement * NumberOfGoodPVtxVsLS
Definition: TrackingMonitor.h:163
TrackingMonitor::NumberofTracks_Hardvtx
MonitorElement * NumberofTracks_Hardvtx
Definition: TrackingMonitor.h:131
reco::Vertex::position
const Point & position() const
position
Definition: Vertex.h:127
TrackingMonitor::NumberOfMeanRecHitsPerTrack
MonitorElement * NumberOfMeanRecHitsPerTrack
Definition: TrackingMonitor.h:133
MonitorTrackSTAMuons_cfi.MeanLayMax
MeanLayMax
Definition: MonitorTrackSTAMuons_cfi.py:160
TrackingMonitor::seedToken_
edm::EDGetTokenT< edm::View< TrajectorySeed > > seedToken_
Definition: TrackingMonitor.h:100
edm::ParameterSet::id
ParameterSetID id() const
Definition: ParameterSet.cc:189
BXlumiParameters_cfi.BXlumiMin
BXlumiMin
Definition: BXlumiParameters_cfi.py:18
TrackingMonitor::NumberOfGoodPVtxVsLUMI
MonitorElement * NumberOfGoodPVtxVsLUMI
Definition: TrackingMonitor.h:191
edm::Handle
Definition: AssociativeIterator.h:50
HLTSiStripMonitoring_cff.AlgoName
AlgoName
Definition: HLTSiStripMonitoring_cff.py:232
TrackingMonitor::theTrackAnalyzer
tadqm::TrackAnalyzer * theTrackAnalyzer
Definition: TrackingMonitor.h:123
parallelization.uint
uint
Definition: parallelization.py:124
TrackingMonitor::NumberOfTracksVsGoodPVtx
MonitorElement * NumberOfTracksVsGoodPVtx
Definition: TrackingMonitor.h:177
edm::LogWarning
Log< level::Warning, false > LogWarning
Definition: MessageLogger.h:122
TrackingMonitor::metaDataToken_
edm::EDGetTokenT< OnlineLuminosityRecord > metaDataToken_
Definition: TrackingMonitor.h:107
TrackingMonitor::doPlotsVsGoodPVtx_
bool doPlotsVsGoodPVtx_
Definition: TrackingMonitor.h:220
tadqm::TrackAnalyzer::setLumi
void setLumi(const edm::Event &, const edm::EventSetup &iSetup)
Definition: TrackAnalyzer.cc:1118
TrackingMonitor::doGeneralPropertiesPlots_
bool doGeneralPropertiesPlots_
Definition: TrackingMonitor.h:207
TrackingMonitor::NumberOfTracksVsBX
MonitorElement * NumberOfTracksVsBX
Definition: TrackingMonitor.h:168
TrackingMonitor::NumberOfTracksVsLS
MonitorElement * NumberOfTracksVsLS
Definition: TrackingMonitor.h:160
MonitorTrackSTAMuons_cfi.NClusStrBin
NClusStrBin
Definition: MonitorTrackSTAMuons_cfi.py:329
contentValuesCheck.ss
ss
Definition: contentValuesCheck.py:33
edm::InputTag::label
std::string const & label() const
Definition: InputTag.h:36
MonitorTrackSTAMuons_cfi.MeanHitMin
MeanHitMin
Definition: MonitorTrackSTAMuons_cfi.py:116
cms::cuda::bs
bs
Definition: HistoContainer.h:76
TrackingMonitor::NumberOfStripClustersVsGoodPVtx
MonitorElement * NumberOfStripClustersVsGoodPVtx
Definition: TrackingMonitor.h:184
TrackingMonitor::NumberOfGoodPVtxVsBX
MonitorElement * NumberOfGoodPVtxVsBX
Definition: TrackingMonitor.h:171
GetLumi
Definition: GetLumi.h:21
pixelTrack::Quality
Quality
Definition: TrackSoAHeterogeneousT.h:13
reco::Vertex::isFake
bool isFake() const
Definition: Vertex.h:76
DivergingColor.frac
float frac
Definition: DivergingColor.py:175
TrackingMonitor::NumberOfTracks_lumiFlag
MonitorElement * NumberOfTracks_lumiFlag
Definition: TrackingMonitor.h:197
MonitorTrackSTAMuons_cfi.MeanLayBin
MeanLayBin
Definition: MonitorTrackSTAMuons_cfi.py:159
ElectronSeedTrackRefFix_cfi.seedCollection
seedCollection
Definition: ElectronSeedTrackRefFix_cfi.py:9
TrackingMonitor::regionLayerSetsToken_
edm::EDGetTokenT< TrackingRegionsSeedingLayerSets > regionLayerSetsToken_
Definition: TrackingMonitor.h:103
TrackingMonitor::NumberOfPixelClustersVsLUMI
MonitorElement * NumberOfPixelClustersVsLUMI
Definition: TrackingMonitor.h:193
tadqm::TrackAnalyzer::setBX
void setBX(const edm::Event &)
Definition: TrackAnalyzer.cc:1116
TrackingMonitor::NumberOfTracksVsLUMI
MonitorElement * NumberOfTracksVsLUMI
Definition: TrackingMonitor.h:188
TrackingMonitor::bsSrcToken_
edm::EDGetTokenT< reco::BeamSpot > bsSrcToken_
Definition: TrackingMonitor.h:94
MonitorTrackInnerTrackMuons_cff.PVMin
PVMin
Definition: MonitorTrackInnerTrackMuons_cff.py:49
ValL1Emulator_cff.regionTag
regionTag
Definition: ValL1Emulator_cff.py:63
dqm::impl::MonitorElement::Fill
void Fill(long long x)
Definition: MonitorElement.h:290
MonitorTrackSTAMuons_cfi.RecHitMin
RecHitMin
Definition: MonitorTrackSTAMuons_cfi.py:111
reco::BeamSpot
Definition: BeamSpot.h:21
TrackingMonitor::doLumiAnalysis
bool doLumiAnalysis
Definition: TrackingMonitor.h:202
TrackingMonitor::FractionCandidatesOverSeeds
MonitorElement * FractionCandidatesOverSeeds
Definition: TrackingMonitor.h:150
dqm::implementation::IBooker::bookProfile
MonitorElement * bookProfile(TString const &name, TString const &title, int nchX, double lowX, double highX, int, double lowY, double highY, char const *option="s", FUNC onbooking=NOOP())
Definition: DQMStore.h:322
TrackingMonitor_cfi.LUMIMax
LUMIMax
Definition: TrackingMonitor_cfi.py:415
TrackingMonitor::transientTrackingRecHitBuilderToken_
edm::ESGetToken< TransientTrackingRecHitBuilder, TransientRecHitRecord > transientTrackingRecHitBuilderToken_
Definition: TrackingMonitor.h:118
reco::Vertex::tracksSize
size_t tracksSize() const
number of tracks
Definition: Vertex.h:112
TrackBuildingAnalyzer
Definition: TrackBuildingAnalyzer.h:36
TrackingMonitor::SeedsVsClusters
std::vector< MonitorElement * > SeedsVsClusters
Definition: TrackingMonitor.h:145
TrackingMonitor::allTrackToken_
edm::EDGetTokenT< edm::View< reco::Track > > allTrackToken_
Definition: TrackingMonitor.h:97
dqm::impl::MonitorElement::getTH1
virtual TH1 * getTH1()
Definition: MonitorElement.cc:972
TrackingMonitor::pvNDOF_
int pvNDOF_
Definition: TrackingMonitor.h:229
TrackingMonitor::NumberOfMeanLayersPerTrack
MonitorElement * NumberOfMeanLayersPerTrack
Definition: TrackingMonitor.h:134
edm::vector_transform
auto vector_transform(std::vector< InputType > const &input, Function predicate) -> std::vector< typename std::remove_cv< typename std::remove_reference< decltype(predicate(input.front()))>::type >::type >
Definition: transform.h:11
TrackingMonitor::NumberOfRecHitsPerTrackVsLUMI
MonitorElement * NumberOfRecHitsPerTrackVsLUMI
Definition: TrackingMonitor.h:190
siStripFEDCheck_cfi.LSBin
LSBin
Definition: siStripFEDCheck_cfi.py:32
edm::View
Definition: CaloClusterFwd.h:14
GenericTriggerEventFlag::accept
bool accept(const edm::Event &event, const edm::EventSetup &setup)
To be called from analyze/filter() methods.
Definition: GenericTriggerEventFlag.cc:266
BXlumiParameters_cfi.BXlumiBin
BXlumiBin
Definition: BXlumiParameters_cfi.py:17
MonitorTrackSTAMuons_cfi.NClusPxMax
NClusPxMax
Definition: MonitorTrackSTAMuons_cfi.py:325
COUT
#define COUT(x)
Definition: TrackingMonitor.cc:41
edm::ParameterSet
Definition: ParameterSet.h:47
TrackCandidateCollection
std::vector< TrackCandidate > TrackCandidateCollection
Definition: TrackCandidateCollection.h:7
MonitorTrackInnerTrackMuons_cff.PVBin
PVBin
Definition: MonitorTrackInnerTrackMuons_cff.py:48
duplicaterechits_cfi.trackCollection
trackCollection
Definition: duplicaterechits_cfi.py:4
TrackingMonitor::NumberEventsOfVsGoodPVtx
MonitorElement * NumberEventsOfVsGoodPVtx
Definition: TrackingMonitor.h:179
TrackingMonitor::mvaTrackToken_
edm::EDGetTokenT< edm::View< reco::Track > > mvaTrackToken_
Definition: TrackingMonitor.h:115
GenericTriggerEventFlag
Provides a code based selection for trigger and DCS information in order to have no failing filters i...
Definition: GenericTriggerEventFlag.h:42
makeGlobalPositionRcd_cfg.tag
tag
Definition: makeGlobalPositionRcd_cfg.py:6
TrackingMonitor::pvSrc_
edm::InputTag pvSrc_
Definition: TrackingMonitor.h:93
TrackingMonitor::seedStopInfoToken_
edm::EDGetTokenT< std::vector< SeedStopInfo > > seedStopInfoToken_
Definition: TrackingMonitor.h:101
TrackingMonitor::NumberOfRecHitsPerTrackVsLS
MonitorElement * NumberOfRecHitsPerTrackVsLS
Definition: TrackingMonitor.h:162
Folder
Definition: DQMStoreStats.h:134
TrackingMonitor::theLumiDetails_
GetLumi * theLumiDetails_
Definition: TrackingMonitor.h:126
TrackingMonitor::NumberOfSeeds
MonitorElement * NumberOfSeeds
Definition: TrackingMonitor.h:143
cand
Definition: decayParser.h:32
MetAnalyzer.pv
def pv(vc)
Definition: MetAnalyzer.py:7
iEvent
int iEvent
Definition: GenABIO.cc:224
TrackingMonitor::NumberOfPixelClustersVsGoodPVtx
MonitorElement * NumberOfPixelClustersVsGoodPVtx
Definition: TrackingMonitor.h:183
MonitorTrackSTAMuons_cfi.NClusPxBin
NClusPxBin
Definition: MonitorTrackSTAMuons_cfi.py:324
TrackingMonitor::theVertexMonitor
std::vector< VertexMonitor * > theVertexMonitor
Definition: TrackingMonitor.h:125
dqm::impl::MonitorElement::setBinLabel
virtual void setBinLabel(int bin, const std::string &label, int axis=1)
set bin label for x, y or z axis (axis=1, 2, 3 respectively)
Definition: MonitorElement.cc:762
TrackerCollisionTrackingMonitor_cfi.GoodPVtxMin
GoodPVtxMin
Definition: TrackerCollisionTrackingMonitor_cfi.py:83
TrackingMonitor::doRegionPlots
bool doRegionPlots
Definition: TrackingMonitor.h:211
MonitorTrackSTAMuons_cfi.NClusStrMax
NClusStrMax
Definition: MonitorTrackSTAMuons_cfi.py:330
TrackingMonitor::pixelClustersToken_
edm::EDGetTokenT< edmNew::DetSetVector< SiPixelCluster > > pixelClustersToken_
Definition: TrackingMonitor.h:112
dqm::implementation::IBooker::UseLumiScope
UseScope< MonitorElementData::Scope::LUMI > UseLumiScope
Definition: DQMStore.h:463
MonitorTrackSTAMuons_cfi.NTrk2DBin
NTrk2DBin
Definition: MonitorTrackSTAMuons_cfi.py:345
MonitorTrackSTAMuons_cfi.NTrk2DMax
NTrk2DMax
Definition: MonitorTrackSTAMuons_cfi.py:346
TrackingMonitor::NumberOfTrackingRegions
MonitorElement * NumberOfTrackingRegions
Definition: TrackingMonitor.h:140
TrackingMonitor::trackCandidateToken_
edm::EDGetTokenT< TrackCandidateCollection > trackCandidateToken_
Definition: TrackingMonitor.h:99
TrackingMonitor::doHitPropertiesPlots_
bool doHitPropertiesPlots_
Definition: TrackingMonitor.h:208
TrackingMonitor::GoodTracksFractionVsLS
MonitorElement * GoodTracksFractionVsLS
Definition: TrackingMonitor.h:161
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
GetLumi::getValue
double getValue(const edm::Event &)
Definition: GetLumi.cc:48
TrackingMonitor::doSeedVsClusterPlot
bool doSeedVsClusterPlot
Definition: TrackingMonitor.h:215
TrackingMonitor::mvaQualityTokens_
std::vector< std::tuple< edm::EDGetTokenT< MVACollection >, edm::EDGetTokenT< QualityMaskCollection > > > mvaQualityTokens_
Definition: TrackingMonitor.h:114
edm::EventSetup::getData
bool getData(T &iHolder) const
Definition: EventSetup.h:127
TrackingMonitor::regionCandidateToken_
edm::EDGetTokenT< reco::CandidateView > regionCandidateToken_
Definition: TrackingMonitor.h:104
TrackingMonitor::doTkCandPlots
bool doTkCandPlots
Definition: TrackingMonitor.h:209
TrackingMonitor::numSelection_
StringCutObjectSelector< reco::Track, true > numSelection_
Definition: TrackingMonitor.h:227
TrackingMonitor::doPlotsVsLUMI_
bool doPlotsVsLUMI_
Definition: TrackingMonitor.h:221
TrackingMonitor::NumberOfTracks
MonitorElement * NumberOfTracks
Definition: TrackingMonitor.h:129
TrackingMonitor::analyze
void analyze(const edm::Event &, const edm::EventSetup &) override
Definition: TrackingMonitor.cc:741
TrackBuildingAnalyzer::analyze
void analyze(const edm::Event &iEvent, const edm::EventSetup &iSetup, const TrajectorySeed &seed, const SeedStopInfo &stopInfo, const reco::BeamSpot &bs, const MagneticField &theMF, const TransientTrackingRecHitBuilder &theTTRHBuilder)
Definition: TrackBuildingAnalyzer.cc:493
TrackingMonitor::forceSCAL_
const bool forceSCAL_
Definition: TrackingMonitor.h:230
GenericTriggerEventFlag::on
bool on()
Definition: GenericTriggerEventFlag.h:135
TrackingMonitor::pixelClusterInputTag_
edm::InputTag pixelClusterInputTag_
Definition: TrackingMonitor.h:110
TrackingMonitor::ClusterLabels
std::vector< std::string > ClusterLabels
Definition: TrackingMonitor.h:146
TrackingMonitor::GoodTracksFractionVsBX
MonitorElement * GoodTracksFractionVsBX
Definition: TrackingMonitor.h:169
TrackingMonitor::NumberOfTracksVsPUPVtx
MonitorElement * NumberOfTracksVsPUPVtx
Definition: TrackingMonitor.h:178
TrackingMonitor::trackToken_
edm::EDGetTokenT< edm::View< reco::Track > > trackToken_
Definition: TrackingMonitor.h:98
TrackingMonitor::doProfilesVsLS_
bool doProfilesVsLS_
Definition: TrackingMonitor.h:203
TrackingMonitor::setNclus
virtual void setNclus(const edm::Event &, std::vector< int > &)
Definition: TrackingMonitor.cc:1138
TrackingMonitor::GoodTracksFractionVsLUMI
MonitorElement * GoodTracksFractionVsLUMI
Definition: TrackingMonitor.h:189
TrackingMonitor::lumiscalersToken_
edm::EDGetTokenT< LumiScalersCollection > lumiscalersToken_
Definition: TrackingMonitor.h:106
TrackingMonitor::doSeedNumberPlot
bool doSeedNumberPlot
Definition: TrackingMonitor.h:213
dqm::implementation::IBooker::book2D
MonitorElement * book2D(TString const &name, TString const &title, int nchX, double lowX, double highX, int nchY, double lowY, double highY, FUNC onbooking=NOOP())
Definition: DQMStore.h:177
TrackingMonitor::NumberOfStripClustersVsLUMI
MonitorElement * NumberOfStripClustersVsLUMI
Definition: TrackingMonitor.h:194
TrackingMonitor::doPUmonitoring_
bool doPUmonitoring_
Definition: TrackingMonitor.h:218
TrackerCollisionTrackingMonitor_cfi.primaryVertexInputTags
primaryVertexInputTags
Definition: TrackerCollisionTrackingMonitor_cfi.py:15
Exception
Definition: hltDiff.cc:245
TrackingMonitor::bsSrc_
edm::InputTag bsSrc_
Definition: TrackingMonitor.h:92
TrackingMonitor::doSeedLumiAnalysis_
bool doSeedLumiAnalysis_
Definition: TrackingMonitor.h:214
OnlineLuminosityRecord::instLumi
float instLumi() const
Return the luminosity for the current nibble.
Definition: OnlineLuminosityRecord.h:33
TrackingMonitor::setMaxMinBin
virtual void setMaxMinBin(std::vector< double > &, std::vector< double > &, std::vector< int > &, double, double, int, double, double, int)
Definition: TrackingMonitor.cc:1102
TrackingMonitor::NumberOfPVtxVsGoodPVtx
MonitorElement * NumberOfPVtxVsGoodPVtx
Definition: TrackingMonitor.h:182
GenericTriggerEventFlag::initRun
void initRun(const edm::Run &run, const edm::EventSetup &setup)
To be called from beginRun() methods.
Definition: GenericTriggerEventFlag.cc:153
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
Definition: ParameterSet.h:303
TrackingMonitor::NumberOfRecHitsPerTrackVsGoodPVtx
MonitorElement * NumberOfRecHitsPerTrackVsGoodPVtx
Definition: TrackingMonitor.h:181
tadqm::TrackAnalyzer::setNumberOfGoodVertices
void setNumberOfGoodVertices(const edm::Event &)
Definition: TrackAnalyzer.cc:1105
TrackingMonitor::magneticFieldToken_
edm::ESGetToken< MagneticField, IdealMagneticFieldRecord > magneticFieldToken_
Definition: TrackingMonitor.h:117
MonitorTrackSTAMuons_cfi.NTrk2DMin
NTrk2DMin
Definition: MonitorTrackSTAMuons_cfi.py:347
edm::View::const_iterator
boost::indirect_iterator< typename seq_t::const_iterator > const_iterator
Definition: View.h:86
TrackingMonitor::NumberOfGoodPVtxWO0VsLS
MonitorElement * NumberOfGoodPVtxWO0VsLS
Definition: TrackingMonitor.h:164
TrackingMonitor::stripClusterInputTag_
edm::InputTag stripClusterInputTag_
Definition: TrackingMonitor.h:109
TrackingMonitor::NumberOfTracksVsBXlumi
MonitorElement * NumberOfTracksVsBXlumi
Definition: TrackingMonitor.h:174
AlignmentPI::regions
regions
Definition: AlignmentPayloadInspectorHelper.h:78
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
TrackingMonitor_cfi.LUMIBin
LUMIBin
Definition: TrackingMonitor_cfi.py:413
tadqm::TrackAnalyzer::analyze
void analyze(const edm::Event &iEvent, const edm::EventSetup &iSetup, const reco::Track &track)
Definition: TrackAnalyzer.cc:1167
TrackingMonitor::theTrackBuildingAnalyzer
TrackBuildingAnalyzer * theTrackBuildingAnalyzer
Definition: TrackingMonitor.h:124
siStripFEDCheck_cfi.LSMin
LSMin
Definition: siStripFEDCheck_cfi.py:33
VertexMonitor
Definition: VertexMonitor.h:31
siStripFEDCheck_cfi.LSMax
LSMax
Definition: siStripFEDCheck_cfi.py:34
c
auto & c
Definition: CAHitNtupletGeneratorKernelsImpl.h:56
TrackingMonitor::NumberEventsOfVsLUMI
MonitorElement * NumberEventsOfVsLUMI
Definition: TrackingMonitor.h:187
TrackingMonitor::AlgoName_
std::string AlgoName_
Definition: TrackingMonitor.h:121
trackingParticleMuon_cfi.pmin
pmin
Definition: trackingParticleMuon_cfi.py:10
edm::HandleBase::isValid
bool isValid() const
Definition: HandleBase.h:70
TrackingMonitor::Quality_
std::string Quality_
Definition: TrackingMonitor.h:120
TrackingMonitor::NumberOfGoodPVtxWO0VsLUMI
MonitorElement * NumberOfGoodPVtxWO0VsLUMI
Definition: TrackingMonitor.h:192
MagneticField
Definition: MagneticField.h:19
lumi
Definition: LumiSectionData.h:20
TransientTrackingRecHitBuilder
Definition: TransientTrackingRecHitBuilder.h:6
TrackingMonitor::NumberOfTracks_PUvtx
MonitorElement * NumberOfTracks_PUvtx
Definition: TrackingMonitor.h:130
MonitorTrackSTAMuons_cfi.MeanLayMin
MeanLayMin
Definition: MonitorTrackSTAMuons_cfi.py:161
TrackingMonitor::doTrackerSpecific_
bool doTrackerSpecific_
Definition: TrackingMonitor.h:201
reco::Vertex::ndof
double ndof() const
Definition: Vertex.h:123
edm::pset::Registry::getMapped
bool getMapped(key_type const &k, value_type &result) const
Definition: Registry.cc:17
dqm::impl::MonitorElement::setAxisTitle
virtual void setAxisTitle(const std::string &title, int axis=1)
set x-, y- or z-axis title (axis=1, 2, 3 respectively)
Definition: MonitorElement.cc:791
edm::InputTag
Definition: InputTag.h:15
edm::ConsumesCollector
Definition: ConsumesCollector.h:45
BXlumiParameters_cfi.BXlumiMax
BXlumiMax
Definition: BXlumiParameters_cfi.py:19
TrackingMonitor::genTriggerEventFlag_
GenericTriggerEventFlag * genTriggerEventFlag_
Definition: TrackingMonitor.h:225
reco::Vertex
Definition: Vertex.h:35
TrackingMonitor::doMVAPlots
bool doMVAPlots
Definition: TrackingMonitor.h:210
MonitorTrackInnerTrackMuons_cff.PVMax
PVMax
Definition: MonitorTrackInnerTrackMuons_cff.py:50
TrackingMonitor_cfi.LUMIMin
LUMIMin
Definition: TrackingMonitor_cfi.py:414
dqm::implementation::IBooker::book1D
MonitorElement * book1D(TString const &name, TString const &title, int const nchX, double const lowX, double const highX, FUNC onbooking=NOOP())
Definition: DQMStore.h:98
TrackingMonitor::denSelection_
StringCutObjectSelector< reco::Track, true > denSelection_
Definition: TrackingMonitor.h:228
TrackerCollisionTrackingMonitor_cfi.GoodPVtxMax
GoodPVtxMax
Definition: TrackerCollisionTrackingMonitor_cfi.py:84
TrackBuildingAnalyzer::initHisto
void initHisto(DQMStore::IBooker &ibooker, const edm::ParameterSet &)
Definition: TrackBuildingAnalyzer.cc:44
TrackingMonitor::runTrackBuildingAnalyzerForSeed
bool runTrackBuildingAnalyzerForSeed
Definition: TrackingMonitor.h:216
TrackingMonitor::MEFolderName
std::string MEFolderName
Definition: TrackingMonitor.h:84
TrackerCollisionTrackingMonitor_cfi.pvLabels
pvLabels
Definition: TrackerCollisionTrackingMonitor_cfi.py:21
Generated for CMSSW Reference Manual by doxygen 1.8.16