TrackingMonitor Class Reference

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

Inheritance diagram for TrackingMonitor:

Public Member Functions
virtual void	analyze (const edm::Event &, const edm::EventSetup &) override
virtual void	beginJob (void)
virtual void	beginLuminosityBlock (const edm::LuminosityBlock &lumi, const edm::EventSetup &eSetup) override
void	bookHistograms (DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override
virtual 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 ()
Public Member Functions inherited from DQMEDAnalyzer
virtual void	beginRun (edm::Run const &, edm::EventSetup const &) final
virtual void	beginStream (edm::StreamID id) final
virtual void	dqmBeginRun (edm::Run const &, edm::EventSetup const &)
	DQMEDAnalyzer (void)
virtual void	endLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, dqmDetails::NoCache *) const final
virtual void	endRunSummary (edm::Run const &, edm::EventSetup const &, dqmDetails::NoCache *) const final
uint32_t	streamId () const
Public Member Functions inherited from edm::stream::EDAnalyzer< edm::RunSummaryCache< dqmDetails::NoCache >, edm::LuminosityBlockSummaryCache< dqmDetails::NoCache > >
	EDAnalyzer ()=default
Public Member Functions inherited from edm::stream::EDAnalyzerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)
	EDAnalyzerBase ()
ModuleDescription const &	moduleDescription () const
virtual	~EDAnalyzerBase ()
Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const
	EDConsumerBase ()
	EDConsumerBase (EDConsumerBase const &)=delete
	EDConsumerBase (EDConsumerBase &&)=default
ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const
void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const
void	labelsForToken (EDGetToken iToken, Labels &oLabels) const
void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const
EDConsumerBase const &	operator= (EDConsumerBase const &)=delete
EDConsumerBase &	operator= (EDConsumerBase &&)=default
bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const
bool	registeredToConsumeMany (TypeID const &, BranchType) const
void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)
virtual	~EDConsumerBase () noexcept(false)

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	doPlotsVsBX_
bool	doPlotsVsBXlumi_
bool	doPlotsVsGoodPVtx_
bool	doPlotsVsLUMI_
bool	doProfilesVsLS_
bool	doPUmonitoring_
bool	doSeedLumiAnalysis_
bool	doSeedNumberPlot
bool	doSeedVsClusterPlot
bool	doTkCandPlots
bool	doTrackerSpecific_
MonitorElement *	FractionOfGoodTracks
GenericTriggerEventFlag *	genTriggerEventFlag_
MonitorElement *	GoodTracksFractionVsBX
MonitorElement *	GoodTracksFractionVsGoodPVtx
MonitorElement *	GoodTracksFractionVsLS
MonitorElement *	GoodTracksFractionVsLUMI
std::string	histname
edm::EDGetTokenT< LumiScalersCollection >	lumiscalersToken_
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 *	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_
bool	runTrackBuildingAnalyzerForSeed
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_

Additional Inherited Members
Public Types inherited from edm::stream::EDAnalyzer< edm::RunSummaryCache< dqmDetails::NoCache >, edm::LuminosityBlockSummaryCache< dqmDetails::NoCache > >
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 Types inherited from edm::stream::EDAnalyzerBase
typedef EDAnalyzerAdaptorBase	ModuleType
Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels
Static Public Member Functions inherited from DQMEDAnalyzer
static std::shared_ptr< dqmDetails::NoCache >	globalBeginLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, LuminosityBlockContext const *)
static std::shared_ptr< dqmDetails::NoCache >	globalBeginRunSummary (edm::Run const &, edm::EventSetup const &, RunContext const *)
static void	globalEndLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, LuminosityBlockContext const *, dqmDetails::NoCache *)
static void	globalEndRunSummary (edm::Run const &, edm::EventSetup const &, RunContext const *, dqmDetails::NoCache *)
Static Public Member Functions inherited from edm::stream::EDAnalyzerBase
static const std::string &	baseType ()
static void	fillDescriptions (ConfigurationDescriptions &descriptions)
static void	prevalidate (ConfigurationDescriptions &descriptions)
Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)
EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)
template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)
ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...
template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()
void	consumesMany (const TypeToGet &id)
template<BranchType B>
void	consumesMany (const TypeToGet &id)
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)
template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Detailed Description

