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 >
typedef CacheContexts< T... > CacheTypes
 
typedef CacheTypes::GlobalCache GlobalCache
 
typedef AbilityChecker< T... > HasAbility
 
typedef CacheTypes::LuminosityBlockCache LuminosityBlockCache
 
typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache > LuminosityBlockContext
 
typedef CacheTypes::LuminosityBlockSummaryCache LuminosityBlockSummaryCache
 
typedef CacheTypes::RunCache RunCache
 
typedef RunContextT< RunCache, GlobalCache > RunContext
 
typedef CacheTypes::RunSummaryCache RunSummaryCache
 

Public 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
 
bool hasAbilityToProduceInBeginLumis () const final
 
bool hasAbilityToProduceInBeginRuns () const final
 
bool hasAbilityToProduceInEndLumis () const final
 
bool hasAbilityToProduceInEndRuns () const final
 

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

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_, cropTnPTrees::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_2018_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, overlapproblemtsosanalyzer_cfi::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 1118 of file TrackingMonitor.cc.

1126  {
1127  arrayMin.resize(ClusterLabels.size());
1128  arrayMax.resize(ClusterLabels.size());
1129  arrayBin.resize(ClusterLabels.size());
1130 
1131  for (uint i = 0; i < ClusterLabels.size(); ++i) {
1132  if (ClusterLabels[i] == "Pix") {
1133  arrayMin[i] = pmin;
1134  arrayMax[i] = pmax;
1135  arrayBin[i] = pbin;
1136  } else if (ClusterLabels[i] == "Strip") {
1137  arrayMin[i] = smin;
1138  arrayMax[i] = smax;
1139  arrayBin[i] = sbin;
1140  } else if (ClusterLabels[i] == "Tot") {
1141  arrayMin[i] = smin;
1142  arrayMax[i] = smax + pmax;
1143  arrayBin[i] = sbin;
1144  } else {
1145  edm::LogWarning("TrackingMonitor") << "Cluster Label " << ClusterLabels[i]
1146  << " not defined, using strip parameters ";
1147  arrayMin[i] = smin;
1148  arrayMax[i] = smax;
1149  arrayBin[i] = sbin;
1150  }
1151  }
1152 }

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

Referenced by bookHistograms().

◆ setNclus()

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

Definition at line 1154 of file TrackingMonitor.cc.

1154  {
1155  int ncluster_pix = -1;
1156  int ncluster_strip = -1;
1157 
1158  edm::Handle<edmNew::DetSetVector<SiStripCluster> > strip_clusters;
1159  iEvent.getByToken(stripClustersToken_, strip_clusters);
1160  edm::Handle<edmNew::DetSetVector<SiPixelCluster> > pixel_clusters;
1161  iEvent.getByToken(pixelClustersToken_, pixel_clusters);
1162 
1163  if (strip_clusters.isValid() && pixel_clusters.isValid()) {
1164  ncluster_pix = (*pixel_clusters).dataSize();
1165  ncluster_strip = (*strip_clusters).dataSize();
1166  }
1167 
1168  arrayNclus.resize(ClusterLabels.size());
1169  for (uint i = 0; i < ClusterLabels.size(); ++i) {
1170  if (ClusterLabels[i] == "Pix")
1171  arrayNclus[i] = ncluster_pix;
1172  else if (ClusterLabels[i] == "Strip")
1173  arrayNclus[i] = ncluster_strip;
1174  else if (ClusterLabels[i] == "Tot")
1175  arrayNclus[i] = ncluster_pix + ncluster_strip;
1176  else {
1177  edm::LogWarning("TrackingMonitor") << "Cluster Label " << ClusterLabels[i]
1178  << " not defined using stri parametrs ";
1179  arrayNclus[i] = ncluster_strip;
1180  }
1181  }
1182 }

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 122 of file TrackingMonitor.h.

Referenced by bookHistograms(), and TrackingMonitor().

◆ allTrackToken_

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

Definition at line 98 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().

◆ bsSrc_

edm::InputTag TrackingMonitor::bsSrc_
private

Definition at line 93 of file TrackingMonitor.h.

Referenced by TrackingMonitor().

◆ bsSrcToken_

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

Definition at line 95 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().

◆ builderName

std::string TrackingMonitor::builderName
private

Definition at line 200 of file TrackingMonitor.h.

Referenced by TrackingMonitor().

◆ ClusterLabels

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

Definition at line 147 of file TrackingMonitor.h.

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

◆ confID_

edm::ParameterSetID TrackingMonitor::confID_
private

Definition at line 90 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

◆ denSelection_

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

Definition at line 229 of file TrackingMonitor.h.

Referenced by analyze().

◆ doAllPlots

bool TrackingMonitor::doAllPlots
private

Definition at line 206 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

◆ doAllSeedPlots

bool TrackingMonitor::doAllSeedPlots
private

Definition at line 205 of file TrackingMonitor.h.

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

◆ doDCAPlots_

bool TrackingMonitor::doDCAPlots_
private

Definition at line 207 of file TrackingMonitor.h.

◆ doFractionPlot_

bool TrackingMonitor::doFractionPlot_
private

Definition at line 224 of file TrackingMonitor.h.

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

◆ doGeneralPropertiesPlots_

bool TrackingMonitor::doGeneralPropertiesPlots_
private

