TrackingMonitor Class Reference

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

Inheritance diagram for TrackingMonitor:

Public Types
using	MVACollection = std::vector< float >
using	QualityMaskCollection = std::vector< unsigned char >

Public Member Functions
void	analyze (const edm::Event &, const edm::EventSetup &) override
void	beginLuminosityBlock (const edm::LuminosityBlock &lumi, const edm::EventSetup &eSetup) override
void	bookHistograms (DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override
void	endRun (const edm::Run &, const edm::EventSetup &) 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 one::DQMEDAnalyzer< one::DQMLuminosityBlockElements >
	DQMEDAnalyzer ()=default
	DQMEDAnalyzer (DQMEDAnalyzer< T... > const &)=delete
	DQMEDAnalyzer (DQMEDAnalyzer< T... > &&)=delete
	~DQMEDAnalyzer () override=default

Private Member Functions
void	doProfileX (TH2 *th2, MonitorElement *me)
void	doProfileX (MonitorElement *th2m, MonitorElement *me)

Private Attributes
std::string	AlgoName_
edm::EDGetTokenT< edm::View< reco::Track > >	allTrackToken_
edm::InputTag	bsSrc_
edm::EDGetTokenT< reco::BeamSpot >	bsSrcToken_
std::string	builderName
std::vector< std::string >	ClusterLabels
edm::ParameterSetID	confID_
StringCutObjectSelector< reco::Track, true >	denSelection_
bool	doAllPlots
bool	doAllSeedPlots
bool	doDCAPlots_
bool	doFractionPlot_
bool	doGeneralPropertiesPlots_
bool	doHitPropertiesPlots_
bool	doLumiAnalysis
bool	doMVAPlots
bool	doPlotsVsBX_
bool	doPlotsVsBXlumi_
bool	doPlotsVsGoodPVtx_
bool	doPlotsVsLUMI_
bool	doProfilesVsLS_
bool	doPUmonitoring_
bool	doRegionCandidatePlots
bool	doRegionPlots
bool	doSeedLumiAnalysis_
bool	doSeedNumberPlot
bool	doSeedVsClusterPlot
bool	doTkCandPlots
bool	doTrackerSpecific_
MonitorElement *	FractionCandidatesOverSeeds
MonitorElement *	FractionOfGoodTracks
GenericTriggerEventFlag *	genTriggerEventFlag_
MonitorElement *	GoodTracksFractionVsBX
MonitorElement *	GoodTracksFractionVsGoodPVtx
MonitorElement *	GoodTracksFractionVsLS
MonitorElement *	GoodTracksFractionVsLUMI
std::string	histname
edm::EDGetTokenT< LumiScalersCollection >	lumiscalersToken_
std::string	MEFolderName
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_lumiFlag
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_
dqm::TrackAnalyzer *	theTrackAnalyzer
TrackBuildingAnalyzer *	theTrackBuildingAnalyzer
edm::ESHandle< TransientTrackingRecHitBuilder >	theTTRHBuilder
std::vector< VertexMonitor * >	theVertexMonitor
edm::EDGetTokenT< TrackCandidateCollection >	trackCandidateToken_
edm::EDGetTokenT< edm::View< reco::Track > >	trackToken_

Detailed Description

Monitoring source for general quantities related to tracks.

Definition at line 60 of file TrackingMonitor.h.

Member Typedef Documentation

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

Definition at line 63 of file TrackingMonitor.h.

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

Definition at line 64 of file TrackingMonitor.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 52 of file TrackingMonitor.cc.

References AlgoName_, allTrackToken_, bsSrc_, bsSrcToken_, EnergyCorrector::c, doFractionPlot_, doMVAPlots, doPlotsVsBX_, doPlotsVsBXlumi_, doPlotsVsGoodPVtx_, doPlotsVsLUMI_, doPUmonitoring_, doRegionCandidatePlots, doRegionPlots, Exception, edm::ParameterSet::getParameter(), mps_fire::i, edm::EDGetTokenT< T >::isUninitialized(), edm::InputTag::label(), lumiscalersToken_, mvaQualityTokens_, mvaTrackToken_, pixelClusterInputTag_, pixelClustersToken_, pvSrc_, pvSrcToken_, Quality_, regionCandidateToken_, regionLayerSetsToken_, regionToken_, seedStopInfoToken_, seedToken_, AlCaHLTBitMon_QueryRunRegistry::string, stripClusterInputTag_, stripClustersToken_, GlobalPosition_Frontier_DevDB_cff::tag, theLumiDetails_, theTrackAnalyzer, theVertexMonitor, trackCandidateToken_, findElectronsInSiStrips_cfi::trackProducer, trackToken_, and edm::vector_transform().

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

    , builderName              ( iConfig.getParameter<std::string>("TTRHBuilder"))
    , doTrackerSpecific_       ( iConfig.getParameter<bool>("doTrackerSpecific") )
    , doLumiAnalysis           ( iConfig.getParameter<bool>("doLumiAnalysis"))
    , doProfilesVsLS_          ( iConfig.getParameter<bool>("doProfilesVsLS"))
    , doAllPlots               ( iConfig.getParameter<bool>("doAllPlots"))
    , doGeneralPropertiesPlots_( iConfig.getParameter<bool>("doGeneralPropertiesPlots"))
    , doHitPropertiesPlots_    ( iConfig.getParameter<bool>("doHitPropertiesPlots"))
    , doPUmonitoring_          ( iConfig.getParameter<bool>("doPUmonitoring") )
    , genTriggerEventFlag_(new GenericTriggerEventFlag(iConfig.getParameter<edm::ParameterSet>("genericTriggerEventPSet"),consumesCollector(), *this))
    , numSelection_       (iConfig.getParameter<std::string>("numCut"))
    , denSelection_       (iConfig.getParameter<std::string>("denCut"))
    , pvNDOF_             ( iConfig.getParameter<int> ("pvNDOF") )
{

  edm::ConsumesCollector c{ consumesCollector() };
  theTrackAnalyzer = new dqm::TrackAnalyzer( iConfig,c );

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

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

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

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

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

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

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

  doFractionPlot_ = true;
  if (alltrackProducer.label()==trackProducer.label()) doFractionPlot_ = false;
  
  Quality_  = iConfig.getParameter<std::string>("Quality");
  AlgoName_ = iConfig.getParameter<std::string>("AlgoName");
  
  // get flag from the configuration
  doPlotsVsBXlumi_   = iConfig.getParameter<bool>("doPlotsVsBXlumi");   
  if ( doPlotsVsBXlumi_ )
      theLumiDetails_ = new GetLumi( iConfig.getParameter<edm::ParameterSet>("BXlumiSetup"), c );
  doPlotsVsGoodPVtx_ = iConfig.getParameter<bool>("doPlotsVsGoodPVtx");
  doPlotsVsLUMI_     = iConfig.getParameter<bool>("doPlotsVsLUMI");
  doPlotsVsBX_       = iConfig.getParameter<bool>("doPlotsVsBX");

  if ( doPUmonitoring_ ) {
    
    std::vector<edm::InputTag> primaryVertexInputTags    = iConfig.getParameter<std::vector<edm::InputTag> >("primaryVertexInputTags");
    std::vector<edm::InputTag> selPrimaryVertexInputTags = iConfig.getParameter<std::vector<edm::InputTag> >("selPrimaryVertexInputTags");
    std::vector<std::string>   pvLabels                  = iConfig.getParameter<std::vector<std::string> >  ("pvLabels");
     
    if (primaryVertexInputTags.size()==pvLabels.size() and primaryVertexInputTags.size()==selPrimaryVertexInputTags.size()) {
      for (size_t i=0; i<primaryVertexInputTags.size(); i++) {
    edm::InputTag iPVinputTag    = primaryVertexInputTags[i];
    edm::InputTag iSelPVinputTag = selPrimaryVertexInputTags[i];
    std::string   iPVlabel       = pvLabels[i];
    
    theVertexMonitor.push_back(new VertexMonitor(iConfig,iPVinputTag,iSelPVinputTag,iPVlabel,c) );
      }
    }
  }
  
}

TrackingMonitor::~TrackingMonitor ( )

override

Definition at line 208 of file TrackingMonitor.cc.

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

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

Member Function Documentation

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

override

Definition at line 729 of file TrackingMonitor.cc.

References funct::abs(), GenericTriggerEventFlag::accept(), allTrackToken_, dqm::TrackAnalyzer::analyze(), TrackBuildingAnalyzer::analyze(), edm::View< T >::begin(), bsSrcToken_, builderName, edm::EventBase::bunchCrossing(), ClusterLabels, COUT, denSelection_, doAllPlots, doAllSeedPlots, doFractionPlot_, doGeneralPropertiesPlots_, doLumiAnalysis, doMVAPlots, doPlotsVsBX_, doPlotsVsBXlumi_, doPlotsVsGoodPVtx_, doPlotsVsLUMI_, doProfilesVsLS_, doPUmonitoring_, doRegionCandidatePlots, doRegionPlots, doSeedLumiAnalysis_, doSeedNumberPlot, doSeedVsClusterPlot, doTkCandPlots, doTrackerSpecific_, edm::View< T >::empty(), edm::View< T >::end(), MonitorElement::Fill(), HcalObjRepresent::Fill(), cropTnPTrees::frac, FractionCandidatesOverSeeds, FractionOfGoodTracks, genTriggerEventFlag_, edm::EventSetup::get(), edm::Event::getByToken(), GetLumi::getValue(), GoodTracksFractionVsBX, GoodTracksFractionVsGoodPVtx, GoodTracksFractionVsLS, GoodTracksFractionVsLUMI, mps_fire::i, edm::EventBase::id(), reco::Vertex::isFake(), edm::EDGetTokenT< T >::isUninitialized(), edm::HandleBase::isValid(), edm::EventID::luminosityBlock(), lumiscalersToken_, MEFolderName, 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_lumiFlag, 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, seedStopInfoToken_, SeedsVsClusters, seedToken_, dqm::TrackAnalyzer::setBX(), dqm::TrackAnalyzer::setLumi(), setNclus(), dqm::TrackAnalyzer::setNumberOfGoodVertices(), edm::View< T >::size(), theLumiDetails_, theTrackAnalyzer, theTrackBuildingAnalyzer, theTTRHBuilder, theVertexMonitor, HiIsolationCommonParameters_cff::track, trackCandidateToken_, findElectronsInSiStrips_cfi::trackCollection, reco::Vertex::tracksSize(), trackToken_, parallelization::uint(), and reco::Vertex::z().

{
  
    // Filter out events if Trigger Filtering is requested
    if (genTriggerEventFlag_->on()&& ! genTriggerEventFlag_->accept( iEvent, iSetup) ) return;

    float lumi = -1.;
    edm::Handle<LumiScalersCollection> lumiScalers;
    iEvent.getByToken(lumiscalersToken_, lumiScalers);
    if ( lumiScalers.isValid() && !lumiScalers->empty() ) {
      LumiScalersCollection::const_iterator scalit = lumiScalers->begin();
      lumi = scalit->instantLumi();
    } else 
      lumi = -1.;

    if (doPlotsVsLUMI_ || doAllPlots) 
      NumberEventsOfVsLUMI->Fill(lumi);
    
    //  Analyse the tracks
    //  if the collection is empty, do not fill anything
    // ---------------------------------------------------------------------------------//

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

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

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

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


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

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

      theTrackAnalyzer->setNumberOfGoodVertices(iEvent);
      theTrackAnalyzer->setBX(iEvent);
      theTrackAnalyzer->setLumi(iEvent,iSetup);
      for ( edm::View<reco::Track>::const_iterator track = trackCollection.begin();
        track != trackCollection.end(); ++track ) {

    if ( doPlotsVsBX_ || doAllPlots )
      NumberOfRecHitsPerTrackVsBX->Fill(bx,track->numberOfValidHits());
    if ( numSelection_(*track) ) {
      numberOfTracks_num++;
          if (pv0 && std::abs(track->dz(pv0->position()))<0.15) ++numberOfTracks_pv0;
        } 

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

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

    totalRecHits    += track->numberOfValidHits();
    totalLayers     += track->hitPattern().trackerLayersWithMeasurement();
    
    // do analysis per track
    theTrackAnalyzer->analyze(iEvent, iSetup, *track);
      }

      double frac = -1.;
      //      if (numberOfAllTracks > 0) frac = static_cast<double>(numberOfTracks)/static_cast<double>(numberOfAllTracks);
      if (numberOfTracks_den > 0) frac = static_cast<double>(numberOfTracks_num)/static_cast<double>(numberOfTracks_den);
      
      if (doGeneralPropertiesPlots_ || doAllPlots){
    NumberOfTracks       -> Fill(numberOfTracks);
    if ( doPlotsVsBX_ || doAllPlots )
      NumberOfTracksVsBX   -> Fill(bx,numberOfTracks);
    if (doPlotsVsLUMI_ || doAllPlots) 
      NumberOfTracksVsLUMI -> Fill(lumi,numberOfTracks);
    if (doFractionPlot_) {
      FractionOfGoodTracks     -> Fill(frac);

      if (doFractionPlot_) {
        if ( doPlotsVsBX_ || doAllPlots )
          GoodTracksFractionVsBX   -> Fill(bx,  frac);
        if (doPlotsVsLUMI_ || doAllPlots) 
          GoodTracksFractionVsLUMI -> Fill(lumi,frac);
      }
    }
    if( numberOfTracks > 0 ) {
      double meanRecHits = static_cast<double>(totalRecHits) / static_cast<double>(numberOfTracks);
      double meanLayers  = static_cast<double>(totalLayers)  / static_cast<double>(numberOfTracks);
      NumberOfMeanRecHitsPerTrack -> Fill(meanRecHits);
      NumberOfMeanLayersPerTrack  -> Fill(meanLayers);
    }
      }
      
      if ( doProfilesVsLS_ || doAllPlots) {
    float nLS = static_cast<double>(iEvent.id().luminosityBlock());
    NumberEventsOfVsLS    ->Fill(nLS);
    NumberOfTracksVsLS    ->Fill(nLS,numberOfTracks);
    if (doFractionPlot_) 
      GoodTracksFractionVsLS->Fill(nLS,frac);
      }
      
      if ( doLumiAnalysis ) {
    NumberOfTracks_lumiFlag       -> Fill(numberOfTracks);
      }
      
      
      //  Analyse the Track Building variables 
      //  if the collection is empty, do not fill anything
      // ---------------------------------------------------------------------------------//
      
      
      // fill the TrackCandidate info
      if (doTkCandPlots) {
    // magnetic field
    edm::ESHandle<MagneticField> theMF;
    iSetup.get<IdealMagneticFieldRecord>().get(theMF);  
    
    // get the candidate collection
    edm::Handle<TrackCandidateCollection> theTCHandle;
    iEvent.getByToken( trackCandidateToken_, theTCHandle );
    const TrackCandidateCollection& theTCCollection = *theTCHandle;
    
    if (theTCHandle.isValid()) {
      
      // get the beam spot
      edm::Handle<reco::BeamSpot> recoBeamSpotHandle;
      iEvent.getByToken(bsSrcToken_, recoBeamSpotHandle );
      const reco::BeamSpot& bs = *recoBeamSpotHandle;      
      
      NumberOfTrackCandidates->Fill(theTCCollection.size());

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

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

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

      edm::Handle<edm::View<reco::Track> > htracks;
      iEvent.getByToken(mvaTrackToken_, htracks);

      edm::Handle<MVACollection> hmva;
      edm::Handle<QualityMaskCollection> hqual;
      for(const auto& tokenTpl: mvaQualityTokens_) {
        iEvent.getByToken(std::get<0>(tokenTpl), hmva);
        iEvent.getByToken(std::get<1>(tokenTpl), hqual);

        mvaCollections.push_back(hmva.product());
        qualityMaskCollections.push_back(hqual.product());
      }
      theTrackBuildingAnalyzer->analyze(*htracks, mvaCollections, qualityMaskCollections);
    }
      }
      
      //plots for trajectory seeds
      
      if (doAllSeedPlots || doSeedNumberPlot || doSeedVsClusterPlot || runTrackBuildingAnalyzerForSeed) {
    
    // get the seed collection
    edm::Handle<edm::View<TrajectorySeed> > seedHandle;
    iEvent.getByToken(seedToken_, seedHandle );
    
    // fill the seed info
    if (seedHandle.isValid()) {
          const auto& seedCollection = *seedHandle;
      
      if(doAllSeedPlots || doSeedNumberPlot) {
        NumberOfSeeds->Fill(seedCollection.size());
        if ( doSeedLumiAnalysis_ )
          NumberOfSeeds_lumiFlag->Fill(seedCollection.size());             
      }
      
      if(doAllSeedPlots || doSeedVsClusterPlot){
        
        std::vector<int> NClus;
        setNclus(iEvent,NClus);
        for (uint  i=0; i< ClusterLabels.size(); i++){
          SeedsVsClusters[i]->Fill(NClus[i],seedCollection.size());
        }
      }
      
      if (doAllSeedPlots || runTrackBuildingAnalyzerForSeed){
            edm::Handle<std::vector<SeedStopInfo> > stopHandle;
            iEvent.getByToken(seedStopInfoToken_, stopHandle);
            const auto& seedStopInfo = *stopHandle;

            if(seedStopInfo.size() == seedCollection.size()) {
              //here duplication of mag field and be informations is needed to allow seed and track cand histos to be independent
              // magnetic field
              edm::ESHandle<MagneticField> theMF;
              iSetup.get<IdealMagneticFieldRecord>().get(theMF);
        
              // get the beam spot
              edm::Handle<reco::BeamSpot> recoBeamSpotHandle;
              iEvent.getByToken(bsSrcToken_, recoBeamSpotHandle);
              const reco::BeamSpot& bs = *recoBeamSpotHandle;
        
              iSetup.get<TransientRecHitRecord>().get(builderName,theTTRHBuilder);
              for(size_t i=0; i < seedCollection.size(); ++i) {
                theTrackBuildingAnalyzer->analyze(iEvent, iSetup, seedCollection[i], seedStopInfo[i], bs, theMF, theTTRHBuilder);
              }
            }
            else {
              edm::LogWarning("TrackingMonitor") << "Seed collection size (" << seedCollection.size()
                                                 << ") differs from seed stop info collection size (" << seedStopInfo.size()
                                                 << "). This is a sign of inconsistency in the configuration. Not filling associated histograms.";
            }
      }
      
    } else {
      edm::LogWarning("TrackingMonitor") << "No Trajectory seeds in the event.  Not filling associated histograms";
    }
      }
      

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

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

          theTrackBuildingAnalyzer->analyze(regions);
        }

        if (doRegionCandidatePlots) {
          edm::Handle<reco::CandidateView> hcandidates;
          iEvent.getByToken(regionCandidateToken_, hcandidates);
          theTrackBuildingAnalyzer->analyze(*hcandidates);
        }
      }
      
      if (doTrackerSpecific_ || doAllPlots) {
    
    std::vector<int> NClus;
    setNclus(iEvent,NClus);
    for (uint  i=0; i< ClusterLabels.size(); i++) {
      NumberOfTrkVsClusters[i]->Fill(NClus[i],numberOfTracks);
    }
      }
      
      if ( doPUmonitoring_ ) {
    
    // do vertex monitoring
    for (size_t i=0; i<theVertexMonitor.size(); i++)
      theVertexMonitor[i]->analyze(iEvent, iSetup);
      }
      if ( doPlotsVsGoodPVtx_ ) {
      
      size_t totalNumGoodPV = 0;
      if (pvHandle.isValid()) {
        
        for (reco::VertexCollection::const_iterator pv = pvHandle->begin();
         pv != pvHandle->end(); ++pv) {
          
          //--- pv fake (the pv collection should have size==1 and the pv==beam spot) 
          if (pv->isFake() || pv->tracksSize()==0) continue;
          
          // definition of goodOfflinePrimaryVertex
          if (pv->ndof() < pvNDOF_ || pv->z() > 24.)  continue;
          totalNumGoodPV++;
        }
        
        NumberEventsOfVsGoodPVtx       -> Fill( float(totalNumGoodPV) );
            NumberOfTracksVsGoodPVtx       -> Fill( float(totalNumGoodPV), numberOfTracks   );
        if (totalNumGoodPV>1) NumberOfTracksVsPUPVtx-> Fill( totalNumGoodPV-1, double(numberOfTracks-numberOfTracks_pv0)/double(totalNumGoodPV-1)      );
        NumberOfPVtxVsGoodPVtx          -> Fill(float(totalNumGoodPV),pvHandle->size());

        for ( edm::View<reco::Track>::const_iterator track = trackCollection.begin();
          track != trackCollection.end(); ++track ) {

          NumberOfRecHitsPerTrackVsGoodPVtx -> Fill(float(totalNumGoodPV), track->numberOfValidHits());
        }

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

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

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

      } // PU monitoring
      
    } // trackHandle is valid
    
}