Monitoring source for general quantities related to tracks.

Definition at line 51 of file TrackingMonitor.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 41 of file TrackingMonitor.cc.

References AlgoName_, allTrackToken_, bsSrc_, bsSrcToken_, EnergyCorrector::c, edm::EDConsumerBase::consumesCollector(), doFractionPlot_, doPlotsVsBX_, doPlotsVsBXlumi_, doPlotsVsGoodPVtx_, doPlotsVsLUMI_, doPUmonitoring_, edm::ParameterSet::getParameter(), mps_fire::i, edm::InputTag::label(), lumiscalersToken_, pixelClusterInputTag_, pixelClustersToken_, pvSrc_, pvSrcToken_, Quality_, seedToken_, AlCaHLTBitMon_QueryRunRegistry::string, stripClusterInputTag_, stripClustersToken_, theLumiDetails_, theTrackAnalyzer, theVertexMonitor, trackCandidateToken_, findElectronsInSiStrips_cfi::trackProducer, and trackToken_.

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

  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

(

)

Definition at line 161 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  )

overridevirtual

Definition at line 692 of file TrackingMonitor.cc.

References funct::abs(), GenericTriggerEventFlag::accept(), allTrackToken_, TrackBuildingAnalyzer::analyze(), dqm::TrackAnalyzer::analyze(), edm::View< T >::begin(), bsSrcToken_, builderName, edm::EventBase::bunchCrossing(), ClusterLabels, compare(), denSelection_, doAllPlots, doAllSeedPlots, doFractionPlot_, doGeneralPropertiesPlots_, doLumiAnalysis, doPlotsVsBX_, doPlotsVsBXlumi_, doPlotsVsGoodPVtx_, doPlotsVsLUMI_, doProfilesVsLS_, doPUmonitoring_, doSeedLumiAnalysis_, doSeedNumberPlot, doSeedVsClusterPlot, doTkCandPlots, doTrackerSpecific_, edm::View< T >::end(), MonitorElement::Fill(), HcalObjRepresent::Fill(), cropTnPTrees::frac, FractionOfGoodTracks, genTriggerEventFlag_, edm::EventSetup::get(), edm::Event::getByToken(), GetLumi::getValue(), GoodTracksFractionVsBX, GoodTracksFractionVsGoodPVtx, GoodTracksFractionVsLS, GoodTracksFractionVsLUMI, mps_fire::i, edm::EventBase::id(), reco::Vertex::isFake(), edm::HandleBase::isValid(), edm::EventID::luminosityBlock(), lumiscalersToken_, 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, NumberOfTracks, NumberOfTracks_lumiFlag, NumberOfTracksVsBX, NumberOfTracksVsBXlumi, NumberOfTracksVsGoodPVtx, NumberOfTracksVsLS, NumberOfTracksVsLUMI, NumberOfTracksVsPUPVtx, NumberOfTrkVsClusters, numSelection_, GenericTriggerEventFlag::on(), reco::Vertex::position(), MetAnalyzer::pv(), pvNDOF_, pvSrcToken_, runTrackBuildingAnalyzerForSeed, SurveyInfoScenario_cff::seed, 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_, 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->size() ) {
      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());
      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";
    }
      }
      
      //plots for trajectory seeds
      
      if (doAllSeedPlots || doSeedNumberPlot || doSeedVsClusterPlot || runTrackBuildingAnalyzerForSeed) {
    
    // get the seed collection
    edm::Handle<edm::View<TrajectorySeed> > seedHandle;
    iEvent.getByToken(seedToken_, seedHandle );
    const edm::View<TrajectorySeed>& seedCollection = *seedHandle;
    
    // fill the seed info
    if (seedHandle.isValid()) {
      
      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){
        
        //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 < seedHandle->size(); ++i) {
          
          edm::RefToBase<TrajectorySeed> seed(seedHandle, i);
          theTrackBuildingAnalyzer->analyze(iEvent, iSetup, *seed, bs, theMF, theTTRHBuilder);
        }
      }
      
    } else {
      edm::LogWarning("TrackingMonitor") << "No Trajectory seeds in the event.  Not filling associated histograms";
    }
      }
      
      
      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);
      for (uint  i=0; i< ClusterLabels.size(); i++){
        if ( doPlotsVsLUMI_ || doAllPlots ) {
          if (ClusterLabels[i].compare("Pix")  ==0) NumberOfPixelClustersVsLUMI->Fill(lumi,NClus[i]);
          if (ClusterLabels[i].compare("Strip")==0) NumberOfStripClustersVsLUMI->Fill(lumi,NClus[i]);
        }
        if (ClusterLabels[i].compare("Pix")  ==0) NumberOfPixelClustersVsGoodPVtx->Fill(float(totalNumGoodPV),NClus[i]);
        if (ClusterLabels[i].compare("Strip")==0) NumberOfStripClustersVsGoodPVtx->Fill(float(totalNumGoodPV),NClus[i]);
      }
    
    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::beginJob ( void  )