Definition at line 208 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

◆ doHitPropertiesPlots_

bool TrackingMonitor::doHitPropertiesPlots_
private

Definition at line 209 of file TrackingMonitor.h.

◆ doLumiAnalysis

bool TrackingMonitor::doLumiAnalysis
private

Definition at line 203 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

◆ doMVAPlots

bool TrackingMonitor::doMVAPlots
private

Definition at line 211 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().

◆ doPlotsVsBX_

bool TrackingMonitor::doPlotsVsBX_
private

Definition at line 223 of file TrackingMonitor.h.

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

◆ doPlotsVsBXlumi_

bool TrackingMonitor::doPlotsVsBXlumi_
private

Definition at line 220 of file TrackingMonitor.h.

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

◆ doPlotsVsGoodPVtx_

bool TrackingMonitor::doPlotsVsGoodPVtx_
private

Definition at line 221 of file TrackingMonitor.h.

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

◆ doPlotsVsLUMI_

bool TrackingMonitor::doPlotsVsLUMI_
private

Definition at line 222 of file TrackingMonitor.h.

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

◆ doProfilesVsLS_

bool TrackingMonitor::doProfilesVsLS_
private

Definition at line 204 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

◆ doPUmonitoring_

bool TrackingMonitor::doPUmonitoring_
private

Definition at line 219 of file TrackingMonitor.h.

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

◆ doRegionCandidatePlots

bool TrackingMonitor::doRegionCandidatePlots
private

Definition at line 213 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().

◆ doRegionPlots

bool TrackingMonitor::doRegionPlots
private

Definition at line 212 of file TrackingMonitor.h.

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

◆ doSeedLumiAnalysis_

bool TrackingMonitor::doSeedLumiAnalysis_
private

Definition at line 215 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

◆ doSeedNumberPlot

bool TrackingMonitor::doSeedNumberPlot
private

Definition at line 214 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

◆ doSeedVsClusterPlot

bool TrackingMonitor::doSeedVsClusterPlot
private

Definition at line 216 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

◆ doTkCandPlots

bool TrackingMonitor::doTkCandPlots
private

Definition at line 210 of file TrackingMonitor.h.

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

◆ doTrackerSpecific_

bool TrackingMonitor::doTrackerSpecific_
private

Definition at line 202 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

◆ forceSCAL_

const bool TrackingMonitor::forceSCAL_
private

Definition at line 231 of file TrackingMonitor.h.

Referenced by analyze().

◆ FractionCandidatesOverSeeds

MonitorElement* TrackingMonitor::FractionCandidatesOverSeeds
private

Definition at line 151 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

◆ FractionOfGoodTracks

MonitorElement* TrackingMonitor::FractionOfGoodTracks
private

Definition at line 138 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

◆ genTriggerEventFlag_

GenericTriggerEventFlag* TrackingMonitor::genTriggerEventFlag_
private

Definition at line 226 of file TrackingMonitor.h.

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

◆ GoodTracksFractionVsBX

MonitorElement* TrackingMonitor::GoodTracksFractionVsBX
private

Definition at line 170 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

◆ GoodTracksFractionVsGoodPVtx

MonitorElement* TrackingMonitor::GoodTracksFractionVsGoodPVtx
private

Definition at line 181 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

◆ GoodTracksFractionVsLS

MonitorElement* TrackingMonitor::GoodTracksFractionVsLS
private

Definition at line 162 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

◆ GoodTracksFractionVsLUMI

MonitorElement* TrackingMonitor::GoodTracksFractionVsLUMI
private

Definition at line 190 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

◆ histname

std::string TrackingMonitor::histname
private

Definition at line 86 of file TrackingMonitor.h.

Referenced by bookHistograms().

◆ lumiscalersToken_

edm::EDGetTokenT<LumiScalersCollection> TrackingMonitor::lumiscalersToken_
private

Definition at line 107 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().

◆ magneticFieldToken_

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

Definition at line 118 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().

◆ MEFolderName

std::string TrackingMonitor::MEFolderName
private

Definition at line 85 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

◆ metaDataToken_

edm::EDGetTokenT<OnlineLuminosityRecord> TrackingMonitor::metaDataToken_
private

Definition at line 108 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 115 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().

◆ mvaTrackToken_

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

Definition at line 116 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().

◆ NumberEventsOfVsBX

MonitorElement* TrackingMonitor::NumberEventsOfVsBX
private

Definition at line 168 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

◆ NumberEventsOfVsGoodPVtx

MonitorElement* TrackingMonitor::NumberEventsOfVsGoodPVtx
private

Definition at line 180 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

◆ NumberEventsOfVsLS

MonitorElement* TrackingMonitor::NumberEventsOfVsLS
private

Definition at line 160 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

◆ NumberEventsOfVsLUMI

MonitorElement* TrackingMonitor::NumberEventsOfVsLUMI
private

Definition at line 188 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

◆ NumberOfGoodPVtxVsBX

MonitorElement* TrackingMonitor::NumberOfGoodPVtxVsBX
private

Definition at line 172 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

◆ NumberOfGoodPVtxVsLS

MonitorElement* TrackingMonitor::NumberOfGoodPVtxVsLS
private

Definition at line 164 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

◆ NumberOfGoodPVtxVsLUMI