void TrackingMonitor::beginLuminosityBlock ( const edm::LuminosityBlock &  lumi, const edm::EventSetup &  eSetup  )

override

Definition at line 715 of file TrackingMonitor.cc.

References doAllSeedPlots, doLumiAnalysis, dqm::TrackAnalyzer::doReset(), doSeedLumiAnalysis_, doSeedNumberPlot, NumberOfSeeds_lumiFlag, NumberOfTracks_lumiFlag, MonitorElement::Reset(), HcalObjRepresent::Reset(), and theTrackAnalyzer.

                                                                                                       {

  if (doLumiAnalysis) {
    if ( NumberOfTracks_lumiFlag ) NumberOfTracks_lumiFlag -> Reset();
    theTrackAnalyzer->doReset();    
  }
  if(doAllSeedPlots || doSeedNumberPlot) {
    if ( doSeedLumiAnalysis_ )
      NumberOfSeeds_lumiFlag->Reset();
  }
}

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

override

Definition at line 220 of file TrackingMonitor.cc.

References AlgoName_, DQMStore::IBooker::book1D(), DQMStore::IBooker::book2D(), DQMStore::IBooker::bookProfile(), 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(), MonitorElement::getTH1(), GoodTracksFractionVsBX, GoodTracksFractionVsGoodPVtx, GoodTracksFractionVsLS, GoodTracksFractionVsLUMI, histname, mps_fire::i, dqm::TrackAnalyzer::initHisto(), TrackBuildingAnalyzer::initHisto(), GenericTriggerEventFlag::initRun(), edm::pset::Registry::instance(), edm::InputTag::label(), MEFolderName, 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_lumiFlag, NumberOfTracksVsBX, NumberOfTracksVsBXlumi, NumberOfTracksVsGoodPVtx, NumberOfTracksVsLS, NumberOfTracksVsLUMI, NumberOfTracksVsPUPVtx, NumberOfTrkVsClusters, GenericTriggerEventFlag::on(), Quality_, runTrackBuildingAnalyzerForSeed, SeedsVsClusters, MonitorElement::setAxisTitle(), DQMStore::IBooker::setCurrentFolder(), dqm::TrackAnalyzer::setLumiFlag(), MonitorElement::setLumiFlag(), setMaxMinBin(), AlCaHLTBitMon_QueryRunRegistry::string, theTrackAnalyzer, theTrackBuildingAnalyzer, theVertexMonitor, fftjetcommon_cfi::title, and parallelization::uint().

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

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

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

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

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

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

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

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

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

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

   ibooker.setCurrentFolder(MEFolderName);

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

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

     histname = "NumberOfTracks_" + CategoryName;
       // MODIFY by Mia in order to cope w/ high multiplicity
     NumberOfTracks = ibooker.book1D(histname, histname, 3*TKNoBin, TKNoMin, (TKNoMax+0.5)*3.-0.5);
     NumberOfTracks->setAxisTitle("Number of Tracks per Event", 1);
     NumberOfTracks->setAxisTitle("Number of Events", 2);
  
     histname = "NumberOfMeanRecHitsPerTrack_" + CategoryName;
     NumberOfMeanRecHitsPerTrack = ibooker.book1D(histname, histname, MeanHitBin, MeanHitMin, MeanHitMax);
     NumberOfMeanRecHitsPerTrack->setAxisTitle("Mean number of valid RecHits per Track", 1);
     NumberOfMeanRecHitsPerTrack->setAxisTitle("Entries", 2);
  
     histname = "NumberOfMeanLayersPerTrack_" + CategoryName;
     NumberOfMeanLayersPerTrack = ibooker.book1D(histname, histname, MeanLayBin, MeanLayMin, MeanLayMax);
     NumberOfMeanLayersPerTrack->setAxisTitle("Mean number of Layers per Track", 1);
     NumberOfMeanLayersPerTrack->setAxisTitle("Entries", 2);
  
     if (doFractionPlot_) {
       histname = "FractionOfGoodTracks_" + CategoryName;
       FractionOfGoodTracks = ibooker.book1D(histname, histname, 101, -0.005, 1.005);
       FractionOfGoodTracks->setAxisTitle("Fraction of Tracks (w.r.t. generalTracks)", 1);
       FractionOfGoodTracks->setAxisTitle("Entries", 2);
     }
   }

   if ( doLumiAnalysis ) {
     // add by Mia in order to deal with LS transitions
     ibooker.setCurrentFolder(MEFolderName+"/LSanalysis");
  
     histname = "NumberOfTracks_lumiFlag_" + CategoryName;
     NumberOfTracks_lumiFlag = ibooker.book1D(histname, histname, 3*TKNoBin, TKNoMin, (TKNoMax+0.5)*3.-0.5);
     NumberOfTracks_lumiFlag->setAxisTitle("Number of Tracks per Event", 1);
     NumberOfTracks_lumiFlag->setAxisTitle("Number of Events", 2);
  
   }

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


   if ( doProfilesVsLS_ || doAllPlots) {
  
     ibooker.setCurrentFolder(MEFolderName+"/GeneralProperties");
  
     histname = "NumberOfTracksVsLS_"+ CategoryName;
     NumberOfTracksVsLS = ibooker.bookProfile(histname,histname, LSBin,LSMin,LSMax, TKNoMin, TKNoMax*3.,"");
     NumberOfTracksVsLS->getTH1()->SetCanExtend(TH1::kAllAxes);
     NumberOfTracksVsLS->setAxisTitle("#Lumi section",1);
     NumberOfTracksVsLS->setAxisTitle("Number of  Tracks",2);
  
     histname = "NumberOfRecHitsPerTrackVsLS_" + CategoryName;
     NumberOfRecHitsPerTrackVsLS = ibooker.bookProfile(histname,histname, LSBin,LSMin,LSMax,0.,200.,"");
     NumberOfRecHitsPerTrackVsLS->getTH1()->SetCanExtend(TH1::kAllAxes);
     NumberOfRecHitsPerTrackVsLS->setAxisTitle("#Lumi section",1);
     NumberOfRecHitsPerTrackVsLS->setAxisTitle("Mean number of Valid RecHits per track",2);
  
     histname = "NumberEventsVsLS_" + CategoryName;
     NumberEventsOfVsLS = ibooker.book1D(histname,histname, LSBin,LSMin,LSMax);
     NumberEventsOfVsLS->getTH1()->SetCanExtend(TH1::kAllAxes);
     NumberEventsOfVsLS->setAxisTitle("#Lumi section",1);
     NumberEventsOfVsLS->setAxisTitle("Number of events",2);
  
     double GoodPVtxMin   = conf->getParameter<double>("GoodPVtxMin");
     double GoodPVtxMax   = conf->getParameter<double>("GoodPVtxMax");

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

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

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

     if ( doPlotsVsBX_ || doAllPlots ) {
       ibooker.setCurrentFolder(MEFolderName+"/BXanalysis");
       int BXBin = 3564; double BXMin = 0.5; double BXMax = 3564.5;
       
       histname = "NumberEventsVsBX_" + CategoryName;
       NumberEventsOfVsBX = ibooker.book1D(histname,histname, BXBin,BXMin,BXMax);
       NumberEventsOfVsBX->setAxisTitle("BX",1);
       NumberEventsOfVsBX->setAxisTitle("Number of events",2);
       
       histname = "NumberOfTracksVsBX_"+ CategoryName;
       NumberOfTracksVsBX = ibooker.bookProfile(histname,histname, BXBin,BXMin,BXMax, TKNoMin, TKNoMax*3.,"");
       NumberOfTracksVsBX->setAxisTitle("BX",1);
       NumberOfTracksVsBX->setAxisTitle("Number of  Tracks",2);
       
       histname = "NumberOfRecHitsPerTrackVsBX_" + CategoryName;
       NumberOfRecHitsPerTrackVsBX = ibooker.bookProfile(histname,histname, BXBin,BXMin,BXMax,0.,200.,"");
       NumberOfRecHitsPerTrackVsBX->setAxisTitle("BX",1);
       NumberOfRecHitsPerTrackVsBX->setAxisTitle("Mean number of Valid RecHits per track",2);
       
       histname = "NumberOfGoodPVtxVsBX_" + CategoryName;
       NumberOfGoodPVtxVsBX = ibooker.bookProfile(histname,histname, BXBin,BXMin,BXMax,GoodPVtxMin,3.*GoodPVtxMax,"");
       NumberOfGoodPVtxVsBX->setAxisTitle("BX",1);
       NumberOfGoodPVtxVsBX->setAxisTitle("Mean number of good PV",2);
       
       histname = "NumberOfGoodPVtxWO0VsBX_" + CategoryName;
       NumberOfGoodPVtxWO0VsBX = ibooker.bookProfile(histname,histname, BXBin,BXMin,BXMax,GoodPVtxMin,3.*GoodPVtxMax,"");
       NumberOfGoodPVtxWO0VsBX->setAxisTitle("BX",1);
       NumberOfGoodPVtxWO0VsBX->setAxisTitle("Mean number of good PV",2);
       
       if (doFractionPlot_) {
     histname = "GoodTracksFractionVsBX_"+ CategoryName;
     GoodTracksFractionVsBX = ibooker.bookProfile(histname,histname, BXBin,BXMin,BXMax,0,1.1,"");
     GoodTracksFractionVsBX->setAxisTitle("BX",1);
     GoodTracksFractionVsBX->setAxisTitle("Fraction of Good Tracks",2);
       }
     }

   }

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

   if ( doPUmonitoring_ ) {
  
     for (size_t i=0; i<theVertexMonitor.size(); i++)
       theVertexMonitor[i]->initHisto(ibooker);
   }
  
     if ( doPlotsVsGoodPVtx_ ) {
      ibooker.setCurrentFolder(MEFolderName+"/PUmonitoring");
      // get binning from the configuration
      int   PVBin = conf->getParameter<int>   ("PVBin");
      float PVMin = conf->getParameter<double>("PVMin");
      float PVMax = conf->getParameter<double>("PVMax");
    
       histname = "NumberOfTracksVsGoodPVtx";
       NumberOfTracksVsGoodPVtx = ibooker.bookProfile(histname,histname,PVBin,PVMin,PVMax,TKNoMin, TKNoMax*5.,"");
       NumberOfTracksVsGoodPVtx->setAxisTitle("Number of PV",1);
       NumberOfTracksVsGoodPVtx->setAxisTitle("Mean number of Tracks per Event",2);

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

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

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

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

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

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

     if ( doPlotsVsLUMI_ || doAllPlots ) {
       ibooker.setCurrentFolder(MEFolderName+"/LUMIanalysis");
       int LUMIBin = conf->getParameter<int>("LUMIBin");
       float LUMIMin = conf->getParameter<double>("LUMIMin");
       float LUMIMax = conf->getParameter<double>("LUMIMax");
       
       histname = "NumberEventsVsLUMI";
       NumberEventsOfVsLUMI = ibooker.book1D(histname,histname,LUMIBin,LUMIMin,LUMIMax);
       NumberEventsOfVsLUMI->setAxisTitle("scal lumi [10e30 Hz cm^{-2}]",1);
       NumberEventsOfVsLUMI->setAxisTitle("Number of events",2);
       
       histname = "NumberOfTracksVsLUMI";
       NumberOfTracksVsLUMI = ibooker.bookProfile(histname,histname,LUMIBin,LUMIMin,LUMIMax,0., 2000.,"");
       NumberOfTracksVsLUMI->setAxisTitle("scal lumi [10e30 Hz cm^{-2}]",1);
       NumberOfTracksVsLUMI->setAxisTitle("Mean number of vertices",2);
       
       if (doFractionPlot_) {
     histname = "GoodTracksFractionVsLUMI";
     GoodTracksFractionVsLUMI = ibooker.bookProfile(histname,histname,LUMIBin,LUMIMin,LUMIMax,0., 1.1,"");
     GoodTracksFractionVsLUMI->setAxisTitle("scal lumi [10e30 Hz cm^{-2}]",1);
     GoodTracksFractionVsLUMI->setAxisTitle("Mean number of vertices",2);
       }

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

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

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

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

     if ( doPlotsVsBXlumi_ ) {
       ibooker.setCurrentFolder(MEFolderName+"/PUmonitoring");
       // get binning from the configuration
       edm::ParameterSet BXlumiParameters = conf->getParameter<edm::ParameterSet>("BXlumiSetup");
       int    BXlumiBin   = BXlumiParameters.getParameter<int>("BXlumiBin");
       double BXlumiMin   = BXlumiParameters.getParameter<double>("BXlumiMin");
       double BXlumiMax   = BXlumiParameters.getParameter<double>("BXlumiMax");
    
       histname = "NumberOfTracksVsBXlumi_"+ CategoryName;
       NumberOfTracksVsBXlumi = ibooker.bookProfile(histname,histname, BXlumiBin,BXlumiMin,BXlumiMax, TKNoMin, 3.*TKNoMax,"");
       NumberOfTracksVsBXlumi->setAxisTitle("lumi BX [10^{30}Hzcm^{-2}]",1);
       NumberOfTracksVsBXlumi->setAxisTitle("Mean number of Tracks",2);
    
     }
   

     theTrackAnalyzer->initHisto(ibooker, iSetup, *conf);

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

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

   doAllSeedPlots      = conf->getParameter<bool>("doSeedParameterHistos");
   doSeedNumberPlot    = conf->getParameter<bool>("doSeedNumberHisto");
   doSeedLumiAnalysis_ = conf->getParameter<bool>("doSeedLumiAnalysis");
   doSeedVsClusterPlot = conf->getParameter<bool>("doSeedVsClusterHisto");
   //    if (doAllPlots) doAllSeedPlots=true;

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

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

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

   }

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

     ClusterLabels=  conf->getParameter<std::vector<std::string> >("ClusterLabels");
  
     std::vector<double> histoMin,histoMax;
     std::vector<int> histoBin; //these vectors are for max min and nbins in histograms 
  
     int    NClusPxBin = conf->getParameter<int>(   "NClusPxBin");
     double NClusPxMin = conf->getParameter<double>("NClusPxMin");
     double NClusPxMax = conf->getParameter<double>("NClusPxMax");
  
     int    NClusStrBin = conf->getParameter<int>(   "NClusStrBin");
     double NClusStrMin = conf->getParameter<double>("NClusStrMin");
     double NClusStrMax = conf->getParameter<double>("NClusStrMax");
  
     setMaxMinBin(histoMin,histoMax,histoBin,NClusStrMin,NClusStrMax,NClusStrBin,NClusPxMin,NClusPxMax,NClusPxBin);
  
     for (uint i=0; i<ClusterLabels.size(); i++){
       histname = "SeedsVsClusters_" + seedProducer.label() + "_Vs_" + ClusterLabels[i] + "_" + CategoryName;
       SeedsVsClusters.push_back(dynamic_cast<MonitorElement*>(ibooker.book2D(histname, histname, histoBin[i], histoMin[i], histoMax[i],
                                         TKNoSeedBin, TKNoSeedMin, TKNoSeedMax)));
       SeedsVsClusters[i]->setAxisTitle("Number of Clusters", 1);
       SeedsVsClusters[i]->setAxisTitle("Number of Seeds", 2);
       SeedsVsClusters[i]->getTH2F()->SetCanExtend(TH1::kAllAxes);
     }
   }
  
   if(doRegionPlots) {
     ibooker.setCurrentFolder(MEFolderName+"/TrackBuilding");

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

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

   doTkCandPlots=conf->getParameter<bool>("doTrackCandHistos");
  //    if (doAllPlots) doTkCandPlots=true;
  
  if (doTkCandPlots){
    ibooker.setCurrentFolder(MEFolderName+"/TrackBuilding");
    
    edm::InputTag tcProducer     = conf->getParameter<edm::InputTag>("TCProducer");
    
    histname = "NumberOfTrackCandidates_"+ tcProducer.label() + "_"+ CategoryName;
    NumberOfTrackCandidates = ibooker.book1D(histname, histname, TCNoBin, TCNoMin, TCNoMax);
    NumberOfTrackCandidates->setAxisTitle("Number of Track Candidates per Event", 1);
    NumberOfTrackCandidates->setAxisTitle("Number of Event", 2);

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

  }
  
  theTrackBuildingAnalyzer->initHisto(ibooker,*conf);
  
  
  if (doLumiAnalysis) {
    if ( NumberOfTracks_lumiFlag ) NumberOfTracks_lumiFlag -> setLumiFlag();
    theTrackAnalyzer->setLumiFlag();    
  }

  if(doAllSeedPlots || doSeedNumberPlot){
    if ( doSeedLumiAnalysis_ )
      NumberOfSeeds_lumiFlag->setLumiFlag();
  }
  
  if (doTrackerSpecific_ || doAllPlots) {
    
    ClusterLabels=  conf->getParameter<std::vector<std::string> >("ClusterLabels");
    
    std::vector<double> histoMin,histoMax;
    std::vector<int> histoBin; //these vectors are for max min and nbins in histograms 
    
    int    NClusStrBin = conf->getParameter<int>(   "NClusStrBin");
    double NClusStrMin = conf->getParameter<double>("NClusStrMin");
    double NClusStrMax = conf->getParameter<double>("NClusStrMax");
    
    int    NClusPxBin = conf->getParameter<int>(   "NClusPxBin");
    double NClusPxMin = conf->getParameter<double>("NClusPxMin");
    double NClusPxMax = conf->getParameter<double>("NClusPxMax");
    
    int    NTrk2DBin     = conf->getParameter<int>(   "NTrk2DBin");
    double NTrk2DMin     = conf->getParameter<double>("NTrk2DMin");
    double NTrk2DMax     = conf->getParameter<double>("NTrk2DMax");
    
    setMaxMinBin(histoMin,histoMax,histoBin,
         NClusStrMin,NClusStrMax,NClusStrBin,
         NClusPxMin,  NClusPxMax,  NClusPxBin);
    
    ibooker.setCurrentFolder(MEFolderName+"/HitProperties");
    
    for (uint i=0; i<ClusterLabels.size(); i++){
      
      ibooker.setCurrentFolder(MEFolderName+"/HitProperties");
      histname = "TracksVs" + ClusterLabels[i] + "Cluster_" + CategoryName;
      NumberOfTrkVsClusters.push_back(dynamic_cast<MonitorElement*>(ibooker.book2D(histname, histname,
                                              histoBin[i], histoMin[i], histoMax[i],
                                              NTrk2DBin,NTrk2DMin,NTrk2DMax
                                              )));
      std::string title = "Number of " + ClusterLabels[i] + " Clusters";
      if(ClusterLabels[i]=="Tot")
    title = "# of Clusters in (Pixel+Strip) Detectors";
      NumberOfTrkVsClusters[i]->setAxisTitle(title, 1);
      NumberOfTrkVsClusters[i]->setAxisTitle("Number of Tracks", 2);
      NumberOfTrkVsClusters[i]->getTH1()->SetCanExtend(TH1::kXaxis);
    }
  }
  
  // Initialize the GenericTriggerEventFlag
  if ( genTriggerEventFlag_->on() ) genTriggerEventFlag_->initRun( iRun, iSetup );
  
}

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