virtual

Definition at line 172 of file TrackingMonitor.cc.

{

    
}

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

overridevirtual

Definition at line 678 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  )

overridevirtual

Implements DQMEDAnalyzer.

Definition at line 178 of file TrackingMonitor.cc.

References AlgoName_, DQMStore::IBooker::book1D(), DQMStore::IBooker::book2D(), DQMStore::IBooker::bookProfile(), ClusterLabels, compare(), confID_, doAllPlots, doAllSeedPlots, doFractionPlot_, doGeneralPropertiesPlots_, doLumiAnalysis, doPlotsVsBX_, doPlotsVsBXlumi_, doPlotsVsGoodPVtx_, doPlotsVsLUMI_, doProfilesVsLS_, doPUmonitoring_, doSeedLumiAnalysis_, doSeedNumberPlot, doSeedVsClusterPlot, doTkCandPlots, doTrackerSpecific_, FractionOfGoodTracks, genTriggerEventFlag_, edm::pset::Registry::getMapped(), edm::ParameterSet::getParameter(), MonitorElement::getTH1(), GoodTracksFractionVsBX, GoodTracksFractionVsGoodPVtx, GoodTracksFractionVsLS, GoodTracksFractionVsLUMI, histname, mps_fire::i, TrackBuildingAnalyzer::initHisto(), dqm::TrackAnalyzer::initHisto(), GenericTriggerEventFlag::initRun(), edm::pset::Registry::instance(), edm::InputTag::label(), 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, 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, and fftjetcommon_cfi::title.

