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 hasAbilityToProduceInBeginProcessBlocks () const final
 
bool hasAbilityToProduceInBeginRuns () const final
 
bool hasAbilityToProduceInEndLumis () const final
 
bool hasAbilityToProduceInEndProcessBlocks () 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_, DivergingColor::frac, FractionCandidatesOverSeeds, FractionOfGoodTracks, genTriggerEventFlag_, edm::EventSetup::getData(), edm::pset::Registry::getMapped(), GetLumi::getValue(), GoodTracksFractionVsBX, GoodTracksFractionVsGoodPVtx, GoodTracksFractionVsLS, GoodTracksFractionVsLUMI, mps_fire::i, iEvent, edm::pset::Registry::instance(), OnlineLuminosityRecord::instLumi(), reco::Vertex::isFake(), edm::EDGetTokenT< T >::isUninitialized(), edm::HandleBase::isValid(), V0Monitor_cfi::lumiScalers, lumiscalersToken_, magneticFieldToken_, MEFolderName, metaDataToken_, mvaQualityTokens_, mvaTrackToken_, reco::Vertex::ndof(), NumberEventsOfVsBX, NumberEventsOfVsGoodPVtx, NumberEventsOfVsLS, NumberEventsOfVsLUMI, NumberOfGoodPVtxVsBX, NumberOfGoodPVtxVsLS, NumberOfGoodPVtxVsLUMI, NumberOfGoodPVtxWO0VsBX, NumberOfGoodPVtxWO0VsLS, NumberOfGoodPVtxWO0VsLUMI, NumberOfMeanLayersPerTrack, NumberOfMeanRecHitsPerTrack, NumberOfPixelClustersVsGoodPVtx, NumberOfPixelClustersVsLUMI, NumberOfPVtxVsGoodPVtx, NumberOfRecHitsPerTrackVsBX, NumberOfRecHitsPerTrackVsGoodPVtx, NumberOfRecHitsPerTrackVsLS, NumberOfRecHitsPerTrackVsLUMI, NumberOfSeeds, NumberOfSeeds_lumiFlag, NumberOfStripClustersVsGoodPVtx, NumberOfStripClustersVsLUMI, NumberOfTrackCandidates, NumberOfTrackingRegions, NumberOfTracks, NumberofTracks_Hardvtx, NumberofTracks_Hardvtx_PUvtx, NumberOfTracks_lumiFlag, NumberOfTracks_PUvtx, NumberOfTracksVsBX, NumberOfTracksVsBXlumi, NumberOfTracksVsGoodPVtx, NumberOfTracksVsLS, NumberOfTracksVsLUMI, NumberOfTracksVsPUPVtx, NumberOfTrkVsClusters, numSelection_, GenericTriggerEventFlag::on(), reco::Vertex::position(), edm::Handle< T >::product(), MetAnalyzer::pv(), pvNDOF_, pvSrcToken_, regionCandidateToken_, regionLayerSetsToken_, regionToken_, runTrackBuildingAnalyzerForSeed, ElectronSeedTrackRefFix_cfi::seedCollection, seedStopInfoToken_, SeedsVsClusters, seedToken_, tadqm::TrackAnalyzer::setBX(), tadqm::TrackAnalyzer::setLumi(), setNclus(), tadqm::TrackAnalyzer::setNumberOfGoodVertices(), contentValuesCheck::ss, AlCaHLTBitMon_QueryRunRegistry::string, theLumiDetails_, theTrackAnalyzer, theTrackBuildingAnalyzer, theVertexMonitor, HLT_FULL_cff::track, trackCandidateToken_, duplicaterechits_cfi::trackCollection, reco::Vertex::tracksSize(), trackToken_, transientTrackingRecHitBuilderToken_, parallelization::uint, and reco::Vertex::z().

◆ bookHistograms()

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

Implements DQMEDAnalyzer.

Definition at line 240 of file TrackingMonitor.cc.

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

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

◆ doProfileX() [1/2]

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

◆ doProfileX() [2/2]

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

◆ setMaxMinBin()

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

Definition at line 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
runGCPTkAlMap.title
string title
Definition: runGCPTkAlMap.py:94
mps_fire.i
i
Definition: mps_fire.py:428
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
HLT_FULL_cff.track
track
Definition: HLT_FULL_cff.py:11713
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
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
dqm::implementation::NavigatorBase::setCurrentFolder
virtual void setCurrentFolder(std::string const &fullpath)
Definition: DQMStore.cc:32
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)
edm::EDGetTokenT::isUninitialized
constexpr bool isUninitialized() const noexcept
Definition: EDGetToken.h:99
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:189
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
edm::LogWarning
Log< level::Warning, false > LogWarning
Definition: MessageLogger.h:122
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
DivergingColor.frac
float frac
Definition: DivergingColor.py:175
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
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
dqm::implementation::IBooker::bookProfile
MonitorElement * bookProfile(TString const &name, TString const &title, int nchX, double lowX, double highX, int, double lowY, double highY, char const *option="s", FUNC onbooking=NOOP())
Definition: DQMStore.h:322
TrackingMonitor_cfi.LUMIMax
LUMIMax
Definition: TrackingMonitor_cfi.py:415
TrackingMonitor::transientTrackingRecHitBuilderToken_
edm::ESGetToken< TransientTrackingRecHitBuilder, TransientRecHitRecord > transientTrackingRecHitBuilderToken_
Definition: TrackingMonitor.h: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
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:266
BXlumiParameters_cfi.BXlumiBin
BXlumiBin
Definition: BXlumiParameters_cfi.py:17
MonitorTrackSTAMuons_cfi.NClusPxMax
NClusPxMax
Definition: MonitorTrackSTAMuons_cfi.py:325
COUT
#define COUT(x)
Definition: TrackingMonitor.cc:41
edm::ParameterSet
Definition: ParameterSet.h:47
TrackCandidateCollection
std::vector< TrackCandidate > TrackCandidateCollection
Definition: TrackCandidateCollection.h:7
MonitorTrackInnerTrackMuons_cff.PVBin
PVBin
Definition: MonitorTrackInnerTrackMuons_cff.py:48
duplicaterechits_cfi.trackCollection
trackCollection
Definition: duplicaterechits_cfi.py:4
TrackingMonitor::NumberEventsOfVsGoodPVtx
MonitorElement * NumberEventsOfVsGoodPVtx
Definition: TrackingMonitor.h: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:32
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:120
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
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
dqm::implementation::IBooker::book2D
MonitorElement * book2D(TString const &name, TString const &title, int nchX, double lowX, double highX, int nchY, double lowY, double highY, FUNC onbooking=NOOP())
Definition: DQMStore.h:177
TrackingMonitor::NumberOfStripClustersVsLUMI
MonitorElement * NumberOfStripClustersVsLUMI
Definition: TrackingMonitor.h: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:153
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
Definition: ParameterSet.h:303
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
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:45
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
dqm::implementation::IBooker::book1D
MonitorElement * book1D(TString const &name, TString const &title, int const nchX, double const lowX, double const highX, FUNC onbooking=NOOP())
Definition: DQMStore.h:98
TrackingMonitor::denSelection_
StringCutObjectSelector< reco::Track, true > denSelection_
Definition: TrackingMonitor.h: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