MonitorElement* TrackingMonitor::NumberOfGoodPVtxVsLUMI
private

Definition at line 192 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

◆ NumberOfGoodPVtxWO0VsBX

MonitorElement* TrackingMonitor::NumberOfGoodPVtxWO0VsBX
private

Definition at line 173 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

◆ NumberOfGoodPVtxWO0VsLS

MonitorElement* TrackingMonitor::NumberOfGoodPVtxWO0VsLS
private

Definition at line 165 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

◆ NumberOfGoodPVtxWO0VsLUMI

MonitorElement* TrackingMonitor::NumberOfGoodPVtxWO0VsLUMI
private

Definition at line 193 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

◆ NumberOfMeanLayersPerTrack

MonitorElement* TrackingMonitor::NumberOfMeanLayersPerTrack
private

Definition at line 135 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

◆ NumberOfMeanRecHitsPerTrack

MonitorElement* TrackingMonitor::NumberOfMeanRecHitsPerTrack
private

Definition at line 134 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

◆ NumberOfPixelClustersVsGoodPVtx

MonitorElement* TrackingMonitor::NumberOfPixelClustersVsGoodPVtx
private

Definition at line 184 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

◆ NumberOfPixelClustersVsLUMI

MonitorElement* TrackingMonitor::NumberOfPixelClustersVsLUMI
private

Definition at line 194 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

◆ NumberOfPVtxVsGoodPVtx

MonitorElement* TrackingMonitor::NumberOfPVtxVsGoodPVtx
private

Definition at line 183 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

◆ NumberOfRecHitsPerTrackVsBX

MonitorElement* TrackingMonitor::NumberOfRecHitsPerTrackVsBX
private

Definition at line 171 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

◆ NumberOfRecHitsPerTrackVsGoodPVtx

MonitorElement* TrackingMonitor::NumberOfRecHitsPerTrackVsGoodPVtx
private

Definition at line 182 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

◆ NumberOfRecHitsPerTrackVsLS

MonitorElement* TrackingMonitor::NumberOfRecHitsPerTrackVsLS
private

Definition at line 163 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

◆ NumberOfRecHitsPerTrackVsLUMI

MonitorElement* TrackingMonitor::NumberOfRecHitsPerTrackVsLUMI
private

Definition at line 191 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

◆ NumberOfSeeds

MonitorElement* TrackingMonitor::NumberOfSeeds
private

Definition at line 144 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

◆ NumberOfSeeds_lumiFlag

MonitorElement* TrackingMonitor::NumberOfSeeds_lumiFlag
private

Definition at line 145 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

◆ NumberOfStripClustersVsGoodPVtx

MonitorElement* TrackingMonitor::NumberOfStripClustersVsGoodPVtx
private

Definition at line 185 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

◆ NumberOfStripClustersVsLUMI

MonitorElement* TrackingMonitor::NumberOfStripClustersVsLUMI
private

Definition at line 195 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

◆ NumberOfTrackCandidates

MonitorElement* TrackingMonitor::NumberOfTrackCandidates
private

Definition at line 150 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

◆ NumberOfTrackingRegions

MonitorElement* TrackingMonitor::NumberOfTrackingRegions
private

Definition at line 141 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

◆ NumberOfTracks

MonitorElement* TrackingMonitor::NumberOfTracks
private

Definition at line 130 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

◆ NumberofTracks_Hardvtx

MonitorElement* TrackingMonitor::NumberofTracks_Hardvtx
private

Definition at line 132 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

◆ NumberofTracks_Hardvtx_PUvtx

MonitorElement* TrackingMonitor::NumberofTracks_Hardvtx_PUvtx
private

Definition at line 133 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

◆ NumberOfTracks_lumiFlag

MonitorElement* TrackingMonitor::NumberOfTracks_lumiFlag
private

Definition at line 198 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

◆ NumberOfTracks_PUvtx

MonitorElement* TrackingMonitor::NumberOfTracks_PUvtx
private

Definition at line 131 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

◆ NumberOfTracksVsBX

MonitorElement* TrackingMonitor::NumberOfTracksVsBX
private

Definition at line 169 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

◆ NumberOfTracksVsBXlumi

MonitorElement* TrackingMonitor::NumberOfTracksVsBXlumi
private

Definition at line 175 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

◆ NumberOfTracksVsGoodPVtx

MonitorElement* TrackingMonitor::NumberOfTracksVsGoodPVtx
private

Definition at line 178 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

◆ NumberOfTracksVsLS

MonitorElement* TrackingMonitor::NumberOfTracksVsLS
private

Definition at line 161 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

◆ NumberOfTracksVsLUMI

MonitorElement* TrackingMonitor::NumberOfTracksVsLUMI
private

Definition at line 189 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

◆ NumberOfTracksVsPUPVtx

MonitorElement* TrackingMonitor::NumberOfTracksVsPUPVtx
private

Definition at line 179 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

◆ NumberOfTrkVsClus

MonitorElement* TrackingMonitor::NumberOfTrkVsClus
private

Definition at line 155 of file TrackingMonitor.h.

◆ NumberOfTrkVsClusters

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

Definition at line 154 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

◆ NumberOfTrkVsPixelClus

MonitorElement* TrackingMonitor::NumberOfTrkVsPixelClus
private

Definition at line 157 of file TrackingMonitor.h.