{
   // 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");
   std::string MEFolderName = conf->getParameter<std::string>("FolderName"); 

   // test for the Quality veriable validity
   if( Quality_ != "") {
     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_ != "" ? 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+0.5)*3.-0.5,"");
     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.,40.,"");
     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,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,GoodPVtxMax,"");
     NumberOfGoodPVtxWO0VsLS->getTH1()->SetCanExtend(TH1::kAllAxes);
     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->getTH1()->SetCanExtend(TH1::kAllAxes);
       NumberEventsOfVsBX->setAxisTitle("BX",1);
       NumberEventsOfVsBX->setAxisTitle("Number of events",2);
       
       histname = "NumberOfTracksVsBX_"+ CategoryName;
       NumberOfTracksVsBX = ibooker.bookProfile(histname,histname, BXBin,BXMin,BXMax, TKNoMin, (TKNoMax+0.5)*3.-0.5,"");
       NumberOfTracksVsBX->getTH1()->SetCanExtend(TH1::kAllAxes);
       NumberOfTracksVsBX->setAxisTitle("BX",1);
       NumberOfTracksVsBX->setAxisTitle("Number of  Tracks",2);
       
       histname = "NumberOfRecHitsPerTrackVsBX_" + CategoryName;
       NumberOfRecHitsPerTrackVsBX = ibooker.bookProfile(histname,histname, BXBin,BXMin,BXMax,0.,40.,"");
       NumberOfRecHitsPerTrackVsBX->getTH1()->SetCanExtend(TH1::kAllAxes);
       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,GoodPVtxMax,"");
       NumberOfGoodPVtxVsBX->getTH1()->SetCanExtend(TH1::kAllAxes);
       NumberOfGoodPVtxVsBX->setAxisTitle("BX",1);
       NumberOfGoodPVtxVsBX->setAxisTitle("Mean number of good PV",2);
       
       histname = "NumberOfGoodPVtxWO0VsBX_" + CategoryName;
       NumberOfGoodPVtxWO0VsBX = ibooker.bookProfile(histname,histname, BXBin,BXMin,BXMax,GoodPVtxMin,GoodPVtxMax,"");
       NumberOfGoodPVtxWO0VsBX->getTH1()->SetCanExtend(TH1::kAllAxes);
       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->getTH1()->SetCanExtend(TH1::kAllAxes);
     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    GoodPVtxBin   = conf->getParameter<int>("GoodPVtxBin");
       double GoodPVtxMin   = conf->getParameter<double>("GoodPVtxMin");
       double GoodPVtxMax   = conf->getParameter<double>("GoodPVtxMax");
    
       histname = "NumberOfTracksVsGoodPVtx";
       NumberOfTracksVsGoodPVtx = ibooker.bookProfile(histname,histname,GoodPVtxBin,GoodPVtxMin,GoodPVtxMax,TKNoMin, (TKNoMax+0.5)*3.-0.5,"");
       NumberOfTracksVsGoodPVtx->getTH1()->SetCanExtend(TH1::kAllAxes);
       NumberOfTracksVsGoodPVtx->setAxisTitle("Number of PV",1);
       NumberOfTracksVsGoodPVtx->setAxisTitle("Mean number of Tracks per Event",2);

       histname = "NumberOfTracksVsPUPVtx";
       NumberOfTracksVsPUPVtx = ibooker.bookProfile(histname,histname,GoodPVtxBin,GoodPVtxMin,GoodPVtxMax,0., 100.,"");
       NumberOfTracksVsPUPVtx->getTH1()->SetCanExtend(TH1::kAllAxes);
       NumberOfTracksVsPUPVtx->setAxisTitle("Number of PU",1);
       NumberOfTracksVsPUPVtx->setAxisTitle("Mean number of Tracks per PUvtx",2);

       histname = "NumberEventsVsGoodPVtx";
       NumberEventsOfVsGoodPVtx = ibooker.book1D(histname,histname,GoodPVtxBin,GoodPVtxMin,GoodPVtxMax);
       NumberEventsOfVsGoodPVtx->getTH1()->SetCanExtend(TH1::kAllAxes);
       NumberEventsOfVsGoodPVtx->setAxisTitle("Number of good PV (PU)",1);
       NumberEventsOfVsGoodPVtx->setAxisTitle("Number of events",2);

       if (doFractionPlot_) {
     histname = "GoodTracksFractionVsGoodPVtx";
     GoodTracksFractionVsGoodPVtx = ibooker.bookProfile(histname,histname,GoodPVtxBin,GoodPVtxMin,GoodPVtxMax,0., 400.,"");
     GoodTracksFractionVsGoodPVtx->getTH1()->SetCanExtend(TH1::kAllAxes);
     GoodTracksFractionVsGoodPVtx->setAxisTitle("Number of good PV (PU)",1);
     GoodTracksFractionVsGoodPVtx->setAxisTitle("Mean fraction of good tracks",2);
       }

       histname = "NumberOfRecHitsPerTrackVsGoodPVtx";
       NumberOfRecHitsPerTrackVsGoodPVtx = ibooker.bookProfile(histname,histname,GoodPVtxBin,GoodPVtxMin,GoodPVtxMax,0., 100.,"");
       NumberOfRecHitsPerTrackVsGoodPVtx->getTH1()->SetCanExtend(TH1::kAllAxes);
       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,GoodPVtxBin,GoodPVtxMin,GoodPVtxMax,0., 100.,"");
       NumberOfPVtxVsGoodPVtx->getTH1()->SetCanExtend(TH1::kAllAxes);
       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,GoodPVtxBin,GoodPVtxMin,GoodPVtxMax,NClusPxMin,NClusPxMax,"");
       NumberOfPixelClustersVsGoodPVtx->getTH1()->SetCanExtend(TH1::kAllAxes);
       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,GoodPVtxBin,GoodPVtxMin,GoodPVtxMax,NClusStrMin,NClusStrMax,"");
       NumberOfStripClustersVsGoodPVtx->getTH1()->SetCanExtend(TH1::kAllAxes);
       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->getTH1()->SetCanExtend(TH1::kAllAxes);
       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., 400.,"");
       NumberOfTracksVsLUMI->getTH1()->SetCanExtend(TH1::kAllAxes);
       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., 100.,"");
     GoodTracksFractionVsLUMI->getTH1()->SetCanExtend(TH1::kAllAxes);
     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., 20.,"");
       NumberOfRecHitsPerTrackVsLUMI->getTH1()->SetCanExtend(TH1::kAllAxes);
       NumberOfRecHitsPerTrackVsLUMI->setAxisTitle("scal lumi [10e30 Hz cm^{-2}]",1);
       NumberOfRecHitsPerTrackVsLUMI->setAxisTitle("Mean number of vertices",2);

       double GoodPVtxMin   = conf->getParameter<double>("GoodPVtxMin");
       double GoodPVtxMax   = conf->getParameter<double>("GoodPVtxMax");
       
       histname = "NumberOfGoodPVtxVsLUMI";
       NumberOfGoodPVtxVsLUMI = ibooker.bookProfile(histname,histname,LUMIBin,LUMIMin,LUMIMax,GoodPVtxMin,GoodPVtxMax,"");
       NumberOfGoodPVtxVsLUMI->getTH1()->SetCanExtend(TH1::kAllAxes);
       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,GoodPVtxMin,GoodPVtxMax,"");
       NumberOfGoodPVtxWO0VsLUMI->getTH1()->SetCanExtend(TH1::kAllAxes);
       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,NClusPxMax,"");
       NumberOfPixelClustersVsLUMI->getTH1()->SetCanExtend(TH1::kAllAxes);
       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,NClusStrMax,"");
       NumberOfStripClustersVsLUMI->getTH1()->SetCanExtend(TH1::kAllAxes);
       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, TKNoMax,"");
       NumberOfTracksVsBXlumi->getTH1()->SetCanExtend(TH1::kAllAxes);
       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);
     }
   }
  
   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);
  }
  
  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].compare("Tot")==0)
    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 &    )