private

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

private

void TrackingMonitor::endRun ( const edm::Run &  , const edm::EventSetup &    )

override

Definition at line 1093 of file TrackingMonitor.cc.

{
}

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 1097 of file TrackingMonitor.cc.

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

Referenced by bookHistograms().

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

  for (uint i=0; i<ClusterLabels.size(); ++i) {

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

  }
    
}

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

virtual

Definition at line 1115 of file TrackingMonitor.cc.

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

Referenced by analyze().

{

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

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

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

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

Member Data Documentation

std::string TrackingMonitor::AlgoName_

private

Definition at line 118 of file TrackingMonitor.h.

Referenced by bookHistograms(), and TrackingMonitor().

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

private

Definition at line 98 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().

edm::InputTag TrackingMonitor::bsSrc_

private

Definition at line 93 of file TrackingMonitor.h.

Referenced by TrackingMonitor().

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

private

Definition at line 95 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().

std::string TrackingMonitor::builderName

private

Definition at line 195 of file TrackingMonitor.h.

Referenced by analyze().

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

private

Definition at line 141 of file TrackingMonitor.h.

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

edm::ParameterSetID TrackingMonitor::confID_

private

Definition at line 90 of file TrackingMonitor.h.

Referenced by bookHistograms().

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

private

Definition at line 225 of file TrackingMonitor.h.

Referenced by analyze().

bool TrackingMonitor::doAllPlots

private

Definition at line 202 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

bool TrackingMonitor::doAllSeedPlots

private

Definition at line 201 of file TrackingMonitor.h.

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

bool TrackingMonitor::doDCAPlots_

private

Definition at line 203 of file TrackingMonitor.h.

bool TrackingMonitor::doFractionPlot_

private

Definition at line 220 of file TrackingMonitor.h.

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

bool TrackingMonitor::doGeneralPropertiesPlots_

private

Definition at line 204 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

bool TrackingMonitor::doHitPropertiesPlots_

private

Definition at line 205 of file TrackingMonitor.h.

bool TrackingMonitor::doLumiAnalysis

private

Definition at line 199 of file TrackingMonitor.h.

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

bool TrackingMonitor::doMVAPlots

private

Definition at line 207 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().

bool TrackingMonitor::doPlotsVsBX_

private

Definition at line 219 of file TrackingMonitor.h.

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

bool TrackingMonitor::doPlotsVsBXlumi_

private

Definition at line 216 of file TrackingMonitor.h.

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

bool TrackingMonitor::doPlotsVsGoodPVtx_

private

Definition at line 217 of file TrackingMonitor.h.

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

bool TrackingMonitor::doPlotsVsLUMI_

private

Definition at line 218 of file TrackingMonitor.h.

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

bool TrackingMonitor::doProfilesVsLS_

private

Definition at line 200 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

bool TrackingMonitor::doPUmonitoring_

private

Definition at line 215 of file TrackingMonitor.h.

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

bool TrackingMonitor::doRegionCandidatePlots

private

Definition at line 209 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().

bool TrackingMonitor::doRegionPlots

private

Definition at line 208 of file TrackingMonitor.h.

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

bool TrackingMonitor::doSeedLumiAnalysis_

private

Definition at line 211 of file TrackingMonitor.h.

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

bool TrackingMonitor::doSeedNumberPlot

private

Definition at line 210 of file TrackingMonitor.h.

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

bool TrackingMonitor::doSeedVsClusterPlot

private

Definition at line 212 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

bool TrackingMonitor::doTkCandPlots

private

Definition at line 206 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

bool TrackingMonitor::doTrackerSpecific_

private

Definition at line 198 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::FractionCandidatesOverSeeds

private

Definition at line 146 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::FractionOfGoodTracks

private

Definition at line 132 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

GenericTriggerEventFlag* TrackingMonitor::genTriggerEventFlag_

private

Definition at line 222 of file TrackingMonitor.h.

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

MonitorElement* TrackingMonitor::GoodTracksFractionVsBX

private

Definition at line 165 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::GoodTracksFractionVsGoodPVtx

private

Definition at line 176 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::GoodTracksFractionVsLS

private

Definition at line 157 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::GoodTracksFractionVsLUMI

private

Definition at line 185 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

std::string TrackingMonitor::histname

private

Definition at line 86 of file TrackingMonitor.h.

Referenced by bookHistograms().

edm::EDGetTokenT<LumiScalersCollection> TrackingMonitor::lumiscalersToken_

private

Definition at line 107 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().

std::string TrackingMonitor::MEFolderName

private

Definition at line 85 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

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

private

Definition at line 114 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().

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

private

Definition at line 115 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().

MonitorElement* TrackingMonitor::NumberEventsOfVsBX

private

Definition at line 163 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberEventsOfVsGoodPVtx

private

Definition at line 175 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberEventsOfVsLS

private

Definition at line 155 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberEventsOfVsLUMI

private

Definition at line 183 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfGoodPVtxVsBX

private

Definition at line 167 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfGoodPVtxVsLS

private

Definition at line 159 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfGoodPVtxVsLUMI

private

Definition at line 187 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfGoodPVtxWO0VsBX

private

Definition at line 168 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfGoodPVtxWO0VsLS

private

Definition at line 160 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfGoodPVtxWO0VsLUMI

private

Definition at line 188 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfMeanLayersPerTrack

private

Definition at line 129 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfMeanRecHitsPerTrack

private

Definition at line 128 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfPixelClustersVsGoodPVtx

private

Definition at line 179 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfPixelClustersVsLUMI

private

Definition at line 189 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfPVtxVsGoodPVtx

private

Definition at line 178 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfRecHitsPerTrackVsBX

private

Definition at line 166 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfRecHitsPerTrackVsGoodPVtx

private

Definition at line 177 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfRecHitsPerTrackVsLS

private

Definition at line 158 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfRecHitsPerTrackVsLUMI

private

Definition at line 186 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfSeeds

private

Definition at line 138 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfSeeds_lumiFlag

private

Definition at line 139 of file TrackingMonitor.h.

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

MonitorElement* TrackingMonitor::NumberOfStripClustersVsGoodPVtx

private

Definition at line 180 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfStripClustersVsLUMI

private

Definition at line 190 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfTrackCandidates

private

Definition at line 145 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfTrackingRegions

private

Definition at line 135 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfTracks

private

Definition at line 127 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfTracks_lumiFlag

private

Definition at line 193 of file TrackingMonitor.h.

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

MonitorElement* TrackingMonitor::NumberOfTracksVsBX

private

Definition at line 164 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfTracksVsBXlumi

private

Definition at line 170 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfTracksVsGoodPVtx

private

Definition at line 173 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfTracksVsLS

private

Definition at line 156 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfTracksVsLUMI

private

Definition at line 184 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfTracksVsPUPVtx

private

Definition at line 174 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfTrkVsClus

private

Definition at line 150 of file TrackingMonitor.h.

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

private

Definition at line 149 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfTrkVsPixelClus

private

Definition at line 152 of file TrackingMonitor.h.

MonitorElement* TrackingMonitor::NumberOfTrkVsStripClus

private

Definition at line 151 of file TrackingMonitor.h.

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

private

Definition at line 224 of file TrackingMonitor.h.

Referenced by analyze().

edm::InputTag TrackingMonitor::pixelClusterInputTag_

private

Definition at line 110 of file TrackingMonitor.h.

Referenced by TrackingMonitor().

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

private

Definition at line 112 of file TrackingMonitor.h.

Referenced by setNclus(), and TrackingMonitor().

int TrackingMonitor::pvNDOF_

private

Definition at line 226 of file TrackingMonitor.h.

Referenced by analyze().

edm::InputTag TrackingMonitor::pvSrc_

private

Definition at line 94 of file TrackingMonitor.h.

Referenced by TrackingMonitor().

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

private

Definition at line 96 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().

std::string TrackingMonitor::Quality_

private

Definition at line 117 of file TrackingMonitor.h.

Referenced by bookHistograms(), and TrackingMonitor().

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

private

Definition at line 105 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().

edm::EDGetTokenT<TrackingRegionsSeedingLayerSets> TrackingMonitor::regionLayerSetsToken_

private

Definition at line 104 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().

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

private

Definition at line 103 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().

bool TrackingMonitor::runTrackBuildingAnalyzerForSeed

private

Definition at line 213 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

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

private

Definition at line 102 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().

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

private

Definition at line 140 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

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

private

Definition at line 101 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().

edm::InputTag TrackingMonitor::stripClusterInputTag_

private

Definition at line 109 of file TrackingMonitor.h.

Referenced by TrackingMonitor().

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

private

Definition at line 111 of file TrackingMonitor.h.

Referenced by setNclus(), and TrackingMonitor().

GetLumi* TrackingMonitor::theLumiDetails_

private

Definition at line 124 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().

dqm::TrackAnalyzer* TrackingMonitor::theTrackAnalyzer

private

Definition at line 121 of file TrackingMonitor.h.

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

TrackBuildingAnalyzer* TrackingMonitor::theTrackBuildingAnalyzer

private

Definition at line 122 of file TrackingMonitor.h.

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

edm::ESHandle<TransientTrackingRecHitBuilder> TrackingMonitor::theTTRHBuilder

private

Definition at line 196 of file TrackingMonitor.h.

Referenced by analyze().

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

private

Definition at line 123 of file TrackingMonitor.h.

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

edm::EDGetTokenT<TrackCandidateCollection> TrackingMonitor::trackCandidateToken_

private

Definition at line 100 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().

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

private

Definition at line 99 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().