◆ NumberOfTrkVsStripClus

MonitorElement* TrackingMonitor::NumberOfTrkVsStripClus
private

Definition at line 156 of file TrackingMonitor.h.

◆ numSelection_

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

Definition at line 228 of file TrackingMonitor.h.

Referenced by analyze().

◆ pixelClusterInputTag_

edm::InputTag TrackingMonitor::pixelClusterInputTag_
private

Definition at line 111 of file TrackingMonitor.h.

Referenced by TrackingMonitor().

◆ pixelClustersToken_

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

Definition at line 113 of file TrackingMonitor.h.

Referenced by setNclus(), and TrackingMonitor().

◆ pvNDOF_

int TrackingMonitor::pvNDOF_
private

Definition at line 230 of file TrackingMonitor.h.

Referenced by analyze().

◆ pvSrc_

edm::InputTag TrackingMonitor::pvSrc_
private

Definition at line 94 of file TrackingMonitor.h.

Referenced by TrackingMonitor().

◆ pvSrcToken_

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

Definition at line 96 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().

◆ Quality_

std::string TrackingMonitor::Quality_
private

Definition at line 121 of file TrackingMonitor.h.

Referenced by bookHistograms(), and TrackingMonitor().

◆ regionCandidateToken_

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

Definition at line 105 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().

◆ regionLayerSetsToken_

edm::EDGetTokenT<TrackingRegionsSeedingLayerSets> TrackingMonitor::regionLayerSetsToken_
private

Definition at line 104 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().

◆ regionToken_

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

Definition at line 103 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().

◆ runTrackBuildingAnalyzerForSeed

bool TrackingMonitor::runTrackBuildingAnalyzerForSeed
private

Definition at line 217 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().

◆ seedStopInfoToken_

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

Definition at line 102 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().

◆ SeedsVsClusters

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

Definition at line 146 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

◆ seedToken_

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

Definition at line 101 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().

◆ stripClusterInputTag_

edm::InputTag TrackingMonitor::stripClusterInputTag_
private

Definition at line 110 of file TrackingMonitor.h.

Referenced by TrackingMonitor().

◆ stripClustersToken_

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

Definition at line 112 of file TrackingMonitor.h.

Referenced by setNclus(), and TrackingMonitor().

◆ theLumiDetails_

GetLumi* TrackingMonitor::theLumiDetails_
private

Definition at line 127 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().

◆ theTrackAnalyzer

tadqm::TrackAnalyzer* TrackingMonitor::theTrackAnalyzer
private

Definition at line 124 of file TrackingMonitor.h.

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

◆ theTrackBuildingAnalyzer

TrackBuildingAnalyzer* TrackingMonitor::theTrackBuildingAnalyzer
private

Definition at line 125 of file TrackingMonitor.h.

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

◆ theVertexMonitor

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

Definition at line 126 of file TrackingMonitor.h.

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

◆ trackCandidateToken_

edm::EDGetTokenT<TrackCandidateCollection> TrackingMonitor::trackCandidateToken_
private

Definition at line 100 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().

◆ trackToken_

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

Definition at line 99 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().

◆ transientTrackingRecHitBuilderToken_

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

Definition at line 119 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().