overridevirtual

Definition at line 991 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 995 of file TrackingMonitor.cc.

References ClusterLabels, compare(), and mps_fire::i.

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].compare("Pix")==0  ) {arrayMin[i]=pmin; arrayMax[i]=pmax;      arrayBin[i]=pbin;}
    else if(ClusterLabels[i].compare("Strip")==0) {arrayMin[i]=smin; arrayMax[i]=smax;      arrayBin[i]=sbin;}
    else if(ClusterLabels[i].compare("Tot")==0  ) {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 1013 of file TrackingMonitor.cc.

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

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].compare("Pix")==0  ) arrayNclus[i]=ncluster_pix ;
    else if(ClusterLabels[i].compare("Strip")==0) arrayNclus[i]=ncluster_strip;
    else if(ClusterLabels[i].compare("Tot")==0  ) 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 99 of file TrackingMonitor.h.

Referenced by bookHistograms(), and TrackingMonitor().

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

private

Definition at line 86 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().

edm::InputTag TrackingMonitor::bsSrc_

private

Definition at line 81 of file TrackingMonitor.h.

Referenced by TrackingMonitor().

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

private

Definition at line 83 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().

std::string TrackingMonitor::builderName

private

Definition at line 172 of file TrackingMonitor.h.

Referenced by analyze().

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

private

Definition at line 119 of file TrackingMonitor.h.

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

edm::ParameterSetID TrackingMonitor::confID_

private

Definition at line 78 of file TrackingMonitor.h.

Referenced by bookHistograms().

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

private

Definition at line 199 of file TrackingMonitor.h.

Referenced by analyze().

bool TrackingMonitor::doAllPlots

private

Definition at line 179 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

bool TrackingMonitor::doAllSeedPlots

private

Definition at line 178 of file TrackingMonitor.h.

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

bool TrackingMonitor::doDCAPlots_

private

Definition at line 180 of file TrackingMonitor.h.

bool TrackingMonitor::doFractionPlot_

private

Definition at line 194 of file TrackingMonitor.h.

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

bool TrackingMonitor::doGeneralPropertiesPlots_

private

Definition at line 181 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

bool TrackingMonitor::doHitPropertiesPlots_

private

Definition at line 182 of file TrackingMonitor.h.

bool TrackingMonitor::doLumiAnalysis

private

Definition at line 176 of file TrackingMonitor.h.

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

bool TrackingMonitor::doPlotsVsBX_

private

Definition at line 193 of file TrackingMonitor.h.

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

bool TrackingMonitor::doPlotsVsBXlumi_

private

Definition at line 190 of file TrackingMonitor.h.

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

bool TrackingMonitor::doPlotsVsGoodPVtx_

private

Definition at line 191 of file TrackingMonitor.h.

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

bool TrackingMonitor::doPlotsVsLUMI_

private

Definition at line 192 of file TrackingMonitor.h.

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

bool TrackingMonitor::doProfilesVsLS_

private

Definition at line 177 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

bool TrackingMonitor::doPUmonitoring_

private

Definition at line 189 of file TrackingMonitor.h.

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

bool TrackingMonitor::doSeedLumiAnalysis_

private

Definition at line 185 of file TrackingMonitor.h.

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

bool TrackingMonitor::doSeedNumberPlot

private

Definition at line 184 of file TrackingMonitor.h.

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

bool TrackingMonitor::doSeedVsClusterPlot

private

Definition at line 186 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

bool TrackingMonitor::doTkCandPlots

private

Definition at line 183 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

bool TrackingMonitor::doTrackerSpecific_

private

Definition at line 175 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::FractionOfGoodTracks

private

Definition at line 113 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

GenericTriggerEventFlag* TrackingMonitor::genTriggerEventFlag_

private

Definition at line 196 of file TrackingMonitor.h.

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

MonitorElement* TrackingMonitor::GoodTracksFractionVsBX

private

Definition at line 142 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::GoodTracksFractionVsGoodPVtx

private

Definition at line 153 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::GoodTracksFractionVsLS

private

Definition at line 134 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::GoodTracksFractionVsLUMI

private

Definition at line 162 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

std::string TrackingMonitor::histname

private

Definition at line 74 of file TrackingMonitor.h.

Referenced by bookHistograms().

edm::EDGetTokenT<LumiScalersCollection> TrackingMonitor::lumiscalersToken_

private

Definition at line 91 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().

MonitorElement* TrackingMonitor::NumberEventsOfVsBX

private

Definition at line 140 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberEventsOfVsGoodPVtx

private

Definition at line 152 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberEventsOfVsLS

private

Definition at line 132 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberEventsOfVsLUMI

private

Definition at line 160 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfGoodPVtxVsBX

private

Definition at line 144 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfGoodPVtxVsLS

private

Definition at line 136 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfGoodPVtxVsLUMI

private

Definition at line 164 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfGoodPVtxWO0VsBX

private

Definition at line 145 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfGoodPVtxWO0VsLS

private

Definition at line 137 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfGoodPVtxWO0VsLUMI

private

Definition at line 165 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfMeanLayersPerTrack

private

Definition at line 110 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfMeanRecHitsPerTrack

private

Definition at line 109 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfPixelClustersVsGoodPVtx

private

Definition at line 156 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfPixelClustersVsLUMI

private

Definition at line 166 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfPVtxVsGoodPVtx

private

Definition at line 155 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfRecHitsPerTrackVsBX

private

Definition at line 143 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfRecHitsPerTrackVsGoodPVtx

private

Definition at line 154 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfRecHitsPerTrackVsLS

private

Definition at line 135 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfRecHitsPerTrackVsLUMI

private

Definition at line 163 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfSeeds

private

Definition at line 116 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfSeeds_lumiFlag

private

Definition at line 117 of file TrackingMonitor.h.

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

MonitorElement* TrackingMonitor::NumberOfStripClustersVsGoodPVtx

private

Definition at line 157 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfStripClustersVsLUMI

private

Definition at line 167 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfTrackCandidates

private

Definition at line 123 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfTracks

private

Definition at line 108 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfTracks_lumiFlag

private

Definition at line 170 of file TrackingMonitor.h.

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

MonitorElement* TrackingMonitor::NumberOfTracksVsBX

private

Definition at line 141 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfTracksVsBXlumi

private

Definition at line 147 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfTracksVsGoodPVtx

private

Definition at line 150 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfTracksVsLS

private

Definition at line 133 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfTracksVsLUMI

private

Definition at line 161 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfTracksVsPUPVtx

private

Definition at line 151 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfTrkVsClus

private

Definition at line 127 of file TrackingMonitor.h.

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

private

Definition at line 126 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TrackingMonitor::NumberOfTrkVsPixelClus

private

Definition at line 129 of file TrackingMonitor.h.

MonitorElement* TrackingMonitor::NumberOfTrkVsStripClus

private

Definition at line 128 of file TrackingMonitor.h.

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

private

Definition at line 198 of file TrackingMonitor.h.

Referenced by analyze().

edm::InputTag TrackingMonitor::pixelClusterInputTag_

private

Definition at line 94 of file TrackingMonitor.h.

Referenced by TrackingMonitor().

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

private

Definition at line 96 of file TrackingMonitor.h.

Referenced by setNclus(), and TrackingMonitor().

int TrackingMonitor::pvNDOF_

private

Definition at line 200 of file TrackingMonitor.h.

Referenced by analyze().

edm::InputTag TrackingMonitor::pvSrc_

private

Definition at line 82 of file TrackingMonitor.h.

Referenced by TrackingMonitor().

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

private

Definition at line 84 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().

std::string TrackingMonitor::Quality_

private

Definition at line 98 of file TrackingMonitor.h.

Referenced by bookHistograms(), and TrackingMonitor().

bool TrackingMonitor::runTrackBuildingAnalyzerForSeed

private

Definition at line 187 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

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

private

Definition at line 118 of file TrackingMonitor.h.

Referenced by analyze(), and bookHistograms().

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

private

Definition at line 89 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().

edm::InputTag TrackingMonitor::stripClusterInputTag_

private

Definition at line 93 of file TrackingMonitor.h.

Referenced by TrackingMonitor().

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

private

Definition at line 95 of file TrackingMonitor.h.

Referenced by setNclus(), and TrackingMonitor().

GetLumi* TrackingMonitor::theLumiDetails_

private

Definition at line 105 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().

dqm::TrackAnalyzer* TrackingMonitor::theTrackAnalyzer

private

Definition at line 102 of file TrackingMonitor.h.

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

TrackBuildingAnalyzer* TrackingMonitor::theTrackBuildingAnalyzer

private

Definition at line 103 of file TrackingMonitor.h.

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

edm::ESHandle<TransientTrackingRecHitBuilder> TrackingMonitor::theTTRHBuilder

private

Definition at line 173 of file TrackingMonitor.h.

Referenced by analyze().

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

private

Definition at line 104 of file TrackingMonitor.h.

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

edm::EDGetTokenT<TrackCandidateCollection> TrackingMonitor::trackCandidateToken_

private

Definition at line 88 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().

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

private

Definition at line 87 of file TrackingMonitor.h.

Referenced by analyze(), and TrackingMonitor().