TrackingMonitor::builderName
std::string builderName
Definition: TrackingMonitor.h:200
edm::pset::Registry::instance
static Registry * instance()
Definition: Registry.cc:12
TrackingMonitor::NumberOfTrkVsClusters
std::vector< MonitorElement * > NumberOfTrkVsClusters
Definition: TrackingMonitor.h:154
TrackingMonitor::doAllPlots
bool doAllPlots
Definition: TrackingMonitor.h:206
mps_fire.i
i
Definition: mps_fire.py:355
TrackingMonitor::FractionOfGoodTracks
MonitorElement * FractionOfGoodTracks
Definition: TrackingMonitor.h:138
TrackingMonitor::doAllSeedPlots
bool doAllSeedPlots
Definition: TrackingMonitor.h:205
edm::ESInputTag
Definition: ESInputTag.h:87
TrackingMonitor::regionToken_
edm::EDGetTokenT< edm::OwnVector< TrackingRegion > > regionToken_
Definition: TrackingMonitor.h:103
MonitorTrackSTAMuons_cfi.RecHitMax
RecHitMax
Definition: MonitorTrackSTAMuons_cfi.py:110
TrackingMonitor::GoodTracksFractionVsGoodPVtx
MonitorElement * GoodTracksFractionVsGoodPVtx
Definition: TrackingMonitor.h:181
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:223
MonitorTrackSTAMuons_cfi.NClusStrMin
NClusStrMin
Definition: MonitorTrackSTAMuons_cfi.py:331
TrackingMonitor::NumberOfRecHitsPerTrackVsBX
MonitorElement * NumberOfRecHitsPerTrackVsBX
Definition: TrackingMonitor.h:171
TrackingMonitor::stripClustersToken_
edm::EDGetTokenT< edmNew::DetSetVector< SiStripCluster > > stripClustersToken_
Definition: TrackingMonitor.h:112
TrackingMonitor::NumberofTracks_Hardvtx_PUvtx
MonitorElement * NumberofTracks_Hardvtx_PUvtx
Definition: TrackingMonitor.h:133
L1TCSCTF_cfi.trackProducer
trackProducer
Run2: False; Run1: True.
Definition: L1TCSCTF_cfi.py:12
reco::Vertex::z
double z() const
z coordinate
Definition: Vertex.h:120
tadqm::TrackAnalyzer
Definition: TrackAnalyzer.h:40
MonitorTrackSTAMuons_cfi.MeanHitMax
MeanHitMax
Definition: MonitorTrackSTAMuons_cfi.py:115
TrackingMonitor::NumberEventsOfVsBX
MonitorElement * NumberEventsOfVsBX
Definition: TrackingMonitor.h:168
cropTnPTrees.frac
frac
Definition: cropTnPTrees.py:18
V0Monitor_cfi.lumiScalers
lumiScalers
Definition: V0Monitor_cfi.py:9
TrackingMonitor::histname
std::string histname
Definition: TrackingMonitor.h:86
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:90
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:160
TrackingMonitor::doFractionPlot_
bool doFractionPlot_
Definition: TrackingMonitor.h:224
TrackingMonitor::doRegionCandidatePlots
bool doRegionCandidatePlots
Definition: TrackingMonitor.h:213
TrackingMonitor::pvSrcToken_
edm::EDGetTokenT< reco::VertexCollection > pvSrcToken_
Definition: TrackingMonitor.h:96
TrackingMonitor::NumberOfSeeds_lumiFlag
MonitorElement * NumberOfSeeds_lumiFlag
Definition: TrackingMonitor.h:145
TrackerCollisionTrackingMonitor_cfi.selPrimaryVertexInputTags
selPrimaryVertexInputTags
Definition: TrackerCollisionTrackingMonitor_cfi.py:18
TrackingMonitor::NumberOfTrackCandidates
MonitorElement * NumberOfTrackCandidates
Definition: TrackingMonitor.h:150
cms::cuda::assert
assert(be >=bs)
TrackingMonitor::doPlotsVsBXlumi_
bool doPlotsVsBXlumi_
Definition: TrackingMonitor.h:220
TrackingMonitor::NumberOfGoodPVtxWO0VsBX
MonitorElement * NumberOfGoodPVtxWO0VsBX
Definition: TrackingMonitor.h:173
TrackingMonitor::NumberOfGoodPVtxVsLS
MonitorElement * NumberOfGoodPVtxVsLS
Definition: TrackingMonitor.h:164
TrackingMonitor::NumberofTracks_Hardvtx
MonitorElement * NumberofTracks_Hardvtx
Definition: TrackingMonitor.h:132
reco::Vertex::position
const Point & position() const
position
Definition: Vertex.h:114
TrackingMonitor::NumberOfMeanRecHitsPerTrack
MonitorElement * NumberOfMeanRecHitsPerTrack
Definition: TrackingMonitor.h:134
MonitorTrackSTAMuons_cfi.MeanLayMax
MeanLayMax
Definition: MonitorTrackSTAMuons_cfi.py:160
TrackingMonitor::seedToken_
edm::EDGetTokenT< edm::View< TrajectorySeed > > seedToken_
Definition: TrackingMonitor.h:101
edm::ParameterSet::id
ParameterSetID id() const
Definition: ParameterSet.cc:182
BXlumiParameters_cfi.BXlumiMin
BXlumiMin
Definition: BXlumiParameters_cfi.py:18
TrackingMonitor::NumberOfGoodPVtxVsLUMI
MonitorElement * NumberOfGoodPVtxVsLUMI
Definition: TrackingMonitor.h:192
edm::Handle
Definition: AssociativeIterator.h:50
HLTSiStripMonitoring_cff.AlgoName
AlgoName
Definition: HLTSiStripMonitoring_cff.py:232
TrackingMonitor::theTrackAnalyzer
tadqm::TrackAnalyzer * theTrackAnalyzer
Definition: TrackingMonitor.h:124
parallelization.uint
uint
Definition: parallelization.py:124
TrackingMonitor::NumberOfTracksVsGoodPVtx
MonitorElement * NumberOfTracksVsGoodPVtx
Definition: TrackingMonitor.h:178
TrackingMonitor::metaDataToken_
edm::EDGetTokenT< OnlineLuminosityRecord > metaDataToken_
Definition: TrackingMonitor.h:108
TrackingMonitor::doPlotsVsGoodPVtx_
bool doPlotsVsGoodPVtx_
Definition: TrackingMonitor.h:221
tadqm::TrackAnalyzer::setLumi
void setLumi(const edm::Event &, const edm::EventSetup &iSetup)
Definition: TrackAnalyzer.cc:1119
TrackingMonitor::doGeneralPropertiesPlots_
bool doGeneralPropertiesPlots_
Definition: TrackingMonitor.h:208
TrackingMonitor::NumberOfTracksVsBX
MonitorElement * NumberOfTracksVsBX
Definition: TrackingMonitor.h:169
TrackingMonitor::NumberOfTracksVsLS
MonitorElement * NumberOfTracksVsLS
Definition: TrackingMonitor.h:161
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:127
TrackingMonitor::NumberOfStripClustersVsGoodPVtx
MonitorElement * NumberOfStripClustersVsGoodPVtx
Definition: TrackingMonitor.h:185
TrackingMonitor::NumberOfGoodPVtxVsBX
MonitorElement * NumberOfGoodPVtxVsBX
Definition: TrackingMonitor.h:172
GetLumi
Definition: GetLumi.h:21
reco::Vertex::isFake
bool isFake() const
Definition: Vertex.h:76
TrackingMonitor::NumberOfTracks_lumiFlag
MonitorElement * NumberOfTracks_lumiFlag
Definition: TrackingMonitor.h:198
MonitorTrackSTAMuons_cfi.MeanLayBin
MeanLayBin
Definition: MonitorTrackSTAMuons_cfi.py:159
GlobalPosition_Frontier_DevDB_cff.tag
tag
Definition: GlobalPosition_Frontier_DevDB_cff.py:11
ElectronSeedTrackRefFix_cfi.seedCollection
seedCollection
Definition: ElectronSeedTrackRefFix_cfi.py:9
TrackingMonitor::regionLayerSetsToken_
edm::EDGetTokenT< TrackingRegionsSeedingLayerSets > regionLayerSetsToken_
Definition: TrackingMonitor.h:104
TrackingMonitor::NumberOfPixelClustersVsLUMI
MonitorElement * NumberOfPixelClustersVsLUMI
Definition: TrackingMonitor.h:194
tadqm::TrackAnalyzer::setBX
void setBX(const edm::Event &)
Definition: TrackAnalyzer.cc:1117
TrackingMonitor::NumberOfTracksVsLUMI
MonitorElement * NumberOfTracksVsLUMI
Definition: TrackingMonitor.h:189
TrackingMonitor::bsSrcToken_
edm::EDGetTokenT< reco::BeamSpot > bsSrcToken_
Definition: TrackingMonitor.h:95
MonitorTrackInnerTrackMuons_cff.PVMin
PVMin
Definition: MonitorTrackInnerTrackMuons_cff.py:49
ValL1Emulator_cff.regionTag
regionTag
Definition: ValL1Emulator_cff.py:63
edm::EDGetTokenT::isUninitialized
bool isUninitialized() const
Definition: EDGetToken.h:70
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:203
TrackingMonitor::FractionCandidatesOverSeeds
MonitorElement * FractionCandidatesOverSeeds
Definition: TrackingMonitor.h:151
TrackingMonitor_cfi.LUMIMax
LUMIMax
Definition: TrackingMonitor_cfi.py:415
TrackingMonitor::transientTrackingRecHitBuilderToken_
edm::ESGetToken< TransientTrackingRecHitBuilder, TransientRecHitRecord > transientTrackingRecHitBuilderToken_
Definition: TrackingMonitor.h:119
TrackBuildingAnalyzer
Definition: TrackBuildingAnalyzer.h:36
TrackingMonitor::SeedsVsClusters
std::vector< MonitorElement * > SeedsVsClusters
Definition: TrackingMonitor.h:146
TrackingMonitor::allTrackToken_
edm::EDGetTokenT< edm::View< reco::Track > > allTrackToken_
Definition: TrackingMonitor.h:98
dqm::impl::MonitorElement::getTH1
virtual TH1 * getTH1()
Definition: MonitorElement.cc:969
TrackingMonitor::pvNDOF_
int pvNDOF_
Definition: TrackingMonitor.h:230
TrackingMonitor::NumberOfMeanLayersPerTrack
MonitorElement * NumberOfMeanLayersPerTrack
Definition: TrackingMonitor.h:135
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
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
edm::LogWarning
Definition: MessageLogger.h:141
TrackingMonitor::NumberOfRecHitsPerTrackVsLUMI
MonitorElement * NumberOfRecHitsPerTrackVsLUMI
Definition: TrackingMonitor.h:191
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:264
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:36
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:180
TrackingMonitor::mvaTrackToken_
edm::EDGetTokenT< edm::View< reco::Track > > mvaTrackToken_
Definition: TrackingMonitor.h:116
GenericTriggerEventFlag
Provides a code based selection for trigger and DCS information in order to have no failing filters i...
Definition: GenericTriggerEventFlag.h:42
TrackingMonitor::pvSrc_
edm::InputTag pvSrc_
Definition: TrackingMonitor.h:94
TrackingMonitor::seedStopInfoToken_
edm::EDGetTokenT< std::vector< SeedStopInfo > > seedStopInfoToken_
Definition: TrackingMonitor.h:102
TrackingMonitor::NumberOfRecHitsPerTrackVsLS
MonitorElement * NumberOfRecHitsPerTrackVsLS
Definition: TrackingMonitor.h:163
Folder
Definition: DQMStoreStats.h:134
TrackingMonitor::theLumiDetails_
GetLumi * theLumiDetails_
Definition: TrackingMonitor.h:127
TrackingMonitor::NumberOfSeeds
MonitorElement * NumberOfSeeds
Definition: TrackingMonitor.h:144
cand
Definition: decayParser.h:34
reco::Vertex::tracksSize
size_t tracksSize() const
number of tracks
Definition: Vertex.cc:69
MetAnalyzer.pv
def pv(vc)
Definition: MetAnalyzer.py:7
iEvent
int iEvent
Definition: GenABIO.cc:224
TrackingMonitor::NumberOfPixelClustersVsGoodPVtx
MonitorElement * NumberOfPixelClustersVsGoodPVtx
Definition: TrackingMonitor.h:184
MonitorTrackSTAMuons_cfi.NClusPxBin
NClusPxBin
Definition: MonitorTrackSTAMuons_cfi.py:324
TrackingMonitor::theVertexMonitor
std::vector< VertexMonitor * > theVertexMonitor
Definition: TrackingMonitor.h:126
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:771
TrackerCollisionTrackingMonitor_cfi.GoodPVtxMin
GoodPVtxMin
Definition: TrackerCollisionTrackingMonitor_cfi.py:83
TrackingMonitor::doRegionPlots
bool doRegionPlots
Definition: TrackingMonitor.h:212
MonitorTrackSTAMuons_cfi.NClusStrMax
NClusStrMax
Definition: MonitorTrackSTAMuons_cfi.py:330
TrackingMonitor::pixelClustersToken_
edm::EDGetTokenT< edmNew::DetSetVector< SiPixelCluster > > pixelClustersToken_
Definition: TrackingMonitor.h:113
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:141
TrackingMonitor::trackCandidateToken_
edm::EDGetTokenT< TrackCandidateCollection > trackCandidateToken_
Definition: TrackingMonitor.h:100
TrackingMonitor::doHitPropertiesPlots_
bool doHitPropertiesPlots_
Definition: TrackingMonitor.h:209
HltBtagPostValidation_cff.c
c
Definition: HltBtagPostValidation_cff.py:31
TrackingMonitor::GoodTracksFractionVsLS
MonitorElement * GoodTracksFractionVsLS
Definition: TrackingMonitor.h:162
GetLumi::getValue
double getValue(const edm::Event &)
Definition: GetLumi.cc:49
TrackingMonitor::doSeedVsClusterPlot
bool doSeedVsClusterPlot
Definition: TrackingMonitor.h:216
TrackingMonitor::mvaQualityTokens_
std::vector< std::tuple< edm::EDGetTokenT< MVACollection >, edm::EDGetTokenT< QualityMaskCollection > > > mvaQualityTokens_
Definition: TrackingMonitor.h:115
edm::EventSetup::getData
bool getData(T &iHolder) const
Definition: EventSetup.h:113
overlapproblemtsosanalyzer_cfi.title
title
Definition: overlapproblemtsosanalyzer_cfi.py:7
TrackingMonitor::regionCandidateToken_
edm::EDGetTokenT< reco::CandidateView > regionCandidateToken_
Definition: TrackingMonitor.h:105
TrackingMonitor::doTkCandPlots
bool doTkCandPlots
Definition: TrackingMonitor.h:210
TrackingMonitor::numSelection_
StringCutObjectSelector< reco::Track, true > numSelection_
Definition: TrackingMonitor.h:228
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
TrackingMonitor::doPlotsVsLUMI_
bool doPlotsVsLUMI_
Definition: TrackingMonitor.h:222
TrackingMonitor::NumberOfTracks
MonitorElement * NumberOfTracks
Definition: TrackingMonitor.h:130
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:495
TrackingMonitor::forceSCAL_
const bool forceSCAL_
Definition: TrackingMonitor.h:231
GenericTriggerEventFlag::on
bool on()
Definition: GenericTriggerEventFlag.h:135
TrackingMonitor::pixelClusterInputTag_
edm::InputTag pixelClusterInputTag_
Definition: TrackingMonitor.h:111
TrackingMonitor::ClusterLabels
std::vector< std::string > ClusterLabels
Definition: TrackingMonitor.h:147
TrackingMonitor::GoodTracksFractionVsBX
MonitorElement * GoodTracksFractionVsBX
Definition: TrackingMonitor.h:170
TrackingMonitor::NumberOfTracksVsPUPVtx
MonitorElement * NumberOfTracksVsPUPVtx
Definition: TrackingMonitor.h:179
TrackingMonitor::trackToken_
edm::EDGetTokenT< edm::View< reco::Track > > trackToken_
Definition: TrackingMonitor.h:99
TrackingMonitor::doProfilesVsLS_
bool doProfilesVsLS_
Definition: TrackingMonitor.h:204
TrackingMonitor::setNclus
virtual void setNclus(const edm::Event &, std::vector< int > &)
Definition: TrackingMonitor.cc:1154
TrackingMonitor::GoodTracksFractionVsLUMI
MonitorElement * GoodTracksFractionVsLUMI
Definition: TrackingMonitor.h:190
TrackingMonitor::lumiscalersToken_
edm::EDGetTokenT< LumiScalersCollection > lumiscalersToken_
Definition: TrackingMonitor.h:107
TrackingMonitor::doSeedNumberPlot
bool doSeedNumberPlot
Definition: TrackingMonitor.h:214
TrackingMonitor::NumberOfStripClustersVsLUMI
MonitorElement * NumberOfStripClustersVsLUMI
Definition: TrackingMonitor.h:195
TrackingMonitor::doPUmonitoring_
bool doPUmonitoring_
Definition: TrackingMonitor.h:219
TrackerCollisionTrackingMonitor_cfi.primaryVertexInputTags
primaryVertexInputTags
Definition: TrackerCollisionTrackingMonitor_cfi.py:15
Exception
Definition: hltDiff.cc:246
TrackingMonitor::bsSrc_
edm::InputTag bsSrc_
Definition: TrackingMonitor.h:93
TrackingMonitor::doSeedLumiAnalysis_
bool doSeedLumiAnalysis_
Definition: TrackingMonitor.h:215
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:1118
TrackingMonitor::NumberOfPVtxVsGoodPVtx
MonitorElement * NumberOfPVtxVsGoodPVtx
Definition: TrackingMonitor.h:183
GenericTriggerEventFlag::initRun
void initRun(const edm::Run &run, const edm::EventSetup &setup)
To be called from beginRun() methods.
Definition: GenericTriggerEventFlag.cc:151
TrackingMonitor::NumberOfRecHitsPerTrackVsGoodPVtx
MonitorElement * NumberOfRecHitsPerTrackVsGoodPVtx
Definition: TrackingMonitor.h:182
tadqm::TrackAnalyzer::setNumberOfGoodVertices
void setNumberOfGoodVertices(const edm::Event &)
Definition: TrackAnalyzer.cc:1105
TrackingMonitor::magneticFieldToken_
edm::ESGetToken< MagneticField, IdealMagneticFieldRecord > magneticFieldToken_
Definition: TrackingMonitor.h:118
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:165
TrackingMonitor::stripClusterInputTag_
edm::InputTag stripClusterInputTag_
Definition: TrackingMonitor.h:110
HLT_2018_cff.track
track
Definition: HLT_2018_cff.py:10352
TrackingMonitor::NumberOfTracksVsBXlumi
MonitorElement * NumberOfTracksVsBXlumi
Definition: TrackingMonitor.h:175
AlignmentPI::regions
regions
Definition: AlignmentPayloadInspectorHelper.h:76
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:1171
TrackingMonitor::theTrackBuildingAnalyzer
TrackBuildingAnalyzer * theTrackBuildingAnalyzer
Definition: TrackingMonitor.h:125
siStripFEDCheck_cfi.LSMin
LSMin
Definition: siStripFEDCheck_cfi.py:33
VertexMonitor
Definition: VertexMonitor.h:31
siStripFEDCheck_cfi.LSMax
LSMax
Definition: siStripFEDCheck_cfi.py:34
TrackingMonitor::NumberEventsOfVsLUMI
MonitorElement * NumberEventsOfVsLUMI
Definition: TrackingMonitor.h:188
TrackingMonitor::AlgoName_
std::string AlgoName_
Definition: TrackingMonitor.h:122
edm::HandleBase::isValid
bool isValid() const
Definition: HandleBase.h:70
TrackingMonitor::Quality_
std::string Quality_
Definition: TrackingMonitor.h:121
TrackingMonitor::NumberOfGoodPVtxWO0VsLUMI
MonitorElement * NumberOfGoodPVtxWO0VsLUMI
Definition: TrackingMonitor.h:193
MagneticField
Definition: MagneticField.h:19
lumi
Definition: LumiSectionData.h:20
TransientTrackingRecHitBuilder
Definition: TransientTrackingRecHitBuilder.h:6
TrackingMonitor::NumberOfTracks_PUvtx
MonitorElement * NumberOfTracks_PUvtx
Definition: TrackingMonitor.h:131
MonitorTrackSTAMuons_cfi.MeanLayMin
MeanLayMin
Definition: MonitorTrackSTAMuons_cfi.py:161
TrackingMonitor::doTrackerSpecific_
bool doTrackerSpecific_
Definition: TrackingMonitor.h:202
reco::Vertex::ndof
double ndof() const
Definition: Vertex.h:110
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:800
edm::InputTag
Definition: InputTag.h:15
edm::ConsumesCollector
Definition: ConsumesCollector.h:39
BXlumiParameters_cfi.BXlumiMax
BXlumiMax
Definition: BXlumiParameters_cfi.py:19
TrackingMonitor::genTriggerEventFlag_
GenericTriggerEventFlag * genTriggerEventFlag_
Definition: TrackingMonitor.h:226
reco::Vertex
Definition: Vertex.h:35
TrackingMonitor::doMVAPlots
bool doMVAPlots
Definition: TrackingMonitor.h:211
MonitorTrackInnerTrackMuons_cff.PVMax
PVMax
Definition: MonitorTrackInnerTrackMuons_cff.py:50
TrackingMonitor_cfi.LUMIMin
LUMIMin
Definition: TrackingMonitor_cfi.py:414
TrackingMonitor::denSelection_
StringCutObjectSelector< reco::Track, true > denSelection_
Definition: TrackingMonitor.h:229
ecaldqm::Quality
Quality
Definition: DBWriterWorkers.cc:55
TrackerCollisionTrackingMonitor_cfi.GoodPVtxMax
GoodPVtxMax
Definition: TrackerCollisionTrackingMonitor_cfi.py:84
TrackBuildingAnalyzer::initHisto
void initHisto(DQMStore::IBooker &ibooker, const edm::ParameterSet &)
Definition: TrackBuildingAnalyzer.cc:46
TrackingMonitor::runTrackBuildingAnalyzerForSeed
bool runTrackBuildingAnalyzerForSeed
Definition: TrackingMonitor.h:217
TrackingMonitor::MEFolderName
std::string MEFolderName
Definition: TrackingMonitor.h:85
TrackerCollisionTrackingMonitor_cfi.pvLabels
pvLabels
Definition: TrackerCollisionTrackingMonitor_cfi.py:21
Generated for CMSSW Reference Manual by doxygen 1.8.16